antechamber 0.1.1 → 0.2.1

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 export { isLoopbackHost, serverPassword } from "./http.js";
-export interface AdapterServerOptions {
+interface AdapterServerOptions {
     port: number;
     host: string;
     /** Fallback directory when requests carry no ?directory= param. */
@@ -12,6 +12,9 @@ export declare class AdapterServer {
     private sessions;
     private sse;
     private sseClients;
+    private webSocketClients;
+    private webSocketEvents;
+    private nextWebSocketEventID;
     private catalogPromise;
     private actualPort;
     private readonly http;
@@ -23,6 +26,11 @@ export declare class AdapterServer {
     private broadcast;
     private writeSSE;
     private handleSSE;
+    private handleUpgrade;
+    private rejectUpgrade;
+    private broadcastWebSocket;
+    private writeWebSocketEvent;
+    private writeWebSocket;
     private route;
     private handle;
 }

package/dist/server.js

@@ -1,4 +1,5 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
+import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
@@ -14,17 +15,22 @@ export class AdapterServer {
     sessions;
     sse;
     sseClients = new Map();
+    webSocketClients = new Set();
+    webSocketEvents = [];
+    nextWebSocketEventID = 0;
     catalogPromise;
     actualPort;
-    http = new Http();
+    http = new Http(() => this.url);
     constructor(options) {
         this.options = options;
         this.sse = new SSE(options, this.sseClients);
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
         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;
             console.error("[catalog] failed to load models from pi:", err);
             return { providers: [], defaults: {} };
         });
@@ -50,6 +56,9 @@ export class AdapterServer {
         // session RPC groups and private task hosts are still being disposed.
         const closed = new Promise((resolve) => this.server.close(() => resolve()));
         this.sse.close();
+        for (const socket of this.webSocketClients)
+            socket.destroy();
+        this.webSocketClients.clear();
         try {
             await this.sessions.disposeAll();
         }
@@ -64,12 +73,91 @@ export class AdapterServer {
     // ---------------------------------------------------------------
     broadcast(directory, event) {
         this.sse.broadcast(directory, event);
+        this.broadcastWebSocket(directory, event);
     }
     writeSSE(res, frame) {
         return this.sse.writeSSE(res, frame);
     }
-    handleSSE(res, flavor) {
-        this.sse.handleSSE(res, flavor, this.writeSSE.bind(this));
+    handleSSE(req, res, flavor, directory, global) {
+        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));
+    }
+    handleUpgrade(req, socket, _head) {
+        const url = new URL(req.url ?? "/", this.url);
+        if (url.pathname !== "/api/global/event/ws") {
+            this.rejectUpgrade(socket, 404, "Not Found");
+            return;
+        }
+        if (!this.http.allowsUpgrade(req)) {
+            this.rejectUpgrade(socket, 403, "Forbidden");
+            return;
+        }
+        const keyHeader = req.headers["sec-websocket-key"];
+        const key = Array.isArray(keyHeader) ? keyHeader[0] : keyHeader;
+        if (req.headers["sec-websocket-version"] !== "13" || typeof key !== "string") {
+            this.rejectUpgrade(socket, 400, "Bad Request");
+            return;
+        }
+        const accept = createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+        socket.write([
+            "HTTP/1.1 101 Switching Protocols",
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            `Sec-WebSocket-Accept: ${accept}`,
+            "",
+            "",
+        ].join("\r\n"));
+        this.webSocketClients.add(socket);
+        socket.once("close", () => this.webSocketClients.delete(socket));
+        socket.once("error", () => this.webSocketClients.delete(socket));
+        const cursor = Number(url.searchParams.get("lastEventId"));
+        const replayReset = Number.isSafeInteger(cursor) && cursor >= 0 && cursor < this.nextWebSocketEventID - this.webSocketEvents.length;
+        this.writeWebSocket(socket, { type: "ready", ...(replayReset ? { replayReset: true } : {}) });
+        if (!Number.isSafeInteger(cursor) || cursor < 0)
+            return;
+        for (const event of this.webSocketEvents) {
+            if (event.id > cursor)
+                this.writeWebSocketEvent(socket, event);
+        }
+    }
+    rejectUpgrade(socket, status, message) {
+        socket.end(`HTTP/1.1 ${status} ${message}\r\nConnection: close\r\n\r\n`);
+    }
+    broadcastWebSocket(directory, payload) {
+        const event = { id: ++this.nextWebSocketEventID, directory, payload };
+        this.webSocketEvents.push(event);
+        if (this.webSocketEvents.length > 1024)
+            this.webSocketEvents.shift();
+        for (const socket of this.webSocketClients)
+            this.writeWebSocketEvent(socket, event);
+    }
+    writeWebSocketEvent(socket, event) {
+        this.writeWebSocket(socket, {
+            type: "event",
+            eventId: String(event.id),
+            directory: event.directory,
+            scope: "global",
+            payload: event.payload,
+        });
+    }
+    writeWebSocket(socket, frame) {
+        if (socket.destroyed || !socket.writable) {
+            this.webSocketClients.delete(socket);
+            return;
+        }
+        const payload = Buffer.from(JSON.stringify(frame));
+        const header = payload.length < 126
+            ? Buffer.from([0x81, payload.length])
+            : payload.length <= 0xffff
+                ? Buffer.from([0x81, 126, payload.length >> 8, payload.length & 0xff])
+                : (() => {
+                    const value = Buffer.alloc(10);
+                    value[0] = 0x81;
+                    value[1] = 127;
+                    value.writeBigUInt64BE(BigInt(payload.length), 2);
+                    return value;
+                })();
+        socket.write(Buffer.concat([header, payload]));
     }
     // ---------------------------------------------------------------
     // Router
@@ -82,18 +170,30 @@ export class AdapterServer {
         const url = new URL(req.url ?? "/", this.url);
         const path = url.pathname.replace(/\/+$/, "") || "/";
         const method = req.method ?? "GET";
-        const directory = url.searchParams.get("directory") ??
+        const directoryQuery = url.searchParams.get("directory") ??
             url.searchParams.get("location[directory]") ??
-            url.searchParams.get("location") ??
-            req.headers["x-opencode-directory"] ??
-            this.options.defaultDirectory;
+            url.searchParams.get("location");
+        const directoryHeader = req.headers["x-opencode-directory"];
+        const encodedDirectory = Array.isArray(directoryHeader) ? directoryHeader[0] : directoryHeader;
+        const directoryEncodingHeader = req.headers["x-opencode-directory-encoding"];
+        const directoryEncoding = Array.isArray(directoryEncodingHeader)
+            ? directoryEncodingHeader[0]
+            : directoryEncodingHeader;
+        let headerDirectory = encodedDirectory;
+        if (encodedDirectory !== undefined &&
+            (directoryEncoding?.toLowerCase() === "uri" || /^(?:%|[a-z]%3a)/i.test(encodedDirectory))) {
+            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(res, "v1");
+            this.handleSSE(req, res, "v1", directory, path === "/global/event");
             return;
         }
         if (method === "GET" && path === "/api/event") {
-            this.handleSSE(res, "v2");
+            // 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);
             return;
         }
         const services = {

package/dist/session-commands.d.ts

@@ -1,16 +1,18 @@
+import type { OCPromptPart } from "./types.js";
 import type { ManagedSession, SessionManager } from "./sessions.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCToolPart, OCTextPart, OCUserMessage } from "./types.js";
-export type CommandDescriptor = {
+type CommandDescriptor = {
     name: string;
     description: string;
     template: "";
 };
-export type SlashCommandInput = {
+type SlashCommandInput = {
     command: string;
     arguments: string;
     messageID?: string;
+    parts?: OCPromptPart[];
 };
-export type ShellResult = {
+type ShellResult = {
     output: string;
     exitCode: number | null;
     cancelled: boolean;
@@ -20,40 +22,36 @@ export type ShellMessage = OCMessageWithParts & {
     info: OCAssistantMessage;
     parts: [OCToolPart];
 };
-export type ShellUserMessage = OCMessageWithParts & {
+type ShellUserMessage = OCMessageWithParts & {
     info: OCUserMessage;
     parts: [OCTextPart];
 };
-export type ShareNoticeMessage = OCMessageWithParts & {
-    info: OCAssistantMessage;
-    parts: [OCTextPart];
-};
-export type ShellExecution = {
+type ShellExecution = {
     kind: "completed";
     message: ShellMessage;
 } | {
     kind: "error";
     message: string;
 };
-export interface ShellCommandContext {
+interface ShellCommandContext {
     sessions: SessionManager;
     session: ManagedSession;
     command: string;
     emit: (directory: string, event: OCEvent) => void;
 }
-export interface ShareNoticeContext {
+interface ShareNoticeContext {
     sessions: SessionManager;
     session: ManagedSession;
     emit: (directory: string, event: OCEvent) => void;
 }
-export type CompactResult = {
+type CompactResult = {
     kind: "compacted";
 } | {
     kind: "error";
     message: string;
 };
 export declare const unsupportedShare: {
-    readonly name: "BadRequestError";
+    readonly name: "UnsupportedError";
     readonly data: {
         readonly message: "Sharing is not available with OmO";
     };
@@ -69,10 +67,8 @@ export declare function parseSlashCommand(value: unknown): SlashCommandInput | u
 export declare function slashTitlePrompt(text: string): {
     sessionTitlePrompt?: string;
 };
-export declare function slashCommandPrompt(input: SlashCommandInput): string;
 export declare function runSlashCommand(sessions: SessionManager, sessionId: string, input: SlashCommandInput): Promise<OCMessageWithParts | undefined>;
 export declare function parseShellCommand(value: unknown): string | undefined;
-export declare function parseShellResult(value: unknown): ShellResult;
 export declare function createShellMessage(session: ManagedSession, command: string): ShellMessage;
 export declare function shellUserMessage(message: ShellMessage): ShellUserMessage;
 export declare function announceSessionNotice(context: ShareNoticeContext, messageText: string, error?: OCAssistantMessage["error"]): void;
@@ -81,3 +77,4 @@ export declare function completeShellMessage(message: ShellMessage, command: str
 export declare function failShellMessage(message: ShellMessage, command: string, error: string, metadata?: Record<string, unknown>): void;
 export declare function compactSession(sessions: SessionManager, sessionId: string): Promise<CompactResult>;
 export declare function runShellCommand(context: ShellCommandContext): Promise<ShellExecution>;
+export {};

package/dist/session-commands.js

@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { PiRpcClient } from "./pi-rpc.js";
+import { PiRpcClient, UpstreamProtocolError } from "./pi-rpc.js";
 import { getAgentName } from "./agent-name.js";
+import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
 // OpenChamber drops rejected Share actions, so emit a visible session notice too.
 export const unsupportedShare = {
-    name: "BadRequestError",
+    name: "UnsupportedError",
     data: { message: "Sharing is not available with OmO" },
 };
 function isRecord(value) {
@@ -12,8 +13,10 @@ function isRecord(value) {
 function id(prefix) {
     return `${prefix}_${randomUUID().replaceAll("-", "")}`;
 }
+const SHELL_TITLE_MAX_CHARS = 60;
+const SHELL_TITLE_TRUNCATED_CHARS = 57;
 export function shellTitle(command) {
-    const short = command.length > 60 ? `${command.slice(0, 57)}…` : command;
+    const short = command.length > SHELL_TITLE_MAX_CHARS ? `${command.slice(0, SHELL_TITLE_TRUNCATED_CHARS)}…` : command;
     return `bash: ${short}`;
 }
 function assistantMessage(session) {
@@ -21,7 +24,7 @@ function assistantMessage(session) {
     const messages = session.messages ?? [];
     const boundary = messages.findIndex((message) => message.info.id === session.tree.revert?.messageID);
     const visible = boundary < 0 ? messages : messages.slice(0, boundary);
-    const parentID = [...visible].reverse().find((message) => message.info.role === "user")?.info.id ?? "";
+    const parentID = visible.findLast((message) => message.info.role === "user")?.info.id ?? "";
     return {
         id: id("msg"),
         sessionID: session.info.id,
@@ -112,7 +115,14 @@ export function parseSlashCommand(value) {
         return undefined;
     // OpenChamber inserts the command's user message optimistically under this id.
     const messageID = typeof value.messageID === "string" && value.messageID !== "" ? value.messageID : undefined;
-    return { command: value.command, arguments: value.arguments, ...(messageID ? { messageID } : {}) };
+    const parts = parsePromptParts(value.parts);
+    nativePromptInput("", parts);
+    return {
+        command: value.command,
+        arguments: value.arguments,
+        ...(messageID ? { messageID } : {}),
+        ...(parts.length > 0 ? { parts } : {}),
+    };
 }
 /**
  * OmO never auto-titles a first prompt that starts with "/", so a session opened
@@ -123,21 +133,22 @@ export function slashTitlePrompt(text) {
     const match = /^\s*\/\S+\s+([\s\S]*\S)/.exec(text);
     return match?.[1] !== undefined && !match[1].startsWith("/") ? { sessionTitlePrompt: match[1] } : {};
 }
-export function slashCommandPrompt(input) {
+function slashCommandPrompt(input) {
     return input.arguments === "" ? `/${input.command}` : `/${input.command} ${input.arguments}`;
 }
 export async function runSlashCommand(sessions, sessionId, input) {
-    await sessions.prompt(sessionId, slashCommandPrompt(input), undefined, false, input.messageID);
+    const text = slashCommandPrompt(input);
+    await sessions.prompt(sessionId, text, undefined, false, input.messageID, "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
     await sessions.reloadMessages(sessionId);
     const messages = sessions.messages(sessionId) ?? [];
-    return [...messages].reverse().find((message) => message.info.role === "assistant") ?? messages[messages.length - 1];
+    return messages.findLast((message) => message.info.role === "assistant") ?? messages[messages.length - 1];
 }
 export function parseShellCommand(value) {
     if (!isRecord(value) || typeof value.command !== "string" || value.command.trim() === "")
         return undefined;
     return value.command;
 }
-export function parseShellResult(value) {
+function parseShellResult(value) {
     if (!isRecord(value) ||
         typeof value.output !== "string" ||
         (typeof value.exitCode !== "number" &&
@@ -145,7 +156,7 @@ export function parseShellResult(value) {
             !(value.cancelled === true && value.exitCode === undefined)) ||
         typeof value.cancelled !== "boolean" ||
         typeof value.truncated !== "boolean") {
-        throw new Error("OmO bash returned an invalid result");
+        throw new UpstreamProtocolError("OmO bash returned an invalid result");
     }
     return {
         output: value.output,
@@ -265,6 +276,15 @@ export async function runShellCommand(context) {
     sessions.messages(session.info.id);
     const message = createShellMessage(session, command);
     const user = shellUserMessage(message);
+    const shell = {
+        id: message.parts[0].callID,
+        command,
+        cwd: session.info.directory,
+        shell: "bash",
+        file: "",
+        metadata: {},
+        time: { started: message.info.time.created },
+    };
     const dispatch = (session.tree.shellDispatch ??= {});
     dispatch[message.info.id] = false;
     const afterEntryId = session.tree.leafId ?? null;
@@ -285,8 +305,12 @@ export async function runShellCommand(context) {
     shellEvent(context, { type: "message.updated", properties: { info: user.info } });
     shellEvent(context, { type: "message.part.updated", properties: { part: user.parts[0] } });
     emitShellMessage(context, message);
+    shellEvent(context, {
+        type: "session.shell.started",
+        properties: { sessionID: session.info.id, shell: { ...shell, status: "running" } },
+    });
     try {
-        sessions.update(session.info.id, {});
+        await sessions.update(session.info.id, {});
         const response = await sessions.sessionRpc(session.info.id, { type: "bash", command }, controller.signal, () => {
             dispatch[message.info.id] = true;
             // Only actual dispatch admissions are durable; queued attempts stay in the live cache.
@@ -294,7 +318,7 @@ export async function runShellCommand(context) {
             // A native result can land beyond the last synchronized leaf.
             if (!session.tree.revert)
                 delete session.tree.leafId;
-            sessions.update(session.info.id, {});
+            void sessions.update(session.info.id, {}).catch((error) => controller.abort(error));
         });
         if (controller.signal.aborted)
             throw controller.signal.reason;
@@ -326,7 +350,24 @@ export async function runShellCommand(context) {
     }
     finally {
         delete session.cancelShell;
+        const state = message.parts[0].state;
+        const metadata = state.status === "pending" ? undefined : state.metadata;
+        const output = state.status === "completed" ? state.output : state.status === "error" ? state.error : "";
+        const size = Buffer.byteLength(output);
+        shellEvent(context, {
+            type: "session.shell.ended",
+            properties: {
+                sessionID: session.info.id,
+                shell: {
+                    ...shell,
+                    status: state.status === "completed" ? "exited" : "killed",
+                    ...(typeof metadata?.exitCode === "number" ? { exit: metadata.exitCode } : {}),
+                    time: { ...shell.time, completed: message.info.time.completed ?? Date.now() },
+                },
+                output: { output, cursor: size, size, truncated: metadata?.truncated === true },
+            },
+        });
         setShellStatus(context, "idle");
-        sessions.update(session.info.id, {});
+        await sessions.update(session.info.id, {});
     }
 }

package/dist/session-diff.d.ts

@@ -11,4 +11,4 @@ export interface SessionFileDiff {
     status: "added" | "modified" | "deleted";
 }
 export declare function touchedFiles(parts: readonly OCPart[]): string[];
-export declare function sessionDiff(directory: string, messages: readonly OCMessageWithParts[]): Promise<SessionFileDiff[]>;
+export declare function sessionDiff(directory: string, messages: readonly OCMessageWithParts[], context?: number): Promise<SessionFileDiff[]>;

package/dist/session-diff.js

@@ -3,6 +3,8 @@ import { readFile, realpath, lstat } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 const exec = promisify(execFile);
+const GIT_EXEC_TIMEOUT_MS = 5_000;
+const GIT_EXEC_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 export function touchedFiles(parts) {
     return [
         ...new Set(parts.flatMap((part) => part.type === "tool" &&
@@ -14,7 +16,11 @@ export function touchedFiles(parts) {
     ];
 }
 async function git(directory, args) {
-    const result = await exec("git", args, { cwd: directory, timeout: 5000, maxBuffer: 16 * 1024 * 1024 });
+    const result = await exec("git", args, {
+        cwd: directory,
+        timeout: GIT_EXEC_TIMEOUT_MS,
+        maxBuffer: GIT_EXEC_MAX_BUFFER_BYTES,
+    });
     return result.stdout;
 }
 /** A removed file may be absent, but neither traversal nor symlinks may escape. */
@@ -49,7 +55,7 @@ async function confinedFile(directory, path) {
     }
     return absolute;
 }
-export async function sessionDiff(directory, messages) {
+export async function sessionDiff(directory, messages, context = 3) {
     let gitRoot;
     try {
         gitRoot = (await git(directory, ["rev-parse", "--show-toplevel"])).trim();
@@ -104,6 +110,7 @@ export async function sessionDiff(directory, messages) {
                     "HEAD",
                     "--no-ext-diff",
                     "--no-color",
+                    `--unified=${Math.floor(context)}`,
                     "--src-prefix=a/",
                     "--dst-prefix=b/",
                     "--",
@@ -118,6 +125,7 @@ export async function sessionDiff(directory, messages) {
                         "--no-index",
                         "--no-ext-diff",
                         "--no-color",
+                        `--unified=${Math.floor(context)}`,
                         "--src-prefix=a/",
                         "--dst-prefix=b/",
                         "--",

package/dist/session-history.d.ts

@@ -5,7 +5,7 @@ import { type PiUsage } from "./pi-event-translation.js";
 export interface PiFileMessage {
     clientMessageId?: string;
     role?: string;
-    content?: Array<Record<string, unknown>>;
+    content?: string | Array<Record<string, unknown>>;
     usage?: PiUsage;
     provider?: string;
     model?: string;