stageflow 0.18.0 → 0.23.0

package/dist/cli/hostClient.d.ts

@@ -0,0 +1,43 @@
+import type { PipelineRunResult } from "../runtime/pipelineRunner.js";
+import type { AbandonStageResult, DecideFeedbackLoopResult, StartRunResult, StopManualRecoveryResult } from "../runtime/runManager.js";
+import type { DeliverAnswerResult } from "../runtime/stageHitl.js";
+import type { RetryStageResult } from "../runtime/runRetryCoordinator.js";
+import type { RunDetail, RunStore } from "../runstore/port.js";
+export declare function computeRunDir(runId: string): string;
+export declare function httpReadRun(base: string, runId: string): Promise<RunDetail>;
+/** Thin RunStore-shaped reader backed by the global service, for the CLI output helpers that only need `readRun`. */
+export declare function httpStoreReader(base: string): Pick<RunStore, "readRun">;
+export declare function pollRunUntilTerminal(base: string, runId: string, options?: {
+    pollIntervalMs?: number;
+}): Promise<RunDetail>;
+export declare function runDetailToPipelineRunResult(detail: RunDetail): PipelineRunResult;
+export type HttpStartRunInput = {
+    pipeline: string;
+    task: string;
+    checkoutOverride?: string;
+    skipGates?: boolean;
+    gitSha?: string;
+    ciPrUrl?: string;
+    ciJobUrl?: string;
+};
+export declare function httpStartRun(base: string, input: HttpStartRunInput): Promise<StartRunResult>;
+export declare function httpRerun(base: string, runId: string): Promise<StartRunResult>;
+export declare function httpDeliverAnswer(base: string, runId: string, stageId: string, answer: unknown): Promise<DeliverAnswerResult>;
+export declare function httpDecideFeedbackLoop(base: string, runId: string, stageId: string, input: {
+    decision: "extend" | "continue" | "abandon";
+    loopId?: string;
+    reason?: string;
+}): Promise<DecideFeedbackLoopResult>;
+type RetryOrchestrationResult = {
+    ok: true;
+    pipeline: PipelineRunResult;
+} | Extract<RetryStageResult, {
+    ok: false;
+}>;
+export declare function httpRetryStageUntilStop(base: string, runId: string, stageId: string): Promise<RetryOrchestrationResult>;
+export declare function httpResumeTimedOutStage(base: string, runId: string, stageId: string): Promise<RetryStageResult>;
+export declare function httpRecoverManualStageUntilStop(base: string, runId: string, stageId: string, guidance?: string): Promise<RetryOrchestrationResult>;
+export declare function httpStopManualRecovery(base: string, runId: string, stageId: string): Promise<StopManualRecoveryResult>;
+export declare function httpAbandonStage(base: string, runId: string, stageId: string): Promise<AbandonStageResult>;
+export declare function resolveAbsolute(cwd: string, maybeRelative: string): string;
+export {};

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/runsCommand.d.ts

@@ -1,22 +1,18 @@
 import type { RunStore } from "../runstore/port.js";
-import { RunManager } from "../runtime/runManager.js";
-export declare const RUNS_USAGE = "Usage:\n  sf runs list [--status created|running|succeeded|failed] [--since <iso>] [--pipeline <id-or-path>] [--json]\n  sf runs show --run <runId> [--from <sf-run.json>] [--json]\n  sf runs verify --run <runId> --stage <stageId> [--json]\n  sf runs recover --run <runId> --stage <stageId> [--guidance <text>] [--stop] [--json]\n  sf runs waiting [--run <runId>] [--json]\n  sf runs wait --run <runId> [--from <sf-run.json>] [--until any|waiting|terminal] [--timeout-ms <n>] [--json]\n  sf runs answer --run <runId> --stage <stageId> [--answer '<json>'] [--json]\n  sf runs feedback-decide --run <runId> --stage <sourceStageId> [--loop <loopId>] --decision extend|continue|abandon [--reason <text>] [--json]\n  sf runs retry --run <runId> --stage <stageId> [--json]\n  sf runs abandon --run <runId> --stage <stageId> [--json]\n  sf runs rerun --run <runId> [--json]";
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
+export declare const RUNS_USAGE = "Usage:\n  sf runs list [--status created|running|succeeded|failed] [--since <iso>] [--pipeline <id-or-path>] [--json]\n  sf runs show --run <runId> [--from <sf-run.json>] [--json]\n  sf runs verify --run <runId> --stage <stageId> [--json]\n  sf runs recover --run <runId> --stage <stageId> [--guidance <text>] [--stop] [--json]\n  sf runs waiting [--run <runId>] [--json]\n  sf runs wait --run <runId> [--from <sf-run.json>] [--until any|waiting|terminal] [--timeout-ms <n>] [--json]\n  sf runs answer --run <runId> --stage <stageId> [--answer '<json>'] [--json]\n  sf runs feedback-decide --run <runId> --stage <sourceStageId> [--loop <loopId>] --decision extend|continue|abandon [--reason <text>] [--json]\n  sf runs retry --run <runId> --stage <stageId> [--json]\n  sf runs resume --run <runId> --stage <stageId> [--json]\n  sf runs abandon --run <runId> --stage <stageId> [--json]\n  sf runs rerun --run <runId> [--json]";
 export type RunsCommandIo = {
     log: (line: string) => void;
     error: (line: string) => void;
 };
-export type HostProbeResult = "up" | "down";
-export declare function defaultProbeHost(): Promise<HostProbeResult>;
 export declare function runRunsCommand(args: string[], options?: {
     cwd?: string;
-    projectRoot?: string;
-    isGitProject?: boolean;
     io?: Partial<RunsCommandIo>;
     store?: RunStore;
-    probeHost?: () => Promise<HostProbeResult>;
     stdinIsTTY?: boolean;
     readStdin?: () => string;
     waitSignal?: AbortSignal;
     env?: NodeJS.ProcessEnv;
-    createManager?: (store: RunStore) => RunManager;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
 }): Promise<number>;