Grcov report - cli

1

use std::env;

2

use std::ffi::OsString;

3

use std::io::IsTerminal;

4

use std::path::Path;

5

use std::sync::Arc;

6

use std::time::Duration;

7

8

use crate::secrets::Secrets;

9

use crate::task_selector::{

10

  FuzzyTaskSelector,

11

  TaskSelectorCandidate,

12

};

13

use anyhow::Context as _;

14

use clap::{

15

  crate_authors,

16

  CommandFactory,

17

  Parser,

18

  Subcommand,

19

};

20

use clap_complete::Shell;

21

use console::style;

22

use mk_lib::file::DisplayPath as _;

23

use mk_lib::label_filter::{

24

  matches_all,

25

  LabelFilter,

26

};

27

use mk_lib::schema::{

28

  run_task_by_name,

29

  Task,

30

  TaskContext,

31

  TaskPlan,

32

  TaskRoot,

33

};

34

use mk_lib::version::get_version_digits;

35

use once_cell::sync::Lazy;

36

use prettytable::format::consts;

37

use prettytable::{

38

  row,

39

  Table,

40

};

41

use reqwest::blocking::Client;

42

use reqwest::header::{

43

  HeaderMap,

44

  ACCEPT,

45

  USER_AGENT,

46

};

47

use reqwest::redirect::Policy;

48

use reqwest::StatusCode;

49

use serde::{

50

  Deserialize,

51

  Serialize,

52

};

53

54

static VERSION: Lazy<String> = Lazy::new(get_version_digits);

55

static INIT_SCHEMA_URL: &str = "https://raw.githubusercontent.com/ffimnsr/mk-rs/main/docs/schema.json";

56

57

/// The CLI arguments

58

#[derive(Debug, Parser)]

59

#[command(

60

  version = VERSION.as_str(),

61

  about,

62

  long_about = "mk is a powerful and flexible task runner designed to help you automate and manage your tasks efficiently. It supports running commands both locally and inside containers, making it versatile for various environments and use cases. Running tasks in containers is a first-class citizen, ensuring seamless integration with containerized workflows.",

63

  arg_required_else_help = true,

64

  author = crate_authors!("\n"),

65

  propagate_version = true,

66

)]

67

struct Args {

68

  #[arg(

69

    short,

70

    long,

71

    help = "Config file to source",

72

    env = "MK_CONFIG",

73

    default_value = "tasks.yaml"

74

)]

75

  config: String,

76

77

  // Waiting for the dynamic completion to be implemented

78

  // Tracking can be found here:

79

  // - https://github.com/clap-rs/clap/issues/3166

80

  // - https://github.com/clap-rs/clap/issues/1232

81

//

82

  // Usually, this would call `mk list --plain` or `mk list --json` to capture

83

  // the available tasks and use them as completions.

84

  #[arg(help = "The task name to run", value_hint = clap::ValueHint::Other)]

85

  task_name: Option<String>,

86

87

  #[command(subcommand)]

88

  command: Option<Command>,

89

90

91

/// The available subcommands

92

#[derive(Debug, Subcommand)]

93

enum Command {

94

  #[command(about = "Initialize a sample task config file in the current directory")]

95

  Init {

96

    #[arg(short, long, help = "Overwrite existing config file if present")]

97

    force: bool,

98

    #[arg(help = "Optional output path for the created config file")]

99

    output: Option<String>,

100

},

101

  #[command(visible_aliases = ["r"], about = "Run specific tasks")]

102

  Run {

103

    #[arg(help = "The task name to run", value_hint = clap::ValueHint::Other)]

104

    task_name: Option<String>,

105

106

    #[arg(

107

      long,

108

      help = "Print the resolved task plan without executing commands",

109

      conflicts_with = "json_events"

110

)]

111

    dry_run: bool,

112

113

    #[arg(long, help = "Bypass task cache and force execution")]

114

    force: bool,

115

116

    #[arg(long, help = "Emit newline-delimited JSON execution events")]

117

    json_events: bool,

118

119

    #[arg(

120

      short = 'F',

121

      long = "fzf",

122

      help = "Choose task with fuzzy finder before execution",

123

      conflicts_with_all = ["task_name", "dry_run", "json_events"]

124

)]

125

    fuzzy: bool,

126

127

    #[arg(

128

      long = "label",

129

      help = "Run tasks matching label (KEY or KEY=VALUE). Repeatable; all must match.",

130

      value_name = "FILTER"

131

)]

132

    labels: Vec<String>,

133

},

134

  #[command(visible_aliases = ["ls"], about = "List all available tasks")]

135

  List {

136

    #[arg(short, long, help = "Show list that does not include headers")]

137

    plain: bool,

138

139

    #[arg(short, long, help = "Show list in JSON format", conflicts_with = "plain")]

140

    json: bool,

141

142

    #[arg(long, help = "Disable colored list output", conflicts_with_all = ["plain", "json"])]

143

    no_color: bool,

144

145

    #[arg(

146

      long = "label",

147

      help = "Filter tasks by label (KEY or KEY=VALUE). Repeatable; all must match.",

148

      value_name = "FILTER"

149

)]

150

    labels: Vec<String>,

151

},

152

  #[command(visible_aliases = ["comp", "completions"], about = "Generate shell completions")]

153

  Completion {

154

    #[arg(required = true, value_enum, help = "The shell to generate completions for")]

155

    shell: Shell,

156

},

157

  #[command(about = "Validate task configuration without executing tasks")]

158

  Validate {

159

    #[arg(long, help = "Show validation results in JSON format")]

160

    json: bool,

161

},

162

  #[command(about = "Show the resolved execution plan for a task")]

163

  Plan {

164

    #[arg(help = "The task name to inspect", value_hint = clap::ValueHint::Other)]

165

    task_name: Option<String>,

166

167

    #[arg(long, help = "Show the plan in JSON format")]

168

    json: bool,

169

170

    #[arg(

171

      long = "label",

172

      help = "Plan tasks matching label (KEY or KEY=VALUE). Repeatable; all must match.",

173

      value_name = "FILTER"

174

)]

175

    labels: Vec<String>,

176

},

177

  #[command(visible_aliases = ["s"], arg_required_else_help = true, about = "Access stored secrets")]

178

  Secrets(Box<Secrets>),

179

  // Update does not require a config file.

180

  #[command(about = "Check for mk (make) updates")]

181

  Update,

182

  #[command(about = "Remove mk task cache metadata")]

183

  CleanCache,

184

  #[command(about = "Print the JSON Schema for the task configuration file")]

185

  Schema,

186

187

188

/// The CLI entry

189

pub(super) struct CliEntry {

190

  args: Args,

191

  task_root: Arc<TaskRoot>,

192

193

194

impl CliEntry {

195

53

  pub fn maybe_print_task_completion_from_env() -> anyhow::Result<bool> {

196

53

    if env::var_os("MK_COMPLETE_TASKS").is_none() {

197

53

      return Ok(false);

198

199

200

    let prefix = env::var("MK_COMPLETE_PREFIX").ok();

201

    let config = Self::completion_config_path()?;

202

    let task_root = if config.exists() {

203

      TaskRoot::from_file(&config)?

204

    } else {

205

      TaskRoot::default()

206

};

207

208

    let mut names = task_root.tasks.keys().map(String::as_str).collect::<Vec<_>>();

209

    names.sort_unstable();

210

211

    for name in names {

212

      if prefix

213

        .as_deref()

214

        .map(|prefix| name.starts_with(prefix))

215

        .unwrap_or(true)

216

217

        println!("{name}");

218

219

220

221

    Ok(true)

222

53

223

224

  /// Create a new CLI entry

225

53

  pub fn new() -> anyhow::Result<Self> {

226

53

    let args = Self::parse_args();

227

53

    assert!(!args.config.is_empty());

228

229

45

    let (config, allow_without_config) = Self::resolve_config(&args)?;

230

45

    log::trace!("Config: {}", config.display_lossy());

231

232

45

    if !config.exists() && !allow_without_config {

233

1

      let mut message = format!("Config file does not exist: {}", config.display_lossy());

234

1

      if args.config == "tasks.yaml" {

235

        message.push_str(". Note: mk also checks for tasks.yml when tasks.yaml is missing.");

236

1

237

1

      anyhow::bail!(message);

238

44

239

240

44

    let task_root = if config.exists() {

241

44

      Arc::new(TaskRoot::from_file(&config)?)

242

    } else {

243

      debug_assert!(allow_without_config);

244

      let mut task_root = TaskRoot::default();

245

      task_root.source_path = Some(Self::absolute_config_path(&config)?);

246

      Arc::new(task_root)

247

};

248

43

    Ok(Self { args, task_root })

249

45

250

251

53

  fn parse_args() -> Args {

252

53

    Args::parse_from(Self::expand_hydra_aliases(env::args_os()))

253

53

254

255

68

  fn expand_hydra_aliases(args: impl IntoIterator<Item = OsString>) -> Vec<OsString> {

256

68

    let mut args = args.into_iter();

257

68

    let mut expanded = Vec::new();

258

259

68

    if let Some(program) = args.next() {

260

68

      expanded.push(program);

261

68

262

263

68

    let mut expanded_command = false;

264

68

    let mut config_value_pending = false;

265

266

216

    for arg in args {

267

216

      if config_value_pending {

268

41

        expanded.push(arg);

269

41

        config_value_pending = false;

270

41

        continue;

271

175

272

273

175

      if !expanded_command {

274

108

        if arg == "-c" || arg == "--config" {

275

41

          config_value_pending = true;

276

41

          expanded.push(arg);

277

41

          continue;

278

67

279

280

67

        if arg.to_string_lossy().starts_with("--config=") {

281

          expanded.push(arg);

282

          continue;

283

67

284

285

        // Hydra aliases: single token → multi-word subcommand path.

286

        // Ordered longest-match first to avoid prefix ambiguity (e.g. `svls`

287

        // before `sv`).  None of these must shadow a top-level clap

288

        // visible_alias (`r`, `ls`, `comp`, `completions`, `s`).

289

67

        let hydra: Option<&[&str]> = match arg.to_string_lossy().as_ref() {

290

          // secrets vault <subcmd>

291

67

          "svls" | "svl" => Some(&["secrets", "vault", "list-secrets"]),

292

64

          "svi" => Some(&["secrets", "vault", "init-vault"]),

293

63

          "svst" => Some(&["secrets", "vault", "store-secret"]),

294

62

          "svsh" => Some(&["secrets", "vault", "show-secret"]),

295

61

          "svp" => Some(&["secrets", "vault", "purge-secret"]),

296

60

          "sve" => Some(&["secrets", "vault", "export-secret"]),

297

          // secrets vault (prefix — remainder passes through unchanged)

298

59

          "sv" => Some(&["secrets", "vault"]),

299

          // secrets <subcmd>

300

58

          "sk" => Some(&["secrets", "key"]),

301

57

          "slk" => Some(&["secrets", "list-keys"]),

302

56

          "sd" => Some(&["secrets", "doctor"]),

303

55

          "si" => Some(&["secrets", "init-vault"]),

304

54

          "se" => Some(&["secrets", "export-secret"]),

305

53

          _ => None,

306

};

307

67

        if let Some(tokens) = hydra {

308

36

          expanded.extend(tokens.iter().map(|t| OsString::from(*t)));

309

14

          expanded_command = true;

310

14

          continue;

311

53

312

313

53

        if !arg.to_string_lossy().starts_with('-') {

314

50

          expanded_command = true;

315

50

316

67

317

318

120

      expanded.push(arg);

319

320

321

68

    expanded

322

68

323

324

46

  fn resolve_config(args: &Args) -> anyhow::Result<(std::path::PathBuf, bool)> {

325

46

    let mut config = Path::new(&args.config).to_path_buf();

326

46

    if !config.exists() && args.config == "tasks.yaml" {

327

      for candidate in Self::default_config_candidates() {

328

        let fallback = Path::new(candidate);

329

        if fallback.exists() {

330

          config = fallback.to_path_buf();

331

          break;

332

333

334

46

335

336

46

    let allow_without_config = matches!(

337

42

      args.command,

338

      Some(Command::Init { .. })

339

        | Some(Command::Completion { .. })

340

        | Some(Command::Update)

341

        | Some(Command::CleanCache)

342

        | Some(Command::Schema)

343

42

    ) || (matches!(args.command, Some(Command::Secrets(_)))

344

      && !Self::config_requested_explicitly(args));

345

346

46

    Ok((config, allow_without_config))

347

46

348

349

  fn config_requested_explicitly(args: &Args) -> bool {

350

    if args.config != "tasks.yaml" || env::var_os("MK_CONFIG").is_some() {

351

      return true;

352

353

354

    env::args_os()

355

      .any(|arg| arg == "-c" || arg == "--config" || arg.to_string_lossy().starts_with("--config="))

356

357

358

1

  fn default_config_candidates() -> &'static [&'static str] {

359

1

&[

360

1

      "tasks.yml",

361

1

      ".mk/tasks.yaml",

362

1

      ".mk/tasks.yml",

363

1

      "mk.toml",

364

1

      "tasks.toml",

365

1

      "tasks.json",

366

1

      "tasks.lua",

367

1

      ".mk/tasks.toml",

368

1

      ".mk/tasks.json",

369

1

      ".mk/tasks.lua",

370

1

371

1

372

373

  fn absolute_config_path(config: &Path) -> anyhow::Result<std::path::PathBuf> {

374

    if config.is_absolute() {

375

      Ok(config.to_path_buf())

376

    } else {

377

      Ok(env::current_dir()?.join(config))

378

379

380

381

  fn completion_config_path() -> anyhow::Result<std::path::PathBuf> {

382

    let mut config = env::var_os("MK_CONFIG")

383

      .map(std::path::PathBuf::from)

384

      .unwrap_or_else(|| std::path::PathBuf::from("tasks.yaml"));

385

386

    let mut args = env::args_os();

387

    let _program = args.next();

388

    let mut expect_config_value = false;

389

390

    for arg in args {

391

      if expect_config_value {

392

        config = std::path::PathBuf::from(arg);

393

        expect_config_value = false;

394

        continue;

395

396

397

      if arg == "-c" || arg == "--config" {

398

        expect_config_value = true;

399

        continue;

400

401

402

      let arg = arg.to_string_lossy();

403

      if let Some(value) = arg.strip_prefix("--config=") {

404

        config = std::path::PathBuf::from(value);

405

406

407

408

    if !config.exists() && config == Path::new("tasks.yaml") {

409

      for candidate in Self::default_config_candidates() {

410

        let candidate = std::path::PathBuf::from(candidate);

411

        if candidate.exists() {

412

          config = candidate;

413

          break;

414

415

416

417

418

    Self::absolute_config_path(&config)

419

420

421

  /// Run the CLI entry

422

43

  pub fn run(&self) -> anyhow::Result<()> {

423

40

    match &self.args.command {

424

      Some(Command::Init { force, output }) => {

425

        let config_path = if let Some(ref out) = output {

426

          Path::new(out)

427

        } else {

428

          Path::new(&self.args.config)

429

};

430

431

        if config_path.exists() && !force {

432

          anyhow::bail!("Config file already exists. Use `--force` to overwrite");

433

434

435

        Self::ensure_init_path_supported(config_path)?;

436

        let contents = Self::build_init_contents(config_path)?;

437

438

        std::fs::write(config_path, contents)?;

439

        println!("Config file created at {}", config_path.display_lossy());

440

},

441

      Some(Command::Run {

442

12

        task_name,

443

12

        dry_run,

444

12

        force,

445

12

        json_events,

446

12

        fuzzy,

447

12

        labels,

448

      }) => {

449

12

        let filters: Vec<LabelFilter> = labels.iter().map(|s| LabelFilter::parse(s)).collect();

450

12

        let names = if *fuzzy {

451

          vec![self.select_run_task(&filters)?]

452

        } else {

453

12

          self.resolve_run_tasks(task_name.as_deref(), &filters)?

454

};

455

7

        if *dry_run {

456

1

          for name in &names {

457

1

            self.print_plan(name, false)?;

458

459

        } else {

460

7

          for name in &names {

461

7

            self.run_task(name, *force, *json_events)?;

462

463

464

},

465

      Some(Command::List {

466

10

        plain,

467

10

        json,

468

10

        no_color,

469

10

        labels,

470

      }) => {

471

10

        let filters: Vec<LabelFilter> = labels.iter().map(|s| LabelFilter::parse(s)).collect();

472

10

        self.print_available_tasks(*plain, *json, *no_color, &filters)?;

473

},

474

1

      Some(Command::Completion { shell }) => {

475

1

        self.write_completions(*shell)?;

476

},

477

8

      Some(Command::Validate { json }) => {

478

8

        self.validate_config(*json)?;

479

},

480

      Some(Command::Plan {

481

7

        task_name,

482

7

        json,

483

7

        labels,

484

      }) => {

485

7

        let filters: Vec<LabelFilter> = labels.iter().map(|s| LabelFilter::parse(s)).collect();

486

7

        let names = self.resolve_run_tasks(task_name.as_deref(), &filters)?;

487

7

        for name in &names {

488

7

          self.print_plan(name, *json)?;

489

490

},

491

      Some(Command::Secrets(secrets)) => {

492

        secrets.execute(&self.task_root)?;

493

},

494

      Some(Command::Update) => {

495

1

        self.update_mk()?;

496

},

497

      Some(Command::CleanCache) => {

498

        mk_lib::cache::CacheStore::remove_in_dir(&self.task_root.cache_base_dir())?;

499

        println!("Cache cleared");

500

},

501

      Some(Command::Schema) => {

502

1

        let schema = mk_lib::generate_schema()?;

503

1

        let schema: serde_json::Value = serde_json::from_str(&schema)?;

504

1

        Self::print_json_value(schema)?;

505

},

506

      None => {

507

3

        if let Some(task_name) = &self.args.task_name {

508

3

          self.run_task(task_name, false, false)?;

509

        } else {

510

          anyhow::bail!("No subcommand or task name provided. Use `--help` flag for more information.");

511

512

},

513

514

515

26

    Ok(())

516

43

517

518

10

  fn print_json<T: Serialize>(value: &T) -> anyhow::Result<()> {

519

10

    Self::print_json_value(serde_json::to_value(value)?)

520

10

521

522

11

  fn print_json_value(value: serde_json::Value) -> anyhow::Result<()> {

523

11

    let value = Self::canonicalize_json(value);

524

11

    println!("{}", serde_json::to_string_pretty(&value)?);

525

11

    Ok(())

526

11

527

528

817

  fn canonicalize_json(value: serde_json::Value) -> serde_json::Value {

529

817

    match value {

530

107

      serde_json::Value::Array(items) => {

531

107

        serde_json::Value::Array(items.into_iter().map(Self::canonicalize_json).collect::<Vec<_>>())

532

},

533

235

      serde_json::Value::Object(map) => {

534

235

        let mut entries = map.into_iter().collect::<Vec<_>>();

535

832

        entries.sort_by(|left, right| left.0.cmp(&right.0));

536

235

        let mut canonical = serde_json::Map::new();

537

624

        for (key, value) in entries {

538

624

          canonical.insert(key, Self::canonicalize_json(value));

539

624

540

235

        serde_json::Value::Object(canonical)

541

},

542

475

      other => other,

543

544

817

545

546

1

  fn update_mk(&self) -> anyhow::Result<()> {

547

1

    println!("Checking for updates...");

548

1

    let current_version = VERSION.as_str();

549

1

    println!("Current version: {}", current_version);

550

551

    // Extract semver without git hash

552

1

    let current_semver = current_version.split_whitespace().next().unwrap_or("0.0.0");

553

554

    // GitHub API endpoint for latest release

555

1

    let client = Self::build_update_client(Self::update_connect_timeout(), Self::update_request_timeout())?;

556

1

    let latest_version = Self::fetch_latest_version(&client, &Self::update_latest_release_url())?;

557

558

    // Compare using semver for accurate ordering

559

    match (

560

      semver::Version::parse(&latest_version),

561

      semver::Version::parse(current_semver),

562

) {

563

      (Result::Ok(latest_v), Result::Ok(current_v)) => {

564

        if latest_v <= current_v {

565

          println!("You are using the latest version.");

566

        } else {

567

          println!(

568

            "New version {} is available (you have {})",

569

            latest_version, current_semver

570

);

571

          println!("Visit https://github.com/ffimnsr/mk-rs/releases/latest to update");

572

573

},

574

      // Fallback to simple equality check if parsing fails

575

      _ => {

576

        if latest_version == current_semver {

577

          println!("You are using the latest version.");

578

        } else {

579

          println!(

580

            "New version {} is available (you have {})",

581

            latest_version, current_semver

582

);

583

          println!("Visit https://github.com/ffimnsr/mk-rs/releases/latest to update");

584

585

},

586

587

588

    Ok(())

589

1

590

591

  /// Resolve task names from an optional explicit name or label filters.

592

  /// Returns a sorted list of matching task names.

593

19

  fn resolve_run_tasks(

594

19

    &self,

595

19

    task_name: Option<&str>,

596

19

    filters: &[LabelFilter],

597

19

  ) -> anyhow::Result<Vec<String>> {

598

19

    if let Some(name) = task_name {

599

9

      if !filters.is_empty() {

600

        anyhow::bail!("Cannot combine a task name with --label filters");

601

9

602

9

      return Ok(vec![name.to_owned()]);

603

10

604

605

10

    if filters.is_empty() {

606

5

      anyhow::bail!("Provide a task name or at least one --label filter");

607

5

608

609

5

    let matched: Vec<String> = self

610

5

      .filtered_tasks(filters)

611

5

      .into_iter()

612

6

      .map(|(name, _)| name.to_owned())

613

5

      .collect();

614

615

5

    if matched.is_empty() {

616

1

      anyhow::bail!("No tasks matched the given label filters");

617

4

618

619

4

    Ok(matched)

620

19

621

622

  fn select_run_task(&self, filters: &[LabelFilter]) -> anyhow::Result<String> {

623

    let candidates = self.task_selector_candidates(filters);

624

625

    if candidates.is_empty() {

626

      if filters.is_empty() {

627

        anyhow::bail!("No tasks available to select");

628

629

      anyhow::bail!("No tasks matched the given label filters");

630

631

632

    if candidates.len() == 1 {

633

      return Ok(candidates[0].name.clone());

634

635

636

    FuzzyTaskSelector::select(&candidates)

637

638

639

  /// Run the specified tasks

640

10

  fn run_task(&self, task_name: &str, force: bool, json_events: bool) -> anyhow::Result<()> {

641

10

    assert!(!task_name.is_empty());

642

10

    let context = TaskContext::new_with_options(self.task_root.clone(), force, json_events);

643

10

    run_task_by_name(&context, task_name)

644

10

645

646

  /// Build contents of new task config, including auto-detected integrations.

647

  fn build_init_contents(config_path: &Path) -> anyhow::Result<String> {

648

    let format = InitTemplateFormat::from_path(config_path)?;

649

    let cwd = std::env::current_dir().unwrap_or_default();

650

    let has_cargo = cwd.join("Cargo.toml").exists();

651

    let has_npm = cwd.join("package.json").exists();

652

    Ok(format.render(has_cargo, has_npm))

653

654

655

6

  fn ensure_init_path_supported(config_path: &Path) -> anyhow::Result<()> {

656

6

    let _ = InitTemplateFormat::from_path(config_path)?;

657

5

    Ok(())

658

6

659

660

2

  fn update_connect_timeout() -> Duration {

661

2

    Duration::from_secs(3)

662

2

663

664

2

  fn update_request_timeout() -> Duration {

665

2

    Duration::from_secs(10)

666

2

667

668

2

  fn update_latest_release_url() -> String {

669

2

    env::var("MK_UPDATE_URL")

670

2

      .unwrap_or_else(|_| String::from("https://api.github.com/repos/ffimnsr/mk-rs/releases/latest"))

671

2

672

673

3

  fn build_update_client(connect_timeout: Duration, request_timeout: Duration) -> anyhow::Result<Client> {

674

3

    Client::builder()

675

3

      .connect_timeout(connect_timeout)

676

3

      .timeout(request_timeout)

677

3

      .redirect(Policy::limited(10))

678

3

      .build()

679

3

      .context("Failed to build update client")

680

3

681

682

3

  fn fetch_latest_version(client: &Client, url: &str) -> anyhow::Result<String> {

683

3

    let resp = client

684

3

      .get(url)

685

3

      .header(USER_AGENT, format!("mk-rs/{}", VERSION.as_str()))

686

3

      .header(ACCEPT, "application/vnd.github+json")

687

3

      .send()

688

3

      .context("Failed to check for updates. Network unavailable or request timed out")?;

689

690

1

    let status = resp.status();

691

1

    let headers = resp.headers().clone();

692

1

    let body = resp.text().context("Failed to read update response body")?;

693

694

1

    if !status.is_success() {

695

1

      anyhow::bail!(Self::format_update_error(url, status, &headers, &body));

696

697

698

    let release: GitHubRelease = serde_json::from_str(&body).context("Invalid update response payload")?;

699

    let latest_version = release.tag_name.trim_start_matches('v').to_owned();

700

701

    Ok(latest_version)

702

3

703

704

1

  fn format_update_error(url: &str, status: StatusCode, headers: &HeaderMap, body: &str) -> String {

705

1

    let mut details = Vec::new();

706

707

1

    if let Ok(api_error) = serde_json::from_str::<GitHubApiError>(body) {

708

1

      if let Some(message) = api_error.message.filter(|message| !message.is_empty()) {

709

1

        details.push(message);

710

1

711

1

      if let Some(documentation_url) = api_error.documentation_url.filter(|url| !url.is_empty()) {

712

1

        details.push(format!("docs: {}", documentation_url));

713

1

714

    } else {

715

      let snippet = body.trim();

716

      if !snippet.is_empty() {

717

        let snippet = if snippet.len() > 240 {

718

          format!("{}...", &snippet[..240])

719

        } else {

720

          snippet.to_string()

721

};

722

        details.push(format!("body: {}", snippet));

723

724

725

726

1

    if let Some(reset) = headers

727

1

      .get("x-ratelimit-reset")

728

1

      .and_then(|value| value.to_str().ok())

729

1

730

1

      details.push(format!("rate limit reset: {}", reset));

731

1

732

733

1

    let reason = status.canonical_reason().unwrap_or("Unknown Status");

734

1

    if details.is_empty() {

735

      format!(

736

        "Failed to check for updates via {}: HTTP {} {}",

737

        url,

738

        status.as_u16(),

739

        reason

740

741

    } else {

742

1

      format!(

743

        "Failed to check for updates via {}: HTTP {} {} ({})",

744

        url,

745

1

        status.as_u16(),

746

        reason,

747

1

        details.join("; ")

748

749

750

1

751

752

16

  fn sorted_tasks(&self) -> Vec<(&str, &Task)> {

753

16

    let mut tasks = self

754

16

      .task_root

755

16

      .tasks

756

16

      .iter()

757

35

      .map(|(name, task)| (name.as_str(), task))

758

16

      .collect::<Vec<_>>();

759

26

    tasks.sort_unstable_by(|left, right| left.0.cmp(right.0));

760

16

    tasks

761

16

762

763

16

  fn filtered_tasks<'a>(&'a self, filters: &[LabelFilter]) -> Vec<(&'a str, &'a Task)> {

764

16

    if filters.is_empty() {

765

7

      return self.sorted_tasks();

766

9

767

9

    self

768

9

      .sorted_tasks()

769

9

      .into_iter()

770

22

      .filter(|(_, task)| match task {

771

22

        Task::Task(t) => matches_all(filters, &t.labels),

772

        // string shorthand tasks have no labels — never match a label filter

773

        Task::String(_) => false,

774

22

})

775

9

      .collect()

776

16

777

778

1

  fn task_selector_candidates(&self, filters: &[LabelFilter]) -> Vec<TaskSelectorCandidate> {

779

1

    self

780

1

      .filtered_tasks(filters)

781

1

      .into_iter()

782

1

      .map(|(name, task)| TaskSelectorCandidate {

783

1

        name: name.to_owned(),

784

        description: match task {

785

          Task::Task(task) if !task.description.is_empty() => task.description.clone(),

786

1

          _ => String::from("No description provided"),

787

},

788

1

})

789

1

      .collect()

790

1

791

792

  /// Print all available tasks

793

10

  fn print_available_tasks(

794

10

    &self,

795

10

    plain: bool,

796

10

    json: bool,

797

10

    no_color: bool,

798

10

    filters: &[LabelFilter],

799

10

  ) -> anyhow::Result<()> {

800

10

    if json {

801

4

      let tasks: Vec<_> = self

802

4

        .filtered_tasks(filters)

803

4

        .into_iter()

804

8

        .map(|(name, task)| {

805

8

          if let Task::Task(task) = task {

806

8

            let mut labels: Vec<_> = task.labels.iter().collect();

807

8

            labels.sort_by_key(|(k, _)| k.as_str());

808

8

            let labels_obj: serde_json::Map<String, serde_json::Value> = labels

809

8

              .into_iter()

810

8

              .map(|(k, v)| (k.clone(), serde_json::Value::String(v.clone())))

811

8

              .collect();

812

8

            serde_json::json!({

813

8

              "description": task.description,

814

8

              "labels": labels_obj,

815

8

              "name": name,

816

})

817

          } else {

818

            serde_json::json!({

819

              "description": "No description provided",

820

              "labels": {},

821

              "name": name,

822

})

823

824

8

})

825

4

        .collect();

826

4

      Self::print_json(&tasks)?;

827

    } else {

828

6

      let mut table = Table::new();

829

6

      if !plain {

830

2

        table.set_titles(row![Fbb->"Task", Fbb->"Description"]);

831

832

2

        let use_color = !no_color && std::io::stdout().is_terminal();

833

2

        println!();

834

2

        if use_color {

835

          println!("{}", style("Available tasks:").bold().cyan());

836

2

        } else {

837

2

          println!("Available tasks:");

838

2

839

2

        println!();

840

4

841

6

      table.set_format(*consts::FORMAT_CLEAN);

842

843

9

      for (task_name, task) in self.filtered_tasks(filters) {

844

9

        if let Task::Task(task) = task {

845

9

          table.add_row(row![b->task_name, Fg->&task.description]);

846

9

        } else {

847

          table.add_row(row![b->task_name, Fg->"No description provided"]);

848

849

850

851

6

      table.printstd();

852

853

854

10

    Ok(())

855

10

856

857

1

  fn write_completions(&self, shell: Shell) -> anyhow::Result<()> {

858

1

    let mut app = Args::command();

859

1

    let mut output = Vec::new();

860

1

    clap_complete::generate(shell, &mut app, "mk", &mut output);

861

1

    let script = String::from_utf8(output).context("Generated completion script was not valid UTF-8")?;

862

1

    print!("{}", Self::augment_completion_script(shell, &script));

863

864

1

    Ok(())

865

1

866

867

1

  fn augment_completion_script(shell: Shell, script: &str) -> String {

868

1

    match shell {

869

1

      Shell::Bash => Self::augment_bash_completion(script),

870

      Shell::Fish => Self::augment_fish_completion(script),

871

      Shell::Zsh => Self::augment_zsh_completion(script),

872

      _ => script.to_owned(),

873

874

1

875

876

1

  fn augment_bash_completion(script: &str) -> String {

877

1

    let static_script = script.replacen("_mk() {", "_mk_clap_static() {", 1);

878

1

    format!(

879

      r#"{static_script}

880

881

__mk_complete_tasks() {{

882

    local cur="$1"

883

    local cmd="$2"

884

    local -a config_args=()

885

    local i=1

886

887

    while (( i < COMP_CWORD )); do

888

        local word="${{COMP_WORDS[i]}}"

889

        case "$word" in

890

            -c|--config)

891

                if (( i + 1 < ${{#COMP_WORDS[@]}} )); then

892

                    config_args+=("$word" "${{COMP_WORDS[i + 1]}}")

893

                    ((i+=2))

894

                    continue

895

fi

896

;;

897

            --config=*)

898

                config_args+=("$word")

899

;;

900

        esac

901

        ((i+=1))

902

    done

903

904

    MK_COMPLETE_TASKS=1 MK_COMPLETE_PREFIX="$cur" "$cmd" "${{config_args[@]}}" 2>/dev/null

905

}}

906

907

__mk_should_complete_task() {{

908

    local mode="top"

909

    local expect_value=0

910

    local i=1

911

912

    while (( i < COMP_CWORD )); do

913

        local word="${{COMP_WORDS[i]}}"

914

915

        if (( expect_value )); then

916

            expect_value=0

917

            ((i+=1))

918

            continue

919

fi

920

921

        case "$mode" in

922

            top)

923

                case "$word" in

924

                    -c|--config)

925

                        expect_value=1

926

;;

927

                    --config=*)

928

;;

929

                    -h|--help|-V|--version)

930

;;

931

                    run|r|plan)

932

                        mode="$word"

933

;;

934

                    init|list|ls|completion|comp|completions|validate|secrets|s|update|clean-cache|schema|help)

935

                        return 1

936

;;

937

-*)

938

;;

939

*)

940

                        return 1

941

;;

942

                esac

943

;;

944

            run|r)

945

                case "$word" in

946

                    --label)

947

                        expect_value=1

948

;;

949

                    --label=*|--dry-run|--force|--json-events|-h|--help|-V|--version)

950

;;

951

-*)

952

;;

953

*)

954

                        return 1

955

;;

956

                esac

957

;;

958

            plan)

959

                case "$word" in

960

                    --label)

961

                        expect_value=1

962

;;

963

                    --label=*|--json|-h|--help|-V|--version)

964

;;

965

-*)

966

;;

967

*)

968

                        return 1

969

;;

970

                esac

971

;;

972

        esac

973

974

        ((i+=1))

975

    done

976

977

    return 0

978

}}

979

980

_mk() {{

981

    _mk_clap_static "$@"

982

983

    if __mk_should_complete_task; then

984

        local cur="$2"

985

        local cmd="${{COMP_WORDS[0]}}"

986

        local candidate

987

        while IFS= read -r candidate; do

988

            [[ -n "$candidate" ]] && COMPREPLY+=("$candidate")

989

        done < <(__mk_complete_tasks "$cur" "$cmd")

990

fi

991

}}

992

"#

993

994

1

995

996

  fn augment_fish_completion(script: &str) -> String {

997

    format!(

998

      r#"{script}

999

1000

function __fish_mk_complete_tasks

1001

    set -l cmd (commandline -opc)

1002

    set -e cmd[1]

1003

1004

    set -l current (commandline -ct)

1005

    set -l mode top

1006

    set -l expect_value 0

1007

    set -l config_args

1008

1009

    for word in $cmd

1010

        if test $expect_value -eq 1

1011

            set config_args $config_args $word

1012

            set expect_value 0

1013

            continue

1014

end

1015

1016

        switch $mode

1017

            case top

1018

                switch $word

1019

                    case -c --config

1020

                        set config_args $config_args $word

1021

                        set expect_value 1

1022

                    case '--config=*'

1023

                        set config_args $config_args $word

1024

                    case -h --help -V --version

1025

                    case run r plan

1026

                        set mode $word

1027

                    case init list ls completion comp completions validate secrets s update clean-cache schema help

1028

                        return

1029

                    case '-*'

1030

                    case '*'

1031

                        return

1032

end

1033

            case run r

1034

                switch $word

1035

                    case --label

1036

                        set expect_value 1

1037

                    case '--label=*' --dry-run --force --json-events -h --help -V --version

1038

                    case '-*'

1039

                    case '*'

1040

                        return

1041

end

1042

            case plan

1043

                switch $word

1044

                    case --label

1045

                        set expect_value 1

1046

                    case '--label=*' --json -h --help -V --version

1047

                    case '-*'

1048

                    case '*'

1049

                        return

1050

end

1051

end

1052

end

1053

1054

    env MK_COMPLETE_TASKS=1 MK_COMPLETE_PREFIX="$current" command mk $config_args 2>/dev/null

1055

end

1056

1057

complete -c mk -f -a "(__fish_mk_complete_tasks)"

1058

"#

1059

1060

1061

1062

  fn augment_zsh_completion(script: &str) -> String {

1063

    let static_script = script.replacen("_mk() {", "_mk_clap_static() {", 1);

1064

    format!(

1065

      r#"{static_script}

1066

1067

function _mk_complete_tasks() {{

1068

    local cur="$1"

1069

    local -a config_args

1070

    local i=2

1071

1072

    while (( i < CURRENT )); do

1073

        local word="${{words[i]}}"

1074

        case "$word" in

1075

            -c|--config)

1076

                if (( i + 1 <= $#words )); then

1077

                    config_args+=("$word" "${{words[i + 1]}}")

1078

                    ((i+=2))

1079

                    continue

1080

fi

1081

;;

1082

            --config=*)

1083

                config_args+=("$word")

1084

;;

1085

        esac

1086

        ((i+=1))

1087

    done

1088

1089

    MK_COMPLETE_TASKS=1 MK_COMPLETE_PREFIX="$cur" "${{words[1]}}" "${{config_args[@]}}" 2>/dev/null

1090

}}

1091

1092

function _mk_should_complete_task() {{

1093

    local mode="top"

1094

    local expect_value=0

1095

    local i=2

1096

1097

    while (( i < CURRENT )); do

1098

        local word="${{words[i]}}"

1099

1100

        if (( expect_value )); then

1101

            expect_value=0

1102

            ((i+=1))

1103

            continue

1104

fi

1105

1106

        case "$mode" in

1107

            top)

1108

                case "$word" in

1109

                    -c|--config)

1110

                        expect_value=1

1111

;;

1112

                    --config=*)

1113

;;

1114

                    -h|--help|-V|--version)

1115

;;

1116

                    run|r|plan)

1117

                        mode="$word"

1118

;;

1119

                    init|list|ls|completion|comp|completions|validate|secrets|s|update|clean-cache|schema|help)

1120

                        return 1

1121

;;

1122

-*)

1123

;;

1124

*)

1125

                        return 1

1126

;;

1127

                esac

1128

;;

1129

            run|r)

1130

                case "$word" in

1131

                    --label)

1132

                        expect_value=1

1133

;;

1134

                    --label=*|--dry-run|--force|--json-events|-h|--help|-V|--version)

1135

;;

1136

-*)

1137

;;

1138

*)

1139

                        return 1

1140

;;

1141

                esac

1142

;;

1143

            plan)

1144

                case "$word" in

1145

                    --label)

1146

                        expect_value=1

1147

;;

1148

                    --label=*|--json|-h|--help|-V|--version)

1149

;;

1150

-*)

1151

;;

1152

*)

1153

                        return 1

1154

;;

1155

                esac

1156

;;

1157

        esac

1158

1159

        ((i+=1))

1160

    done

1161

1162

    return 0

1163

}}

1164

1165

function _mk() {{

1166

    _mk_clap_static "$@"

1167

1168

    if _mk_should_complete_task; then

1169

        local -a task_candidates

1170

        task_candidates=(${{(@f)$(_mk_complete_tasks "$PREFIX")}})

1171

        (( $#task_candidates )) && compadd -a task_candidates

1172

fi

1173

}}

1174

"#

1175

1176

1177

1178

8

  fn validate_config(&self, json: bool) -> anyhow::Result<()> {

1179

8

    let report = self.task_root.validate();

1180

8

    if json {

1181

2

      Self::print_json(&report)?;

1182

6

    } else if report.has_errors() {

1183

5

      println!("Validation failed");

1184

5

      println!();

1185

5

      for issue in &report.issues {

1186

5

        let task = issue

1187

5

          .task

1188

5

          .as_ref()

1189

5

          .map(|task| format!(" task={}", task))

1190

5

          .unwrap_or_default();

1191

5

        let field = issue

1192

5

          .field

1193

5

          .as_ref()

1194

5

          .map(|field| format!(" field={}", field))

1195

5

          .unwrap_or_default();

1196

5

        println!(

1197

          "{}{}{}",

1198

5

          match issue.severity {

1199

5

            mk_lib::schema::ValidationSeverity::Error => "ERROR",

1200

            mk_lib::schema::ValidationSeverity::Warning => "WARNING",

1201

},

1202

          task,

1203

          field

1204

);

1205

5

        println!("  {}", issue.message);

1206

1207

    } else {

1208

1

      println!("Validation passed");

1209

1

      if !report.issues.is_empty() {

1210

        println!();

1211

1

1212

1

      for issue in &report.issues {

1213

        let task = issue

1214

          .task

1215

          .as_ref()

1216

          .map(|task| format!(" task={}", task))

1217

          .unwrap_or_default();

1218

        let field = issue

1219

          .field

1220

          .as_ref()

1221

          .map(|field| format!(" field={}", field))

1222

          .unwrap_or_default();

1223

        println!(

1224

          "{}{}{}",

1225

          match issue.severity {

1226

            mk_lib::schema::ValidationSeverity::Error => "ERROR",

1227

            mk_lib::schema::ValidationSeverity::Warning => "WARNING",

1228

},

1229

          task,

1230

          field

1231

);

1232

        println!("  {}", issue.message);

1233

1234

1235

1236

8

    if report.has_errors() {

1237

7

      anyhow::bail!("Validation failed");

1238

1

1239

1240

1

    Ok(())

1241

8

1242

1243

8

  fn print_plan(&self, task_name: &str, json: bool) -> anyhow::Result<()> {

1244

8

    let plan = self.task_root.plan_task(task_name)?;

1245

8

    if json {

1246

4

      Self::print_json(&plan)?;

1247

4

    } else {

1248

4

      self.print_plan_text(&plan);

1249

4

1250

8

    Ok(())

1251

8

1252

1253

4

  fn print_plan_text(&self, plan: &TaskPlan) {

1254

4

    println!("Plan for task: {}", plan.root_task);

1255

4

    println!();

1256

1257

5

    for (index, step) in plan.steps.iter().enumerate() {

1258

5

      println!("{}. {}", index + 1, step.name);

1259

5

      println!("   base_dir: {}", step.base_dir);

1260

5

      if let Some(description) = &step.description {

1261

2

        if !description.is_empty() {

1262

2

          println!("   description: {}", description);

1263

2

1264

3

1265

5

      println!(

1266

        "   mode: {}",

1267

5

        match step.execution_mode {

1268

5

          mk_lib::schema::PlannedExecutionMode::Sequential => "sequential",

1269

          mk_lib::schema::PlannedExecutionMode::Parallel => "parallel",

1270

1271

);

1272

5

      if !step.dependencies.is_empty() {

1273

1

        println!("   depends_on: {}", step.dependencies.join(", "));

1274

4

1275

5

      for command in &step.commands {

1276

5

        println!("   {}", command.summary());

1277

5

1278

5

      if let Some(reason) = &step.skipped_reason {

1279

        println!("   skip: {}", reason);

1280

5

1281

5

      println!();

1282

1283

4

1284

1285

1286

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

1287

enum InitTemplateFormat {

1288

  Yaml,

1289

  Toml,

1290

  Json,

1291

  Lua,

1292

1293

1294

impl InitTemplateFormat {

1295

6

  fn from_path(config_path: &Path) -> anyhow::Result<Self> {

1296

6

    match config_path.extension().and_then(|ext| ext.to_str()) {

1297

6

      Some("yaml") | Some("yml") | None => Ok(Self::Yaml),

1298

4

      Some("toml") => Ok(Self::Toml),

1299

3

      Some("json") => Ok(Self::Json),

1300

2

      Some("lua") => Ok(Self::Lua),

1301

1

      Some(ext) => anyhow::bail!(

1302

        "Unsupported `mk init` output extension .{}. Supported formats: .yaml, .yml, .toml, .json, .lua",

1303

ext

1304

),

1305

1306

6

1307

1308

  fn render(self, has_cargo: bool, has_npm: bool) -> String {

1309

    match self {

1310

      Self::Yaml => self.render_yaml(has_cargo, has_npm),

1311

      Self::Toml => self.render_toml(has_cargo, has_npm),

1312

      Self::Json => self.render_json(has_cargo, has_npm),

1313

      Self::Lua => self.render_lua(has_cargo, has_npm),

1314

1315

1316

1317

  fn render_yaml(self, has_cargo: bool, has_npm: bool) -> String {

1318

    let mut out = String::new();

1319

    out.push_str("# yaml-language-server: $schema=");

1320

    out.push_str(INIT_SCHEMA_URL);

1321

    out.push('\n');

1322

    out.push('\n');

1323

    self.push_shared_flags(&mut out, has_cargo, has_npm, "", ": true\n", '\n');

1324

    out.push_str("tasks:\n");

1325

    out.push_str("  greet:\n");

1326

    out.push_str("    commands:\n");

1327

    out.push_str("      - echo \"Hello, World!\"\n");

1328

    out.push_str("    description: Sample greet command\n");

1329

out

1330

1331

1332

  fn render_toml(self, has_cargo: bool, has_npm: bool) -> String {

1333

    let mut out = String::new();

1334

    self.push_shared_flags(&mut out, has_cargo, has_npm, "", " = true\n", '\n');

1335

    out.push_str("[tasks.greet]\n");

1336

    out.push_str("commands = [\"echo \\\"Hello, World!\\\"\"]\n");

1337

    out.push_str("description = \"Sample greet command\"\n");

1338

out

1339

1340

1341

  fn render_json(self, has_cargo: bool, has_npm: bool) -> String {

1342

    let mut lines = Vec::new();

1343

    lines.push("{".to_string());

1344

    if has_cargo {

1345

      lines.push("  \"use_cargo\": true,".to_string());

1346

1347

    if has_npm {

1348

      lines.push("  \"use_npm\": true,".to_string());

1349

1350

    lines.push("  \"tasks\": {".to_string());

1351

    lines.push("    \"greet\": {".to_string());

1352

    lines.push("      \"commands\": [\"echo \\\"Hello, World!\\\"\"],".to_string());

1353

    lines.push("      \"description\": \"Sample greet command\"".to_string());

1354

    lines.push("    }".to_string());

1355

    lines.push("  }".to_string());

1356

    lines.push("}".to_string());

1357

    lines.join("\n")

1358

1359

1360

  fn render_lua(self, has_cargo: bool, has_npm: bool) -> String {

1361

    let mut out = String::new();

1362

    out.push_str("return {\n");

1363

    self.push_shared_flags(&mut out, has_cargo, has_npm, "  ", " = true,\n", '\0');

1364

    out.push_str("  tasks = {\n");

1365

    out.push_str("    greet = {\n");

1366

    out.push_str("      commands = { \"echo \\\"Hello, World!\\\"\" },\n");

1367

    out.push_str("      description = \"Sample greet command\"\n");

1368

    out.push_str("    }\n");

1369

    out.push_str("  }\n");

1370

    out.push_str("}\n");

1371

out

1372

1373

1374

  fn push_shared_flags(

1375

    self,

1376

    out: &mut String,

1377

    has_cargo: bool,

1378

    has_npm: bool,

1379

    prefix: &str,

1380

    suffix: &str,

1381

    separator: char,

1382

) {

1383

    if has_cargo {

1384

      out.push_str(prefix);

1385

      out.push_str("use_cargo");

1386

      out.push_str(suffix);

1387

1388

    if has_npm {

1389

      out.push_str(prefix);

1390

      out.push_str("use_npm");

1391

      out.push_str(suffix);

1392

1393

    if (has_cargo || has_npm) && separator != '\0' {

1394

      out.push(separator);

1395

1396

1397

1398

1399

#[derive(Debug, Deserialize)]

1400

struct GitHubRelease {

1401

  tag_name: String,

1402

1403

1404

#[derive(Debug, Deserialize)]

1405

struct GitHubApiError {

1406

  message: Option<String>,

1407

  documentation_url: Option<String>,

1408

1409

1410

#[cfg(test)]

1411

mod tests {

1412

  use super::{

1413

    Args,

1414

    CliEntry,

1415

    Command,

1416

};

1417

  use mk_lib::schema::{

1418

    Task,

1419

    TaskRoot,

1420

};

1421

  use std::io::Read as _;

1422

  use std::net::TcpListener;

1423

  use std::sync::{

1424

    mpsc,

1425

    Arc,

1426

};

1427

  use std::thread;

1428

1429

  #[test]

1430

1

  fn init_rejects_unsupported_output_paths() {

1431

1

    let err = CliEntry::ensure_init_path_supported(std::path::Path::new("mk.txt")).unwrap_err();

1432

1

    assert!(err

1433

1

      .to_string()

1434

1

      .contains("Unsupported `mk init` output extension .txt"));

1435

1

1436

1437

  #[test]

1438

1

  fn init_accepts_supported_output_paths() {

1439

1

    assert!(CliEntry::ensure_init_path_supported(std::path::Path::new("tasks.yaml")).is_ok());

1440

1

    assert!(CliEntry::ensure_init_path_supported(std::path::Path::new("tasks.yml")).is_ok());

1441

1

    assert!(CliEntry::ensure_init_path_supported(std::path::Path::new("mk.toml")).is_ok());

1442

1

    assert!(CliEntry::ensure_init_path_supported(std::path::Path::new("tasks.json")).is_ok());

1443

1

    assert!(CliEntry::ensure_init_path_supported(std::path::Path::new("tasks.lua")).is_ok());

1444

1

1445

1446

  #[test]

1447

1

  fn clean_cache_allows_missing_config() {

1448

1

    let args = Args {

1449

1

      config: String::from("tasks.yaml"),

1450

1

      task_name: None,

1451

1

      command: Some(Command::CleanCache),

1452

1

};

1453

1454

1

    let (_, allow_without_config) = CliEntry::resolve_config(&args).unwrap();

1455

1

    assert!(allow_without_config);

1456

1

1457

1458

  #[test]

1459

1

  fn update_timeouts_stay_bounded() {

1460

1

    assert_eq!(

1461

1

      CliEntry::update_connect_timeout(),

1462

1

      std::time::Duration::from_secs(3)

1463

);

1464

1

    assert_eq!(

1465

1

      CliEntry::update_request_timeout(),

1466

1

      std::time::Duration::from_secs(10)

1467

);

1468

1

1469

1470

  #[test]

1471

1

  fn update_fetch_times_out_with_clear_error() {

1472

1

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();

1473

1

    let address = listener.local_addr().unwrap();

1474

1

    let (ready_tx, ready_rx) = mpsc::channel();

1475

1476

1

    let server = thread::spawn(move || {

1477

1

      ready_tx.send(()).unwrap();

1478

1

      let (mut stream, _) = listener.accept().unwrap();

1479

1

      let mut buf = [0_u8; 1024];

1480

1

      let _ = stream.read(&mut buf);

1481

1

      thread::sleep(std::time::Duration::from_millis(250));

1482

1

});

1483

1484

1

    ready_rx.recv().unwrap();

1485

1486

1

    let client = CliEntry::build_update_client(

1487

1

      std::time::Duration::from_millis(50),

1488

1

      std::time::Duration::from_millis(100),

1489

1490

1

    .unwrap();

1491

1

    let err = CliEntry::fetch_latest_version(&client, &format!("http://{}/latest", address)).unwrap_err();

1492

1493

1

    assert!(err

1494

1

      .to_string()

1495

1

      .contains("Failed to check for updates. Network unavailable or request timed out"));

1496

1497

1

    server.join().unwrap();

1498

1

1499

1500

  #[test]

1501

1

  fn update_fetch_surfaces_api_error_details() {

1502

1

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();

1503

1

    let address = listener.local_addr().unwrap();

1504

1

    let (ready_tx, ready_rx) = mpsc::channel();

1505

1506

1

    let server = thread::spawn(move || {

1507

1

      ready_tx.send(()).unwrap();

1508

1

      let (mut stream, _) = listener.accept().unwrap();

1509

1

      let mut buf = [0_u8; 1024];

1510

1

      let _ = stream.read(&mut buf);

1511

1

      let body =

1512

1

        "{\"message\":\"API rate limit exceeded\",\"documentation_url\":\"https://docs.github.com\"}";

1513

1

      let response = format!(

1514

        concat!(

1515

          "HTTP/1.1 403 Forbidden\r\n",

1516

          "Content-Type: application/json\r\n",

1517

          "X-RateLimit-Reset: 1712345678\r\n",

1518

          "Content-Length: {}\r\n",

1519

          "\r\n",

1520

          "{}"

1521

),

1522

1

        body.len(),

1523

        body

1524

);

1525

      use std::io::Write as _;

1526

1

      stream.write_all(response.as_bytes()).unwrap();

1527

1

});

1528

1529

1

    ready_rx.recv().unwrap();

1530

1531

1

    let client = CliEntry::build_update_client(

1532

1

      std::time::Duration::from_millis(50),

1533

1

      std::time::Duration::from_millis(100),

1534

1535

1

    .unwrap();

1536

1

    let err = CliEntry::fetch_latest_version(&client, &format!("http://{}/latest", address)).unwrap_err();

1537

1

    let message = err.to_string();

1538

1539

1

    assert!(message.contains("HTTP 403 Forbidden"));

1540

1

    assert!(message.contains("API rate limit exceeded"));

1541

1

    assert!(message.contains("https://docs.github.com"));

1542

1

    assert!(message.contains("rate limit reset: 1712345678"));

1543

1544

1

    server.join().unwrap();

1545

1

1546

1547

  #[test]

1548

1

  fn update_url_can_be_overridden_for_tests() {

1549

1

    unsafe {

1550

1

      std::env::set_var("MK_UPDATE_URL", "http://127.0.0.1:9/latest");

1551

1

1552

1

    assert_eq!(CliEntry::update_latest_release_url(), "http://127.0.0.1:9/latest");

1553

1

    unsafe {

1554

1

      std::env::remove_var("MK_UPDATE_URL");

1555

1

1556

1

1557

1558

  #[test]

1559

1

  fn default_config_candidates_include_supported_formats() {

1560

1

    let candidates = CliEntry::default_config_candidates();

1561

1

    assert!(candidates.contains(&"tasks.toml"));

1562

1

    assert!(candidates.contains(&"tasks.json"));

1563

1

    assert!(candidates.contains(&"tasks.lua"));

1564

1

1565

1566

46

  fn os(s: &str) -> std::ffi::OsString {

1567

46

    std::ffi::OsString::from(s)

1568

46

1569

1570

15

  fn expand(args: &[&str]) -> Vec<String> {

1571

46

    CliEntry::expand_hydra_aliases(args.iter().map(|s| os(s)))

1572

15

      .into_iter()

1573

68

      .map(|s| s.to_string_lossy().into_owned())

1574

15

      .collect()

1575

15

1576

1577

  #[test]

1578

1

  fn hydra_svls_expands_to_secrets_vault_list_secrets() {

1579

1

    assert_eq!(

1580

1

      expand(&["mk", "svls"]),

1581

      ["mk", "secrets", "vault", "list-secrets"]

1582

);

1583

1

1584

1585

  #[test]

1586

1

  fn hydra_svl_expands_to_secrets_vault_list_secrets() {

1587

1

    assert_eq!(expand(&["mk", "svl"]), ["mk", "secrets", "vault", "list-secrets"]);

1588

1

1589

1590

  #[test]

1591

1

  fn hydra_sv_expands_to_secrets_vault_prefix() {

1592

1

    assert_eq!(

1593

1

      expand(&["mk", "sv", "show", "mykey"]),

1594

      ["mk", "secrets", "vault", "show", "mykey"]

1595

);

1596

1

1597

1598

  #[test]

1599

1

  fn hydra_svi_expands_to_secrets_vault_init_vault() {

1600

1

    assert_eq!(expand(&["mk", "svi"]), ["mk", "secrets", "vault", "init-vault"]);

1601

1

1602

1603

  #[test]

1604

1

  fn hydra_svst_expands_to_secrets_vault_store_secret() {

1605

1

    assert_eq!(

1606

1

      expand(&["mk", "svst", "app/token", "value"]),

1607

      ["mk", "secrets", "vault", "store-secret", "app/token", "value"]

1608

);

1609

1

1610

1611

  #[test]

1612

1

  fn hydra_svsh_expands_to_secrets_vault_show_secret() {

1613

1

    assert_eq!(

1614

1

      expand(&["mk", "svsh", "app/token"]),

1615

      ["mk", "secrets", "vault", "show-secret", "app/token"]

1616

);

1617

1

1618

1619

  #[test]

1620

1

  fn hydra_svp_expands_to_secrets_vault_purge_secret() {

1621

1

    assert_eq!(

1622

1

      expand(&["mk", "svp", "app/token"]),

1623

      ["mk", "secrets", "vault", "purge-secret", "app/token"]

1624

);

1625

1

1626

1627

  #[test]

1628

1

  fn hydra_sve_expands_to_secrets_vault_export_secret() {

1629

1

    assert_eq!(

1630

1

      expand(&["mk", "sve", "app/token", "--output", "out.txt"]),

1631

1632

        "mk",

1633

        "secrets",

1634

        "vault",

1635

        "export-secret",

1636

        "app/token",

1637

        "--output",

1638

        "out.txt"

1639

1640

);

1641

1

1642

1643

  #[test]

1644

1

  fn hydra_sk_expands_to_secrets_key() {

1645

1

    assert_eq!(

1646

1

      expand(&["mk", "sk", "generate-key"]),

1647

      ["mk", "secrets", "key", "generate-key"]

1648

);

1649

1

1650

1651

  #[test]

1652

1

  fn hydra_slk_expands_to_secrets_list_keys() {

1653

1

    assert_eq!(expand(&["mk", "slk"]), ["mk", "secrets", "list-keys"]);

1654

1

1655

1656

  #[test]

1657

1

  fn hydra_sd_expands_to_secrets_doctor() {

1658

1

    assert_eq!(expand(&["mk", "sd"]), ["mk", "secrets", "doctor"]);

1659

1

1660

1661

  #[test]

1662

1

  fn hydra_si_expands_to_secrets_init_vault() {

1663

1

    assert_eq!(expand(&["mk", "si"]), ["mk", "secrets", "init-vault"]);

1664

1

1665

1666

  #[test]

1667

1

  fn hydra_se_expands_to_secrets_export_secret() {

1668

1

    assert_eq!(

1669

1

      expand(&["mk", "se", "app/token", "--output", "out.txt"]),

1670

1671

        "mk",

1672

        "secrets",

1673

        "export-secret",

1674

        "app/token",

1675

        "--output",

1676

        "out.txt"

1677

1678

);

1679

1

1680

1681

  #[test]

1682

1

  fn hydra_config_flag_preserved_before_hydra_token() {

1683

1

    assert_eq!(

1684

1

      expand(&["mk", "-c", "my.yaml", "svls"]),

1685

      ["mk", "-c", "my.yaml", "secrets", "vault", "list-secrets"]

1686

);

1687

1

1688

1689

  #[test]

1690

1

  fn hydra_unknown_token_passes_through_unchanged() {

1691

1

    assert_eq!(expand(&["mk", "run", "my-task"]), ["mk", "run", "my-task"]);

1692

1

1693

1694

  #[test]

1695

1

  fn task_selector_candidates_use_description_fallback() {

1696

1

    let mut task_root = TaskRoot::default();

1697

1

    task_root

1698

1

      .tasks

1699

1

      .insert(String::from("plain"), Task::String(String::from("echo plain")));

1700

1

    let cli = CliEntry {

1701

1

      args: Args {

1702

1

        config: String::from("tasks.yaml"),

1703

1

        task_name: None,

1704

1

        command: None,

1705

1

},

1706

1

      task_root: Arc::new(task_root),

1707

1

};

1708

1709

1

    let candidates = cli.task_selector_candidates(&[]);

1710

1

    assert_eq!(candidates.len(), 1);

1711

1

    assert_eq!(candidates[0].name, "plain");

1712

1

    assert_eq!(candidates[0].description, "No description provided");

1713

1

1714