stageflow 0.27.0 → 0.30.0

package/dist/cli/runsCommand.js

@@ -616,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;
         }

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) {

package/dist/cli.js

@@ -5,6 +5,7 @@ import { realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { globalAgentBackendFromManifest, resolveAgentPort } from "./agent/resolveAgentPort.js";
+import { BROWSER_USAGE, runBrowserCommand } from "./cli/browserCommand.js";
 import { ARTIFACT_USAGE, runArtifactCommand } from "./cli/artifactCommand.js";
 import { ENVELOPE_USAGE, runEnvelopeCommand, } from "./cli/envelopeCommand.js";
 import { EXPORT_RUN_USAGE, runExportRunCommand, } from "./cli/exportRunCommand.js";
@@ -17,6 +18,7 @@ import { PROVIDERS_USAGE, runProvidersCommand } from "./cli/providersCommand.js"
 import { RUN_USAGE, runRunCommand } from "./cli/runCommand.js";
 import { RUN_STAGE_USAGE, runRunStageCommand } from "./cli/runStageCommand.js";
 import { RUNS_USAGE, runRunsCommand } from "./cli/runsCommand.js";
+import { TRIGGER_USAGE, runTriggerCommand } from "./cli/triggerCommand.js";
 import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { SKILLS_USAGE, runSkillsCommand } from "./cli/skillsCommand.js";
 import { VALIDATE_USAGE, runValidateCommand } from "./cli/validateCommand.js";
@@ -73,6 +75,11 @@ const USAGE = `Usage:
   sf skills list
   sf skills install --from-path <dir> [--skill-name <name>]
   sf skills install --from-zip <url-or-path> [--skill-name <name>] [--checksum sha256:<hex>]
+  sf browser profiles [--json]
+  sf browser status <name> [--json]
+  sf browser check <name> --url <url> --logged-in <glob> [--logged-out <glob>]... [--headless] [--json]
+  sf browser login <name> --url <login-url> --logged-in <glob> [--timeout-sec <n>]
+  sf browser clear <name> [--yes]
   sf --version
   sf -V
   sf --help
@@ -115,9 +122,13 @@ ${EXPORT_ALL_USAGE}
 
 ${RUNS_USAGE}
 
+${TRIGGER_USAGE}
+
 ${PROVIDERS_USAGE}
 
-${SKILLS_USAGE}`;
+${SKILLS_USAGE}
+
+${BROWSER_USAGE}`;
 function parseArgs(argv) {
     const args = argv.slice(2);
     if (args.length === 0) {
@@ -153,7 +164,9 @@ function parseArgs(argv) {
         command === "restore" ||
         command === "export" ||
         command === "runs" ||
-        command === "skills") {
+        command === "trigger" ||
+        command === "skills" ||
+        command === "browser") {
         return { help: false, command };
     }
     if (args.includes("--help") || args.includes("-h")) {
@@ -473,6 +486,11 @@ async function main(argv) {
                 cwd: ctx.invocationCwd,
             });
         }
+        if (parsed.command === "trigger") {
+            return runTriggerCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+            });
+        }
         if (parsed.command === "providers") {
             return runProvidersCommand(argv.slice(3), ctx.invocationCwd);
         }
@@ -482,6 +500,9 @@ async function main(argv) {
                 projectRoot: ctx.projectRoot,
             });
         }
+        if (parsed.command === "browser") {
+            return runBrowserCommand(argv.slice(3));
+        }
         const globalAgent = globalAgentBackendFromManifest(ctx.manifest);
         if (parsed.command === "ui") {
             const listenHost = resolveListenHost({ flag: parsed.host });
@@ -499,6 +520,14 @@ async function main(argv) {
                 mcpStateless,
                 controlTokens: tokens,
             });
+            if (host.store) {
+                try {
+                    await host.store.ensureProject(ctx.projectRoot);
+                }
+                catch {
+                    // The console still serves seeded catalogs when this project cannot be registered.
+                }
+            }
             console.log(`Operator console: ${host.url}`);
             console.log(`MCP endpoint: ${host.mcpUrl}`);
             if (!isNoOpenEnabled(parsed.noOpen)) {

package/dist/config/browseCatalog.d.ts

@@ -37,6 +37,7 @@ export type CatalogBrowseResult = {
 export type CatalogScanPaths = {
     pipelinePaths: string[];
     taskPaths: string[];
+    triggerPaths: string[];
 };
 export declare function getCatalogScanPaths(ctx: CatalogContext): Promise<CatalogScanPaths | null>;
 export declare function browseCatalog(invocationCwd: string | StageflowContext): Promise<CatalogBrowseResult>;

package/dist/config/browseCatalog.js

@@ -28,7 +28,7 @@ function bakedModels() {
     return [...BAKED_MODEL_IDS].sort((a, b) => a.localeCompare(b));
 }
 function catalogReadyFromStageflow(ctx) {
-    return ctx.isGitProject && ctx.manifestStatus === "ok" && ctx.manifest !== null;
+    return ctx.manifestStatus === "ok" && ctx.manifest !== null;
 }
 function catalogReady(ctx) {
     return ctx.manifestStatus === "ok" && ctx.projectRoot !== null && ctx.manifest !== null;
@@ -37,11 +37,12 @@ export async function getCatalogScanPaths(ctx) {
     if (!catalogReady(ctx)) {
         return null;
     }
-    const [pipelinePaths, taskPaths] = await Promise.all([
+    const [pipelinePaths, taskPaths, triggerPaths] = await Promise.all([
         scanCatalogPaths(ctx.manifest, "pipeline"),
         scanCatalogPaths(ctx.manifest, "task"),
+        scanCatalogPaths(ctx.manifest, "trigger"),
     ]);
-    return { pipelinePaths, taskPaths };
+    return { pipelinePaths, taskPaths, triggerPaths };
 }
 async function listTasksFromManifest(projectRoot, manifest, warnings) {
     const filePaths = await scanCatalogPaths(manifest, "task");
@@ -122,7 +123,7 @@ export async function browseCatalog(invocationCwd) {
         ? await resolveStageflowContext(invocationCwd)
         : invocationCwd;
     const base = {
-        projectRoot: ctx.isGitProject ? ctx.projectRoot : null,
+        projectRoot: ctx.manifestStatus === "not_git" ? null : ctx.projectRoot,
         manifest: ctx.manifest,
         manifestStatus: ctx.manifestStatus,
         issues: ctx.manifestIssues,

package/dist/config/builtinSkills.d.ts

@@ -0,0 +1,4 @@
+export declare const BROWSER_SKILL_NAME = "browser";
+export declare function isBuiltinSkillName(name: string): boolean;
+/** Absolute SKILL.md of a skill shipped inside the package, if present on disk. */
+export declare function resolveBuiltinSkillFile(name: string, fromUrl?: string): string | undefined;

package/dist/config/builtinSkills.js

@@ -0,0 +1,23 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const BROWSER_SKILL_NAME = "browser";
+const BUILTIN_SKILL_NAMES = new Set([BROWSER_SKILL_NAME]);
+export function isBuiltinSkillName(name) {
+    return BUILTIN_SKILL_NAMES.has(name);
+}
+/** Absolute SKILL.md of a skill shipped inside the package, if present on disk. */
+export function resolveBuiltinSkillFile(name, fromUrl = import.meta.url) {
+    if (!isBuiltinSkillName(name))
+        return undefined;
+    const here = path.dirname(fileURLToPath(fromUrl));
+    for (const root of [
+        path.resolve(here, "../../builtin-skills"),
+        path.resolve(here, "../../../builtin-skills"),
+    ]) {
+        const file = path.join(root, name, "SKILL.md");
+        if (existsSync(file))
+            return file;
+    }
+    return undefined;
+}

package/dist/config/catalogRelativePath.d.ts

@@ -28,6 +28,7 @@ export declare function catalogPathErrorBody(err: CatalogPathError): {
     error: string;
     code: CatalogPathErrorCode;
     registered_roots: string[];
+    hint?: string;
 };
 /**
  * Pick the catalog root for start_run / POST /api/runs.

package/dist/config/catalogRelativePath.js

@@ -33,7 +33,10 @@ export function resolveCatalogRelativePath(input) {
     const field = input.fieldName ?? "path";
     const registered = input.roots.map((r) => r.project_root);
     if (path.isAbsolute(input.inputPath)) {
-        throw new CatalogPathError(`Absolute ${field} is not allowed on network surfaces; use a catalog-relative path under a registered project_root, or an inline definition.`, "absolute_path_not_allowed", registered);
+        const rootsList = registered.length > 0
+            ? registered.join(", ")
+            : "(none — register a project or use seeded examples)";
+        throw new CatalogPathError(`Absolute ${field} is not allowed on network surfaces. Use a catalog-relative path under project_root (registered or seeded roots: ${rootsList}). Local CLI may pass absolute paths and auto-registers the project folder.`, "absolute_path_not_allowed", registered);
     }
     const root = selectCatalogRootForStart(input.roots, input.projectRoot);
     const absolutePath = path.resolve(root.path, input.inputPath);
@@ -47,11 +50,16 @@ export function resolveCatalogRelativePath(input) {
     };
 }
 export function catalogPathErrorBody(err) {
-    return {
+    const body = {
         error: err.message,
         code: err.code,
         registered_roots: err.registered_roots,
     };
+    if (err.code === "absolute_path_not_allowed") {
+        body.hint =
+            "MCP/HTTP: relative path under project_root; CLI may pass absolute paths and auto-register.";
+    }
+    return body;
 }
 /**
  * Pick the catalog root for start_run / POST /api/runs.

package/dist/config/createTrigger.d.ts

@@ -0,0 +1,27 @@
+import type { TriggerEvent, TriggerSchedule } from "../types/trigger.js";
+import type { TriggerListItem } from "./triggerCatalog.js";
+export type CreateTriggerInput = {
+    directory: string;
+    id: string;
+    pipeline: string;
+    task?: string;
+    kind: "manual" | "schedule" | "event";
+    schedule?: TriggerSchedule;
+    event?: TriggerEvent;
+    enabled?: boolean;
+};
+export type CreateTriggerParseError = {
+    ok: false;
+    status: 400;
+    error: string;
+};
+export type CreateTriggerResult = {
+    ok: true;
+    trigger: TriggerListItem;
+} | {
+    ok: false;
+    status: 400 | 409 | 422 | 500;
+    error: string;
+};
+export declare function parseCreateTriggerBody(body: unknown): CreateTriggerInput | CreateTriggerParseError;
+export declare function createTrigger(rawProjectRoot: string, input: CreateTriggerInput): Promise<CreateTriggerResult>;