stageflow 0.36.0 → 0.40.0

package/dist/server/http.js

@@ -1,3 +1,4 @@
+import { OVERVIEW_RANGES, buildOverview, isOverviewRange, overviewWindowMs, } from "../runstore/overviewSummary.js";
 import { readFile, access } from "node:fs/promises";
 import { createReadStream, statSync } from "node:fs";
 import path from "node:path";
@@ -25,7 +26,7 @@ import { createWorkshopBuild, focusUnboundWorkshopBuild, getWorkshopBuild, listW
 import { resolveAgentPort } from "../operatorAgent/index.js";
 import { listPipelinesForContext } from "../config/browseCatalog.js";
 import { catalogContextFromStageflow } from "../config/resolveCatalogContext.js";
-import { listModelsMultiProject, listPipelinesMultiProject, listTasksMultiProject, } from "../config/multiProjectCatalog.js";
+import { listPipelinesMultiProject, listTasksMultiProject, } from "../config/multiProjectCatalog.js";
 import { catalogPathErrorBody, CatalogPathError, resolveCatalogRelativePath, resolveCatalogStartInput, resolveDefaultWriteRoot, resolveWritableCatalogRoot, } from "../config/catalogRelativePath.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
@@ -36,6 +37,7 @@ import { validateCatalog } from "../config/validateCatalog.js";
 import { artifactMediaType, classifyArtifactContent, readRunArtifact, readRunArtifactBytes, } from "../mcp/readArtifact.js";
 import { getRunDiff, listCheckoutChanges, readCheckoutFileBytes, } from "../mcp/checkoutTools.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
+import { sqliteConnectionFromStore } from "../runstore/createStore.js";
 import { BackupError, createBackup, resolveBackupDownloadPath, } from "../runstore/backup.js";
 import { RestoreError, resolveBackupNameForRestore, stageRestoreForBoot, } from "../runstore/restore.js";
 import { iterateExportNdjson } from "../cli/exportAllCommand.js";
@@ -51,7 +53,15 @@ import { isTaskFile } from "../runtime/taskInput.js";
 import { findTokenShapedField, tokenRejectedPayload, } from "../runtime/startPayload.js";
 import { parseAskOperatorAnswer } from "../tools/askOperator.js";
 import { handleEmailRoutes } from "./emailRoutes.js";
+import { defaultAgentProjectRoot } from "../agents/projectRoot.js";
+import { PublicWebChat } from "../agents/webChat/publicChat.js";
+import { buildModelsResponse } from "../models/response.js";
+import { createAgentHostContext } from "../agents/hostContext.js";
+import { AgentScheduleSource, agentScheduleTickIntervalMsFromEnv, } from "../agents/scheduleSource.js";
+import { handleAgentAuthorRoutes } from "./agentAuthorRoutes.js";
+import { handleAgentRoutes } from "./agentRoutes.js";
 import { handleChannelRoutes } from "./channelRoutes.js";
+import { handleMemoryRoutes } from "./memoryRoutes.js";
 import { bootstrapStageflowHost, } from "./bootstrap.js";
 import { assertAllowedHttpAccess, isTrustedLocalHttpRequest, resolveAllowedHosts, } from "./allowedHosts.js";
 import { enforceBearerAuth, loadControlTokens, requiredScopeFor, } from "./controlToken.js";
@@ -173,13 +183,38 @@ export function defaultUiDistDir() {
     return path.resolve(here, "../ui");
 }
 export function createOperatorRoutes(deps) {
-    const { manager, store, cwd, agentDir, rootDir, providerAuthContext, uiDistDir, workshopOperatorHost, } = deps;
-    const workshopChatRegistry = deps.workshopChatRegistry ??
-        new WorkshopChatSessionRegistry(workshopOperatorHost ??
-            resolveAgentPort({
+    const { manager, store, cwd, agentDir, rootDir, providerAuthContext, uiDistDir, workshopOperatorHost, agentConversationBackend, agentHost: injectedHost, } = deps;
+    const agentConnection = injectedHost ? undefined : sqliteConnectionFromStore(store);
+    const agentHost = injectedHost ??
+        (agentConnection
+            ? createAgentHostContext({
                 cwd,
-                projectRoot: cwd,
-            }));
+                agentDir,
+                connection: agentConnection,
+                ...(agentConversationBackend ? { backend: agentConversationBackend } : {}),
+            })
+            : undefined);
+    const agentScheduleSource = agentHost
+        ? new AgentScheduleSource({
+            service: agentHost.service,
+            projectRoot: defaultAgentProjectRoot(cwd),
+            intervalMs: agentScheduleTickIntervalMsFromEnv(),
+        })
+        : undefined;
+    void agentScheduleSource?.start(async (event) => {
+        await agentHost.chat.send({
+            projectRoot: defaultAgentProjectRoot(cwd),
+            agentId: event.agentId,
+            text: event.message,
+            source: "schedule",
+        });
+    });
+    const operatorHost = workshopOperatorHost ??
+        resolveAgentPort({
+            cwd,
+            projectRoot: cwd,
+        });
+    const workshopChatRegistry = deps.workshopChatRegistry ?? new WorkshopChatSessionRegistry(operatorHost);
     const workshopSessionStoreRoot = () => resolveWorkshopSessionStoreRoot();
     const workshopBuildStoreRoot = () => resolveWorkshopBuildStoreRoot();
     const allowedHosts = deps.allowedHosts ?? resolveAllowedHosts();
@@ -215,6 +250,98 @@ export function createOperatorRoutes(deps) {
             try {
                 if (await liveView.handle(req, res))
                     return true;
+                if (pathname === "/api/agent-author/chat" || pathname === "/api/agent-author/undo") {
+                    if (await handleAgentAuthorRoutes(req, method, pathname, cwd, operatorHost, res, json))
+                        return true;
+                }
+                if (PublicWebChat.owns(pathname)) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "web_chat.unavailable" });
+                        return true;
+                    }
+                    return await agentHost.publicChat.handle(req, res, method, pathname);
+                }
+                if (method === "GET" && uiDistDir !== undefined && /^\/chat\/[^/]+$/.test(pathname)) {
+                    const page = path.join(uiDistDir, "chat.html");
+                    try {
+                        const html = await readFile(page);
+                        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "X-Robots-Tag": "noindex" });
+                        res.end(html);
+                        return true;
+                    }
+                    catch {
+                        json(res, 404, { error: "Chat page not built. Run npm run ui:build." });
+                        return true;
+                    }
+                }
+                const agentInbound = method === "POST" ? pathname.match(/^\/api\/agent-inbound\/([^/]+)$/) : null;
+                if (agentInbound) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "agent.store_unavailable" });
+                        return true;
+                    }
+                    const declared = Number(req.headers["content-length"] ?? 0);
+                    if (declared > 1024 * 1024) {
+                        json(res, 413, {});
+                        return true;
+                    }
+                    const chunks = [];
+                    let received = 0;
+                    for await (const chunk of req) {
+                        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+                        received += buffer.length;
+                        if (received > 1024 * 1024) {
+                            json(res, 413, {});
+                            req.destroy();
+                            return true;
+                        }
+                        chunks.push(buffer);
+                    }
+                    const raw = Buffer.concat(chunks);
+                    const headers = {};
+                    for (const [name, value] of Object.entries(req.headers))
+                        headers[name] = Array.isArray(value) ? value[0] : value;
+                    const outcome = await agentHost.inbound.handle(decodeURIComponent(agentInbound[1]), headers, raw.toString("utf8"));
+                    json(res, outcome.status, outcome.body ?? {});
+                    return true;
+                }
+                if (pathname === "/api/agents" || pathname.startsWith("/api/agents/")) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "agent.store_unavailable" });
+                        return true;
+                    }
+                    // Default: the Host's own project. An explicit project_root must be a known catalog root
+                    // (writable for writes); its filesystem path, not its wire id, is where agents/ lives.
+                    let agentProjectRoot = defaultAgentProjectRoot(cwd);
+                    const requestedRoot = url.searchParams.get("project_root");
+                    if (requestedRoot !== null && path.resolve(requestedRoot) !== path.resolve(agentProjectRoot)) {
+                        try {
+                            const resolved = method === "GET"
+                                ? await resolveCatalogStartInput({ store, bootCwd: cwd }, requestedRoot)
+                                : await resolveWritableCatalogRoot({ store, bootCwd: cwd }, requestedRoot);
+                            agentProjectRoot = resolved.wireRoot.path;
+                        }
+                        catch (err) {
+                            if (err instanceof CatalogPathError) {
+                                json(res, 400, catalogPathErrorBody(err));
+                                return true;
+                            }
+                            throw err;
+                        }
+                    }
+                    if (await handleAgentRoutes(req, method, pathname, agentHost, agentProjectRoot, res, json))
+                        return true;
+                }
+                if (pathname === "/api/memories" || pathname.startsWith("/api/memories/")) {
+                    if (!assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: method !== "GET" }))
+                        return true;
+                    if (!boot.memories) {
+                        json(res, 503, { code: "memory.unavailable" });
+                        return true;
+                    }
+                    if (await handleMemoryRoutes(req, method, pathname, boot.memories, res, json))
+                        return true;
+                }
                 if (pathname === "/api/connections" || pathname.startsWith("/api/connections/")) {
                     if (!assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: method !== "GET" }))
                         return true;
@@ -2730,27 +2857,26 @@ export function createOperatorRoutes(deps) {
                     });
                     return true;
                 }
-                if (method === "GET" && pathname === "/api/models") {
+                if ((method === "GET" && pathname === "/api/models") || (method === "POST" && pathname === "/api/models/refresh")) {
+                    if (method === "POST" && !assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: true }))
+                        return true;
                     const filter = url.searchParams.get("project_root") ?? undefined;
-                    const result = await listModelsMultiProject({
+                    const { response, used } = await buildModelsResponse({
                         store,
-                        bootCwd: cwd,
+                        cwd,
                         projectRootFilter: filter,
+                        refresh: method === "POST",
                     });
-                    if (result.root_errors.some((e) => e.code === "unknown_project_root") &&
-                        result.items.length === 0) {
+                    if (used.root_errors.some((e) => e.code === "unknown_project_root") &&
+                        used.items.length === 0) {
                         json(res, 400, {
-                            error: result.root_errors[0].message,
+                            error: used.root_errors[0].message,
                             code: "unknown_project_root",
-                            root_errors: result.root_errors,
+                            root_errors: used.root_errors,
                         });
                         return true;
                     }
-                    json(res, 200, {
-                        models: result.models,
-                        entries: result.items,
-                        root_errors: result.root_errors,
-                    });
+                    json(res, 200, response);
                     return true;
                 }
                 if (await handleProviderRoutes(req, res, {
@@ -2763,6 +2889,7 @@ export function createOperatorRoutes(deps) {
                 }
                 if (await handleProjectMcpRoutes(req, res, {
                     projectRoot: rootDir,
+                    readJsonBody,
                     json,
                 })) {
                     return true;
@@ -2876,6 +3003,20 @@ export function createOperatorRoutes(deps) {
                     await handleApiHealth(req, res, boot);
                     return true;
                 }
+                if (method === "GET" && pathname === "/api/overview") {
+                    const rangeParam = url.searchParams.get("range") ?? "7d";
+                    if (!isOverviewRange(rangeParam)) {
+                        json(res, 400, {
+                            error: `range must be one of ${OVERVIEW_RANGES.join(", ")}`,
+                            code: "invalid_range",
+                        });
+                        return true;
+                    }
+                    const now = new Date();
+                    const since = new Date(now.getTime() - 2 * overviewWindowMs(rangeParam)).toISOString();
+                    json(res, 200, buildOverview(await store.listRunOverviewRows(since), rangeParam, now));
+                    return true;
+                }
                 if (method === "GET" && pathname === "/api/settings") {
                     const health = manager.getHealth();
                     const credential = getCredentialSourceSettings(cwd);
@@ -2972,7 +3113,14 @@ export function createOperatorRoutes(deps) {
             }
         }
     };
-    return Object.assign(handler, { dispose: () => liveView.dispose() });
+    return Object.assign(handler, {
+        dispose: async () => {
+            await agentScheduleSource?.stop();
+            if (!injectedHost)
+                await agentHost?.stop();
+            await liveView.dispose();
+        },
+    });
 }
 export async function startUiServer(options) {
     const host = options.host ?? "127.0.0.1";
@@ -3002,6 +3150,10 @@ export async function startUiServer(options) {
             ...(options.workshopOperatorHost
                 ? { workshopOperatorHost: options.workshopOperatorHost }
                 : {}),
+            ...(boot.agentHost ? { agentHost: boot.agentHost } : {}),
+            ...(options.agentConversationBackend
+                ? { agentConversationBackend: options.agentConversationBackend }
+                : {}),
         });
     const envelope = await createHttpHost({
         boot,

package/dist/server/mcpHost.js

@@ -27,6 +27,7 @@ export async function startMcpServer(options) {
             allowedHosts,
             controlTokens,
             getShutdown: () => shutdown,
+            ...(boot.agentHost ? { agentHost: boot.agentHost } : {}),
         });
     const envelope = await createHttpHost({
         boot,

package/dist/server/memoryRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type MemoryHost } from "../memory/host.js";
+type Json = (res: ServerResponse, status: number, body: unknown) => void;
+export declare function handleMemoryRoutes(req: IncomingMessage, method: string, pathname: string, host: MemoryHost, res: ServerResponse, json: Json): Promise<boolean>;
+export {};

package/dist/server/memoryRoutes.js

@@ -0,0 +1,146 @@
+import { MemoryError } from "../memory/host.js";
+const MAX_BODY_BYTES = 256 * 1024;
+const STATUS = {
+    MEMORY_INVALID_ID: 400,
+    MEMORY_INVALID_DESCRIPTION: 400,
+    MEMORY_INVALID_KEY: 400,
+    MEMORY_TOO_LARGE: 400,
+    MEMORY_TOO_MANY_CARDS: 400,
+    MEMORY_NOT_ATTACHED: 403,
+    MEMORY_NOT_FOUND: 404,
+    MEMORY_NO_PREVIOUS: 404,
+    MEMORY_CARD_NOT_FOUND: 404,
+    MEMORY_EXISTS: 409,
+    MEMORY_CARD_EXISTS: 409,
+    MEMORY_MISMATCH: 422,
+    MEMORY_UNREADABLE: 500,
+};
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        size += buffer.length;
+        if (size > MAX_BODY_BYTES)
+            throw new MemoryError("MEMORY_TOO_LARGE");
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new MemoryError("MEMORY_INVALID_ID");
+    }
+}
+function memoryId(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        throw new MemoryError("MEMORY_INVALID_ID");
+    }
+}
+function queryKey(req) {
+    const raw = req.url ?? "";
+    const mark = raw.indexOf("?");
+    if (mark < 0)
+        return null;
+    const params = new URLSearchParams(raw.slice(mark + 1));
+    if (!params.has("key"))
+        return null;
+    return params.get("key") ?? "";
+}
+function textField(value, code) {
+    if (typeof value !== "string")
+        throw new MemoryError(code);
+    return value;
+}
+export async function handleMemoryRoutes(req, method, pathname, host, res, json) {
+    const previousCard = pathname.match(/^\/api\/memories\/([^/]+)\/cards\/previous$/);
+    const cards = pathname.match(/^\/api\/memories\/([^/]+)\/cards$/);
+    const previousCover = pathname.match(/^\/api\/memories\/([^/]+)\/previous$/);
+    const detail = pathname.match(/^\/api\/memories\/([^/]+)$/);
+    const collection = pathname === "/api/memories";
+    if (!collection && !detail && !cards && !previousCard && !previousCover)
+        return false;
+    if (cards && method === "POST")
+        return false;
+    try {
+        if (collection && method === "GET") {
+            json(res, 200, { memories: await host.list() });
+            return true;
+        }
+        if (collection && method === "POST") {
+            const body = await readBody(req);
+            if (typeof body.id !== "string" || typeof body.description !== "string") {
+                throw new MemoryError("MEMORY_INVALID_ID");
+            }
+            const created = await host.create({ id: body.id, description: body.description });
+            json(res, 201, created);
+            return true;
+        }
+        if (detail && method === "GET") {
+            const id = memoryId(detail[1]);
+            const meta = await host.readMeta(id);
+            const page = await host.read(id);
+            json(res, 200, { ...meta, body: page });
+            return true;
+        }
+        if (detail && method === "PATCH") {
+            const id = memoryId(detail[1]);
+            const payload = await readBody(req);
+            const body = textField(payload.body, "MEMORY_TOO_LARGE");
+            await host.replace(id, body);
+            const meta = await host.readMeta(id);
+            json(res, 200, { ...meta, body });
+            return true;
+        }
+        if (previousCover && method === "GET") {
+            const id = memoryId(previousCover[1]);
+            json(res, 200, { body: await host.readPreviousCover(id) });
+            return true;
+        }
+        if (cards && method === "GET") {
+            const id = memoryId(cards[1]);
+            const key = queryKey(req);
+            if (key === null) {
+                json(res, 200, { keys: await host.listCards(id) });
+                return true;
+            }
+            json(res, 200, { body: await host.readCard(id, key) });
+            return true;
+        }
+        if (cards && method === "PATCH") {
+            const id = memoryId(cards[1]);
+            const payload = await readBody(req);
+            const key = textField(payload.key, "MEMORY_INVALID_KEY");
+            const body = textField(payload.body, "MEMORY_TOO_LARGE");
+            await host.updateCard(id, key, body);
+            json(res, 200, { body });
+            return true;
+        }
+        if (cards && method === "DELETE") {
+            const id = memoryId(cards[1]);
+            const payload = await readBody(req);
+            await host.deleteCard(id, textField(payload.key, "MEMORY_INVALID_KEY"));
+            json(res, 200, { removed: true });
+            return true;
+        }
+        if (previousCard && method === "GET") {
+            const id = memoryId(previousCard[1]);
+            const key = queryKey(req);
+            if (key === null)
+                throw new MemoryError("MEMORY_INVALID_KEY");
+            json(res, 200, { body: await host.readPreviousCard(id, key) });
+            return true;
+        }
+    }
+    catch (error) {
+        const code = error instanceof MemoryError ? error.code : "MEMORY_UNREADABLE";
+        json(res, STATUS[code], { code });
+        return true;
+    }
+    return false;
+}

package/dist/server/projectMcpRoutes.d.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 export type ProjectMcpRoutesCtx = {
     projectRoot: string;
+    readJsonBody: (req: IncomingMessage) => Promise<unknown>;
     json: (res: ServerResponse, status: number, body: unknown) => void;
 };
 export declare function handleProjectMcpRoutes(req: IncomingMessage, res: ServerResponse, ctx: ProjectMcpRoutesCtx): Promise<boolean>;