stageflow 0.19.0 → 0.25.0

package/dist/server/ensureGlobalService.js

@@ -0,0 +1,138 @@
+import { spawn as spawnDefault } from "node:child_process";
+import { openSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureGlobalHome } from "../project/globalHome.js";
+import { DEFAULT_PORT } from "./createHttpHost.js";
+/**
+ * The well-known port the global service listens on. Overridable via
+ * STAGEFLOW_SERVICE_PORT — real usage never sets this (there's exactly one
+ * global service by design), but tests use it to point a spawned `sf run`
+ * subprocess at an isolated, already-running test server instead of the
+ * real machine's global service.
+ */
+function resolveServicePort() {
+    const raw = process.env.STAGEFLOW_SERVICE_PORT;
+    if (raw === undefined)
+        return DEFAULT_PORT;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT;
+}
+/**
+ * The published `sf` binary is compiled JS (`dist/cli.js`), directly
+ * runnable as `node <entry> mcp`. In dev/test, `cliEntry` is instead raw
+ * TypeScript source (`src/cli.ts`), which plain node can't execute — route
+ * through the same tsx loader `npm run dev` already uses for that case.
+ */
+function resolveSpawnArgs(cliEntry) {
+    const portArgs = ["--port", String(resolveServicePort())];
+    if (!/\.(?:m|c)?ts$/.test(cliEntry)) {
+        return [cliEntry, "mcp", ...portArgs];
+    }
+    try {
+        const tsxCliUrl = import.meta.resolve("tsx/cli");
+        return [fileURLToPath(tsxCliUrl), cliEntry, "mcp", ...portArgs];
+    }
+    catch {
+        return [cliEntry, "mcp", ...portArgs];
+    }
+}
+export function hostBaseUrl() {
+    return `http://127.0.0.1:${resolveServicePort()}`;
+}
+export async function probeGlobalServiceDetailed() {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 1500);
+    try {
+        let res;
+        try {
+            res = await fetch(`${hostBaseUrl()}/api/health`, { signal: ac.signal });
+        }
+        catch {
+            return "unreachable";
+        }
+        if (res.status !== 200)
+            return "unhealthy";
+        try {
+            JSON.parse(await res.text());
+        }
+        catch {
+            return "unhealthy";
+        }
+        return "up";
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function defaultProbeHost() {
+    return (await probeGlobalServiceDetailed()) === "up" ? "up" : "down";
+}
+const DEFAULT_POLL_INTERVAL_MS = 200;
+const DEFAULT_TIMEOUT_MS = Number(process.env.STAGEFLOW_AUTOSTART_TIMEOUT_MS) || 10_000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Health-probe-then-spawn: makes sure a global Stageflow service is
+ * reachable at the well-known port, starting one headlessly (`<cliEntry>
+ * mcp`, detached) if nothing answers yet. No-ops if one is already up.
+ */
+export async function ensureGlobalService(options = {}) {
+    const probeHost = options.probeHost ?? probeGlobalServiceDetailed;
+    const spawnFn = options.spawnFn ?? spawnDefault;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const initial = await probeHost();
+    if (initial === "up") {
+        return { ok: true, alreadyRunning: true };
+    }
+    if (initial === "unhealthy") {
+        return {
+            ok: false,
+            reason: "port_occupied",
+            message: `Port ${resolveServicePort()} is already in use by a process that isn't the Stageflow service (its health check didn't return valid health JSON). Free the port and try again.`,
+        };
+    }
+    const cliEntry = options.cliEntry ?? process.argv[1] ?? "";
+    const globalHome = ensureGlobalHome();
+    const logPath = path.join(globalHome, "service.log");
+    let logFd;
+    try {
+        logFd = openSync(logPath, "a");
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: "spawn_failed",
+            message: `Failed to open service log at ${logPath}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    try {
+        const spawnArgs = resolveSpawnArgs(cliEntry);
+        const child = spawnFn(process.execPath, spawnArgs, {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+        });
+        child.unref();
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: "spawn_failed",
+            message: `Failed to spawn the global Stageflow service: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await sleep(pollIntervalMs);
+        if ((await probeHost()) === "up") {
+            return { ok: true, alreadyRunning: false };
+        }
+    }
+    return {
+        ok: false,
+        reason: "timed_out",
+        message: `Timed out after ${timeoutMs}ms waiting for the global Stageflow service to become healthy. Check the log at ${logPath}.`,
+    };
+}

package/dist/server/http.d.ts

@@ -2,8 +2,9 @@ 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 type { RunManager } from "../runtime/runManager.js";
 import type { RunChangeBus } from "../runtime/runChangeBus.js";
-import { DEFAULT_PORT, type HttpHostEnvelope } from "./createHttpHost.js";
+import { DEFAULT_PORT, type HttpHostEnvelope, type HttpHostRouteContext } from "./createHttpHost.js";
 export type UiServerOptions = {
     agent: AgentPort;
     cwd?: string;
@@ -20,5 +21,23 @@ export type UiServerOptions = {
     runChangeBus?: RunChangeBus;
 };
 export declare function defaultUiDistDir(): string;
+export type OperatorRouteDeps = {
+    manager: RunManager;
+    store: RunStore;
+    cwd: string;
+    agentDir: string;
+    rootDir: string;
+    providerAuthContext: ProviderAuthContext | undefined;
+    /** Omit for a headless service (e.g. `sf mcp`) — GETs outside the API surface just 404. */
+    uiDistDir?: string;
+};
+/**
+ * The full operator-console route surface: REST API (runs, stages,
+ * catalog, settings, providers) plus, when `uiDistDir` is given, static
+ * console UI file serving. Shared by `startUiServer` (browser-facing) and
+ * `startMcpServer` (headless global-service daemon) — both need the REST
+ * API; only the former needs the UI files.
+ */
+export declare function createOperatorRoutes(deps: OperatorRouteDeps): (ctx: HttpHostRouteContext) => Promise<boolean | void>;
 export declare function startUiServer(options: UiServerOptions): Promise<HttpHostEnvelope>;
 export { DEFAULT_PORT };