antechamber 1.0.40 → 2.0.1

package/dist/latency.js

@@ -0,0 +1,115 @@
+import { performance } from "node:perf_hooks";
+import { envSetting } from "./config.js";
+const SAMPLE_MS = 100;
+// The router uses explicit path comparisons rather than a routing framework. Unknown
+// paths get a constant label so neither identifiers nor query credentials enter logs.
+const ROUTE_PATTERNS = `
+  / /health /global/health /global/upgrade /event /global/event
+  /session /session/status /project /project/current /config /global/config /provider
+  /config/providers /experimental/session /question /permission /lsp /formatter
+  /command /path /vcs /agent /file /file/content /file/status /find /find/file /find/symbol
+  /provider/auth /auth/:providerID /provider/:providerID/oauth/authorize /provider/:providerID/oauth/callback
+  /question/:requestID/reply /question/:requestID/reject /permission/:requestID/reply
+  /api/info /api/location /api/config /api/provider /api/model /api/model/default
+  /api/agent /api/agent/:agentID /api/command /api/skill /api/debug/location
+  /api/credential /api/credential/:credentialID /api/credential/:credentialID/activate
+  /api/integration/:integrationID /api/integration/:integrationID/connect/key
+  /api/integration/:integrationID/connect/external /api/integration/:integrationID/connect/oauth
+  /api/integration/:integrationID/connect/command /api/integration/:integrationID/connect/oauth/:flowID
+  /api/integration/:integrationID/connect/command/:flowID
+  /api/integration/:integrationID/connect/oauth/:flowID/complete
+  /api/plugin /api/plugin/check /api/plugin/update /api/experimental/generate /api/experimental/generate/text
+  /api/shell /api/shell/:shellID /api/shell/:shellID/output /api/websearch/provider
+  /api/experimental/session/stats /api/experimental/usage/limits /api/experimental/fs/watch
+  /api/fs/find /api/project /api/project/:projectID /api/permission/request /api/question/request
+  /api/permission/saved /api/permission/saved/:permissionID /api/form /api/vcs/init /api/vcs
+  /api/session /api/session/active /api/event /api/global/event/ws
+  /api/experimental/session/:sessionID/instructions/entries/:entryID
+  /antechamber/work-status/:sessionID
+`
+    .trim()
+    .split(/\s+/);
+for (const prefix of ["", "/api"]) {
+    const base = `${prefix}/session/:sessionID`;
+    ROUTE_PATTERNS.push(base, `${base}/message/:messageID`);
+    for (const action of [
+        "diff",
+        "children",
+        "todo",
+        "message",
+        "prompt_async",
+        "abort",
+        "fork",
+        "revert",
+        "unrevert",
+        "summarize",
+        "shell",
+        "command",
+        "share",
+        "generate",
+        "background",
+        "move",
+        "view",
+        "compact",
+        "prompt",
+        "synthetic",
+        "context",
+        "interrupt",
+        "revert/stage",
+        "revert/commit",
+        "agent",
+        "model",
+        "form",
+        "question",
+        "permission",
+        "inbox",
+    ])
+        ROUTE_PATTERNS.push(`${base}/${action}`);
+    for (const resource of ["form", "question", "permission"])
+        for (const suffix of ["", "/reply", "/reject"])
+            ROUTE_PATTERNS.push(`${base}/${resource}/:requestID${suffix}`);
+}
+const routes = ROUTE_PATTERNS.map((pattern) => ({
+    pattern,
+    match: new RegExp(`^${pattern.replace(/:[A-Za-z]+/g, "[^/]+")}$`),
+}));
+function routePattern(req) {
+    const path = new URL(req.url ?? "/", "http://localhost").pathname.replace(/\/+$/, "") || "/";
+    return routes.find((route) => route.match.test(path))?.pattern ?? "unmatched";
+}
+function threshold(name, fallback) {
+    const value = Number(envSetting(name));
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+export class LatencyMonitor {
+    lagThreshold = threshold("EVENT_LOOP_LAG_MS", 250);
+    requestThreshold = threshold("SLOW_REQUEST_MS", 1000);
+    timer;
+    start() {
+        let expected = performance.now() + SAMPLE_MS;
+        this.timer = setInterval(() => {
+            const now = performance.now();
+            const lag = now - expected;
+            expected = now + SAMPLE_MS;
+            if (lag > this.lagThreshold)
+                console.warn(`[latency] event-loop-lag duration_ms=${Math.round(lag)} threshold_ms=${this.lagThreshold}`);
+        }, SAMPLE_MS);
+        this.timer.unref();
+    }
+    stop() {
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async request(req, res, handle) {
+        const start = performance.now();
+        try {
+            await handle();
+        }
+        finally {
+            // SSE handlers return after setup; connection lifetime is not request latency.
+            const duration = performance.now() - start;
+            if (duration > this.requestThreshold)
+                console.warn(`[latency] slow-request method=${req.method ?? "GET"} route=${routePattern(req)} status=${res.statusCode} duration_ms=${Math.round(duration)}`);
+        }
+    }
+}

package/dist/misc-routes.js

@@ -42,18 +42,10 @@ async function confinedDirectory(root, path) {
     }
 }
 export async function miscRoute(method, path, url, directory) {
-    if (method === "GET" && ["/skill", "/lsp", "/formatter", "/experimental/tool/ids"].includes(path)) {
+    if (method === "GET" && ["/skill", "/formatter"].includes(path)) {
         return { status: 200, body: [] };
     }
-    if (method === "GET" && path === "/provider/auth")
-        return { status: 200, body: {} };
-    if ((method === "PUT" && /^\/auth\/[^/]+$/.test(path)) ||
-        (method === "POST" && /^\/provider\/[^/]+\/oauth\/(authorize|callback)$/.test(path)) ||
-        (method === "PATCH" && path === "/config")) {
-        return unsupported("Not supported with OmO; configure providers in OmO");
-    }
-    if ((["POST", "DELETE"].includes(method) && /^\/mcp\/[^/]+\/(connect|disconnect|auth)$/.test(path)) ||
-        (method === "POST" && path === "/experimental/control-plane/move-session")) {
+    if (["POST", "DELETE"].includes(method) && /^\/mcp\/[^/]+\/(connect|disconnect|auth)$/.test(path)) {
         return unsupported("Not supported with OmO; configure MCP and session directories in OmO");
     }
     if (method !== "GET" || !["/file", "/find/file"].includes(path))
@@ -93,6 +85,7 @@ export async function miscRoute(method, path, url, directory) {
     const dirs = url.searchParams.get("dirs") !== "false" && url.searchParams.get("type") !== "file";
     const onlyDirs = url.searchParams.get("type") === "directory";
     const files = [];
+    const matchedDirs = new Set();
     let visited = 0;
     const lowerQuery = query.toLowerCase();
     async function visit(directory, depth) {
@@ -107,12 +100,21 @@ export async function miscRoute(method, path, url, directory) {
                 continue;
             const absolute = resolve(directory, entry.name);
             const path = relative(root, absolute).split(sep).join("/");
+            if (onlyDirs && entry.isFile() && path.toLowerCase().includes(lowerQuery)) {
+                matchedDirs.add("/");
+                const segments = path.split("/");
+                for (let i = 1; i < segments.length; i++)
+                    matchedDirs.add(`${segments.slice(0, i).join("/")}/`);
+            }
             if (((entry.isFile() && !onlyDirs) || (entry.isDirectory() && dirs)) && path.toLowerCase().includes(lowerQuery))
-                files.push(path);
+                if (onlyDirs)
+                    matchedDirs.add(`${path}/`);
+                else
+                    files.push(path);
             if (entry.isDirectory() && entry.name !== "node_modules")
                 await visit(absolute, depth + 1);
         }
     }
     await visit(root, 0);
-    return { status: 200, body: files.sort() };
+    return { status: 200, body: onlyDirs ? [...matchedDirs].sort().slice(0, limit) : files.sort() };
 }

package/dist/pi-event-translation.js

@@ -202,6 +202,24 @@ export class PiEventTranslator {
         }
         delete s.compactingFromIdle;
         delete s.info.time.compacting;
+        // A compaction the run never finished must not stay "running": a later Compact would join it and report
+        // success for work that will never happen.
+        if (s.compactionID !== undefined) {
+            const inputID = s.compactionID;
+            const reason = s.compactionReason ?? "manual";
+            delete s.compactionID;
+            delete s.compactionReason;
+            delete s.heldCompactionEnd;
+            this.services.emit(s.info.directory, {
+                type: "session.compaction.failed",
+                properties: {
+                    sessionID: s.info.id,
+                    inputID,
+                    reason,
+                    error: { name: "CompactionError", data: { message: error.data.message } },
+                },
+            });
+        }
     }
     setStatus(s, status) {
         s.status = status;
@@ -211,6 +229,14 @@ export class PiEventTranslator {
         });
         if (status.type === "idle") {
             s.info.time.idle = Date.now();
+            // Restored as time.idle after a restart, so /view can still accept the watermark a client saw.
+            s.tree.lastIdle = s.info.time.idle;
+            try {
+                this.services.persistMeta(s);
+            }
+            catch (error) {
+                console.error(`[session] could not save the idle time of ${s.info.id}:`, error);
+            }
             const last = s.messages?.findLast((message) => message.info.role === "assistant" && !message.info.id.startsWith("msg_background_"));
             s.info.outcome =
                 s.interruptRequested || (last?.info.role === "assistant" && last.info.error?.name === "MessageAbortedError")
@@ -323,6 +349,7 @@ export class PiEventTranslator {
                 this.onMessageEvent(s, ev);
                 break;
             case "compaction_start":
+            case "compaction_progress":
             case "compaction_end":
                 this.onCompactionEvent(s, ev);
                 break;
@@ -641,7 +668,8 @@ export class PiEventTranslator {
                 }
                 // An auto-compaction can fall between steps; its summary is a new step.
                 this.completeAwaitingTools(s);
-                s.compactionID = id("compaction");
+                s.compactionID ??= id("msg");
+                s.compactionReason = typeof ev.reason === "string" ? ev.reason : "manual";
                 this.services.emit(s.info.directory, {
                     type: "session.compaction.started",
                     properties: {
@@ -658,6 +686,15 @@ export class PiEventTranslator {
                     this.setStatus(s, { type: "busy" });
                 }
                 return;
+            case "compaction_progress":
+                // Extension compaction feedback carries actual partial summary fragments
+                // (senpi/dist/core/agent-session.js _updateExtensionCompactionFeedback).
+                if (s.compactionID !== undefined && typeof ev.delta === "string" && ev.delta !== "")
+                    this.services.emit(s.info.directory, {
+                        type: "session.compaction.delta",
+                        properties: { sessionID: s.info.id, text: ev.delta },
+                    });
+                return;
             case "compaction_end": {
                 const retry = s.compactRetry;
                 if (ev.aborted === true && retry !== undefined && retry.left > 0 && (s.abortRequests ?? 0) === retry.aborts) {
@@ -666,8 +703,9 @@ export class PiEventTranslator {
                 }
                 delete s.info.time.compacting;
                 const result = ev.result;
-                const inputID = s.compactionID ?? id("compaction");
+                const inputID = s.compactionID ?? id("msg");
                 delete s.compactionID;
+                delete s.compactionReason;
                 this.services.emit(s.info.directory, ev.aborted === true || typeof result?.summary !== "string"
                     ? {
                         type: "session.compaction.failed",
@@ -702,6 +740,10 @@ export class PiEventTranslator {
                                 key = entry.id;
                         }
                     }
+                    if (key !== undefined) {
+                        s.tree.messageEntries[inputID] ??= key;
+                        (s.tree.compactionReasons ??= {})[key] = ev.reason === "manual" ? "manual" : "auto";
+                    }
                     for (const message of compactionMessages(s, key ?? id("compaction"), result.summary, Date.now(), s.model, s.thinkingLevel)) {
                         if (messages.some((item) => item.info.id === message.info.id))
                             continue;

package/dist/route-services.d.ts

@@ -5,15 +5,20 @@ import type { Catalog } from "./catalog.js";
 import type { ModelSelection } from "./thinking-levels.js";
 import type { OCEvent, OCMessageWithParts, OCPromptPart } from "./types.js";
 import type { TodoUpdated } from "./todo-bridge.js";
-import type { SelfUpdateResult } from "./self-update.js";
+import type { FileWatchRegistry } from "./file-watch.js";
+import type { getCommands } from "./session-commands.js";
+import type { TextGeneration } from "./text-generation.js";
 export interface RouteServices {
     readonly sessions: SessionManager;
     readonly defaultDirectory: string;
     readonly url: string;
     readonly body: (req: IncomingMessage) => Promise<unknown>;
-    readonly catalog: () => Promise<Catalog>;
+    readonly catalog: (directory?: string, refresh?: boolean) => Promise<Catalog>;
     readonly broadcast: (directory: string, event: OCEvent | TodoUpdated) => void;
-    readonly selfUpdate: () => Promise<SelfUpdateResult>;
+    readonly fileWatches: FileWatchRegistry;
+    readonly commands: (directory: string) => ReturnType<typeof getCommands>;
+    readonly vcsBranch: (directory: string) => Promise<string | undefined>;
+    readonly textGeneration: TextGeneration;
 }
 export declare const OPENCODE_COMPAT_VERSION: string | null;
 export declare function numberParam(value: string | null): number | undefined;

package/dist/routes-v1.d.ts

@@ -1,4 +1,4 @@
-/** OpenCode v1 routes, using the services composed by AdapterServer. */
+/** Unprefixed compatibility routes retained for evidenced or uncertain callers. */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type RouteServices } from "./route-services.js";
 export declare function handleV1(services: RouteServices, req: IncomingMessage, res: ServerResponse, url: URL, path: string, method: string, directory: string): Promise<void>;