antechamber 1.0.40 → 2.0.1

package/dist/server.js

@@ -1,16 +1,23 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 import { createHash, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { watch } from "node:fs";
 import { createServer } from "node:http";
+import { basename, dirname, resolve } from "node:path";
+import { promisify } from "node:util";
 import { disposeMcpAgents, mcpSurfacesChanged } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
-import { loadCatalog } from "./catalog.js";
+import { catalogFingerprint, loadCatalog } from "./catalog.js";
 import { Http } from "./http.js";
 import { SSE } from "./sse.js";
 import { handleV1 } from "./routes-v1.js";
 import { handleV2 } from "./routes-v2.js";
-import { selfUpdate } from "./self-update.js";
 import { handleWorkStatus } from "./work-status.js";
+import { FileWatchRegistry } from "./file-watch.js";
+import { getCommands } from "./session-commands.js";
+import { TextGeneration } from "./text-generation.js";
+import { LatencyMonitor } from "./latency.js";
 export { isLoopbackHost, serverPassword } from "./http.js";
 export class AdapterServer {
     options;
@@ -22,26 +29,150 @@ export class AdapterServer {
     webSocketEvents = [];
     nextWebSocketEventID = 0;
     catalogPromise;
+    catalogExpiresAt = 0;
+    catalogColdExpiresAt = 0;
+    commandSnapshots = new Map();
+    commandColdReads = new Map();
+    branchSnapshots = new Map();
+    branchWatchers = new Map();
+    branchChecks = new Map();
+    projectDirectories = new Set();
+    fileWatches = new FileWatchRegistry((directory, event) => this.broadcast(directory, event));
+    pendingRefreshes = new Set();
+    textGeneration = new TextGeneration();
+    latency = new LatencyMonitor();
+    stopping = false;
     actualPort;
     /** Bearer token for the `/antechamber/work-status` routes, published in the run record for the OmO Work extension. */
     extensionToken = randomBytes(32).toString("base64url");
     http = new Http(() => this.url, this.extensionToken);
     constructor(options) {
         this.options = options;
+        this.projectDirectories.add(options.defaultDirectory);
         this.sse = new SSE(options, this.sseClients, (id) => this.sessions.monitors.owns(id));
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
         this.sessions.onMcpSurfacesChanged = () => mcpSurfacesChanged((directory, event) => this.broadcast(directory, event));
         this.server = createServer((req, res) => void this.route(req, res));
         this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
     }
-    catalog() {
-        this.catalogPromise ??= loadCatalog(this.options.defaultDirectory).catch((err) => {
-            this.catalogPromise = undefined;
+    catalog(directory = this.options.defaultDirectory, client, mode = "cached") {
+        // A live session's agent can only refresh an existing snapshot: its get_state reports that session's
+        // selected model, so the first snapshot (and the configured default) always comes from a fresh agent.
+        const pi = this.catalogPromise === undefined ? undefined : (client ?? this.sessions.liveClient(directory));
+        if (this.catalogPromise !== undefined &&
+            (this.catalogExpiresAt === Infinity ||
+                (mode !== "settled" &&
+                    (Date.now() < this.catalogExpiresAt ||
+                        (pi === undefined && (mode === "cached" || Date.now() < this.catalogColdExpiresAt))))))
+            return this.catalogPromise;
+        const previous = this.catalogPromise;
+        this.catalogExpiresAt = Infinity;
+        this.catalogColdExpiresAt = Date.now() + 60_000;
+        this.catalogPromise = (pi === undefined || previous === undefined
+            ? loadCatalog(directory)
+            : previous.then((last) => loadCatalog(directory, pi, last)))
+            .then(async (current) => {
+            this.catalogExpiresAt = Date.now() + 5_000;
+            this.catalogColdExpiresAt = Date.now() + 60_000;
+            if (previous !== undefined) {
+                const last = await previous;
+                if (catalogFingerprint(last) !== catalogFingerprint(current)) {
+                    this.broadcast(directory, { type: "provider.updated", properties: {} });
+                    this.broadcast(directory, { type: "model.updated", properties: {} });
+                }
+            }
+            return current;
+        })
+            .catch((err) => {
+            this.catalogExpiresAt = Date.now() + 5_000;
             console.error("[catalog] failed to load models from pi:", err);
-            return { providers: [], defaults: {} };
+            if (previous === undefined) {
+                // An unsuccessful first read established no snapshot to rate-limit or refresh.
+                this.catalogPromise = undefined;
+                this.catalogColdExpiresAt = 0;
+            }
+            return previous ?? { providers: [], defaults: {} };
         });
         return this.catalogPromise;
     }
+    async commands(directory, client, refresh = false) {
+        const pi = client ?? this.sessions.liveClient(directory);
+        const cold = this.commandColdReads.get(directory);
+        if (pi === undefined && cold !== undefined && Date.now() < cold.expiresAt)
+            return cold.promise;
+        const request = getCommands(directory, pi, refresh);
+        if (pi === undefined)
+            this.commandColdReads.set(directory, { expiresAt: Date.now() + 60_000, promise: request });
+        const commands = await request;
+        const previous = this.commandSnapshots.get(directory);
+        this.commandSnapshots.set(directory, commands);
+        this.commandColdReads.set(directory, { expiresAt: Date.now() + 60_000, promise: Promise.resolve(commands) });
+        if (previous !== undefined && JSON.stringify(previous) !== JSON.stringify(commands))
+            this.broadcast(directory, { type: "command.updated", properties: {} });
+        return commands;
+    }
+    watchBranch(directory) {
+        if (this.stopping)
+            return Promise.resolve(undefined);
+        const existing = this.branchWatchers.get(directory);
+        if (existing !== undefined)
+            return existing;
+        const pending = promisify(execFile)("git", ["rev-parse", "--git-path", "HEAD"], {
+            cwd: directory,
+            timeout: 3000,
+        })
+            .then(({ stdout }) => {
+            if (this.stopping)
+                return undefined;
+            const head = resolve(directory, stdout.trim());
+            const watcher = watch(dirname(head), (_event, name) => {
+                if (this.stopping || (name !== null && name.toString() !== basename(head)))
+                    return;
+                void this.vcsBranch(directory);
+            });
+            watcher.on("error", () => {
+                watcher.close();
+                this.branchWatchers.delete(directory);
+            });
+            watcher.unref();
+            return watcher;
+        })
+            .catch(() => {
+            this.branchWatchers.delete(directory);
+            return undefined;
+        });
+        this.branchWatchers.set(directory, pending);
+        return pending;
+    }
+    vcsBranch(directory) {
+        const pending = this.branchChecks.get(directory) ?? Promise.resolve();
+        const current = pending.then(() => this.readBranch(directory));
+        this.branchChecks.set(directory, current.then(() => undefined));
+        return current;
+    }
+    async readBranch(directory) {
+        if (this.stopping)
+            return this.branchSnapshots.get(directory);
+        await this.watchBranch(directory);
+        let branch;
+        try {
+            const { stdout } = await promisify(execFile)("git", ["symbolic-ref", "--short", "HEAD"], {
+                cwd: directory,
+                timeout: 3000,
+            });
+            branch = stdout.trim() || undefined;
+        }
+        catch {
+            branch = undefined;
+        }
+        if (this.branchSnapshots.has(directory) && this.branchSnapshots.get(directory) !== branch)
+            this.broadcast(directory, {
+                type: "vcs.branch.updated",
+                properties: branch === undefined ? {} : { branch },
+            });
+        this.branchSnapshots.set(directory, branch);
+        return branch;
+    }
     async start() {
         await new Promise((resolve, reject) => {
             this.server.once("error", reject);
@@ -49,6 +180,7 @@ export class AdapterServer {
         });
         const addr = this.server.address();
         this.actualPort = typeof addr === "object" && addr !== null ? addr.port : this.options.port;
+        this.latency.start();
     }
     get url() {
         const port = this.actualPort ?? this.options.port;
@@ -58,10 +190,21 @@ export class AdapterServer {
         return `http://${host}:${port}`;
     }
     async stop() {
+        this.stopping = true;
+        this.latency.stop();
+        await this.textGeneration.dispose();
+        await Promise.all([...this.pendingRefreshes]);
+        const branchWatchers = [...this.branchWatchers.values()];
+        this.branchWatchers.clear();
+        await Promise.all(this.branchChecks.values());
+        for (const watcher of await Promise.all([...branchWatchers, ...this.branchWatchers.values()]))
+            watcher?.close();
+        this.branchWatchers.clear();
         // Stop admission before ending SSE: its clients can reconnect while the
         // session RPC groups and private task hosts are still being disposed.
         const closed = new Promise((resolve) => this.server.close(() => resolve()));
         this.sse.close();
+        this.fileWatches.close();
         for (const socket of this.webSocketClients)
             socket.destroy();
         this.webSocketClients.clear();
@@ -78,15 +221,47 @@ export class AdapterServer {
     // SSE
     // ---------------------------------------------------------------
     broadcast(directory, event) {
+        if (event.type === "session.idle" && !this.stopping) {
+            const session = this.sessions.get(event.properties.sessionID);
+            if (session?.pi !== undefined) {
+                const reads = [
+                    ...(this.catalogPromise === undefined ? [] : [this.catalog(session.info.directory, session.pi, "settled")]),
+                    ...(this.commandSnapshots.has(session.info.directory)
+                        ? [this.commands(session.info.directory, session.pi, true)]
+                        : []),
+                ];
+                if (reads.length > 0) {
+                    const refresh = Promise.all(reads)
+                        .then(() => undefined)
+                        .catch((error) => console.error("[catalog] live refresh failed:", error));
+                    this.pendingRefreshes.add(refresh);
+                    void refresh.finally(() => this.pendingRefreshes.delete(refresh));
+                }
+            }
+        }
+        if (event.type === "session.created" && !this.projectDirectories.has(directory)) {
+            this.projectDirectories.add(directory);
+            const now = Date.now();
+            this.broadcast(directory, {
+                type: "project.updated",
+                properties: {
+                    id: directory,
+                    canonical: directory,
+                    time: { created: now, updated: now, active: now },
+                    sandboxes: [],
+                    vcs: "git",
+                },
+            });
+        }
         this.sse.broadcast(directory, event);
         this.broadcastWebSocket(directory, event);
     }
     writeSSE(res, frame) {
         return this.sse.writeSSE(res, frame);
     }
-    handleSSE(req, res, flavor, directory, global) {
+    handleSSE(req, res, directory) {
         const lastEventID = req.headers["last-event-id"];
-        this.sse.handleSSE(res, { flavor, global, ...(global ? {} : { directory }) }, Array.isArray(lastEventID) ? lastEventID[0] : lastEventID, this.writeSSE.bind(this));
+        this.sse.handleSSE(res, { ...(directory !== undefined ? { directory } : {}) }, Array.isArray(lastEventID) ? lastEventID[0] : lastEventID, this.writeSSE.bind(this));
     }
     handleUpgrade(req, socket, _head) {
         const url = new URL(req.url ?? "/", this.url);
@@ -170,7 +345,7 @@ export class AdapterServer {
     // ---------------------------------------------------------------
     async route(req, res) {
         debugLog(`[http] ${req.method} ${(req.url ?? "/").split("?")[0]}`);
-        await this.http.route(req, res, () => this.handle(req, res));
+        await this.latency.request(req, res, () => this.http.route(req, res, () => this.handle(req, res)));
     }
     async handle(req, res) {
         const url = new URL(req.url ?? "/", this.url);
@@ -191,15 +366,10 @@ export class AdapterServer {
             headerDirectory = decodeURIComponent(encodedDirectory);
         }
         const directory = directoryQuery ?? headerDirectory ?? this.options.defaultDirectory;
-        // SSE stream (v2 clients subscribe at /api/event; v1 at /event)
-        if (method === "GET" && (path === "/event" || path === "/global/event")) {
-            this.handleSSE(req, res, "v1", directory, path === "/global/event");
-            return;
-        }
-        if (method === "GET" && path === "/api/event") {
+        if (method === "GET" && (path === "/api/event" || path === "/api/global/event")) {
             // OpenChamber 2.3.2 opens one unscoped /api/event as its global hub (captured);
             // only an explicit directory selector scopes the stream.
-            this.handleSSE(req, res, "v2", directory, directoryQuery === null && headerDirectory === undefined);
+            this.handleSSE(req, res, directoryQuery === null && headerDirectory === undefined ? undefined : directory);
             return;
         }
         if (path.startsWith("/antechamber/work-status/")) {
@@ -211,9 +381,12 @@ export class AdapterServer {
             defaultDirectory: this.options.defaultDirectory,
             url: this.url,
             body: (request) => this.http.body(request),
-            catalog: () => this.catalog(),
+            catalog: (dir, refresh) => this.catalog(dir, undefined, refresh === true ? "read" : "cached"),
             broadcast: (dir, event) => this.broadcast(dir, event),
-            selfUpdate: this.options.selfUpdate ?? (() => selfUpdate()),
+            fileWatches: this.fileWatches,
+            commands: (dir) => this.commands(dir),
+            vcsBranch: (dir) => this.vcsBranch(dir),
+            textGeneration: this.textGeneration,
         };
         if (path === "/api" || path.startsWith("/api/")) {
             await handleV2(services, req, res, url, path, method, directory);

package/dist/session-commands.d.ts

@@ -1,3 +1,4 @@
+import { PiRpcClient } from "./pi-rpc.js";
 import type { OCPromptPart } from "./types.js";
 import type { ManagedSession, SessionManager } from "./sessions.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCToolPart, OCTextPart, OCUserMessage } from "./types.js";
@@ -11,6 +12,7 @@ type SlashCommandInput = {
     arguments: string;
     messageID?: string;
     parts?: OCPromptPart[];
+    delivery?: "steer" | "queue";
 };
 type ShellResult = {
     output: string;
@@ -63,7 +65,7 @@ export declare const unsupportedShare: {
     };
 };
 export declare function shellTitle(command: string): string;
-export declare function getCommands(directory: string): Promise<CommandDescriptor[]>;
+export declare function getCommands(directory: string, client?: PiRpcClient, refresh?: boolean): Promise<CommandDescriptor[]>;
 export declare function parseSlashCommand(value: unknown): SlashCommandInput | undefined;
 /**
  * OmO never auto-titles a first prompt that starts with "/", so a session opened

package/dist/session-commands.js

@@ -91,19 +91,19 @@ function mapCommands(data) {
 }
 const COMMAND_CACHE_TTL_MS = 5_000;
 const commandCache = new Map();
-export function getCommands(directory) {
+export function getCommands(directory, client, refresh = false) {
     const now = Date.now();
     for (const [key, entry] of commandCache) {
         if (entry.expiresAt <= now)
             commandCache.delete(key);
     }
     const existing = commandCache.get(directory);
-    if (existing)
+    if (existing && (!refresh || existing.expiresAt === Infinity))
         return existing.promise;
     const entry = {
         expiresAt: Infinity,
         promise: (async () => {
-            const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+            const pi = client ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
             try {
                 const response = await pi.command({ type: "get_commands" });
                 if (!response.success)
@@ -111,13 +111,16 @@ export function getCommands(directory) {
                 return mapCommands(response.data);
             }
             finally {
-                await pi.dispose();
+                if (client === undefined)
+                    await pi.dispose();
             }
         })().then((commands) => {
-            entry.expiresAt = Date.now() + COMMAND_CACHE_TTL_MS;
+            if (commandCache.get(directory) === entry)
+                entry.expiresAt = Date.now() + COMMAND_CACHE_TTL_MS;
             return commands;
         }, (error) => {
-            commandCache.delete(directory);
+            if (commandCache.get(directory) === entry)
+                commandCache.delete(directory);
             throw error;
         }),
     };
@@ -133,11 +136,14 @@ export function parseSlashCommand(value) {
     const messageID = typeof value.messageID === "string" && value.messageID !== "" ? value.messageID : undefined;
     const parts = parsePromptParts(value.parts);
     nativePromptInput("", parts);
+    if (value.delivery !== undefined && value.delivery !== "steer" && value.delivery !== "queue")
+        return undefined;
     return {
         command: value.command,
         arguments: value.arguments,
         ...(messageID ? { messageID } : {}),
         ...(parts.length > 0 ? { parts } : {}),
+        ...(value.delivery !== undefined ? { delivery: value.delivery } : {}),
     };
 }
 /**
@@ -168,7 +174,7 @@ function slashCommandPrompt(input) {
 }
 export async function runSlashCommand(sessions, sessionId, input) {
     const text = slashCommandPrompt(input);
-    await sessions.prompt(sessionId, text, undefined, false, input.messageID, "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
+    await sessions.prompt(sessionId, text, undefined, false, input.messageID, input.delivery ?? "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
     await sessions.reloadMessages(sessionId);
     const messages = sessions.messages(sessionId) ?? [];
     return messages.findLast((message) => message.info.role === "assistant") ?? messages[messages.length - 1];

package/dist/session-history.js

@@ -208,6 +208,9 @@ export function parsePiSessionText(s, agentName, raw) {
                     agent: agentName,
                     model: userMessageModel(currentModel, currentThinkingLevel),
                     synthetic: true,
+                    ...(s.tree.promptDescriptions?.[contextID] !== undefined
+                        ? { description: s.tree.promptDescriptions[contextID] }
+                        : {}),
                 },
                 parts: [
                     {

package/dist/session-store.d.ts

@@ -6,7 +6,7 @@
  * so the adapter never needs its own transcript store — only:
  *
  *   1. a scan of that directory to rebuild the sidebar after a restart, and
- *   2. a small registry JSON for adapter-owned metadata that pi does not
+ *   2. a SQLite registry for adapter-owned metadata that pi does not
  *      keep (titles, conversation cursors and child-task metadata).
  *
  * OpenChamber session ids for restored sessions are derived deterministically
@@ -39,6 +39,10 @@ export interface ScannedSession extends SessionSelection {
     updated: number;
 }
 export type TitleSource = "user" | "native" | "fallback" | "generated";
+export interface InstructionEntryState {
+    value: unknown;
+    removed?: true;
+}
 /** Adapter-owned metadata that pi's files do not carry. */
 export interface SessionRegistryEntry {
     /** Created by this connector, rather than discovered from another OmO client. */
@@ -50,6 +54,7 @@ export interface SessionRegistryEntry {
     parentMessageID?: string;
     agent?: string;
     metadata?: Record<string, unknown>;
+    instructions?: Record<string, InstructionEntryState>;
     task?: ChildTask;
     piSessionId: string;
     piPath: string;
@@ -58,6 +63,8 @@ export interface SessionRegistryEntry {
     titleSource?: TitleSource;
     /** Archive timestamp (absent/0 = live) — OpenChamber's archive toggle. */
     archived?: number;
+    /** Last idle watermark acknowledged by a viewer. */
+    viewed?: number;
     /**
      * Last model pi was known to run. pi's JSONL header does not carry it, so
      * without this a dormant session would advertise no model at all until it is
@@ -104,23 +111,25 @@ export declare function scanPiSessions(directory: string): ScannedSession[];
 export declare class SessionStore {
     readonly stateDir: string;
     private readonly file;
-    private entries;
-    /** The registry bytes `entries` was parsed from or last written as; equal bytes on disk mean the cache is current. */
-    private raw;
+    private db;
+    private version;
+    private readonly entries;
     private batchState;
     constructor(stateDir?: string);
-    private load;
-    private committed;
-    private readRaw;
-    private parseEntries;
-    private withRegistryLock;
+    private database;
+    private migrate;
+    private upsert;
+    private writeRow;
+    private refresh;
+    private read;
     private persist;
     private mutate;
-    /** Synchronous restoration reads its own changes, then merges them under one short-lived write lock. */
+    /** Stage only touched rows; replay partial updates against the latest rows under SQLite's write lock. */
     batch<T>(action: () => T): T;
     get(ocSessionId: string): SessionRegistryEntry | undefined;
     idFor(piSessionId: string): string | undefined;
     childIds(): string[];
+    private matching;
     set(ocSessionId: string, entry: SessionRegistryEntry): void;
     /** Merge a partial update (e.g. title override, updated timestamp). */
     update(ocSessionId: string, patch: Partial<SessionRegistryEntry>): void;