@sema-agent/server 1.314.0 → 1.316.0

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

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

package/dist/http/routes/observability.js

@@ -0,0 +1,63 @@
+import { sendJson } from "../send.js";
+import { gatedPrincipal, isOperator, explicitOperatorOk } from "../principal-gate.js";
+export async function handleObservability(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleObservabilityBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+async function handleObservabilityBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    if (url === "/v1/outcomes" && req.method === "GET") {
+        if (deps.config.requirePrincipal) {
+            const principal = gatedPrincipal(req, deps.config);
+            if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
+                sendJson(res, 403, { error: "outcomes view is operator-only on a multi-tenant worker" });
+                return;
+            }
+        }
+        if (!deps.outcomeSink?.summary) {
+            sendJson(res, 501, { error: "no queryable outcome ledger on this worker (File sink — read the JSONL dataset directly)" });
+            return;
+        }
+        const q = new URL(req.url ?? "/", "http://localhost").searchParams;
+        const sig = q.get("signature") ?? undefined;
+        try {
+            const rows = await deps.outcomeSink.summary({ ...(sig ? { taskSignature: sig } : {}), includeAborted: q.get("includeAborted") === "true" });
+            sendJson(res, 200, { outcomes: rows });
+        }
+        catch (err) {
+            deps.logger?.warn?.("outcomes_summary_failed", { err: String(err) });
+            sendJson(res, 500, { error: "outcome summary failed" });
+        }
+        return;
+    }
+    if (url === "/v1/usage" && req.method === "GET") {
+        const principal = gatedPrincipal(req, deps.config);
+        if (!principal) {
+            sendJson(res, 401, { error: `missing principal header '${deps.config.principalHeader}'` });
+            return;
+        }
+        const windowSec = deps.config.costQuotaWindowSec;
+        if (!deps.costQuota) {
+            sendJson(res, 200, { enabled: false, windowSec, maxTaskCostUsd: deps.config.maxTaskCostUsd, maxTaskTokens: deps.config.maxTaskTokens });
+            return;
+        }
+        const d = deps.costQuota.check(principal);
+        sendJson(res, 200, {
+            enabled: true,
+            windowSec,
+            usedMicroUsd: d.usedMicroUsd,
+            usedUsd: d.usedMicroUsd / 1_000_000,
+            limitMicroUsd: d.limitMicroUsd,
+            limitUsd: d.limitMicroUsd / 1_000_000,
+            remainingMicroUsd: Math.max(0, d.limitMicroUsd - d.usedMicroUsd),
+            overLimit: !d.allowed,
+            retryAfterSec: d.retryAfterSec,
+            maxTaskCostUsd: deps.config.maxTaskCostUsd,
+            maxTaskTokens: deps.config.maxTaskTokens,
+        });
+        return;
+    }
+    miss.fell = true;
+}
+//# sourceMappingURL=observability.js.map

package/dist/http/routes/session-sync.d.ts

@@ -0,0 +1,36 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type SessionRulesRecord } from "@sema-agent/core";
+import { type StagingHandle } from "../../session-sync.js";
+import type { RouteCtx } from "../route-ctx.js";
+export type PendingStaging = {
+    handle: StagingHandle;
+    realSessionId: string;
+    owner: string | null;
+    resolution?: "overwrite-dst";
+    operatorOk: boolean;
+    snapshots: Array<{
+        key: string;
+        manifest: Array<[string, string]>;
+    }>;
+    policy: SessionRulesRecord[];
+    anchors: Array<{
+        eventId: string;
+        entryId: string;
+        owner: string | null;
+    }>;
+    declaredEntryIds: string[];
+    openedBy: string | null;
+    openedFleetWide: boolean;
+};
+export interface SessionSyncLocal {
+    pendingStagings: Map<string, PendingStaging>;
+    importLeases: Map<string, {
+        at: number;
+        stagingId: string;
+    }>;
+    touchImportLease(sessionId: string): void;
+    cleanupStaging(stagingId: string): void;
+}
+export declare function createSessionSyncLocal(): SessionSyncLocal;
+export declare function handleSessionSync(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+//# sourceMappingURL=session-sync.d.ts.map

package/dist/http/routes/session-sync.js

@@ -0,0 +1,513 @@
+import { once } from "node:events";
+import { randomBytes, createHash } from "node:crypto";
+import { sessionLogDigest, sessionLogDigestsComparable, uuidv7, StreamingImportValidator, SessionError, SessionPolicyError } from "@sema-agent/core";
+import { StringDecoder } from "node:string_decoder";
+import { exportSession, exportSessionManifest, importSession, classifySyncRelationshipByIds, SyncConflictError, stagingIdFor } from "../../session-sync.js";
+import { isUuidV7, isUuidShape } from "../../security.js";
+import { sendJson, sendError, msg } from "../send.js";
+import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
+const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
+const SYNC_NDJSON_LINE_MAX_BYTES = 8 * 1024 * 1024;
+const SYNC_IMPORT_BATCH = 500;
+const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+export function createSessionSyncLocal() {
+    const pendingStagings = new Map();
+    const importLeases = new Map();
+    const touchImportLease = (sessionId) => {
+        const cur = importLeases.get(sessionId);
+        if (cur)
+            importLeases.set(sessionId, { ...cur, at: Date.now() });
+    };
+    const cleanupStaging = (stagingId) => {
+        const p = pendingStagings.get(stagingId);
+        if (p)
+            importLeases.delete(p.realSessionId);
+        pendingStagings.delete(stagingId);
+    };
+    return { pendingStagings, importLeases, touchImportLease, cleanupStaging };
+}
+export async function handleSessionSync(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleSessionSyncBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+async function handleSessionSyncBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    const { readJson, readRawBody, safeDecode, sessionOwnerScopeForWrite } = ctx.helpers;
+    const { pendingStagings, importLeases, touchImportLease, cleanupStaging } = ctx.local.sessionSync;
+    {
+        const sm = /^\/v1\/sessions\/([^/]+)\/sync\/(manifest|entries|import|plan|blobs(?:\/([^/]+))?|snapshots\/([^/]+)\/blobs\/([^/]+)|import\/([^/]+)\/entries)$/.exec(url);
+        if (sm) {
+            const ownerOf = deps.sessionStorage?.ownerOf?.bind(deps.sessionStorage);
+            if (!deps.backend || !ownerOf) {
+                sendJson(res, 501, { error: "session sync requires a durable session store" });
+                return;
+            }
+            const scope = sessionOwnerScopeForWrite(req);
+            if (!scope.fleetWide && scope.gateOwner === null) {
+                sendJson(res, 401, { error: "unauthorized" });
+                return;
+            }
+            const sessionId = safeDecode(sm[1]);
+            if (sessionId === null || !isUuidShape(sessionId)) {
+                sendJson(res, 400, { error: "invalid session id (must be a canonical uuid)" });
+                return;
+            }
+            const owner = await ownerOf(sessionId);
+            const ownsOrFleet = (o) => scope.fleetWide || o === scope.gateOwner;
+            const pullGateOk = () => {
+                if (owner === undefined) {
+                    sendJson(res, 404, { error: "session not found" });
+                    return false;
+                }
+                if (!ownsOrFleet(owner)) {
+                    sendJson(res, 404, { error: "session not found" });
+                    return false;
+                }
+                return true;
+            };
+            const pushGateOk = () => {
+                if (owner !== undefined && !ownsOrFleet(owner)) {
+                    sendJson(res, 404, { error: "session not found" });
+                    return false;
+                }
+                return true;
+            };
+            if (sm[2] === "manifest" && req.method === "GET") {
+                if (!pullGateOk())
+                    return;
+                const out = await exportSessionManifest(sessionId, deps.backend);
+                if (out === null) {
+                    sendJson(res, 404, { error: "session not found" });
+                    return;
+                }
+                sendJson(res, 200, { manifest: out.manifest });
+                return;
+            }
+            if (sm[2] === "entries" && req.method === "GET") {
+                if (!pullGateOk())
+                    return;
+                const afterSeqRaw = new URL(req.url ?? "", "http://x").searchParams.get("afterSeq");
+                let afterSeq;
+                if (afterSeqRaw !== null) {
+                    const n = Number(afterSeqRaw);
+                    if (!Number.isInteger(n) || n < 0) {
+                        sendJson(res, 400, { error: "afterSeq must be a non-negative integer" });
+                        return;
+                    }
+                    afterSeq = n;
+                }
+                const stream = deps.sessionStorage?.exportEntriesStream?.bind(deps.sessionStorage);
+                if (!stream) {
+                    sendJson(res, 501, { error: "session entry streaming requires a durable session store" });
+                    return;
+                }
+                const it = await stream(sessionId, afterSeq === undefined ? undefined : { afterSeq });
+                if (it === null) {
+                    sendJson(res, 404, { error: "session not found" });
+                    return;
+                }
+                res.writeHead(200, { "content-type": "application/x-ndjson", "transfer-encoding": "chunked" });
+                const write = async (line) => { if (!res.write(line))
+                    await once(res, "drain"); };
+                let count = 0;
+                try {
+                    await write(`${JSON.stringify({ __sync: "begin", sessionId })}\n`);
+                    for await (const entry of it) {
+                        await write(`${JSON.stringify(entry)}\n`);
+                        count++;
+                    }
+                    await write(`${JSON.stringify({ __sync: "end", count })}\n`);
+                    res.end();
+                }
+                catch (e) {
+                    deps.logger?.error?.("sync entries stream failed", { sessionId, count, error: msg(e) });
+                    res.end();
+                }
+                return;
+            }
+            if (sm[4] !== undefined && req.method === "GET") {
+                if (!pullGateOk())
+                    return;
+                const key = safeDecode(sm[4]);
+                const hash = safeDecode(sm[5]);
+                if (key === null || hash === null) {
+                    sendJson(res, 400, { error: "invalid snapshot key or blob hash" });
+                    return;
+                }
+                if (!SHA256_HEX_RE.test(hash)) {
+                    sendJson(res, 400, { error: "blob hash must be 64 lowercase-hex chars" });
+                    return;
+                }
+                const fs = deps.fileSnapshotStore;
+                const manifest = await fs?.exportManifest?.(sessionId, key);
+                if (!manifest || ![...manifest.values()].includes(hash)) {
+                    sendJson(res, 404, { error: "blob not found" });
+                    return;
+                }
+                const bytes = await fs?.getBlob?.(hash);
+                if (!bytes) {
+                    sendJson(res, 404, { error: "blob not found" });
+                    return;
+                }
+                res.writeHead(200, { "content-type": "application/octet-stream" });
+                res.end(Buffer.from(bytes));
+                return;
+            }
+            if (sm[3] !== undefined && req.method === "PUT") {
+                if (!pushGateOk())
+                    return;
+                const hash = safeDecode(sm[3]);
+                if (hash === null || !SHA256_HEX_RE.test(hash)) {
+                    sendJson(res, 400, { error: "blob hash must be 64 lowercase-hex chars" });
+                    return;
+                }
+                const fs = deps.fileSnapshotStore;
+                if (typeof fs?.putBlob !== "function") {
+                    sendJson(res, 501, { error: "blob upload requires a durable snapshot store" });
+                    return;
+                }
+                const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
+                if (deps.snapshotBlobSqlCapBytes !== undefined && body.byteLength > deps.snapshotBlobSqlCapBytes) {
+                    sendError(res, 413, "blob_too_large_for_sql", `blob of ${body.byteLength} bytes exceeds this deployment's SQL snapshot-blob cap (${deps.snapshotBlobSqlCapBytes} bytes — TiDB's txn-entry-size-limit is the low wall at 6MiB by default; the mysql-protocol packet limit sits above it) — configure MinIO object storage (MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY) for large snapshot blobs, or raise SNAPSHOT_BLOB_SQL_MAX_BYTES if your deployment lifted those limits`, { code: "blob_too_large_for_sql" });
+                    return;
+                }
+                if (createHash("sha256").update(body).digest("hex") !== hash) {
+                    sendJson(res, 400, { error: "blob hash mismatch" });
+                    return;
+                }
+                const put = await fs.putBlob(hash, new Uint8Array(body));
+                if (!put.ok) {
+                    sendError(res, 502, put.error.code, "blob store write failed", { code: put.error.code });
+                    return;
+                }
+                res.writeHead(204).end();
+                return;
+            }
+            if (sm[2] === "import" && req.method === "POST") {
+                if (!pushGateOk())
+                    return;
+                if (deps.sessionMirrorRuling && !scope.fleetWide && scope.gateOwner !== null) {
+                    const auditPrincipal = scope.gateOwner;
+                    void deps.sessionMirrorRuling(auditPrincipal).then((mirror) => {
+                        if (mirror?.required) {
+                            deps.metrics?.inc("session_mirror_required_push_total");
+                            deps.logger?.info("session_mirror_required_push_observed", { principal: auditPrincipal, engineUrl: mirror.engineUrl, sessionId });
+                        }
+                    }).catch(() => { });
+                }
+                if (!deps.sessionStorage?.beginImportStaging) {
+                    sendJson(res, 501, { error: "staged session import requires a durable session store" });
+                    return;
+                }
+                let body;
+                try {
+                    body = (await readJson(req));
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!Array.isArray(body.entryIds) || !body.entryIds.every((x) => typeof x === "string")) {
+                    sendJson(res, 400, { error: "entryIds must be an array of strings" });
+                    return;
+                }
+                const snapshotsOk = Array.isArray(body.snapshots) && body.snapshots.every((s) => typeof s === "object" && s !== null && typeof s.key === "string" && Array.isArray(s.manifest));
+                if (!snapshotsOk || !Array.isArray(body.policy) || !Array.isArray(body.anchors)) {
+                    sendJson(res, 400, { error: "malformed import metadata" });
+                    return;
+                }
+                if (body.resolution !== undefined && body.resolution !== "overwrite-dst") {
+                    sendJson(res, 400, { error: "resolution must be 'overwrite-dst'" });
+                    return;
+                }
+                const resolution = body.resolution;
+                const srcLogDigest = typeof body.logDigest === "string" && body.logDigest.length > 0 ? body.logDigest : undefined;
+                const entryIds = body.entryIds;
+                const snapshots = body.snapshots;
+                const policy = body.policy;
+                const anchors = body.anchors;
+                const dstIds = (await deps.sessionStorage.listEntryIds?.(sessionId)) ?? null;
+                const relA = classifySyncRelationshipByIds(entryIds, dstIds);
+                if ((relA.relation === "fork" || relA.relation === "stale") && resolution !== "overwrite-dst") {
+                    sendError(res, 409, "conflict", "sync conflict", { relation: relA });
+                    return;
+                }
+                let payloadVerified = false;
+                let digestSaysDiffer = false;
+                if (relA.relation === "identical" && srcLogDigest !== undefined) {
+                    const dstEntries = await deps.sessionStorage.exportEntries?.(sessionId).catch(() => null) ?? null;
+                    const dstDigest = dstEntries === null ? undefined : sessionLogDigest(dstEntries);
+                    if (sessionLogDigestsComparable(srcLogDigest, dstDigest)) {
+                        if (srcLogDigest === dstDigest)
+                            payloadVerified = true;
+                        else
+                            digestSaysDiffer = true;
+                    }
+                    if (!payloadVerified)
+                        digestSaysDiffer = true;
+                }
+                if (relA.relation === "identical" && !digestSaysDiffer) {
+                    const fss = deps.fileSnapshotStore;
+                    if (fss?.importManifest && fss.getBlob && snapshots.length > 0) {
+                        const getBlobA = (h) => fss.getBlob(h);
+                        for (const snap of snapshots) {
+                            const r = await fss.importManifest(sessionId, snap.key, new Map(snap.manifest), getBlobA);
+                            if (!r.ok) {
+                                sendError(res, 422, r.error.code === "restore_failed" ? "restore_failed" : "missing_blob", `snapshot import failed (${r.error.code})`);
+                                return;
+                            }
+                        }
+                    }
+                    const opOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config.operatorPrincipals);
+                    if (deps.sessionPolicyStore)
+                        for (const rec of policy)
+                            await deps.sessionPolicyStore.putRules(sessionId, rec.principal, rec.rules, { operator: opOk });
+                    const importingP = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
+                    if (deps.resumeAnchorStore)
+                        for (const a of anchors)
+                            await deps.resumeAnchorStore.put(sessionId, a.eventId, a.entryId, importingP);
+                    sendJson(res, 200, {
+                        relation: "identical",
+                        basis: payloadVerified ? "entry-ids+digest" : "entry-ids",
+                        payloadVerified,
+                    });
+                    return;
+                }
+                const activeTaskId = await deps.runStore?.getActiveTaskId(sessionId);
+                if (activeTaskId) {
+                    sendError(res, 409, "session_active", "session has an active run; sync after it settles", { activeTaskId });
+                    return;
+                }
+                const heldLease = importLeases.get(sessionId);
+                if (heldLease) {
+                    const staleSecRaw = deps.config.syncImportLeaseStaleSec;
+                    const staleSec = typeof staleSecRaw === "number" && Number.isFinite(staleSecRaw) ? staleSecRaw : 600;
+                    const staleMs = staleSec * 1000;
+                    const ageMs = Date.now() - heldLease.at;
+                    if (staleMs > 0 && ageMs >= staleMs) {
+                        deps.logger?.warn?.("sync_import_lease_taken_over", { sessionId, ageMs, staleMs, stagingId: heldLease.stagingId });
+                        cleanupStaging(heldLease.stagingId);
+                        importLeases.delete(sessionId);
+                    }
+                    else {
+                        const retryAfterSec = staleMs > 0 ? Math.max(1, Math.ceil((staleMs - ageMs) / 1000)) : undefined;
+                        sendError(res, 409, "import_in_flight", "an import is already in flight for this session"
+                            + (retryAfterSec !== undefined ? ` (a stalled holder is taken over after ${staleSec}s of inactivity; retry in ~${retryAfterSec}s)` : ""), retryAfterSec !== undefined ? { retryAfterSec } : undefined);
+                        return;
+                    }
+                }
+                const fss = deps.fileSnapshotStore;
+                const canImportSnapshots = typeof fss?.importManifest === "function";
+                if (canImportSnapshots) {
+                    const distinct = new Set();
+                    for (const snap of snapshots)
+                        for (const [, hash] of snap.manifest)
+                            distinct.add(hash);
+                    const all = [...distinct];
+                    if (typeof fss?.hasBlobs === "function") {
+                        const present = await fss.hasBlobs(all);
+                        const missing = all.find((h) => !present.has(h));
+                        if (missing !== undefined) {
+                            sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
+                            return;
+                        }
+                    }
+                    else {
+                        for (const hash of all) {
+                            if (!(await deps.fileSnapshotStore.getBlob(hash))) {
+                                sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
+                                return;
+                            }
+                        }
+                    }
+                }
+                const importingPrincipal = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
+                const operatorOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config.operatorPrincipals);
+                const token = randomBytes(8).toString("hex");
+                const handle = deps.sessionStorage.beginImportStaging(sessionId, token);
+                const stagingId = handle.stagingId;
+                importLeases.set(sessionId, { at: Date.now(), stagingId });
+                pendingStagings.set(stagingId, {
+                    handle, realSessionId: sessionId, owner: importingPrincipal, ...(resolution ? { resolution } : {}), operatorOk,
+                    snapshots, policy, anchors, declaredEntryIds: entryIds, openedBy: scope.gateOwner, openedFleetWide: scope.fleetWide,
+                });
+                sendJson(res, 200, { stagingId, relation: relA.relation });
+                return;
+            }
+            if (sm[6] !== undefined && req.method === "POST") {
+                const stagingId = safeDecode(sm[6]);
+                if (stagingId === null) {
+                    sendJson(res, 400, { error: "invalid staging id" });
+                    return;
+                }
+                const pending = pendingStagings.get(stagingId);
+                if (!pending || pending.realSessionId !== sessionId) {
+                    sendJson(res, 404, { error: "staging not found" });
+                    return;
+                }
+                if (!pending.openedFleetWide && !scope.fleetWide && pending.openedBy !== scope.gateOwner) {
+                    sendJson(res, 404, { error: "staging not found" });
+                    return;
+                }
+                const getBlob = (h) => deps.fileSnapshotStore.getBlob(h);
+                const canImportSnapshots = typeof deps.fileSnapshotStore?.importManifest === "function";
+                const validator = new StreamingImportValidator();
+                let lineBuf = "";
+                let pendingBatch = [];
+                const flush = async () => { if (pendingBatch.length) {
+                    await pending.handle.appendBatch(pendingBatch);
+                    pendingBatch = [];
+                } };
+                class PrecheckError extends Error {
+                    status;
+                    constructor(status, msg) {
+                        super(msg);
+                        this.status = status;
+                    }
+                }
+                const streamedIds = new Set();
+                const onEntry = (e) => {
+                    if (!e || typeof e !== "object" || typeof e.id !== "string")
+                        throw new PrecheckError(422, "malformed entry (missing id)");
+                    streamedIds.add(e.id);
+                    validator.step(e);
+                };
+                const utf8 = new StringDecoder("utf8");
+                try {
+                    for await (const chunk of req) {
+                        touchImportLease(pending.realSessionId);
+                        lineBuf += utf8.write(chunk);
+                        if (Buffer.byteLength(lineBuf, "utf8") > SYNC_NDJSON_LINE_MAX_BYTES)
+                            throw new PrecheckError(413, "NDJSON line too large");
+                        let nl;
+                        while ((nl = lineBuf.indexOf("\n")) >= 0) {
+                            const line = lineBuf.slice(0, nl).trim();
+                            lineBuf = lineBuf.slice(nl + 1);
+                            if (line.length === 0)
+                                continue;
+                            let e;
+                            try {
+                                e = JSON.parse(line);
+                            }
+                            catch {
+                                throw new PrecheckError(400, "malformed NDJSON line");
+                            }
+                            onEntry(e);
+                            pendingBatch.push(e);
+                            if (pendingBatch.length >= SYNC_IMPORT_BATCH)
+                                await flush();
+                        }
+                    }
+                    lineBuf += utf8.end();
+                    const tail = lineBuf.trim();
+                    if (tail.length > 0) {
+                        let e;
+                        try {
+                            e = JSON.parse(tail);
+                        }
+                        catch {
+                            throw new PrecheckError(400, "malformed NDJSON line");
+                        }
+                        onEntry(e);
+                        pendingBatch.push(e);
+                    }
+                    await flush();
+                    validator.finish();
+                    if (streamedIds.size !== pending.declaredEntryIds.length || !pending.declaredEntryIds.every((id) => streamedIds.has(id))) {
+                        throw new PrecheckError(422, "streamed entries do not match the Phase-A declared entryIds");
+                    }
+                }
+                catch (e) {
+                    if (e instanceof PrecheckError) {
+                        await pending.handle.abort().catch(() => undefined);
+                        cleanupStaging(stagingId);
+                        sendError(res, e.status, "invalid_entries", e.message);
+                        return;
+                    }
+                    if (e instanceof SessionError && e.code === "invalid_session") {
+                        await pending.handle.abort().catch(() => undefined);
+                        cleanupStaging(stagingId);
+                        sendError(res, 422, "invalid_entries", "staged session log failed validation");
+                        return;
+                    }
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
+                    throw e;
+                }
+                const activeAtCommit = await deps.runStore?.getActiveTaskId(sessionId);
+                if (activeAtCommit) {
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
+                    sendError(res, 409, "session_active", "session started an active run while the import streamed; sync after it settles", { activeTaskId: activeAtCommit });
+                    return;
+                }
+                try {
+                    const committed = await pending.handle.commit(pending.owner, pending.resolution ? { resolution: pending.resolution } : undefined);
+                    if (canImportSnapshots) {
+                        const importManifest = deps.fileSnapshotStore.importManifest.bind(deps.fileSnapshotStore);
+                        for (const snap of pending.snapshots) {
+                            const r = await importManifest(sessionId, snap.key, new Map(snap.manifest), getBlob);
+                            if (!r.ok) {
+                                sendError(res, 422, r.error.code === "restore_failed" ? "restore_failed" : "missing_blob", `snapshot import failed (${r.error.code})`);
+                                cleanupStaging(stagingId);
+                                return;
+                            }
+                        }
+                    }
+                    const policyStore = deps.sessionPolicyStore;
+                    if (policyStore)
+                        for (const rec of pending.policy)
+                            await policyStore.putRules(sessionId, rec.principal, rec.rules, { operator: pending.operatorOk });
+                    const anchorStore = deps.resumeAnchorStore;
+                    if (anchorStore)
+                        for (const a of pending.anchors)
+                            await anchorStore.put(sessionId, a.eventId, a.entryId, pending.owner);
+                    deps.sessionStorage.evict?.(sessionId);
+                    cleanupStaging(stagingId);
+                    sendJson(res, 200, { relation: committed.relation });
+                }
+                catch (e) {
+                    if (e instanceof SyncConflictError) {
+                        await pending.handle.abort().catch(() => undefined);
+                        cleanupStaging(stagingId);
+                        sendError(res, 409, "conflict", "sync conflict", { relation: e.relation });
+                        return;
+                    }
+                    if (e instanceof SessionPolicyError) {
+                        cleanupStaging(stagingId);
+                        sendError(res, e.code === "loosen_forbidden" ? 403 : 409, e.code, e.message);
+                        return;
+                    }
+                    cleanupStaging(stagingId);
+                    throw e;
+                }
+                return;
+            }
+            if (sm[2] === "plan" && req.method === "POST") {
+                if (!pushGateOk())
+                    return;
+                let body;
+                try {
+                    body = (await readJson(req));
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!Array.isArray(body.entryIds) || !body.entryIds.every((x) => typeof x === "string")) {
+                    sendJson(res, 400, { error: "entryIds must be an array of strings" });
+                    return;
+                }
+                const dst = await deps.sessionStorage?.exportEntries?.(sessionId);
+                const relation = classifySyncRelationshipByIds(body.entryIds, dst ? dst.map((e) => e.id) : null);
+                sendJson(res, 200, relation);
+                return;
+            }
+            sendJson(res, 404, { error: "not found" });
+            return;
+        }
+    }
+    miss.fell = true;
+}
+//# sourceMappingURL=session-sync.js.map

package/dist/http/routes/sessions-list.d.ts

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