stageflow 0.2.0 → 0.8.0

package/dist/runtime/stageWorker.js

@@ -1,7 +1,7 @@
 import { PiAgentAdapter } from "../agent/piAdapter.js";
-import { loadPipeline } from "../config/loadPipeline.js";
-import { loadTaskFromYaml } from "../config/loadTask.js";
+import { definitionIdForInstance } from "../runstore/stageInstanceId.js";
 import { createRunStore } from "../runstore/createStore.js";
+import { loadRunContext } from "./resumeReconstruct.js";
 import { bindPiAgentDirEnv, rootsForStageWorker, withResolvedAuthPath, } from "./stageRoots.js";
 import { runStage, isRunStageWaiting, } from "./stageRunner.js";
 import { openStageAttempt } from "./stageAttemptBootstrap.js";
@@ -9,17 +9,16 @@ import { attemptContext } from "./stageAttemptContext.js";
 import { outcomeToWorkerResult, STAGE_WORKER_EXIT, } from "./stageWorkerProtocol.js";
 export async function runStageWorker(input) {
     const store = createRunStore({ rootDir: input.rootDir });
-    const meta = await store.readRunMeta(input.runId);
-    const taskYaml = await store.readTaskYaml(input.runId);
-    const task = loadTaskFromYaml(taskYaml, `run ${input.runId} task`);
-    const loaded = await loadPipeline(meta.pipeline_id, { cwd: input.rootDir });
-    const stage = loaded.stages.find((s) => s.id === input.stageId);
+    const { meta, task, loaded } = await loadRunContext(store, input.runId, input.rootDir);
+    const definitionId = definitionIdForInstance(meta.pipeline_dag, input.stageId);
+    const stage = loaded.stages.find((s) => s.id === definitionId);
     if (!stage) {
         return {
             ok: false,
             reason: `Stage ${input.stageId} not in pipeline ${meta.pipeline_id}`,
         };
     }
+    const dag = meta.pipeline_dag ?? loaded.dag;
     const agent = new PiAgentAdapter();
     const workspaceDir = store.getWorkspaceDir(input.runId);
     const checkoutRoot = meta.checkout_root;
@@ -36,8 +35,9 @@ export async function runStageWorker(input) {
                 store,
                 runId: input.runId,
                 stage,
+                stageId: input.stageId,
                 task,
-                dag: loaded.dag,
+                dag,
                 checkoutRoot,
                 workspaceDir,
                 factoryCwd: input.rootDir,
@@ -58,12 +58,14 @@ export async function runStageWorker(input) {
                 store,
                 runId: input.runId,
                 stage,
+                stageId: input.stageId,
                 task,
-                dag: loaded.dag,
+                dag,
                 checkoutRoot,
                 workspaceDir,
                 skipStarted: true,
                 existingHandle: opened.handle,
+                workerMode: true,
                 roots,
                 attemptCtx,
                 factoryCwd: input.rootDir,
@@ -77,8 +79,9 @@ export async function runStageWorker(input) {
             store,
             runId: input.runId,
             stage,
+            stageId: input.stageId,
             task,
-            dag: loaded.dag,
+            dag,
             checkoutRoot,
             workspaceDir,
             workerMode: true,

package/dist/server/bootstrap.d.ts

@@ -0,0 +1,32 @@
+import type { AgentPort } from "../agent/port.js";
+import type { ProviderAuthContext } from "../agent/providerAuth.js";
+import { type RunStoreKind } from "../runstore/createStore.js";
+import type { RunStore } from "../runstore/port.js";
+import { RunManager } from "../runtime/runManager.js";
+import { type RunChangeBus } from "../runtime/runChangeBus.js";
+import { type McpHttpHandler } from "../mcp/server.js";
+export type StageflowHostOptions = {
+    agent: AgentPort;
+    cwd?: string;
+    agentDir?: string;
+    rootDir?: string;
+    store?: RunStore;
+    storeKind?: RunStoreKind;
+    maxConcurrent?: number;
+    providerAuthContext?: ProviderAuthContext;
+    mcpStateless?: boolean;
+    runChangeBus?: RunChangeBus;
+};
+export type StageflowHostBootstrap = {
+    cwd: string;
+    agentDir: string;
+    rootDir: string;
+    isGitProject: boolean;
+    store: RunStore;
+    manager: RunManager;
+    runChangeBus: RunChangeBus;
+    mcpStateless: boolean;
+    providerAuthContext: ProviderAuthContext | undefined;
+    mcpHandler: McpHttpHandler;
+};
+export declare function bootstrapStageflowHost(options: StageflowHostOptions): Promise<StageflowHostBootstrap>;

package/dist/server/bootstrap.js

@@ -0,0 +1,56 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { createRunStore } from "../runstore/createStore.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { findProjectRoot } from "../project/findProjectRoot.js";
+import { RunManager } from "../runtime/runManager.js";
+import { createRunChangeBus, getRunChangeBusFromWrappedStore, isRunStoreWrapped, wrapRunStoreWithChangeBus, } from "../runtime/runChangeBus.js";
+import { createMcpHttpHandler, resolveMcpStateless, } from "../mcp/server.js";
+export async function bootstrapStageflowHost(options) {
+    const invocationCwd = options.cwd ?? process.cwd();
+    const ctx = await resolveStageflowContext(invocationCwd);
+    const cwd = ctx.invocationCwd;
+    const agentDir = options.agentDir ?? getAgentDir();
+    const rootDir = options.rootDir ?? ctx.projectRoot;
+    const isGitProject = options.rootDir !== undefined
+        ? findProjectRoot(rootDir) !== null
+        : ctx.isGitProject;
+    const rawStore = options.store ??
+        createRunStore({ rootDir, kind: options.storeKind });
+    const boundBus = isRunStoreWrapped(rawStore)
+        ? getRunChangeBusFromWrappedStore(rawStore)
+        : undefined;
+    if (boundBus !== undefined &&
+        options.runChangeBus !== undefined &&
+        options.runChangeBus !== boundBus) {
+        throw new Error("runChangeBus does not match the bus already bound to the provided store");
+    }
+    const runChangeBus = options.runChangeBus ?? boundBus ?? createRunChangeBus();
+    const store = wrapRunStoreWithChangeBus(rawStore, runChangeBus);
+    const manager = new RunManager({
+        agent: options.agent,
+        cwd,
+        projectRoot: rootDir,
+        isGitProject,
+        store,
+        maxConcurrent: options.maxConcurrent,
+        operatorCatalog: { cwd, agentDir },
+    });
+    await manager.attachWaitingStages();
+    await manager.reconcileOrphanedStages();
+    const mcpStateless = resolveMcpStateless({
+        mcpStateless: options.mcpStateless,
+    });
+    const mcpHandler = createMcpHttpHandler({ manager, store, cwd, runChangeBus }, { mcpStateless });
+    return {
+        cwd,
+        agentDir,
+        rootDir,
+        isGitProject,
+        store,
+        manager,
+        runChangeBus,
+        mcpStateless,
+        providerAuthContext: options.providerAuthContext,
+        mcpHandler,
+    };
+}

package/dist/server/createHttpHost.d.ts

@@ -0,0 +1,34 @@
+import { type IncomingMessage, type ServerResponse, type Server } from "node:http";
+import type { RunStore } from "../runstore/port.js";
+import type { RunManager } from "../runtime/runManager.js";
+import type { RunChangeBus } from "../runtime/runChangeBus.js";
+import type { StageflowHostBootstrap } from "./bootstrap.js";
+export declare const DEFAULT_PORT = 3847;
+export declare function json(res: ServerResponse, status: number, body: unknown): void;
+export type HttpHostRouteContext = {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: URL;
+    pathname: string;
+    method: string;
+    json: typeof json;
+    boot: StageflowHostBootstrap;
+};
+export type CreateHttpHostOptions = {
+    boot: StageflowHostBootstrap;
+    host: string;
+    port: number;
+    routes: (ctx: HttpHostRouteContext) => Promise<boolean | void>;
+};
+export type HttpHostEnvelope = {
+    server: Server;
+    port: number;
+    host: string;
+    url: string;
+    mcpUrl: string;
+    manager: RunManager;
+    store: RunStore;
+    runChangeBus: RunChangeBus;
+    mcpStateless: boolean;
+};
+export declare function createHttpHost(options: CreateHttpHostOptions): Promise<HttpHostEnvelope>;

package/dist/server/createHttpHost.js

@@ -0,0 +1,70 @@
+import { createServer, } from "node:http";
+import { localhostHostValidation, localhostOriginValidation, } from "@modelcontextprotocol/node";
+export const DEFAULT_PORT = 3847;
+export function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+export async function createHttpHost(options) {
+    const { boot, host, port, routes } = options;
+    const validateMcpHost = localhostHostValidation();
+    const validateMcpOrigin = localhostOriginValidation();
+    const server = createServer(async (req, res) => {
+        const method = req.method ?? "GET";
+        const url = new URL(req.url ?? "/", `http://${host}:${port}`);
+        const pathname = url.pathname;
+        if (pathname === "/mcp") {
+            if (!validateMcpHost(req, res) || !validateMcpOrigin(req, res)) {
+                return;
+            }
+            try {
+                await boot.mcpHandler.handle(req, res);
+            }
+            catch (err) {
+                if (!res.headersSent) {
+                    res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+                    res.end(err instanceof Error ? err.message : String(err));
+                }
+            }
+            return;
+        }
+        const handled = await routes({
+            req,
+            res,
+            url,
+            pathname,
+            method,
+            json,
+            boot,
+        });
+        if (handled)
+            return;
+        json(res, 404, { error: "Not found" });
+    });
+    server.requestTimeout = 0;
+    server.on("close", () => {
+        void boot.mcpHandler.close();
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(port, host, () => resolve());
+        server.on("error", reject);
+    });
+    const address = server.address();
+    const boundPort = address && typeof address !== "string" ? address.port : port;
+    const url = `http://${host}:${boundPort}`;
+    return {
+        server,
+        port: boundPort,
+        host,
+        url,
+        mcpUrl: `${url}/mcp`,
+        manager: boot.manager,
+        store: boot.store,
+        runChangeBus: boot.runChangeBus,
+        mcpStateless: boot.mcpStateless,
+    };
+}

package/dist/server/http.d.ts

@@ -1,10 +1,9 @@
-import { type Server } from "node:http";
 import type { AgentPort } from "../agent/port.js";
 import { type ProviderAuthContext } from "../agent/providerAuth.js";
-import { type RunStoreKind } from "../runstore/createStore.js";
+import type { RunStoreKind } from "../runstore/createStore.js";
 import type { RunStore } from "../runstore/port.js";
-import { RunManager } from "../runtime/runManager.js";
-declare const DEFAULT_PORT = 3847;
+import type { RunChangeBus } from "../runtime/runChangeBus.js";
+import { DEFAULT_PORT, type HttpHostEnvelope } from "./createHttpHost.js";
 export type UiServerOptions = {
     agent: AgentPort;
     cwd?: string;
@@ -17,15 +16,9 @@ export type UiServerOptions = {
     uiDistDir?: string;
     maxConcurrent?: number;
     providerAuthContext?: ProviderAuthContext;
+    mcpStateless?: boolean;
+    runChangeBus?: RunChangeBus;
 };
 export declare function defaultUiDistDir(): string;
-export declare function startUiServer(options: UiServerOptions): Promise<{
-    server: Server;
-    port: number;
-    host: string;
-    url: string;
-    mcpUrl: string;
-    manager: RunManager;
-    store: RunStore;
-}>;
+export declare function startUiServer(options: UiServerOptions): Promise<HttpHostEnvelope>;
 export { DEFAULT_PORT };