stageflow 0.19.0 → 0.25.0

package/dist/cli/hostClient.js

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { globalStageflowHome } from "../project/globalHome.js";
+import { PipelineValidationError } from "../runtime/pipelineValidationError.js";
+import { runWorkspaceDir, storeRootFor } from "../runstore/paths.js";
+async function postJson(base, urlPath, body) {
+    const res = await fetch(`${base}${urlPath}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body ?? {}),
+    });
+    return { status: res.status, body: await parseJsonBody(res) };
+}
+async function getJson(base, urlPath) {
+    const res = await fetch(`${base}${urlPath}`);
+    return { status: res.status, body: await parseJsonBody(res) };
+}
+async function parseJsonBody(res) {
+    const text = await res.text();
+    if (text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractError(body, status) {
+    if (body && typeof body === "object" && typeof body.error === "string") {
+        return body.error;
+    }
+    return `request to global Stageflow service failed (status ${status})`;
+}
+function enc(value) {
+    return encodeURIComponent(value);
+}
+export function computeRunDir(runId) {
+    return runWorkspaceDir(storeRootFor(globalStageflowHome()), runId);
+}
+export async function httpReadRun(base, runId) {
+    const { status, body } = await getJson(base, `/api/runs/${enc(runId)}`);
+    if (status !== 200) {
+        throw new Error(extractError(body, status));
+    }
+    return body;
+}
+/** Thin RunStore-shaped reader backed by the global service, for the CLI output helpers that only need `readRun`. */
+export function httpStoreReader(base) {
+    return { readRun: (runId) => httpReadRun(base, runId) };
+}
+function isRunTerminal(detail) {
+    return (detail.status === "succeeded" ||
+        detail.status === "failed" ||
+        (detail.status === "running" && detail.waiting_stage_id !== undefined));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function pollRunUntilTerminal(base, runId, options) {
+    const pollIntervalMs = options?.pollIntervalMs ?? 500;
+    for (;;) {
+        const detail = await httpReadRun(base, runId);
+        if (isRunTerminal(detail))
+            return detail;
+        await sleep(pollIntervalMs);
+    }
+}
+export function runDetailToPipelineRunResult(detail) {
+    const outcome = detail.status === "succeeded"
+        ? "succeeded"
+        : detail.status === "failed"
+            ? "failed"
+            : "waiting";
+    return {
+        ok: outcome === "succeeded",
+        outcome,
+        runId: detail.run_id,
+        runDir: computeRunDir(detail.run_id),
+        ...(outcome === "failed" && detail.failed_reason !== undefined
+            ? { reason: detail.failed_reason }
+            : {}),
+    };
+}
+function toStartFailure(status, body) {
+    const rest = body && typeof body === "object" ? { ...body } : {};
+    const error = typeof rest.error === "string" ? rest.error : undefined;
+    delete rest.error;
+    return {
+        ok: false,
+        reason: error ?? extractError(body, status),
+        status,
+        ...rest,
+    };
+}
+function validationResultFrom(body) {
+    if (body && typeof body === "object" && "validation" in body) {
+        return body.validation;
+    }
+    return undefined;
+}
+export async function httpStartRun(base, input) {
+    const { status, body } = await postJson(base, "/api/runs", input);
+    if (status === 400) {
+        const validation = validationResultFrom(body);
+        if (validation !== undefined)
+            throw new PipelineValidationError(validation);
+    }
+    if (status !== 202)
+        return toStartFailure(status, body);
+    const runId = body.runId;
+    return {
+        ok: true,
+        runId,
+        done: pollRunUntilTerminal(base, runId).then(runDetailToPipelineRunResult),
+    };
+}
+export async function httpRerun(base, runId) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/rerun`, {});
+    if (status !== 202)
+        return toStartFailure(status, body);
+    const newRunId = body.runId;
+    return {
+        ok: true,
+        runId: newRunId,
+        done: pollRunUntilTerminal(base, newRunId).then(runDetailToPipelineRunResult),
+    };
+}
+export async function httpDeliverAnswer(base, runId, stageId, answer) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/answer`, answer);
+    if (status === 202)
+        return { ok: true };
+    return { ok: false, reason: extractError(body, status), status: status };
+}
+export async function httpDecideFeedbackLoop(base, runId, stageId, input) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/feedback-decision`, input);
+    if (status === 202) {
+        const parsed = body;
+        return { ok: true, effect: parsed.effect, loopId: parsed.loopId };
+    }
+    return { ok: false, reason: extractError(body, status), status };
+}
+export async function httpRetryStageUntilStop(base, runId, stageId) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/retry`, {});
+    if (status !== 202) {
+        return { ok: false, reason: extractError(body, status), status };
+    }
+    const detail = await pollRunUntilTerminal(base, runId);
+    return { ok: true, pipeline: runDetailToPipelineRunResult(detail) };
+}
+export async function httpResumeTimedOutStage(base, runId, stageId) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/resume`, {});
+    if (status === 202) {
+        const parsed = body;
+        return { ok: true, runId: parsed.runId, stageId: parsed.stageId, attemptIndex: parsed.attemptIndex };
+    }
+    return { ok: false, reason: extractError(body, status), status };
+}
+export async function httpRecoverManualStageUntilStop(base, runId, stageId, guidance) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/recovery`, guidance !== undefined ? { guidance } : {});
+    if (status !== 202) {
+        return { ok: false, reason: extractError(body, status), status };
+    }
+    const detail = await pollRunUntilTerminal(base, runId);
+    return { ok: true, pipeline: runDetailToPipelineRunResult(detail) };
+}
+export async function httpStopManualRecovery(base, runId, stageId) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/recovery/stop`, {});
+    if (status === 202)
+        return body;
+    return { ok: false, reason: extractError(body, status), status };
+}
+export async function httpAbandonStage(base, runId, stageId) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/abandon`, {});
+    if (status === 202) {
+        const parsed = body;
+        return { ok: true, runId: parsed.runId, stageId: parsed.stageId };
+    }
+    return { ok: false, reason: extractError(body, status), status };
+}
+export function resolveAbsolute(cwd, maybeRelative) {
+    return path.resolve(cwd, maybeRelative);
+}

package/dist/cli/providersCommand.js

@@ -1,4 +1,5 @@
-import { defaultContext, detectPiHome, getAuthStatus, getCredentialSourceSettings, listProviders, loginWithApiKey, loginWithOauth, logoutProvider, ProviderAuthError, setCredentialSource, } from "../agent/providerAuth.js";
+import { defaultContext, detectPiHome, getAuthStatus, getCredentialSourceSettings, listProviders, loginWithApiKey, loginWithOauth, logoutProvider, setCredentialSource, } from "../agent/providerAuth.js";
+import { mapProviderAuthError } from "../agent/providerInspect.js";
 import { createTerminalAuthInteraction } from "./terminalAuthInteraction.js";
 import { promptSecret, readApiKeyFromEnv } from "./terminalSecret.js";
 export const PROVIDERS_USAGE = `Usage:
@@ -152,8 +153,9 @@ export async function runProvidersCommand(args, cwd, io = {}, ctx = defaultConte
                     return 0;
                 }
                 catch (err) {
-                    if (err instanceof ProviderAuthError && err.status === 404) {
-                        out.error("Provider not found");
+                    const mapped = mapProviderAuthError(err);
+                    if (mapped.status === 404) {
+                        out.error(mapped.body.error);
                         return 1;
                     }
                     throw err;

package/dist/cli/runCommand.d.ts

@@ -1,5 +1,6 @@
 import type { RunStore } from "../runstore/port.js";
-import { type StartRunResult } from "../runtime/runManager.js";
+import type { StartRunResult } from "../runtime/runManager.js";
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
 import { type CliRunReportIo } from "./runOutput.js";
 export declare const RUN_USAGE = "Usage:\n  sf run --task <path> --pipeline <path> [--checkout <path>] [--json] [--include stages] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>] [--operator-cwd <path>] [--operator-agent-dir <path>]";
 export type RunCommandIo = CliRunReportIo;
@@ -16,15 +17,15 @@ export declare function completeCliRun(started: Extract<StartRunResult, {
     ok: true;
 }>, io?: RunCommandIo, options?: {
     json?: boolean;
-    store?: RunStore;
+    store?: Pick<RunStore, "readRun">;
     includeStages?: boolean;
 }): Promise<number>;
 export declare function runRunCommand(args: string[], options?: {
     cwd?: string;
-    projectRoot?: string;
-    isGitProject?: boolean;
     io?: Partial<RunCommandIo>;
     startRun?: StartRunFn;
-    store?: RunStore;
+    store?: Pick<RunStore, "readRun">;
     env?: Record<string, string | undefined>;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
 }): Promise<number>;

package/dist/cli/runCommand.js

@@ -1,11 +1,8 @@
-import { resolveGlobalOnlyAgentPort } from "../agent/resolveAgentPort.js";
-import { createRunStore } from "../runstore/createStore.js";
 import { PipelineValidationError } from "../runtime/pipelineRunner.js";
-import { RunManager } from "../runtime/runManager.js";
-import { readStageExecutionMode } from "../runtime/stageConcurrency.js";
+import { ensureGlobalService, hostBaseUrl, } from "../server/ensureGlobalService.js";
+import { httpStartRun, httpStoreReader, resolveAbsolute } from "./hostClient.js";
 import { reportCliRun, } from "./runOutput.js";
 import { resolveCiIdentity } from "./ciIdentity.js";
-import { resolveOperatorCatalog } from "./operatorCatalog.js";
 import { exitCodeForValidation, formatValidationHuman, formatValidationJson, } from "./validateOutput.js";
 export const RUN_USAGE = `Usage:
   sf run --task <path> --pipeline <path> [--checkout <path>] [--json] [--include stages] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>] [--operator-cwd <path>] [--operator-agent-dir <path>]`;
@@ -133,19 +130,23 @@ function parseRunArgs(args) {
         operatorAgentDir,
     };
 }
-function defaultStartRun(cwd, projectRoot, isGitProject, operatorCatalog) {
+function defaultStartRun(cwd, base, ensureService) {
     return async (input) => {
-        const store = createRunStore({ rootDir: projectRoot });
-        const manager = new RunManager({
-            agent: await resolveGlobalOnlyAgentPort(projectRoot),
-            store,
-            cwd,
-            projectRoot,
-            isGitProject,
-            operatorCatalog,
-            executionMode: readStageExecutionMode(process.env, "process"),
+        const ensured = await ensureService();
+        if (!ensured.ok) {
+            return { ok: false, reason: ensured.message, status: 503 };
+        }
+        return httpStartRun(base, {
+            pipeline: resolveAbsolute(cwd, input.pipeline),
+            task: resolveAbsolute(cwd, input.task),
+            ...(input.checkoutOverride !== undefined
+                ? { checkoutOverride: resolveAbsolute(cwd, input.checkoutOverride) }
+                : {}),
+            ...(input.skipGates !== undefined ? { skipGates: input.skipGates } : {}),
+            ...(input.gitSha !== undefined ? { gitSha: input.gitSha } : {}),
+            ...(input.ciPrUrl !== undefined ? { ciPrUrl: input.ciPrUrl } : {}),
+            ...(input.ciJobUrl !== undefined ? { ciJobUrl: input.ciJobUrl } : {}),
         });
-        return manager.startRun(input);
     };
 }
 export async function completeCliRun(started, io = defaultIo, options = {}) {
@@ -159,9 +160,8 @@ export async function completeCliRun(started, io = defaultIo, options = {}) {
 }
 export async function runRunCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const projectRoot = options.projectRoot ?? cwd;
-    const isGitProject = options.isGitProject ?? false;
     const out = { ...defaultIo, ...options.io };
+    const base = options.hostBaseUrl ?? hostBaseUrl();
     let parsed;
     try {
         parsed = parseRunArgs(args);
@@ -185,16 +185,11 @@ export async function runRunCommand(args, options = {}) {
         out.error("error: --include stages requires --json");
         return 1;
     }
-    const operatorCatalog = resolveOperatorCatalog({
-        flags: {
-            operatorCwd: parsed.operatorCwd,
-            operatorAgentDir: parsed.operatorAgentDir,
-        },
-        env: options.env ?? process.env,
-        defaultCwd: cwd,
-    });
+    if (parsed.operatorCwd !== undefined || parsed.operatorAgentDir !== undefined) {
+        out.error("warning: --operator-cwd/--operator-agent-dir have no effect on `sf run` now that pipelines execute in the shared global Stageflow service; set STAGEFLOW_OPERATOR_CWD/STAGEFLOW_OPERATOR_AGENT_DIR before that service first starts instead.");
+    }
     const startRun = options.startRun ??
-        defaultStartRun(cwd, projectRoot, isGitProject, operatorCatalog);
+        defaultStartRun(cwd, base, options.ensureService ?? (() => ensureGlobalService()));
     const identity = resolveCiIdentity({
         flags: {
             gitSha: parsed.gitSha,
@@ -203,10 +198,7 @@ export async function runRunCommand(args, options = {}) {
         },
         env: options.env ?? process.env,
     });
-    const store = options.store ??
-        (parsed.includeStages
-            ? createRunStore({ rootDir: projectRoot })
-            : undefined);
+    const store = options.store ?? (parsed.includeStages ? httpStoreReader(base) : undefined);
     try {
         const started = await startRun({
             task: parsed.task,

package/dist/cli/runOutput.d.ts

@@ -17,6 +17,6 @@ export type CliRunReportEvent = {
 export declare function reportCliRun(event: CliRunReportEvent, options: {
     json?: boolean;
     io: CliRunReportIo;
-    store?: RunStore;
+    store?: Pick<RunStore, "readRun">;
     includeStages?: boolean;
 }): Promise<number>;

package/dist/cli/runStageCommand.d.ts

@@ -0,0 +1,33 @@
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
+export declare const RUN_STAGE_USAGE = "Usage:\n  sf run-stage (--stage <path> | --stage-inline '<json>') (--task <path> | --task-inline '<json>' | --envelope-ref <runId>:<stageId>[:<attempt>] [--envelope-ref ...]) [--checkout <path>] [--model <id>] [--blocking] [--timeout-ms <n>] [--json]\n\nRun a single stage directly against the shared Stageflow service, without authoring a pipeline file. Distinct from the internal-only, worker-process-only `sf internal run-stage`.\n  --stage <path>          Filesystem path to a catalog stage YAML file\n  --stage-inline <json>   Inline stage body object ({ id, system_prompt, io, ... } \u2014 no uses:/route/pipeline wrapper)\n  --task <path>           Filesystem path to a catalog task YAML file\n  --task-inline <json>    Inline task object ({ id, goal, ... })\n  --envelope-ref <ref>    Resolve a previously stored StageEnvelope as this stage's input instead of a task: <runId>:<stageId>[:<attempt>]. Repeat to pass more than one \u2014 each resolved payload is namespaced under its stageId in input (disambiguated by runId on a stageId collision), and summaries are combined into goal.\n  --checkout <path>       Optional checkout to use with --envelope-ref (--task/--task-inline carry their own checkout)\n  --model <id>            Override the model/backend for this call only, ahead of the stage's own declared model\n  --blocking              Wait for the run to reach a terminal or waiting state and print the result in this same call, instead of returning immediately with just the run id\n  --timeout-ms <n>        Wait budget in ms when --blocking is set\n  --json                  Machine-readable JSON output";
+export type RunStageEnvelopeRef = {
+    runId: string;
+    stageId: string;
+    attempt?: number;
+};
+export type RunStageToolArgs = {
+    stage: string | Record<string, unknown>;
+    task_path?: string;
+    task?: Record<string, unknown>;
+    envelope_ref?: RunStageEnvelopeRef | RunStageEnvelopeRef[];
+    checkout?: string;
+    model?: string;
+    blocking?: boolean;
+    timeout_ms?: number;
+};
+export type RunStageToolResult = {
+    isError: boolean;
+    payload: Record<string, unknown> | null;
+};
+export type RunStageCallFn = (args: RunStageToolArgs) => Promise<RunStageToolResult>;
+export type RunStageCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export declare function runRunStageCommand(args: string[], options?: {
+    cwd?: string;
+    io?: Partial<RunStageCommandIo>;
+    callTool?: RunStageCallFn;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
+}): Promise<number>;