stageflow 0.25.0 → 0.30.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))) {
@@ -556,10 +616,14 @@ export async function runRunsCommand(args, options = {}) {
                 return 1;
             }
             if (parsed.json) {
-                printJson(out, { ok: true });
+                printJson(out, result.verification !== undefined
+                    ? { ok: true, verification: result.verification }
+                    : { ok: true });
             }
             else {
-                out.log("ok");
+                out.log(result.verification !== undefined
+                    ? `ok (${result.verification})`
+                    : "ok");
             }
             return 0;
         }
@@ -730,14 +794,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(),

package/dist/cli/triggerCommand.d.ts

@@ -0,0 +1,12 @@
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
+export declare const TRIGGER_USAGE = "Usage:\n  sf trigger list [--json]\n  sf trigger show <id> [--json]\n  sf trigger fire <id> [--task-inline '<json>'] [--json]";
+export type TriggerCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export declare function runTriggerCommand(args: string[], options?: {
+    cwd?: string;
+    io?: Partial<TriggerCommandIo>;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
+}): Promise<number>;

package/dist/cli/triggerCommand.js

@@ -0,0 +1,183 @@
+import { completeCliRun } from "./runCommand.js";
+import { reportCliRun, writeQueuedAdmissionLine } from "./runOutput.js";
+import { ensureGlobalService, hostBaseUrl, } from "../server/ensureGlobalService.js";
+import { httpFireTrigger, httpGetTrigger, httpListTriggers, } from "./hostClient.js";
+export const TRIGGER_USAGE = `Usage:
+  sf trigger list [--json]
+  sf trigger show <id> [--json]
+  sf trigger fire <id> [--task-inline '<json>'] [--json]`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+function parseTriggerArgs(args) {
+    if (args.length === 0) {
+        return { help: false, json: false };
+    }
+    if (args[0] === "--help" || args[0] === "-h") {
+        return { help: true, json: false };
+    }
+    const subcommand = args[0];
+    let help = false;
+    let json = false;
+    let id;
+    let taskInline;
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--task-inline") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --task-inline");
+            }
+            taskInline = value;
+        }
+        else if (arg.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else if (id === undefined) {
+            id = arg;
+        }
+        else {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+    }
+    return { help, json, subcommand, id, taskInline };
+}
+function parseJsonFlag(raw, flagName) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${flagName} must be valid JSON`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${flagName} must be a JSON object`);
+    }
+    return parsed;
+}
+function printJson(io, payload) {
+    io.log(JSON.stringify(payload, null, 2));
+}
+function usageError(io, message) {
+    if (message !== undefined)
+        io.error(message);
+    io.error(TRIGGER_USAGE);
+    return 1;
+}
+export async function runTriggerCommand(args, options = {}) {
+    const out = { ...defaultIo, ...options.io };
+    const base = options.hostBaseUrl ?? hostBaseUrl();
+    const ensureService = options.ensureService ?? (() => ensureGlobalService());
+    let parsed;
+    try {
+        parsed = parseTriggerArgs(args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return usageError(out, message);
+    }
+    if (parsed.help) {
+        out.error(TRIGGER_USAGE);
+        return 0;
+    }
+    if (!parsed.subcommand) {
+        return usageError(out);
+    }
+    if (parsed.subcommand !== "list" &&
+        parsed.subcommand !== "show" &&
+        parsed.subcommand !== "fire") {
+        return usageError(out, `Unknown trigger subcommand: ${parsed.subcommand}`);
+    }
+    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;
+    }
+    const mutatingIo = out;
+    switch (parsed.subcommand) {
+        case "list": {
+            const result = await httpListTriggers(base);
+            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, { triggers: result.triggers });
+            }
+            else {
+                for (const trigger of result.triggers) {
+                    out.log(`${trigger.id}\t${trigger.kind}\t${trigger.enabled}`);
+                }
+            }
+            return 0;
+        }
+        case "show": {
+            if (!parsed.id) {
+                return usageError(out, "Missing <id>");
+            }
+            const result = await httpGetTrigger(base, parsed.id);
+            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, result.trigger);
+            }
+            else {
+                out.log(`${result.trigger.id}\t${result.trigger.kind}\t${result.trigger.enabled}`);
+            }
+            return 0;
+        }
+        case "fire": {
+            if (!parsed.id) {
+                return usageError(out, "Missing <id>");
+            }
+            let task;
+            if (parsed.taskInline !== undefined) {
+                try {
+                    task = parseJsonFlag(parsed.taskInline, "--task-inline");
+                }
+                catch (err) {
+                    out.error(err instanceof Error ? err.message : String(err));
+                    return 1;
+                }
+            }
+            const started = await httpFireTrigger(base, parsed.id, task);
+            if (!started.ok) {
+                return reportCliRun({ kind: "start-failure", started }, { json: parsed.json, io: mutatingIo });
+            }
+            writeQueuedAdmissionLine(started, mutatingIo);
+            return completeCliRun(started, mutatingIo, { json: parsed.json });
+        }
+        default:
+            return usageError(out, `Unknown trigger subcommand: ${parsed.subcommand}`);
+    }
+}

package/dist/cli/validateCommand.d.ts

@@ -1,5 +1,5 @@
 import { validateCatalog as defaultValidateCatalog, type ValidationResult } from "../config/validateCatalog.js";
-export declare const VALIDATE_USAGE = "Usage:\n  sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]\n\n  With no flags, validates all pipelines and tasks declared in stageflow.yaml (manifest-all).\n  --pipeline validates one pipeline file (includes uses:/include: transitively).\n  --task validates one task file.";
+export declare const VALIDATE_USAGE = "Usage:\n  sf validate [--pipeline <path>] [--task <path>] [--trigger <path>] [--strict] [--json]\n\n  With no flags, validates all pipelines and tasks declared in stageflow.yaml (manifest-all).\n  --pipeline validates one pipeline file (includes uses:/include: transitively).\n  --task validates one task file.\n  --trigger validates one trigger file, including its pipeline/task refs.";
 export type ValidateCommandIo = {
     log: (line: string) => void;
     error: (line: string) => void;

package/dist/cli/validateCommand.js

@@ -1,11 +1,12 @@
 import { validateCatalog as defaultValidateCatalog, } from "../config/validateCatalog.js";
 import { exitCodeForValidation, formatValidationHuman, formatValidationJson, } from "./validateOutput.js";
 export const VALIDATE_USAGE = `Usage:
-  sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]
+  sf validate [--pipeline <path>] [--task <path>] [--trigger <path>] [--strict] [--json]
 
   With no flags, validates all pipelines and tasks declared in stageflow.yaml (manifest-all).
   --pipeline validates one pipeline file (includes uses:/include: transitively).
-  --task validates one task file.`;
+  --task validates one task file.
+  --trigger validates one trigger file, including its pipeline/task refs.`;
 const defaultIo = {
     log: (line) => console.log(line),
     error: (line) => console.error(line),
@@ -19,6 +20,7 @@ function parseValidateArgs(args) {
     }
     let pipeline;
     let task;
+    let trigger;
     let strict = false;
     let json = false;
     let help = false;
@@ -41,6 +43,13 @@ function parseValidateArgs(args) {
             }
             task = value;
         }
+        else if (arg === "--trigger") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --trigger");
+            }
+            trigger = value;
+        }
         else if (arg === "--strict") {
             strict = true;
         }
@@ -54,10 +63,11 @@ function parseValidateArgs(args) {
             throw new Error(`Unexpected argument: ${arg}`);
         }
     }
-    if (pipeline !== undefined && task !== undefined) {
-        throw new Error("Use at most one of --pipeline or --task");
+    const scopedFlagCount = [pipeline, task, trigger].filter((v) => v !== undefined).length;
+    if (scopedFlagCount > 1) {
+        throw new Error("Use at most one of --pipeline, --task, or --trigger");
     }
-    return { help, pipeline, task, strict, json };
+    return { help, pipeline, task, trigger, strict, json };
 }
 export async function runValidateCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -70,13 +80,20 @@ export async function runValidateCommand(args, options = {}) {
             out.error(VALIDATE_USAGE);
             return 0;
         }
-        const scope = parsed.pipeline ? "pipeline" : parsed.task ? "task" : "full";
+        const scope = parsed.pipeline
+            ? "pipeline"
+            : parsed.task
+                ? "task"
+                : parsed.trigger
+                    ? "trigger"
+                    : "full";
         const result = await validateCatalogFn({
             scope,
             cwd,
             projectRoot,
             pipeline: parsed.pipeline,
             task: parsed.task,
+            trigger: parsed.trigger,
             strict: parsed.strict,
         });
         if (parsed.json) {