@sema-agent/server 1.315.0 → 1.317.0

package/dist/http/routes/capabilities.js

@@ -0,0 +1,111 @@
+import { DEFAULT_EFFORT_LEVELS } from "@sema-agent/core";
+import { cwdHonored } from "../../task-cwd.js";
+import { mcpInjectionHonored } from "../../task-mcp.js";
+import { sendJson, sendError } from "../send.js";
+export async function handleCapabilities(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleCapabilitiesBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+async function handleCapabilitiesBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    if (req.method === "GET" && url.startsWith("/v1/capabilities/scenarios/")) {
+        const name = url.slice("/v1/capabilities/scenarios/".length).split("?")[0];
+        const detail = deps.scenarioDetails?.[name];
+        if (!detail) {
+            sendError(res, 404, "scenario_not_found", "scenario not found");
+            return;
+        }
+        sendJson(res, 200, detail);
+        return;
+    }
+    if (req.method === "GET" && url === "/v1/capabilities") {
+        sendJson(res, 200, {
+            ...deps.capabilities,
+            asyncRuns: Boolean(deps.runStore),
+            artifacts: Boolean(deps.runStore),
+            approvals: Boolean(deps.checkpointStore),
+            sessions: Boolean(deps.sessionAudit),
+            sessionEvents: Boolean(deps.sessionWatch && deps.sessionStorage?.getLeafId && deps.sessionStorage?.ownerOf),
+            fleet: deps.fleetBus
+                ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory" }
+                : false,
+            workspace: (() => {
+                const wfs = deps.fileSnapshotStore;
+                return wfs && typeof wfs.listKeys === "function" && typeof wfs.exportManifest === "function" && typeof wfs.getBlob === "function" && Boolean(deps.sessionStorage?.ownerOf)
+                    ? { browse: true, archive: true, maxFileBytes: deps.config.workspaceFileMaxBytes ?? 8 * 1024 * 1024 }
+                    : false;
+            })(),
+            leader: Boolean(deps.leaderEndpoint),
+            memory: false,
+            memoryWrite: false,
+            policy: true,
+            usage: Boolean(deps.costQuota),
+            permissionModeWrite: false,
+            modelSelection: true,
+            effortSelection: true,
+            toolOutput: true,
+            messageIdentity: true,
+            forwardSubagentEvents: true,
+            scratchpadDir: true,
+            subagentSteer: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
+            subagentResume: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
+            taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: false, hooks: deps.config.requirePrincipal !== true },
+            appendSystemPrompt: true,
+            compactionModel: true,
+            subagentOutput: Boolean(deps.subagentTaskOutput) && Boolean(deps.runStore),
+            subagentStream: Boolean(deps.subagentTaskOutput) && Boolean(deps.runStore),
+            taskHandles: Boolean(deps.taskHandleOutput) && Boolean(deps.taskHandleStop) && Boolean(deps.runStore),
+            taskAgents: deps.config.requirePrincipal !== true,
+            retainBackgroundProcesses: deps.config.requirePrincipal !== true,
+            interactiveTools: true,
+            projectContext: cwdHonored(deps.config),
+            mcpInjection: mcpInjectionHonored(deps.config),
+            modelUsage: Boolean(deps.runStore && deps.modelUsage),
+            sessionInit: true,
+            mcp: true,
+            mcpElicitation: Boolean(deps.elicitation),
+            askUserQuestion: Boolean(deps.question),
+            toolApproval: Boolean(deps.toolApproval),
+            sideQuery: true,
+            sessionList: Boolean(deps.sessionStorage?.listSessions ?? deps.runStore?.listSessions),
+            sessionSearch: Boolean(deps.sessionStorage?.listSessions ?? deps.runStore?.listSessions),
+            sessionFork: Boolean(deps.sessionStorage?.fork),
+            sessionDelete: Boolean(deps.purgeSession),
+            resumeAt: Boolean(deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
+            promptSuggestions: true,
+            sessionPolicy: Boolean(deps.sessionPolicyStore),
+            rewindFiles: Boolean(deps.fileSnapshotStore),
+            rewindFilesTo: Boolean(deps.fileSnapshotStore && deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
+            scheduler: Boolean(deps.config.schedulerEnabled && deps.config.requirePrincipal !== true && deps.config.remoteExec?.provider === "host"),
+            sessionSync: Boolean(deps.backend && deps.sessionStorage?.exportEntries && deps.fileSnapshotStore),
+            sendUserFile: Boolean(deps.sendUserFile && deps.config.sendUserFile?.publicEndpoint),
+            s3PublicEndpoint: deps.config.sendUserFile?.publicEndpoint ?? null,
+            sendUserFileLedger: Boolean(deps.sendFileLedger),
+            workflows: deps.workflowsCapable ?? Boolean(deps.workflowRunStore),
+            workflowsList: Boolean(deps.workflowRunStore),
+            manualCompact: Boolean(deps.runStore),
+        });
+        return;
+    }
+    if (req.method === "GET" && url === "/v1/models") {
+        const models = Object.entries(deps.config.models)
+            .filter(([name]) => name !== "default")
+            .map(([name, m]) => ({
+            name,
+            id: m.id,
+            provider: m.provider,
+            reasoning: m.reasoning,
+            vision: Array.isArray(m.input) ? m.input.includes("image") : false,
+            ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+            ...(m.maxTokens ? { maxOutputTokens: m.maxTokens } : {}),
+            ...(m.reasoning ? { supportedEffortLevels: [...DEFAULT_EFFORT_LEVELS] } : {}),
+        }));
+        const nonAlias = Object.entries(deps.config.models).filter(([n]) => n !== "default");
+        const defaultName = (nonAlias.find(([, m]) => m === deps.config.model) ?? nonAlias.find(([, m]) => m.id === deps.config.model.id))?.[0];
+        sendJson(res, 200, { models, default: deps.config.model.id, defaultModel: { id: deps.config.model.id, ...(defaultName ? { name: defaultName } : {}) } });
+        return;
+    }
+    miss.fell = true;
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/http/routes/fleet.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteCtx } from "../route-ctx.js";
+export declare function handleFleet(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+//# sourceMappingURL=fleet.d.ts.map

package/dist/http/routes/fleet.js

@@ -0,0 +1,147 @@
+import { taskNotificationFoldKey } from "../../orchestration/workflow-completion-inbox.js";
+import { sendJson, sendError, sseHeaders } from "../send.js";
+import { gatedPrincipal } from "../principal-gate.js";
+export async function handleFleet(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleFleetBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+async function handleFleetBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    const { sessionOwnerScope } = ctx.helpers;
+    void url;
+    if (req.method === "GET" && new URL(req.url ?? "", "http://x").pathname === "/v1/fleet/stream") {
+        if (!deps.fleetBus) {
+            sendError(res, 501, "capability.self_orchestration_required", "fleet stream requires self-orchestration / fleet wiring");
+            return;
+        }
+        const { fleetWide } = sessionOwnerScope(req);
+        const principal = gatedPrincipal(req, deps.config);
+        if (deps.config.requirePrincipal && !principal && !fleetWide) {
+            sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
+            return;
+        }
+        const fleetParams = new URL(req.url ?? "", "http://x").searchParams;
+        const callerSession = fleetParams.get("session");
+        const observeOnly = fleetParams.get("observe") === "1";
+        await streamFleet(req, res, deps.fleetBus, fleetWide ? null : (principal ?? "default"), callerSession || null, observeOnly ? undefined : deps.workflowCompletionInbox);
+        return;
+    }
+    miss.fell = true;
+}
+function streamFleet(req, res, bus, callerScope, callerSession = null, completionInbox) {
+    return new Promise((resolve) => {
+        sseHeaders(res);
+        res.write(`event: meta\ndata: ${JSON.stringify({ version: 1, scoped: callerScope !== null, sessionScoped: callerSession !== null, bgNotifyFailClosed: true })}\n\n`);
+        const seenTasks = new Set();
+        const seenWf = new Set();
+        const sessionOk = (rowSession) => callerSession === null || rowSession === undefined || rowSession === callerSession;
+        const visT = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
+        const visW = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
+        const stripT = (r) => {
+            const { scope: _s, sessionId: _sid, ...rest } = r;
+            if (callerSession !== null && r.sessionId === undefined) {
+                const { description: _d, agentType: _at, agentName: _an, currentAction: _ca, ...keep } = rest;
+                return { ...keep, name: "(unattributed)" };
+            }
+            return rest;
+        };
+        const stripW = (r) => {
+            const { scope: _s, sessionId: _sid, ...rest } = r;
+            if (callerSession !== null && r.sessionId === undefined) {
+                const { description: _d, ...keep } = rest;
+                return { ...keep, name: "(unattributed)" };
+            }
+            return rest;
+        };
+        const send = (event, data) => { if (!res.writableEnded)
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`); };
+        const snap = bus.snapshot();
+        const tasks = snap.tasks.filter(visT);
+        const workflows = snap.workflows.filter(visW);
+        tasks.forEach((r) => seenTasks.add(r.id));
+        workflows.forEach((r) => seenWf.add(r.id));
+        send("snapshot", { tasks: tasks.map(stripT), workflows: workflows.map(stripW), ts: snap.ts });
+        const unsubscribe = bus.subscribe((frame) => {
+            switch (frame.type) {
+                case "task":
+                    if (visT(frame.row)) {
+                        seenTasks.add(frame.row.id);
+                        send("task", { row: stripT(frame.row), ts: frame.ts });
+                    }
+                    break;
+                case "workflow":
+                    if (visW(frame.row)) {
+                        seenWf.add(frame.row.id);
+                        send("workflow", { row: stripW(frame.row), ts: frame.ts });
+                    }
+                    break;
+                case "task_remove":
+                    if (seenTasks.delete(frame.id))
+                        send("task_remove", { id: frame.id, ts: frame.ts });
+                    break;
+                case "workflow_remove":
+                    if (seenWf.delete(frame.id))
+                        send("workflow_remove", { id: frame.id, ts: frame.ts });
+                    break;
+                case "hook_notice": {
+                    const hn = frame.notice;
+                    const hScopeOk = callerScope === null || hn.ownerScope === callerScope;
+                    const hSessionOk = callerSession === null || hn.ownerSessionId === callerSession;
+                    if (hScopeOk && hSessionOk) {
+                        const { ownerScope: _hs, ownerSessionId: _hsid, ...wire } = hn;
+                        send("hook_notice", { type: "hook_notice", ...wire, ts: frame.ts });
+                    }
+                    break;
+                }
+                case "bg_notification": {
+                    const n = frame.notification;
+                    const scopeOk = callerScope === null || n.ownerScope === callerScope;
+                    const sessionInjectOk = callerSession === null || n.ownerSessionId === callerSession;
+                    if (scopeOk && sessionInjectOk) {
+                        const { ownerScope: _os, ownerSessionId: _osid, ...wire } = n;
+                        send("bg_notification", { type: "bg_notification", ...wire, ts: frame.ts });
+                        if (completionInbox && n.ownerSessionId && callerSession !== null && callerSession === n.ownerSessionId && !res.writableEnded) {
+                            const ownerSid = n.ownerSessionId;
+                            const family = taskNotificationFoldKey({ task_id: n.taskId, status: n.status, ...(n.seq !== undefined ? { seq: n.seq } : {}) });
+                            const familyUuid = n.sessionId !== undefined && n.sessionId !== n.taskId
+                                ? taskNotificationFoldKey({ task_id: n.sessionId, status: n.status, ...(n.seq !== undefined ? { seq: n.seq } : {}) })
+                                : undefined;
+                            const ackIfAlive = () => {
+                                if (res.writableEnded || res.socket?.destroyed)
+                                    return;
+                                void completionInbox.markTerminalServed(ownerSid, family).catch(() => undefined);
+                                if (familyUuid !== undefined)
+                                    void completionInbox.markTerminalServed(ownerSid, familyUuid).catch(() => undefined);
+                            };
+                            res.write(`: ack
+
+`, ackIfAlive);
+                        }
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        });
+        const hb = setInterval(() => { if (!res.writableEnded)
+            res.write(`event: heartbeat\ndata: {}\n\n`); }, 15_000);
+        if (typeof hb.unref === "function")
+            hb.unref();
+        let done = false;
+        const shutdown = () => {
+            if (done)
+                return;
+            done = true;
+            clearInterval(hb);
+            unsubscribe();
+            if (!res.writableEnded)
+                res.end();
+            resolve();
+        };
+        req.on("close", shutdown);
+        res.on("close", shutdown);
+    });
+}
+//# sourceMappingURL=fleet.js.map

package/dist/http/routes/images.d.ts

@@ -0,0 +1,20 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { RateLimiter } from "../../observability/rate-limit.js";
+import type { BakeState, BakeErrorCode } from "../../plugins/store-contracts.js";
+import type { FlatServiceDeps } from "../server.js";
+import type { RouteCtx } from "../route-ctx.js";
+export interface ImagesLocal {
+    bakeSubmitLimiter: RateLimiter;
+}
+export declare function createImagesLocal(deps: FlatServiceDeps): ImagesLocal;
+export declare function coarseStatusForState(state: BakeState): "running" | "done" | "failed";
+export declare function errorCodeForExit(exitCode: number | null | undefined, cancelled: boolean): BakeErrorCode;
+export declare const IMAGE_DIGEST_RE: RegExp;
+export declare const IMAGE_PROFILE_RE: RegExp;
+export declare const BAKE_ID_RE: RegExp;
+export declare const BAKE_EVENTS_RE: RegExp;
+export declare const BAKE_CANCEL_RE: RegExp;
+export declare const BAKE_CLAIM_RE: RegExp;
+export declare const BAKE_INGEST_RE: RegExp;
+export declare function handleImages(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+//# sourceMappingURL=images.d.ts.map