stageflow 0.23.0 → 0.27.0

package/dist/cli/runsCommand.js

@@ -4,16 +4,16 @@ import { projectRun } from "../projection/projectRun.js";
 import { waitRun } from "../mcp/waitRun.js";
 import { projectWaitingGates } from "../mcp/waitingGates.js";
 import { completeCliRun } from "./runCommand.js";
-import { reportCliRun } from "./runOutput.js";
+import { reportCliRun, writeQueuedAdmissionLine } from "./runOutput.js";
 import { globalStageflowHome } from "../project/globalHome.js";
-import { createRunStore } from "../runstore/createStore.js";
+import { createRunStore, storeNeedsHostMigration, } from "../runstore/createStore.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
 import { ensureGlobalService, hostBaseUrl, } from "../server/ensureGlobalService.js";
 import { mapRetryStageFailure } from "../server/operatorResults.js";
-import { httpAbandonStage, httpDecideFeedbackLoop, httpDeliverAnswer, httpRecoverManualStageUntilStop, httpRerun, httpResumeTimedOutStage, httpRetryStageUntilStop, httpStopManualRecovery, } from "./hostClient.js";
+import { httpAbandonStage, httpCancelRun, httpDecideFeedbackLoop, httpDeleteRun, httpDeliverAnswer, httpGcRuns, httpRecoverManualStageUntilStop, httpRerun, httpResumeTimedOutStage, httpRetryStageUntilStop, httpStopManualRecovery, } from "./hostClient.js";
 import { AskOperatorError, parseAskOperatorAnswer, } from "../tools/askOperator.js";
 export const RUNS_USAGE = `Usage:
-  sf runs list [--status created|running|succeeded|failed] [--since <iso>] [--pipeline <id-or-path>] [--json]
+  sf runs list [--status created|queued|running|succeeded|failed|cancelled] [--since <iso>] [--pipeline <id-or-path>] [--json]
   sf runs show --run <runId> [--from <sf-run.json>] [--json]
   sf runs verify --run <runId> --stage <stageId> [--json]
   sf runs recover --run <runId> --stage <stageId> [--guidance <text>] [--stop] [--json]
@@ -24,16 +24,21 @@ export const RUNS_USAGE = `Usage:
   sf runs retry --run <runId> --stage <stageId> [--json]
   sf runs resume --run <runId> --stage <stageId> [--json]
   sf runs abandon --run <runId> --stage <stageId> [--json]
-  sf runs rerun --run <runId> [--json]`;
+  sf runs cancel --run <runId> --reason <text> [--json]
+  sf runs delete --run <runId> [--force] [--json]
+  sf runs gc [--dry-run] [--json]
+  sf runs rerun --run <runId> [--pinned] [--json]`;
 const defaultIo = {
     log: (line) => console.log(line),
     error: (line) => console.error(line),
 };
 const RUN_STATUSES = [
     "created",
+    "queued",
     "running",
     "succeeded",
     "failed",
+    "cancelled",
 ];
 const LIST_FLAGS = new Set([
     "--status",
@@ -85,7 +90,10 @@ const FEEDBACK_DECIDE_FLAGS = new Set([
 ]);
 const RETRY_FLAGS = new Set(["--run", "--stage", "--json", "--help", "-h"]);
 const ABANDON_FLAGS = new Set(["--run", "--stage", "--json", "--help", "-h"]);
-const RERUN_FLAGS = new Set(["--run", "--json", "--help", "-h"]);
+const CANCEL_FLAGS = new Set(["--run", "--reason", "--json", "--help", "-h"]);
+const DELETE_FLAGS = new Set(["--run", "--force", "--json", "--help", "-h"]);
+const GC_FLAGS = new Set(["--dry-run", "--json", "--help", "-h"]);
+const RERUN_FLAGS = new Set(["--run", "--pinned", "--json", "--help", "-h"]);
 const VALUE_FLAGS = new Set([
     "--status",
     "--since",
@@ -125,6 +133,12 @@ function flagsFor(subcommand) {
             return RETRY_FLAGS;
         case "abandon":
             return ABANDON_FLAGS;
+        case "cancel":
+            return CANCEL_FLAGS;
+        case "delete":
+            return DELETE_FLAGS;
+        case "gc":
+            return GC_FLAGS;
         case "rerun":
             return RERUN_FLAGS;
         default:
@@ -156,6 +170,9 @@ function parseRunsArgs(args) {
     let answer;
     let guidance;
     let stop = false;
+    let pinned = false;
+    let force = false;
+    let dryRun = false;
     let loopId;
     let decision;
     let reason;
@@ -172,6 +189,21 @@ function parseRunsArgs(args) {
                 throw new Error(`Unknown flag: ${arg}`);
             stop = true;
         }
+        else if (arg === "--pinned") {
+            if (!allowed.has(arg))
+                throw new Error(`Unknown flag: ${arg}`);
+            pinned = true;
+        }
+        else if (arg === "--force") {
+            if (!allowed.has(arg))
+                throw new Error(`Unknown flag: ${arg}`);
+            force = true;
+        }
+        else if (arg === "--dry-run") {
+            if (!allowed.has(arg))
+                throw new Error(`Unknown flag: ${arg}`);
+            dryRun = true;
+        }
         else if (VALUE_FLAGS.has(arg)) {
             if (!allowed.has(arg)) {
                 throw new Error(`Unknown flag: ${arg}`);
@@ -229,6 +261,9 @@ function parseRunsArgs(args) {
         answer,
         guidance,
         stop,
+        pinned,
+        force,
+        dryRun,
         loopId,
         decision,
         reason,
@@ -287,8 +322,18 @@ const MUTATING_SUBCOMMANDS = new Set([
     "resume",
     "recover",
     "abandon",
+    "cancel",
+    "delete",
+    "gc",
     "rerun",
 ]);
+const READ_ONLY_SUBCOMMANDS = new Set([
+    "list",
+    "show",
+    "verify",
+    "waiting",
+    "wait",
+]);
 export async function runRunsCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const out = { ...defaultIo, ...options.io };
@@ -331,6 +376,21 @@ export async function runRunsCommand(args, options = {}) {
             return 1;
         }
     }
+    if (READ_ONLY_SUBCOMMANDS.has(parsed.subcommand) &&
+        resolvedStore === undefined) {
+        if (storeNeedsHostMigration(globalStageflowHome())) {
+            const ensured = await ensureService();
+            if (!ensured.ok) {
+                if (parsed.json) {
+                    printJson(out, { error: ensured.message, reason: ensured.reason });
+                }
+                else {
+                    out.error(ensured.message);
+                }
+                return 1;
+            }
+        }
+    }
     switch (parsed.subcommand) {
         case "list": {
             if (parsed.status === "waiting") {
@@ -338,7 +398,7 @@ export async function runRunsCommand(args, options = {}) {
                 return 1;
             }
             if (parsed.status !== undefined && !isRunStatus(parsed.status)) {
-                out.error("--status must be created, running, succeeded, or failed");
+                out.error("--status must be created, queued, running, succeeded, failed, or cancelled");
                 return 1;
             }
             if (parsed.since !== undefined && !Number.isFinite(Date.parse(parsed.since))) {
@@ -730,14 +790,108 @@ export async function runRunsCommand(args, options = {}) {
             }
             return 0;
         }
+        case "cancel": {
+            if (!parsed.runId || !parsed.reason) {
+                return usageError(out, "Missing --run and/or --reason");
+            }
+            const result = await httpCancelRun(base, parsed.runId, parsed.reason);
+            if (!result.ok) {
+                const payload = { error: result.reason };
+                if (result.status !== undefined)
+                    payload.status = result.status;
+                if (parsed.json) {
+                    printJson(out, payload);
+                }
+                else {
+                    out.error(result.reason);
+                }
+                return 1;
+            }
+            if (parsed.json) {
+                printJson(out, {
+                    ok: true,
+                    runId: result.runId,
+                });
+            }
+            else {
+                out.log(result.runId);
+            }
+            return 0;
+        }
+        case "delete": {
+            if (!parsed.runId) {
+                return usageError(out, "Missing --run");
+            }
+            const result = await httpDeleteRun(base, parsed.runId, {
+                force: parsed.force === true,
+            });
+            if (!result.ok) {
+                const payload = { error: result.reason };
+                if (result.status !== undefined)
+                    payload.status = result.status;
+                if (parsed.json) {
+                    printJson(out, payload);
+                }
+                else {
+                    out.error(result.reason);
+                }
+                return 1;
+            }
+            if (parsed.json) {
+                printJson(out, {
+                    ok: true,
+                    runId: result.runId,
+                });
+            }
+            else {
+                out.log(result.runId);
+            }
+            return 0;
+        }
+        case "gc": {
+            const execute = parsed.dryRun !== true;
+            const result = await httpGcRuns(base, { execute });
+            if (!result.ok) {
+                const payload = { error: result.reason };
+                if (result.status !== undefined)
+                    payload.status = result.status;
+                if (parsed.json) {
+                    printJson(out, payload);
+                }
+                else {
+                    out.error(result.reason);
+                }
+                return 1;
+            }
+            const report = {
+                slimmed: result.slimmed,
+                purged: result.purged,
+                bareCachesEvicted: result.bareCachesEvicted,
+            };
+            if (parsed.json) {
+                printJson(out, report);
+            }
+            else {
+                out.log([
+                    `slimmed:\t${report.slimmed.length}`,
+                    ...report.slimmed.map((id) => `\t${id}`),
+                    `purged:\t${report.purged.length}`,
+                    ...report.purged.map((id) => `\t${id}`),
+                    `bareCachesEvicted:\t${report.bareCachesEvicted.length}`,
+                    ...report.bareCachesEvicted.map((id) => `\t${id}`),
+                ].join("\n"));
+            }
+            return 0;
+        }
         case "rerun": {
             if (!parsed.runId) {
                 return usageError(out, "Missing --run");
             }
-            const started = await httpRerun(base, parsed.runId);
+            const started = await httpRerun(base, parsed.runId, parsed.pinned ? { pinned: true } : undefined);
             if (!started.ok) {
                 return reportCliRun({ kind: "start-failure", started }, { json: parsed.json, io: mutatingIo });
             }
+            writeQueuedAdmissionLine(started, mutatingIo);
             return completeCliRun(started, mutatingIo, {
                 json: parsed.json,
                 store: getStore(),