@sema-agent/server 1.315.0 → 1.316.0

package/dist/http/idempotency.d.ts

@@ -9,4 +9,5 @@ export declare class IdempotencyCache<T> {
     private live;
     private maybeSweep;
 }
+export declare function scopedIdempotencyKey(raw: string | undefined, source: string | null, principal: string | undefined): string | undefined;
 //# sourceMappingURL=idempotency.d.ts.map

package/dist/http/idempotency.js

@@ -46,4 +46,7 @@ export class IdempotencyCache {
                 this.entries.delete(k);
     }
 }
+export function scopedIdempotencyKey(raw, source, principal) {
+    return raw ? `${source ?? ""}\x1f${principal ?? ""}\x1f${raw}` : undefined;
+}
 //# sourceMappingURL=idempotency.js.map

package/dist/http/principal-gate.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage } from "node:http";
+import type { ServiceConfig } from "../config-types.js";
+export declare function headerStr(v: string | string[] | undefined): string | undefined;
+export declare function safeEqual(a: string, b: string): boolean;
+export declare function authorized(req: IncomingMessage, token: string): boolean;
+export declare function systemFor(req: IncomingMessage, config: ServiceConfig): string | null | undefined;
+export declare function bearerPresentedButUnverified(req: IncomingMessage, config: ServiceConfig): boolean;
+export declare function gatedPrincipal(req: IncomingMessage, config: ServiceConfig): string | undefined;
+export declare function explicitOperatorOk(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+export declare function isOperator(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+export declare function explicitOperator(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+//# sourceMappingURL=principal-gate.d.ts.map

package/dist/http/principal-gate.js

@@ -0,0 +1,52 @@
+import { timingSafeEqual } from "node:crypto";
+import { verifiedPrincipal, ssoVerifiedPrincipal } from "../security.js";
+export function headerStr(v) {
+    return Array.isArray(v) ? v[0] : v;
+}
+export function safeEqual(a, b) {
+    const ab = Buffer.from(a, "utf8");
+    const bb = Buffer.from(b, "utf8");
+    return ab.length === bb.length && timingSafeEqual(ab, bb);
+}
+export function authorized(req, token) {
+    const h = req.headers.authorization ?? "";
+    return safeEqual(h, `Bearer ${token}`) || safeEqual(h, `token ${token}`);
+}
+export function systemFor(req, config) {
+    for (const [tok, system] of Object.entries(config.authTokens ?? {})) {
+        if (authorized(req, tok))
+            return system;
+    }
+    if (config.authToken && authorized(req, config.authToken))
+        return null;
+    return undefined;
+}
+export function bearerPresentedButUnverified(req, config) {
+    const h = req.headers.authorization;
+    if (typeof h !== "string" || !/^(Bearer|token) /i.test(h))
+        return false;
+    if (ssoVerifiedPrincipal(req))
+        return false;
+    if (systemFor(req, config) !== undefined)
+        return false;
+    if (config.traceToken && authorized(req, config.traceToken))
+        return false;
+    return true;
+}
+export function gatedPrincipal(req, config) {
+    if (bearerPresentedButUnverified(req, config))
+        return undefined;
+    return verifiedPrincipal(req, config);
+}
+export function explicitOperatorOk(principal, operatorPrincipals) {
+    return operatorPrincipals.length > 0 && principal !== undefined && operatorPrincipals.includes(principal);
+}
+export function isOperator(principal, operatorPrincipals) {
+    if (operatorPrincipals.length === 0)
+        return true;
+    return principal !== undefined && operatorPrincipals.includes(principal);
+}
+export function explicitOperator(principal, operatorPrincipals) {
+    return operatorPrincipals.length > 0 && principal !== undefined && operatorPrincipals.includes(principal);
+}
+//# sourceMappingURL=principal-gate.js.map

package/dist/http/route-ctx.d.ts

@@ -0,0 +1,67 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { TaskStream } from "@sema-agent/core";
+import type { FlatServiceDeps } from "./server.js";
+import type { IdempotencyCache } from "./idempotency.js";
+import type { ImagesLocal } from "./routes/images.js";
+import type { SessionsLocal } from "./routes/sessions.js";
+import type { SessionSyncLocal } from "./routes/session-sync.js";
+export interface RunRegistry {
+    idemCache: IdempotencyCache<{
+        status: number;
+        body: unknown;
+    }>;
+    inflightRuns: Map<string, AbortController>;
+    preemptableRuns: Map<string, AbortController>;
+    cancelledViaVerb: Set<string>;
+    steerableRuns: Map<string, TaskStream>;
+    wakeParkMints: Map<string, Promise<void>>;
+    counters: {
+        uncountedBillableInflight: number;
+        admittedInflight: number;
+    };
+}
+export interface RouteHelpers {
+    readJson(req: IncomingMessage): Promise<unknown>;
+    readRawBody(req: IncomingMessage, max: number): Promise<Buffer>;
+    rateLimited(req: IncomingMessage, res: ServerResponse): boolean;
+    quotaExceeded(req: IncomingMessage, res: ServerResponse): boolean;
+    leaseDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    safeDecode(seg: string): string | null;
+    isFleetWide(req: IncomingMessage): boolean;
+    runOwnerOk(req: IncomingMessage, res: ServerResponse, owner: string | null): boolean;
+    sessionOwnerScope(req: IncomingMessage): {
+        fleetWide: boolean;
+        gateOwner: string | null;
+    };
+    sessionOwnerScopeForWrite(req: IncomingMessage): {
+        fleetWide: boolean;
+        gateOwner: string | null;
+    };
+    runSessionAcceptOk(req: IncomingMessage, res: ServerResponse, run: {
+        sessionId: string | null;
+    }, face: string, notFoundError?: string): boolean;
+}
+export interface RouteLocals {
+    images: ImagesLocal;
+    sessions: SessionsLocal;
+    sessionSync: SessionSyncLocal;
+}
+export interface RouteRequestState {
+    streamTaskId: string | undefined;
+    streamDetached: boolean;
+    source: string | null;
+}
+export interface RouteCtxBase {
+    deps: FlatServiceDeps;
+    registry: RunRegistry;
+    helpers: RouteHelpers;
+    local: RouteLocals;
+}
+export interface RouteCtx extends RouteCtxBase {
+    req: RouteRequestState;
+}
+export type RouteHandler = (req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx) => Promise<boolean>;
+export interface RouteMiss {
+    fell: boolean;
+}
+//# sourceMappingURL=route-ctx.d.ts.map

package/dist/http/route-ctx.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route-ctx.js.map

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

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

package/dist/http/routes/attachments.js

@@ -0,0 +1,106 @@
+import { createHash } from "node:crypto";
+import { uuidv7, sanitizePathComponent } from "@sema-agent/core";
+import { HttpError } from "../../security.js";
+import { sendJson, sendError } from "../send.js";
+import { gatedPrincipal } from "../principal-gate.js";
+export async function handleAttachments(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleAttachmentsBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+async function handleAttachmentsBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    const { rateLimited, quotaExceeded, safeDecode, readRawBody } = ctx.helpers;
+    {
+        const am = /^\/v1\/attachments(?:\/([^/?]+))?$/.exec(url);
+        if (am) {
+            if (rateLimited(req, res) || quotaExceeded(req, res))
+                return;
+            const store = deps.taskAttachmentStore;
+            if (!store) {
+                sendJson(res, 501, { error: "attachment store not configured" });
+                return;
+            }
+            const principal = gatedPrincipal(req, deps.config);
+            if (deps.config.requirePrincipal && principal === undefined) {
+                sendJson(res, 401, { error: `missing principal header '${deps.config.principalHeader}'` });
+                return;
+            }
+            const owner = principal ?? "default";
+            const attId = am[1] !== undefined ? safeDecode(am[1]) : undefined;
+            if (attId === undefined && req.method === "POST") {
+                const q = new URL(req.url ?? "", "http://x").searchParams;
+                const rawName = q.get("name");
+                const base = ((rawName ?? "").split(/[/\\]/).filter(Boolean).pop() ?? "").slice(0, 128);
+                if (!rawName || base === "" || base === "." || base === ".." || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(base)) {
+                    sendJson(res, 400, { error: "query param `name` is required and must reduce to a safe basename ([A-Za-z0-9._-], not starting with a dot)" });
+                    return;
+                }
+                const name = sanitizePathComponent(base);
+                const mime = String(req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
+                if (!/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(mime) || mime.length > 128) {
+                    sendJson(res, 400, { error: "content-type must be a well-formed mime type (type/subtype)" });
+                    return;
+                }
+                const allow = deps.config.attachmentMimeAllowlist;
+                if (allow && !allow.some((a) => a === mime || (a.endsWith("/*") && mime.startsWith(a.slice(0, -1))))) {
+                    sendError(res, 415, "attachment.mime_not_allowed", `mime '${mime}' is not in this deployment's allowlist`, { code: "attachment.mime_not_allowed", allowed: allow });
+                    return;
+                }
+                const max = deps.config.attachmentMaxBytes ?? 32 * 1024 * 1024;
+                let body;
+                try {
+                    body = await readRawBody(req, max);
+                }
+                catch (err) {
+                    if (err instanceof HttpError && err.status === 413) {
+                        sendError(res, 413, "attachment.too_large", `attachment exceeds the per-file limit (${max} bytes)`, { code: "attachment.too_large", maxBytes: max });
+                        return;
+                    }
+                    throw err;
+                }
+                const rec = {
+                    id: uuidv7(),
+                    owner,
+                    name,
+                    mime,
+                    sha256: createHash("sha256").update(body).digest("hex"),
+                    sizeBytes: body.length,
+                    createdAtMs: Date.now(),
+                };
+                await store.put({ ...rec, content: new Uint8Array(body) });
+                deps.metrics?.inc("attachment_uploads_total");
+                sendJson(res, 201, { id: rec.id, name: rec.name, mime: rec.mime, sha256: rec.sha256, sizeBytes: rec.sizeBytes });
+                return;
+            }
+            if (attId !== undefined && attId !== null && req.method === "GET") {
+                const meta = await store.get(owner, attId);
+                const bytes = meta ? await store.getContent(owner, attId) : null;
+                if (!meta || !bytes) {
+                    sendJson(res, 404, { error: "not found" });
+                    return;
+                }
+                res.writeHead(200, {
+                    "content-type": meta.mime,
+                    "content-length": String(bytes.byteLength),
+                    "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(meta.name)}`,
+                });
+                res.end(Buffer.from(bytes));
+                return;
+            }
+            if (attId !== undefined && attId !== null && req.method === "DELETE") {
+                const ok = await store.delete(owner, attId);
+                if (!ok) {
+                    sendJson(res, 404, { error: "not found" });
+                    return;
+                }
+                res.writeHead(204).end();
+                return;
+            }
+            sendJson(res, 404, { error: "not found" });
+            return;
+        }
+    }
+    miss.fell = true;
+}
+//# sourceMappingURL=attachments.js.map

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

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

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/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