stageflow 0.35.0 → 0.39.0

package/dist/channels/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/agentsCommand.d.ts

@@ -0,0 +1,14 @@
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
+export declare const AGENTS_USAGE = "Usage:\n  sf agents list [--json]\n  sf agents get <id> [--json]\n  sf agents validate <file.agent.yaml> [--json]\n  sf agents enable <id> [--json]\n  sf agents disable <id> [--json]\n  sf agents history <id> [--json]\n  sf agents restore <id> <revision> --base <current revision> [--json]\n  sf agents sessions <id> [--status <status>] [--json]\n  sf agents session <id> <sessionId> [--json]\n  sf agents chat <id> --message <text> [--session <sessionId>] [--json]\n  sf agents approve <id> <sessionId> [--json]\n  sf agents deny <id> <sessionId> [--json]\n\nrestore needs --base: the revision you looked at. If the agent has moved on since, the restore is refused instead of\noverwriting a newer edit. Run it without --base to see the current revision.\n\nTalks to the running Stageflow Host for the project in the current directory.";
+export type AgentsCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+    write: (chunk: string) => void;
+};
+export declare function runAgentsCommand(args: string[], options?: {
+    io?: Partial<AgentsCommandIo>;
+    cwd?: string;
+    projectRoot?: string;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
+}): Promise<number>;

package/dist/cli/agentsCommand.js

@@ -0,0 +1,291 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { clientAuthorizationHeaders } from "../server/controlToken.js";
+import { ensureGlobalService, hostBaseUrl } from "../server/ensureGlobalService.js";
+export const AGENTS_USAGE = `Usage:
+  sf agents list [--json]
+  sf agents get <id> [--json]
+  sf agents validate <file.agent.yaml> [--json]
+  sf agents enable <id> [--json]
+  sf agents disable <id> [--json]
+  sf agents history <id> [--json]
+  sf agents restore <id> <revision> --base <current revision> [--json]
+  sf agents sessions <id> [--status <status>] [--json]
+  sf agents session <id> <sessionId> [--json]
+  sf agents chat <id> --message <text> [--session <sessionId>] [--json]
+  sf agents approve <id> <sessionId> [--json]
+  sf agents deny <id> <sessionId> [--json]
+
+restore needs --base: the revision you looked at. If the agent has moved on since, the restore is refused instead of
+overwriting a newer edit. Run it without --base to see the current revision.
+
+Talks to the running Stageflow Host for the project in the current directory.`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+    write: (chunk) => process.stdout.write(chunk),
+};
+const FLAGS_WITH_VALUE = new Set(["--message", "--session", "--status", "--base"]);
+function parseArgs(args) {
+    const parsed = { help: false, json: false, positional: [] };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h")
+            parsed.help = true;
+        else if (arg === "--json")
+            parsed.json = true;
+        else if (FLAGS_WITH_VALUE.has(arg)) {
+            const value = args[++index];
+            if (value === undefined || value.length === 0)
+                throw new Error(`Missing value for ${arg}`);
+            if (arg === "--message")
+                parsed.message = value;
+            else if (arg === "--session")
+                parsed.session = value;
+            else if (arg === "--base")
+                parsed.base = value;
+            else
+                parsed.status = value;
+        }
+        else if (arg.startsWith("-"))
+            throw new Error(`Unknown flag: ${arg}`);
+        else if (parsed.subcommand === undefined)
+            parsed.subcommand = arg;
+        else
+            parsed.positional.push(arg);
+    }
+    return parsed;
+}
+class HostError extends Error {
+    code;
+    issues;
+    constructor(code, message, issues = []) {
+        super(message);
+        this.code = code;
+        this.issues = issues;
+    }
+}
+function hostClient(base, projectRoot) {
+    const withRoot = (urlPath) => {
+        const url = new URL(urlPath, base);
+        url.searchParams.set("project_root", projectRoot);
+        return url;
+    };
+    const fail = async (res) => {
+        const body = (await res.json().catch(() => ({})));
+        throw new HostError(body.code ?? `http_${res.status}`, body.message ?? body.code ?? `Host returned ${res.status}`, body.issues);
+    };
+    return {
+        async get(urlPath) {
+            const res = await fetch(withRoot(urlPath), { headers: clientAuthorizationHeaders("GET") });
+            if (!res.ok)
+                await fail(res);
+            return res.json();
+        },
+        async post(urlPath, body) {
+            const res = await fetch(withRoot(urlPath), {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...clientAuthorizationHeaders("POST") },
+                body: JSON.stringify(body ?? {}),
+            });
+            if (!res.ok)
+                await fail(res);
+            return res.json();
+        },
+        async stream(urlPath, body, onFrame) {
+            const res = await fetch(withRoot(urlPath), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/x-ndjson",
+                    ...clientAuthorizationHeaders("POST"),
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok || !res.body)
+                await fail(res);
+            const decoder = new TextDecoder();
+            let buffered = "";
+            for await (const chunk of res.body) {
+                buffered += decoder.decode(chunk, { stream: true });
+                let newline = buffered.indexOf("\n");
+                while (newline >= 0) {
+                    const line = buffered.slice(0, newline).trim();
+                    buffered = buffered.slice(newline + 1);
+                    if (line)
+                        onFrame(JSON.parse(line));
+                    newline = buffered.indexOf("\n");
+                }
+            }
+        },
+    };
+}
+export async function runAgentsCommand(args, options = {}) {
+    const io = { ...defaultIo, ...options.io };
+    let parsed;
+    try {
+        parsed = parseArgs(args);
+    }
+    catch (error) {
+        io.error(error instanceof Error ? error.message : String(error));
+        io.error(AGENTS_USAGE);
+        return 1;
+    }
+    if (parsed.help || !parsed.subcommand) {
+        io.error(AGENTS_USAGE);
+        return parsed.help ? 0 : 1;
+    }
+    const need = (count, what) => {
+        if (parsed.positional.length !== count)
+            throw new HostError("usage", `${parsed.subcommand} needs ${what}`);
+        return parsed.positional;
+    };
+    const print = (value, human) => (parsed.json ? io.log(JSON.stringify(value, null, 2)) : human());
+    try {
+        const cwd = options.cwd ?? process.cwd();
+        const projectRoot = options.projectRoot ?? (await resolveStageflowContext(cwd)).projectRoot;
+        const ensured = await (options.ensureService ?? (() => ensureGlobalService()))();
+        if (!ensured.ok)
+            throw new HostError("host.unavailable", ensured.message);
+        const client = hostClient(options.hostBaseUrl ?? hostBaseUrl(), projectRoot);
+        const agentPath = (id, tail = "") => `/api/agents/${encodeURIComponent(id)}${tail}`;
+        switch (parsed.subcommand) {
+            case "list": {
+                need(0, "no arguments");
+                const { agents } = await client.get("/api/agents");
+                print({ agents }, () => {
+                    for (const agent of agents) {
+                        const state = agent.issues.length > 0 ? "invalid" : agent.enabled ? "enabled" : "disabled";
+                        io.log(`${agent.id}\tv${agent.revision}\t${state}\t${agent.name}`);
+                    }
+                });
+                return 0;
+            }
+            case "get": {
+                const [id] = need(1, "<id>");
+                const detail = await client.get(agentPath(id));
+                print(detail, () => io.log(detail.yaml ?? "(no valid revision)"));
+                return 0;
+            }
+            case "validate": {
+                const [file] = need(1, "<file.agent.yaml>");
+                const definition = parseYaml(await readFile(path.resolve(cwd, file), "utf8"));
+                const result = await client.post("/api/agents/validate", { definition });
+                print(result, () => {
+                    for (const issue of result.issues)
+                        io.error(`error   ${issue.path || "(file)"}: ${issue.message}`);
+                    for (const warning of result.warnings)
+                        io.error(`warning ${warning.path}: ${warning.message}`);
+                    if (result.issues.length === 0)
+                        io.log("valid");
+                });
+                return result.issues.length === 0 ? 0 : 1;
+            }
+            case "enable":
+            case "disable": {
+                const [id] = need(1, "<id>");
+                const detail = await client.post(agentPath(id, `/${parsed.subcommand}`));
+                print(detail, () => io.log(`${id} ${parsed.subcommand}d (v${detail.agent.revision})`));
+                return 0;
+            }
+            case "history": {
+                const [id] = need(1, "<id>");
+                const { revisions } = await client.get(agentPath(id, "/revisions"));
+                print({ revisions }, () => {
+                    for (const row of revisions)
+                        io.log(`v${row.revision}\t${row.createdAt}\t${row.source}\t${row.summary ?? ""}`);
+                });
+                return 0;
+            }
+            case "restore": {
+                const [id, raw] = need(2, "<id> <revision>");
+                const revision = Number(raw);
+                if (!Number.isInteger(revision) || revision < 1)
+                    throw new HostError("usage", "revision must be a positive integer");
+                if (parsed.base === undefined) {
+                    // The lock only means something if the caller names the revision they saw; reading it here and echoing it back would not.
+                    const current = await client.get(agentPath(id));
+                    throw new HostError("usage", `restore needs --base: ${id} is at v${current.agent.revision}. Pass --base ${current.agent.revision} to restore v${revision} over it`);
+                }
+                const baseRevision = Number(parsed.base);
+                if (!Number.isInteger(baseRevision) || baseRevision < 1)
+                    throw new HostError("usage", "--base must be a positive integer");
+                const detail = await client.post(agentPath(id, `/revisions/${revision}/restore`), { baseRevision });
+                print(detail, () => io.log(`${id} restored v${revision} as v${detail.agent.revision}`));
+                return 0;
+            }
+            case "sessions": {
+                const [id] = need(1, "<id>");
+                const query = parsed.status ? `?status=${encodeURIComponent(parsed.status)}` : "";
+                const page = await client.get(agentPath(id, `/sessions${query}`));
+                print(page, () => {
+                    for (const row of page.sessions)
+                        io.log(`${row.id}\t${row.status}\t${row.source}\t${row.updatedAt}\t${row.title ?? ""}`);
+                });
+                return 0;
+            }
+            case "session": {
+                const [id, sessionId] = need(2, "<id> <sessionId>");
+                const detail = await client.get(agentPath(id, `/sessions/${encodeURIComponent(sessionId)}`));
+                print(detail, () => {
+                    for (const message of detail.messages)
+                        io.log(`${message.author ?? message.role}: ${message.text}\n`);
+                });
+                return 0;
+            }
+            case "chat": {
+                const [id] = need(1, "<id>");
+                if (!parsed.message)
+                    throw new HostError("usage", "chat needs --message");
+                let failure;
+                let done;
+                await client.stream(agentPath(id, "/chat"), { message: parsed.message, ...(parsed.session ? { sessionId: parsed.session } : {}) }, (frame) => {
+                    if (frame.type === "delta" && !parsed.json)
+                        io.write(String(frame.text));
+                    else if (frame.type === "session" && !parsed.json)
+                        io.error(`session ${String(frame.sessionId)}`);
+                    else if (frame.type === "done")
+                        done = frame.session;
+                    else if (frame.type === "error")
+                        failure = new HostError(String(frame.code), String(frame.message ?? frame.code));
+                });
+                if (failure)
+                    throw failure;
+                // A stream that ends with neither a result nor an error was cut off: not a success.
+                if (done === undefined)
+                    throw new HostError("agent.stream_closed", "The Host closed the connection before the reply finished");
+                if (parsed.json)
+                    io.log(JSON.stringify(done, null, 2));
+                else
+                    io.write("\n");
+                return 0;
+            }
+            case "approve":
+            case "deny": {
+                const [id, sessionId] = need(2, "<id> <sessionId>");
+                const result = await client.post(agentPath(id, `/sessions/${encodeURIComponent(sessionId)}/approval/${parsed.subcommand}`));
+                print(result, () => io.log(`${parsed.subcommand === "approve" ? "Approved" : "Denied"} ${result.approval.tool}`));
+                return 0;
+            }
+            default:
+                throw new HostError("usage", `Unknown subcommand: ${parsed.subcommand}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof HostError) {
+            if (parsed.json)
+                io.log(JSON.stringify({ code: error.code, message: error.message, issues: error.issues }, null, 2));
+            else {
+                io.error(error.message);
+                for (const issue of error.issues)
+                    io.error(`  ${issue.path || "(file)"}: ${issue.message}`);
+            }
+            if (error.code === "usage")
+                io.error(AGENTS_USAGE);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/cli/doctorCommand.js

@@ -293,7 +293,9 @@ function preflightToDoctorChecks(preflight, strict) {
             ? `toolchain:${c.tool ?? i}`
             : c.kind === "secret"
                 ? `secret:${c.secret ?? i}`
-                : `mcp:${c.server ?? c.stageId ?? i}`;
+                : c.kind === "channel"
+                    ? `channel:${c.connection ?? i}`
+                    : `mcp:${c.server ?? c.stageId ?? i}`;
         let status = "pass";
         if (c.status === "ok") {
             status = "pass";

package/dist/cli.js

@@ -18,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 { AGENTS_USAGE, runAgentsCommand } from "./cli/agentsCommand.js";
 import { TRIGGER_USAGE, runTriggerCommand } from "./cli/triggerCommand.js";
 import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { SKILLS_USAGE, runSkillsCommand } from "./cli/skillsCommand.js";
@@ -124,6 +125,8 @@ ${RUNS_USAGE}
 
 ${TRIGGER_USAGE}
 
+${AGENTS_USAGE}
+
 ${PROVIDERS_USAGE}
 
 ${SKILLS_USAGE}
@@ -165,6 +168,7 @@ function parseArgs(argv) {
         command === "export" ||
         command === "runs" ||
         command === "trigger" ||
+        command === "agents" ||
         command === "skills" ||
         command === "browser") {
         return { help: false, command };
@@ -491,6 +495,11 @@ async function main(argv) {
                 cwd: ctx.invocationCwd,
             });
         }
+        if (parsed.command === "agents") {
+            return runAgentsCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+            });
+        }
         if (parsed.command === "providers") {
             return runProvidersCommand(argv.slice(3), ctx.invocationCwd);
         }

package/dist/config/browseCatalog.js

@@ -3,11 +3,6 @@ import { loadPipeline } from "./loadPipeline.js";
 import { loadTask } from "./loadTask.js";
 import { resolveStageflowContext, } from "../project/resolveStageflowContext.js";
 import { scanCatalogPaths } from "./scanCatalogPaths.js";
-const BAKED_MODEL_IDS = [
-    "anthropic/claude-sonnet-4-5",
-    "cursor/auto",
-    "cursor/composer-2-5",
-];
 function repoRelPath(projectRoot, absPath) {
     return path.relative(projectRoot, absPath).replace(/\\/g, "/");
 }
@@ -30,9 +25,6 @@ function mapStageListing(stage, source, projectRoot) {
     }
     return listing;
 }
-function bakedModels() {
-    return [...BAKED_MODEL_IDS].sort((a, b) => a.localeCompare(b));
-}
 function catalogReadyFromStageflow(ctx) {
     return ctx.manifestStatus === "ok" && ctx.manifest !== null;
 }
@@ -106,8 +98,9 @@ async function listPipelinesFromManifest(projectRoot, manifest, warnings) {
     });
     return listings;
 }
+/** Model ids the project's pipelines already use. The provider catalog (src/models) owns the choosable list. */
 async function listModelsFromManifest(projectRoot, manifest) {
-    const models = new Set(BAKED_MODEL_IDS);
+    const models = new Set();
     const filePaths = await scanCatalogPaths(manifest, "pipeline");
     for (const filePath of filePaths) {
         try {
@@ -139,7 +132,7 @@ export async function browseCatalog(invocationCwd) {
             ...base,
             pipelines: [],
             tasks: [],
-            models: bakedModels(),
+            models: [],
             warnings: [],
         };
     }
@@ -171,7 +164,7 @@ export async function listTasksForContext(ctx) {
 }
 export async function listModelsForContext(ctx) {
     if (!catalogReady(ctx)) {
-        return bakedModels();
+        return [];
     }
     return listModelsFromManifest(ctx.projectRoot, ctx.manifest);
 }

package/dist/config/draftPackage.d.ts

@@ -12,6 +12,8 @@ export type DraftPackage = {
         model?: unknown;
         schemas?: unknown;
         requires?: unknown;
+        channels?: unknown;
+        memories?: unknown;
     };
     stages?: DraftStageArtifact[];
     task?: {

package/dist/config/draftPackage.js

@@ -77,6 +77,10 @@ function pipelineDocument(pipeline) {
         doc.schemas = pipeline.schemas;
     if (pipeline.requires !== undefined)
         doc.requires = pipeline.requires;
+    if (pipeline.channels !== undefined)
+        doc.channels = pipeline.channels;
+    if (pipeline.memories !== undefined)
+        doc.memories = pipeline.memories;
     return doc;
 }
 function resolveDirectory(projectRoot, directory) {
@@ -164,6 +168,8 @@ export async function validateDraftPackage(draft, options = {}) {
             ...(draft.pipeline.requires !== undefined
                 ? { requires: draft.pipeline.requires }
                 : {}),
+            ...(draft.pipeline.channels !== undefined ? { channels: draft.pipeline.channels } : {}),
+            ...(draft.pipeline.memories !== undefined ? { memories: draft.pipeline.memories } : {}),
         };
         const result = await loadPipelineValidated(inline, {
             cwd,
@@ -716,6 +722,8 @@ export async function loadDraftPackage(projectRoot, pipelineRelPath, options = {
             ...(raw.model !== undefined ? { model: raw.model } : {}),
             ...(raw.schemas !== undefined ? { schemas: raw.schemas } : {}),
             ...(raw.requires !== undefined ? { requires: raw.requires } : {}),
+            ...(raw.channels !== undefined ? { channels: raw.channels } : {}),
+            ...(raw.memories !== undefined ? { memories: raw.memories } : {}),
         },
         ...(stageArtifacts.length > 0 ? { stages: stageArtifacts } : {}),
     };

package/dist/config/hostConfig.js

@@ -18,6 +18,7 @@ export class HostConfigError extends Error {
 export const KNOWN_STAGEFLOW_ENV_KEYS = new Set([
     "STAGEFLOW_HOME",
     "STAGEFLOW_CREDENTIAL_HOME",
+    "STAGEFLOW_CONNECTIONS_FILE",
     "STAGEFLOW_BIND",
     "STAGEFLOW_ALLOW_UNAUTHENTICATED_BIND",
     "STAGEFLOW_ALLOWED_HOSTS",
@@ -68,6 +69,13 @@ export const KNOWN_STAGEFLOW_ENV_KEYS = new Set([
     "STAGEFLOW_SECRET_REGISTRY",
     "STAGEFLOW_BUILD_SHA",
     "STAGEFLOW_TRIGGER_TICK_INTERVAL_MS",
+    "STAGEFLOW_AGENT_SCHEDULE_TICK_INTERVAL_MS",
+    "STAGEFLOW_AGENT_SESSION_IDLE_MINUTES",
+    "STAGEFLOW_AGENT_STALL_SECONDS",
+    "STAGEFLOW_AGENT_CHANNEL_LISTENERS",
+    "STAGEFLOW_AGENTS_ALLOW_CURSOR_NATIVE_TOOLS",
+    "STAGEFLOW_PUBLIC_CHAT_ORIGINS",
+    "STAGEFLOW_MCP_ENV_ALLOW",
     "STAGEFLOW_GITHUB_POLL_INTERVAL_MS",
 ]);
 const KNOWN_ENV_PREFIXES = [