@yolo-labs/yolo-cli 0.41.0 → 0.42.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.js CHANGED
@@ -21,17 +21,7 @@
21
21
  */
22
22
  import { readSessionContext, formatContext, ContextResolutionError } from './context.js';
23
23
  import { validatePlanFile, formatErrors } from './plan-validate.js';
24
- import { runPlanImport, formatSuccess as formatImportSuccess, exitCodeForFailure as importExitCode, } from './plan-import.js';
25
- import { runPlanExport, formatSuccess as formatExportSuccess, exitCodeForFailure as exportExitCode, } from './plan-export.js';
26
- import { runPlanStateTransition, formatSuccess as formatStateSuccess, exitCodeForFailure as stateExitCode, } from './plan-state.js';
27
- import { runPlanGet, exitCodeForFailure as getExitCode, } from './plan-get.js';
28
- import { runPlanOpen, exitCodeForFailure as openExitCode, } from './plan-open.js';
29
- import { runPlanList, exitCodeForFailure as listExitCode, } from './plan-list.js';
30
- import { runRunStart, exitCodeForFailure as runStartExitCode, } from './run-start.js';
31
- import { runRunLifecycle, exitCodeForFailure as runLifecycleExitCode, } from './run-lifecycle.js';
32
- import { runRunGet, exitCodeForFailure as runGetExitCode, } from './run-get.js';
33
24
  import { runRunList, exitCodeForFailure as runListExitCode, } from './run-list.js';
34
- import { runRunTransfer, exitCodeForFailure as runTransferExitCode, } from './run-transfer.js';
35
25
  import { runArtifactGet, exitCodeForFailure as artifactGetExitCode, } from './artifact-get.js';
36
26
  import { runArtifactList, exitCodeForFailure as artifactListExitCode, } from './artifact-list.js';
37
27
  import { runTileAppSign, runTileAppPublish, exitCodeForFailure as tileAppExitCode, } from './tileapp-publisher.js';
@@ -66,54 +56,10 @@ function printHelp() {
66
56
  'Commands:',
67
57
  ' context Print resolved session/workspace/API context.',
68
58
  ' plan validate <file> Validate a .yolo/plans/<slug>.md plan file (offline).',
69
- ' plan import <file> [opts] Import file → DB (work.create_plan / update_plan).',
70
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
71
- ' [--lockfile <name>] Use .imports.<name>.json instead of the gitignored default.',
72
- ' [--force] Override divergence (DB ahead of lockfile) or 409 on create.',
73
- ' [--json] Emit the result as JSON (for scripting).',
74
- ' plan export <planId> [opts] Export DB → file (work.get_plan + canonicalize).',
75
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
76
- ' [--lockfile <name>] Refresh .imports.<name>.json instead of the default.',
77
- ' [-o <file>] Output path. Default: <plansDir>/<planId>.md.',
78
- ' [--json] Emit the result as JSON.',
79
- ' plan activate <planId> [opts] Transition Plan.state → active (work.update_plan).',
80
- ' plan archive <planId> [opts] Transition Plan.state → archived (work.update_plan).',
81
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
82
- ' [--lockfile <name>] Refresh .imports.<name>.json lockfile entry post-update.',
83
- ' [--json] Emit the result as JSON.',
84
- ' plan get <planId> [opts] Read a Plan from the DB (work.get_plan, no file write).',
85
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
86
- ' [--waves] Group steps by topological wave (parallel-execution view).',
87
- ' [--json] Pretty-print raw JSON instead of the summary.',
88
- ' plan list [opts] List Plans in the current workspace (work.list_plans).',
89
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
90
- ' [--state <draft|active|archived>] Server-side Plan.state filter.',
91
- ' [--json] Pretty-print raw JSON instead of the table.',
92
- ' plan open <planId> [opts] Print the Plan-DAG URL for the given Plan (no Run).',
93
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
94
- ' [--json] Emit {planId, workspaceId, url} as JSON.',
95
- ' run start <planId> [opts] Bootstrap a Plan Run (work.start_run).',
96
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
97
- ' [--inputs <json>] JSON object of Plan inputs. Default: {}.',
98
- ' [--json] Emit the response as JSON.',
99
- ' run get <runId> [opts] Read a Plan Run (work.get_run, no mutation).',
100
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
101
- ' [--json] Pretty-print raw JSON instead of the summary.',
102
59
  ' run list [opts] List Plan Runs in the current workspace (work.list_runs).',
103
60
  ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
104
61
  ' [--state <pending|running|paused|...>] Server-side executionState filter.',
105
62
  ' [--json] Pretty-print raw JSON instead of the table.',
106
- ' run pause <runId> [opts] Pause a running Plan Run.',
107
- ' run resume <runId> [opts] Resume a paused Plan Run.',
108
- ' run cancel <runId> [opts] Cancel a Plan Run.',
109
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
110
- ' [--reason <text>] Optional reason (pause/cancel only). ≤1024 chars.',
111
- ' [--json] Emit the response as JSON.',
112
- ' run transfer <runId> [opts] Reassign the Operator (work.transfer_run_operator).',
113
- ' --to <agentId> Target Operator (Operator-tier: claude, codex).',
114
- ' --user-driven Transfer to user-driven (operatorAgentId=null). Mutex with --to.',
115
- ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
116
- ' [--json] Emit the response as JSON.',
117
63
  ' artifact get <key> [opts] Read a workspace artifact (work.get_artifact).',
118
64
  ' [--version <n>] Pin to a specific version. Default: latest.',
119
65
  ' [--workspace <wsId>] Sanity-check the workspace bound to this session.',
@@ -199,555 +145,6 @@ function runPlanValidate(args) {
199
145
  process.stderr.write(`${formatErrors(result.errors)}\n`);
200
146
  return 1;
201
147
  }
202
- function parseImportArgs(args) {
203
- let filePath;
204
- let workspaceFlag;
205
- let lockfileFlag;
206
- let force = false;
207
- let jsonOutput = false;
208
- for (let i = 0; i < args.length; i++) {
209
- const a = args[i];
210
- if (a === '--workspace') {
211
- const v = args[++i];
212
- if (!v || v.startsWith('--'))
213
- return { ok: false, message: '--workspace requires a value' };
214
- workspaceFlag = v;
215
- }
216
- else if (a.startsWith('--workspace=')) {
217
- workspaceFlag = a.slice('--workspace='.length);
218
- }
219
- else if (a === '--lockfile') {
220
- const v = args[++i];
221
- if (!v || v.startsWith('--'))
222
- return { ok: false, message: '--lockfile requires a value' };
223
- lockfileFlag = v;
224
- }
225
- else if (a.startsWith('--lockfile=')) {
226
- lockfileFlag = a.slice('--lockfile='.length);
227
- }
228
- else if (a === '--force') {
229
- force = true;
230
- }
231
- else if (a === '--json') {
232
- jsonOutput = true;
233
- }
234
- else if (a.startsWith('--')) {
235
- return { ok: false, message: `unknown option: ${a}` };
236
- }
237
- else if (!filePath) {
238
- filePath = a;
239
- }
240
- else {
241
- return { ok: false, message: `unexpected positional argument: ${a}` };
242
- }
243
- }
244
- if (!filePath)
245
- return { ok: false, message: 'plan import requires a file path' };
246
- return { ok: true, filePath, workspaceFlag, lockfileFlag, force, jsonOutput };
247
- }
248
- async function runPlanImportCmd(args) {
249
- const parsed = parseImportArgs(args);
250
- if (!parsed.ok) {
251
- process.stderr.write(`yolo: ${parsed.message}\n`);
252
- process.stderr.write('Usage: yolo plan import <file> [--workspace <wsId>] [--lockfile <name>] [--force] [--json]\n');
253
- return 64;
254
- }
255
- const result = await runPlanImport({
256
- filePath: parsed.filePath,
257
- workspaceFlag: parsed.workspaceFlag,
258
- lockfileFlag: parsed.lockfileFlag,
259
- force: parsed.force,
260
- });
261
- if (result.ok) {
262
- process.stdout.write(`${parsed.jsonOutput ? formatJsonResult(result) : formatImportSuccess(result)}\n`);
263
- return 0;
264
- }
265
- process.stderr.write(parsed.jsonOutput ? `${formatJsonResult(result)}\n` : `FAIL [${result.kind}]: ${result.message}\n`);
266
- return importExitCode(result.kind);
267
- }
268
- function parseExportArgs(args) {
269
- let planId;
270
- let workspaceFlag;
271
- let lockfileFlag;
272
- let outputFlag;
273
- let jsonOutput = false;
274
- for (let i = 0; i < args.length; i++) {
275
- const a = args[i];
276
- if (a === '--workspace') {
277
- const v = args[++i];
278
- if (!v || v.startsWith('--'))
279
- return { ok: false, message: '--workspace requires a value' };
280
- workspaceFlag = v;
281
- }
282
- else if (a.startsWith('--workspace=')) {
283
- workspaceFlag = a.slice('--workspace='.length);
284
- }
285
- else if (a === '--lockfile') {
286
- const v = args[++i];
287
- if (!v || v.startsWith('--'))
288
- return { ok: false, message: '--lockfile requires a value' };
289
- lockfileFlag = v;
290
- }
291
- else if (a.startsWith('--lockfile=')) {
292
- lockfileFlag = a.slice('--lockfile='.length);
293
- }
294
- else if (a === '-o' || a === '--output') {
295
- const v = args[++i];
296
- if (!v || v.startsWith('--'))
297
- return { ok: false, message: '-o requires a value' };
298
- outputFlag = v;
299
- }
300
- else if (a.startsWith('--output=')) {
301
- outputFlag = a.slice('--output='.length);
302
- }
303
- else if (a === '--json') {
304
- jsonOutput = true;
305
- }
306
- else if (a.startsWith('--')) {
307
- return { ok: false, message: `unknown option: ${a}` };
308
- }
309
- else if (!planId) {
310
- planId = a;
311
- }
312
- else {
313
- return { ok: false, message: `unexpected positional argument: ${a}` };
314
- }
315
- }
316
- if (!planId)
317
- return { ok: false, message: 'plan export requires a planId' };
318
- return { ok: true, planId, workspaceFlag, lockfileFlag, outputFlag, jsonOutput };
319
- }
320
- async function runPlanExportCmd(args) {
321
- const parsed = parseExportArgs(args);
322
- if (!parsed.ok) {
323
- process.stderr.write(`yolo: ${parsed.message}\n`);
324
- process.stderr.write('Usage: yolo plan export <planId> [--workspace <wsId>] [--lockfile <name>] [-o <file>] [--json]\n');
325
- return 64;
326
- }
327
- const result = await runPlanExport({
328
- planId: parsed.planId,
329
- workspaceFlag: parsed.workspaceFlag,
330
- lockfileFlag: parsed.lockfileFlag,
331
- outputFlag: parsed.outputFlag,
332
- });
333
- if (result.ok) {
334
- process.stdout.write(`${parsed.jsonOutput ? formatJsonResult(result) : formatExportSuccess(result)}\n`);
335
- return 0;
336
- }
337
- process.stderr.write(parsed.jsonOutput ? `${formatJsonResult(result)}\n` : `FAIL [${result.kind}]: ${result.message}\n`);
338
- return exportExitCode(result.kind);
339
- }
340
- function parseStateArgs(args) {
341
- let planId;
342
- let workspaceFlag;
343
- let lockfileFlag;
344
- let jsonOutput = false;
345
- for (let i = 0; i < args.length; i++) {
346
- const a = args[i];
347
- if (a === '--workspace') {
348
- const v = args[++i];
349
- if (!v || v.startsWith('--'))
350
- return { ok: false, message: '--workspace requires a value' };
351
- workspaceFlag = v;
352
- }
353
- else if (a.startsWith('--workspace=')) {
354
- workspaceFlag = a.slice('--workspace='.length);
355
- }
356
- else if (a === '--lockfile') {
357
- const v = args[++i];
358
- if (!v || v.startsWith('--'))
359
- return { ok: false, message: '--lockfile requires a value' };
360
- lockfileFlag = v;
361
- }
362
- else if (a.startsWith('--lockfile=')) {
363
- lockfileFlag = a.slice('--lockfile='.length);
364
- }
365
- else if (a === '--json') {
366
- jsonOutput = true;
367
- }
368
- else if (a.startsWith('--')) {
369
- return { ok: false, message: `unknown option: ${a}` };
370
- }
371
- else if (!planId) {
372
- planId = a;
373
- }
374
- else {
375
- return { ok: false, message: `unexpected positional argument: ${a}` };
376
- }
377
- }
378
- if (!planId)
379
- return { ok: false, message: 'requires a planId' };
380
- return { ok: true, planId, workspaceFlag, lockfileFlag, jsonOutput };
381
- }
382
- async function runPlanStateCmd(verb, args) {
383
- const parsed = parseStateArgs(args);
384
- if (!parsed.ok) {
385
- process.stderr.write(`yolo: plan ${verb}: ${parsed.message}\n`);
386
- process.stderr.write(`Usage: yolo plan ${verb} <planId> [--workspace <wsId>] [--lockfile <name>] [--json]\n`);
387
- return 64;
388
- }
389
- const targetState = verb === 'activate' ? 'active' : 'archived';
390
- const result = await runPlanStateTransition({
391
- planId: parsed.planId,
392
- targetState,
393
- workspaceFlag: parsed.workspaceFlag,
394
- lockfileFlag: parsed.lockfileFlag,
395
- });
396
- if (result.ok) {
397
- process.stdout.write(`${parsed.jsonOutput ? formatJsonResult(result) : formatStateSuccess(result)}\n`);
398
- return 0;
399
- }
400
- process.stderr.write(parsed.jsonOutput ? `${formatJsonResult(result)}\n` : `FAIL [${result.kind}]: ${result.message}\n`);
401
- return stateExitCode(result.kind);
402
- }
403
- function parseGetArgs(args) {
404
- let planId;
405
- let workspaceFlag;
406
- let jsonOutput = false;
407
- let wavesOutput = false;
408
- for (let i = 0; i < args.length; i++) {
409
- const a = args[i];
410
- if (a === '--workspace') {
411
- const v = args[++i];
412
- if (!v || v.startsWith('--'))
413
- return { ok: false, message: '--workspace requires a value' };
414
- workspaceFlag = v;
415
- }
416
- else if (a.startsWith('--workspace=')) {
417
- workspaceFlag = a.slice('--workspace='.length);
418
- }
419
- else if (a === '--json') {
420
- jsonOutput = true;
421
- }
422
- else if (a === '--waves') {
423
- wavesOutput = true;
424
- }
425
- else if (a.startsWith('--')) {
426
- return { ok: false, message: `unknown option: ${a}` };
427
- }
428
- else if (!planId) {
429
- planId = a;
430
- }
431
- else {
432
- return { ok: false, message: `unexpected positional argument: ${a}` };
433
- }
434
- }
435
- if (!planId)
436
- return { ok: false, message: 'plan get requires a planId' };
437
- if (jsonOutput && wavesOutput) {
438
- return { ok: false, message: '--json and --waves are mutually exclusive' };
439
- }
440
- return { ok: true, planId, workspaceFlag, jsonOutput, wavesOutput };
441
- }
442
- async function runPlanGetCmd(args) {
443
- const parsed = parseGetArgs(args);
444
- if (!parsed.ok) {
445
- process.stderr.write(`yolo: ${parsed.message}\n`);
446
- process.stderr.write('Usage: yolo plan get <planId> [--workspace <wsId>] [--waves | --json]\n');
447
- return 64;
448
- }
449
- const outputFormat = parsed.jsonOutput ? 'json' : parsed.wavesOutput ? 'waves' : 'summary';
450
- const result = await runPlanGet({
451
- planId: parsed.planId,
452
- workspaceFlag: parsed.workspaceFlag,
453
- outputFormat,
454
- });
455
- if (result.ok) {
456
- process.stdout.write(`${result.output}\n`);
457
- return 0;
458
- }
459
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
460
- return getExitCode(result.kind);
461
- }
462
- function parseListArgs(args) {
463
- let workspaceFlag;
464
- let stateFilter;
465
- let jsonOutput = false;
466
- for (let i = 0; i < args.length; i++) {
467
- const a = args[i];
468
- if (a === '--workspace') {
469
- const v = args[++i];
470
- if (!v || v.startsWith('--'))
471
- return { ok: false, message: '--workspace requires a value' };
472
- workspaceFlag = v;
473
- }
474
- else if (a.startsWith('--workspace=')) {
475
- workspaceFlag = a.slice('--workspace='.length);
476
- }
477
- else if (a === '--state') {
478
- const v = args[++i];
479
- if (!v || v.startsWith('--'))
480
- return { ok: false, message: '--state requires a value' };
481
- stateFilter = v;
482
- }
483
- else if (a.startsWith('--state=')) {
484
- stateFilter = a.slice('--state='.length);
485
- }
486
- else if (a === '--json') {
487
- jsonOutput = true;
488
- }
489
- else if (a.startsWith('--')) {
490
- return { ok: false, message: `unknown option: ${a}` };
491
- }
492
- else {
493
- return { ok: false, message: `unexpected positional argument: ${a}` };
494
- }
495
- }
496
- return { ok: true, workspaceFlag, stateFilter, jsonOutput };
497
- }
498
- async function runPlanListCmd(args) {
499
- const parsed = parseListArgs(args);
500
- if (!parsed.ok) {
501
- process.stderr.write(`yolo: plan list: ${parsed.message}\n`);
502
- process.stderr.write('Usage: yolo plan list [--workspace <wsId>] [--state <draft|active|archived>] [--json]\n');
503
- return 64;
504
- }
505
- const result = await runPlanList({
506
- workspaceFlag: parsed.workspaceFlag,
507
- stateFilter: parsed.stateFilter,
508
- outputFormat: parsed.jsonOutput ? 'json' : 'summary',
509
- });
510
- if (result.ok) {
511
- process.stdout.write(`${result.output}\n`);
512
- return 0;
513
- }
514
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
515
- return listExitCode(result.kind);
516
- }
517
- function parseOpenArgs(args) {
518
- let planId;
519
- let workspaceFlag;
520
- let jsonOutput = false;
521
- for (let i = 0; i < args.length; i++) {
522
- const a = args[i];
523
- if (a === '--workspace') {
524
- const v = args[++i];
525
- if (!v || v.startsWith('--'))
526
- return { ok: false, message: '--workspace requires a value' };
527
- workspaceFlag = v;
528
- }
529
- else if (a.startsWith('--workspace=')) {
530
- workspaceFlag = a.slice('--workspace='.length);
531
- }
532
- else if (a === '--json') {
533
- jsonOutput = true;
534
- }
535
- else if (a.startsWith('--')) {
536
- return { ok: false, message: `unknown option: ${a}` };
537
- }
538
- else if (!planId) {
539
- planId = a;
540
- }
541
- else {
542
- return { ok: false, message: `unexpected positional argument: ${a}` };
543
- }
544
- }
545
- if (!planId)
546
- return { ok: false, message: 'plan open requires a planId' };
547
- return { ok: true, planId, workspaceFlag, jsonOutput };
548
- }
549
- async function runPlanOpenCmd(args) {
550
- const parsed = parseOpenArgs(args);
551
- if (!parsed.ok) {
552
- process.stderr.write(`yolo: plan open: ${parsed.message}\n`);
553
- process.stderr.write('Usage: yolo plan open <planId> [--workspace <wsId>] [--json]\n');
554
- return 64;
555
- }
556
- const result = await runPlanOpen({
557
- planId: parsed.planId,
558
- workspaceFlag: parsed.workspaceFlag,
559
- outputFormat: parsed.jsonOutput ? 'json' : 'text',
560
- });
561
- if (result.ok) {
562
- if (parsed.jsonOutput) {
563
- process.stdout.write(`${formatJsonResult(result)}\n`);
564
- }
565
- else {
566
- process.stdout.write(`${result.output}\n`);
567
- }
568
- return 0;
569
- }
570
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
571
- return openExitCode(result.kind);
572
- }
573
- function parseRunStartArgs(args) {
574
- let planId;
575
- let workspaceFlag;
576
- let inputs;
577
- let jsonOutput = false;
578
- for (let i = 0; i < args.length; i++) {
579
- const a = args[i];
580
- if (a === '--workspace') {
581
- const v = args[++i];
582
- if (!v || v.startsWith('--'))
583
- return { ok: false, message: '--workspace requires a value' };
584
- workspaceFlag = v;
585
- }
586
- else if (a.startsWith('--workspace=')) {
587
- workspaceFlag = a.slice('--workspace='.length);
588
- }
589
- else if (a === '--inputs') {
590
- const v = args[++i];
591
- if (!v || v.startsWith('--'))
592
- return { ok: false, message: '--inputs requires a JSON object value' };
593
- const parsed = parseInputsJson(v);
594
- if (!parsed.ok)
595
- return parsed;
596
- inputs = parsed.value;
597
- }
598
- else if (a.startsWith('--inputs=')) {
599
- const parsed = parseInputsJson(a.slice('--inputs='.length));
600
- if (!parsed.ok)
601
- return parsed;
602
- inputs = parsed.value;
603
- }
604
- else if (a === '--json') {
605
- jsonOutput = true;
606
- }
607
- else if (a.startsWith('--')) {
608
- return { ok: false, message: `unknown option: ${a}` };
609
- }
610
- else if (!planId) {
611
- planId = a;
612
- }
613
- else {
614
- return { ok: false, message: `unexpected positional argument: ${a}` };
615
- }
616
- }
617
- if (!planId)
618
- return { ok: false, message: 'run start requires a planId' };
619
- return { ok: true, planId, workspaceFlag, inputs, jsonOutput };
620
- }
621
- function parseInputsJson(raw) {
622
- let parsed;
623
- try {
624
- parsed = JSON.parse(raw);
625
- }
626
- catch (err) {
627
- return { ok: false, message: `--inputs is not valid JSON: ${err instanceof Error ? err.message : String(err)}` };
628
- }
629
- if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
630
- return { ok: false, message: '--inputs must be a JSON object (e.g. \'{"env":"prod"}\')' };
631
- }
632
- return { ok: true, value: parsed };
633
- }
634
- async function runRunStartCmd(args) {
635
- const parsed = parseRunStartArgs(args);
636
- if (!parsed.ok) {
637
- process.stderr.write(`yolo: run start: ${parsed.message}\n`);
638
- process.stderr.write('Usage: yolo run start <planId> [--workspace <wsId>] [--inputs <json>] [--json]\n');
639
- return 64;
640
- }
641
- const result = await runRunStart({
642
- planId: parsed.planId,
643
- workspaceFlag: parsed.workspaceFlag,
644
- inputs: parsed.inputs,
645
- outputFormat: parsed.jsonOutput ? 'json' : 'summary',
646
- });
647
- if (result.ok) {
648
- process.stdout.write(`${result.output}\n`);
649
- return 0;
650
- }
651
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
652
- return runStartExitCode(result.kind);
653
- }
654
- function parseRunLifecycleArgs(args) {
655
- let planRunId;
656
- let workspaceFlag;
657
- let reason;
658
- let jsonOutput = false;
659
- for (let i = 0; i < args.length; i++) {
660
- const a = args[i];
661
- if (a === '--workspace') {
662
- const v = args[++i];
663
- if (!v || v.startsWith('--'))
664
- return { ok: false, message: '--workspace requires a value' };
665
- workspaceFlag = v;
666
- }
667
- else if (a.startsWith('--workspace=')) {
668
- workspaceFlag = a.slice('--workspace='.length);
669
- }
670
- else if (a === '--reason') {
671
- const v = args[++i];
672
- if (v === undefined || v.startsWith('--')) {
673
- return { ok: false, message: '--reason requires a value' };
674
- }
675
- reason = v;
676
- }
677
- else if (a.startsWith('--reason=')) {
678
- reason = a.slice('--reason='.length);
679
- }
680
- else if (a === '--json') {
681
- jsonOutput = true;
682
- }
683
- else if (a.startsWith('--')) {
684
- return { ok: false, message: `unknown option: ${a}` };
685
- }
686
- else if (!planRunId) {
687
- planRunId = a;
688
- }
689
- else {
690
- return { ok: false, message: `unexpected positional argument: ${a}` };
691
- }
692
- }
693
- if (!planRunId)
694
- return { ok: false, message: 'run <verb> requires a planRunId' };
695
- return { ok: true, planRunId, workspaceFlag, reason, jsonOutput };
696
- }
697
- async function runRunLifecycleCmd(verb, args) {
698
- const parsed = parseRunLifecycleArgs(args);
699
- if (!parsed.ok) {
700
- process.stderr.write(`yolo: run ${verb}: ${parsed.message}\n`);
701
- const reasonHint = verb === 'resume' ? '' : ' [--reason <text>]';
702
- process.stderr.write(`Usage: yolo run ${verb} <planRunId> [--workspace <wsId>]${reasonHint} [--json]\n`);
703
- return 64;
704
- }
705
- const result = await runRunLifecycle({
706
- verb,
707
- planRunId: parsed.planRunId,
708
- workspaceFlag: parsed.workspaceFlag,
709
- reason: parsed.reason,
710
- outputFormat: parsed.jsonOutput ? 'json' : 'summary',
711
- });
712
- if (result.ok) {
713
- process.stdout.write(`${result.output}\n`);
714
- return 0;
715
- }
716
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
717
- return runLifecycleExitCode(result.kind);
718
- }
719
- function parseRunGetArgs(args) {
720
- let planRunId;
721
- let workspaceFlag;
722
- let jsonOutput = false;
723
- for (let i = 0; i < args.length; i++) {
724
- const a = args[i];
725
- if (a === '--workspace') {
726
- const v = args[++i];
727
- if (!v || v.startsWith('--'))
728
- return { ok: false, message: '--workspace requires a value' };
729
- workspaceFlag = v;
730
- }
731
- else if (a.startsWith('--workspace=')) {
732
- workspaceFlag = a.slice('--workspace='.length);
733
- }
734
- else if (a === '--json') {
735
- jsonOutput = true;
736
- }
737
- else if (a.startsWith('--')) {
738
- return { ok: false, message: `unknown option: ${a}` };
739
- }
740
- else if (!planRunId) {
741
- planRunId = a;
742
- }
743
- else {
744
- return { ok: false, message: `unexpected positional argument: ${a}` };
745
- }
746
- }
747
- if (!planRunId)
748
- return { ok: false, message: 'run get requires a planRunId' };
749
- return { ok: true, planRunId, workspaceFlag, jsonOutput };
750
- }
751
148
  function tileAppUsage(sub, message) {
752
149
  process.stderr.write(`yolo tileapp ${sub}: ${message}\n`);
753
150
  const usage = {
@@ -1143,25 +540,6 @@ async function runTileAppDevCmd(args) {
1143
540
  }
1144
541
  return runTileAppDev({ manifestPath, port, host, bundleDir, allow });
1145
542
  }
1146
- async function runRunGetCmd(args) {
1147
- const parsed = parseRunGetArgs(args);
1148
- if (!parsed.ok) {
1149
- process.stderr.write(`yolo: run get: ${parsed.message}\n`);
1150
- process.stderr.write('Usage: yolo run get <planRunId> [--workspace <wsId>] [--json]\n');
1151
- return 64;
1152
- }
1153
- const result = await runRunGet({
1154
- planRunId: parsed.planRunId,
1155
- workspaceFlag: parsed.workspaceFlag,
1156
- outputFormat: parsed.jsonOutput ? 'json' : 'summary',
1157
- });
1158
- if (result.ok) {
1159
- process.stdout.write(`${result.output}\n`);
1160
- return 0;
1161
- }
1162
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
1163
- return runGetExitCode(result.kind);
1164
- }
1165
543
  function parseRunListArgs(args) {
1166
544
  let workspaceFlag;
1167
545
  let stateFilter;
@@ -1217,90 +595,6 @@ async function runRunListCmd(args) {
1217
595
  process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
1218
596
  return runListExitCode(result.kind);
1219
597
  }
1220
- function parseRunTransferArgs(args) {
1221
- let planRunId;
1222
- let workspaceFlag;
1223
- let toFlag;
1224
- let userDriven = false;
1225
- let jsonOutput = false;
1226
- for (let i = 0; i < args.length; i++) {
1227
- const a = args[i];
1228
- if (a === '--workspace') {
1229
- const v = args[++i];
1230
- if (!v || v.startsWith('--'))
1231
- return { ok: false, message: '--workspace requires a value' };
1232
- workspaceFlag = v;
1233
- }
1234
- else if (a.startsWith('--workspace=')) {
1235
- workspaceFlag = a.slice('--workspace='.length);
1236
- }
1237
- else if (a === '--to') {
1238
- const v = args[++i];
1239
- if (!v || v.startsWith('--')) {
1240
- // Without the `--` guard, `--to --user-driven` and `--to --json`
1241
- // silently consume the next flag as the agentId, bypassing the
1242
- // mutex / boolean check and triggering a network round-trip with
1243
- // a bogus target. Use the `--to=<value>` form for values that
1244
- // legitimately start with `--`.
1245
- return { ok: false, message: '--to requires an agentId value' };
1246
- }
1247
- toFlag = v;
1248
- }
1249
- else if (a.startsWith('--to=')) {
1250
- toFlag = a.slice('--to='.length);
1251
- }
1252
- else if (a === '--user-driven') {
1253
- userDriven = true;
1254
- }
1255
- else if (a === '--json') {
1256
- jsonOutput = true;
1257
- }
1258
- else if (a.startsWith('--')) {
1259
- return { ok: false, message: `unknown option: ${a}` };
1260
- }
1261
- else if (!planRunId) {
1262
- planRunId = a;
1263
- }
1264
- else {
1265
- return { ok: false, message: `unexpected positional argument: ${a}` };
1266
- }
1267
- }
1268
- if (!planRunId)
1269
- return { ok: false, message: 'run transfer requires a planRunId' };
1270
- if (toFlag !== undefined && userDriven) {
1271
- return { ok: false, message: '--to and --user-driven are mutually exclusive' };
1272
- }
1273
- if (toFlag === undefined && !userDriven) {
1274
- return { ok: false, message: 'one of --to <agentId> or --user-driven is required' };
1275
- }
1276
- return {
1277
- ok: true,
1278
- planRunId,
1279
- newOperatorAgentId: userDriven ? null : toFlag,
1280
- workspaceFlag,
1281
- jsonOutput,
1282
- };
1283
- }
1284
- async function runRunTransferCmd(args) {
1285
- const parsed = parseRunTransferArgs(args);
1286
- if (!parsed.ok) {
1287
- process.stderr.write(`yolo: run transfer: ${parsed.message}\n`);
1288
- process.stderr.write('Usage: yolo run transfer <planRunId> (--to <agentId> | --user-driven) [--workspace <wsId>] [--json]\n');
1289
- return 64;
1290
- }
1291
- const result = await runRunTransfer({
1292
- planRunId: parsed.planRunId,
1293
- newOperatorAgentId: parsed.newOperatorAgentId,
1294
- workspaceFlag: parsed.workspaceFlag,
1295
- outputFormat: parsed.jsonOutput ? 'json' : 'summary',
1296
- });
1297
- if (result.ok) {
1298
- process.stdout.write(`${result.output}\n`);
1299
- return 0;
1300
- }
1301
- process.stderr.write(`FAIL [${result.kind}]: ${result.message}\n`);
1302
- return runTransferExitCode(result.kind);
1303
- }
1304
598
  function parseArtifactGetArgs(args) {
1305
599
  let key;
1306
600
  let version;
@@ -1492,58 +786,25 @@ async function main(argv) {
1492
786
  if (sub === 'validate') {
1493
787
  return runPlanValidate(args.slice(2));
1494
788
  }
1495
- if (sub === 'import') {
1496
- return runPlanImportCmd(args.slice(2));
1497
- }
1498
- if (sub === 'export') {
1499
- return runPlanExportCmd(args.slice(2));
1500
- }
1501
- if (sub === 'activate') {
1502
- return runPlanStateCmd('activate', args.slice(2));
1503
- }
1504
- if (sub === 'archive') {
1505
- return runPlanStateCmd('archive', args.slice(2));
1506
- }
1507
- if (sub === 'get') {
1508
- return runPlanGetCmd(args.slice(2));
1509
- }
1510
- if (sub === 'list') {
1511
- return runPlanListCmd(args.slice(2));
1512
- }
1513
- if (sub === 'open') {
1514
- return runPlanOpenCmd(args.slice(2));
1515
- }
1516
789
  if (!sub) {
1517
- process.stderr.write('yolo: plan requires a subcommand (validate, import, export, activate, archive, get, list, open)\n');
790
+ process.stderr.write('yolo: plan requires a subcommand (validate)\n');
1518
791
  return 64;
1519
792
  }
1520
793
  process.stderr.write(`yolo: unknown plan subcommand '${sub}'\n`);
1521
- process.stderr.write('Subcommands: validate, import, export, activate, archive, get, list, open\n');
794
+ process.stderr.write('Subcommands: validate\n');
1522
795
  return 64;
1523
796
  }
1524
797
  if (cmd === 'run') {
1525
798
  const sub = args[1];
1526
- if (sub === 'start') {
1527
- return runRunStartCmd(args.slice(2));
1528
- }
1529
- if (sub === 'get') {
1530
- return runRunGetCmd(args.slice(2));
1531
- }
1532
799
  if (sub === 'list') {
1533
800
  return runRunListCmd(args.slice(2));
1534
801
  }
1535
- if (sub === 'pause' || sub === 'resume' || sub === 'cancel') {
1536
- return runRunLifecycleCmd(sub, args.slice(2));
1537
- }
1538
- if (sub === 'transfer') {
1539
- return runRunTransferCmd(args.slice(2));
1540
- }
1541
802
  if (!sub) {
1542
- process.stderr.write('yolo: run requires a subcommand (start, get, list, pause, resume, cancel, transfer)\n');
803
+ process.stderr.write('yolo: run requires a subcommand (list)\n');
1543
804
  return 64;
1544
805
  }
1545
806
  process.stderr.write(`yolo: unknown run subcommand '${sub}'\n`);
1546
- process.stderr.write('Subcommands: start, get, list, pause, resume, cancel, transfer\n');
807
+ process.stderr.write('Subcommands: list\n');
1547
808
  return 64;
1548
809
  }
1549
810
  if (cmd === 'artifact') {