antechamber 1.0.40 → 2.0.1

package/dist/routes-v2.js

@@ -2,6 +2,7 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
+import { resolve } from "node:path";
 import { promisify } from "node:util";
 import { errorBody, json, RequestBodyError } from "./http.js";
 import { nativePromptInput, parsePromptParts, v2PromptAttachments, v2PromptParts } from "./prompt-parts.js";
@@ -12,10 +13,11 @@ import { toV2Permission } from "./approvals.js";
 import { formQuestionAnswer, questionFormID, toQuestionForm } from "./question-forms.js";
 import { getAgentName } from "./agent-name.js";
 import { vcsRead, VcsError } from "./vcs.js";
-import { announceSessionError, compactSession, getCommands, unsupportedShare } from "./session-commands.js";
+import { announceSessionError, compactSession, unsupportedShare } from "./session-commands.js";
 import { defaultV2Model, flattenModels, toV2Message, toV2Session } from "./v2.js";
 import { SHELL_CANCELLATION_KEY } from "./omo-shells.js";
 import { WorkStatusError } from "./work-status.js";
+import { FileWatchError } from "./file-watch.js";
 import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 async function v2Agents(services) {
     return (await agentDescriptors(services)).map(({ model, variant, ...agent }) => ({
@@ -71,18 +73,6 @@ function followsCursor(session, cursor, order) {
     const comparison = session.time.updated - cursor.updated || session.id.localeCompare(cursor.id);
     return order === "asc" ? comparison > 0 : comparison < 0;
 }
-async function currentGitBranch(directory) {
-    try {
-        const { stdout } = await execFileAsync("git", ["symbolic-ref", "--short", "HEAD"], {
-            cwd: directory,
-            timeout: 3000,
-        });
-        return stdout.trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 async function initializeGit(directory) {
     try {
         await execFileAsync("git", ["init", "-q"], { cwd: directory, timeout: 3000 });
@@ -107,7 +97,7 @@ function v2Projects(services) {
         vcs: "git",
     }));
 }
-async function handleV2Bootstrap(services, res, path, method, directory) {
+async function handleV2Bootstrap(services, res, url, path, method, directory) {
     const withLocation = (data) => ({ location: { directory }, data });
     if (path === "/api/info" && method === "GET") {
         json(res, 200, {
@@ -128,17 +118,19 @@ async function handleV2Bootstrap(services, res, path, method, directory) {
         return true;
     }
     if (path === "/api/provider" && method === "GET") {
-        const cat = await services.catalog();
+        const cat = await services.catalog(directory, true);
         json(res, 200, withLocation(cat.providers.map((p) => ({ ...p, activation: "enabled" }))));
         return true;
     }
     if (path === "/api/model" && method === "GET") {
-        const cat = await services.catalog();
-        json(res, 200, withLocation(flattenModels(cat)));
+        const cat = await services.catalog(directory, true);
+        const requested = url.searchParams.getAll("types");
+        const types = requested.length === 0 ? ["chat"] : requested;
+        json(res, 200, withLocation(flattenModels(cat).filter((model) => types.some((type) => model.capabilities.output.includes(type === "chat" ? "text" : type)))));
         return true;
     }
     if (path === "/api/model/default" && method === "GET") {
-        const cat = await services.catalog();
+        const cat = await services.catalog(directory);
         json(res, 200, withLocation(defaultV2Model(cat) ?? null));
         return true;
     }
@@ -157,7 +149,7 @@ async function handleV2Bootstrap(services, res, path, method, directory) {
         return true;
     }
     if (path === "/api/command" && method === "GET") {
-        json(res, 200, withLocation((await getCommands(directory)).map((command) => ({
+        json(res, 200, withLocation((await services.commands(directory)).map((command) => ({
             ...command,
             source: "command",
             hints: [],
@@ -210,8 +202,12 @@ export async function handleV2(services, req, res, url, path, method, directory)
     const location = { directory };
     const withLocation = (data) => ({ location, data });
     // --- bootstrap ---
-    if (await handleV2Bootstrap(services, res, path, method, directory))
+    if (await handleV2Bootstrap(services, res, url, path, method, directory))
         return;
+    if (path === "/api/debug/location" && method === "GET") {
+        json(res, 200, []);
+        return;
+    }
     if (path === "/api/debug/location" && method === "DELETE") {
         // OpenChamber evicts a location after git worktree changes so OpenCode re-reads it. antechamber
         // keeps no per-location instance (project and VCS reads are fresh per request): nothing to evict.
@@ -272,6 +268,56 @@ export async function handleV2(services, req, res, url, path, method, directory)
         });
         return;
     }
+    if (path === "/api/experimental/generate/text" && method === "POST") {
+        const body = await services.body(req);
+        if (typeof body !== "object" ||
+            body === null ||
+            !("prompt" in body) ||
+            typeof body.prompt !== "string" ||
+            body.prompt.trim() === "") {
+            json(res, 400, errorBody("InvalidRequestError", "prompt must be a nonempty string"));
+            return;
+        }
+        const model = "model" in body ? body.model : undefined;
+        if (model !== undefined &&
+            (typeof model !== "object" ||
+                model === null ||
+                !("providerID" in model) ||
+                typeof model.providerID !== "string" ||
+                !("id" in model) ||
+                typeof model.id !== "string")) {
+            json(res, 400, errorBody("InvalidRequestError", "model must include providerID and id"));
+            return;
+        }
+        const selected = model !== undefined && typeof model === "object" && model !== null && "providerID" in model && "id" in model
+            ? { providerID: String(model.providerID), id: String(model.id) }
+            : undefined;
+        const cancellation = new AbortController();
+        const disconnected = () => cancellation.abort(new Error("Text generation caller disconnected"));
+        res.once("close", disconnected);
+        if (res.destroyed)
+            disconnected();
+        try {
+            json(res, 200, {
+                data: {
+                    text: await services.textGeneration.generate(services.defaultDirectory, body.prompt, selected, cancellation.signal),
+                },
+            });
+        }
+        catch (error) {
+            if (res.destroyed)
+                return;
+            json(res, 503, {
+                _tag: "ServiceUnavailableError",
+                message: error instanceof Error ? error.message : "Text generation is unavailable",
+                service: "opencode",
+            });
+        }
+        finally {
+            res.off("close", disconnected);
+        }
+        return;
+    }
     // OmO's background work (monitors, background terminal sessions, detached eval cells) as OpenCode shells.
     if (path === "/api/shell" && method === "GET") {
         json(res, 200, withLocation(services.sessions.shells.list(directory)));
@@ -291,10 +337,35 @@ export async function handleV2(services, req, res, url, path, method, directory)
         json(res, 400, errorBody("UnsupportedError", "Session statistics are not available with OmO"));
         return;
     }
+    if (path === "/api/experimental/usage/limits" && method === "GET") {
+        json(res, 200, withLocation(null));
+        return;
+    }
     if (path === "/api/mcp" || path.startsWith("/api/mcp/") || path.startsWith("/api/experimental/mcp/")) {
         json(res, 400, errorBody("UnsupportedError", "MCP is not available with OmO"));
         return;
     }
+    if (path === "/api/experimental/fs/watch" && (method === "POST" || method === "DELETE")) {
+        const body = await services.body(req);
+        if (typeof body !== "object" || body === null || !("path" in body) || typeof body.path !== "string") {
+            json(res, 400, errorBody("InvalidRequestError", "path must be a string"));
+            return;
+        }
+        try {
+            const file = await services.fileWatches.file(directory, body.path, method === "POST");
+            if (method === "POST")
+                services.fileWatches.watch(directory, file, resolve(directory, body.path));
+            else
+                services.fileWatches.unwatch(directory, file);
+            res.writeHead(204).end();
+        }
+        catch (error) {
+            if (!(error instanceof FileWatchError))
+                throw error;
+            json(res, error.status, errorBody(error.kind, error.message));
+        }
+        return;
+    }
     if (path === "/api/fs/find" && method === "GET") {
         const result = await miscRoute("GET", "/find/file", url, directory);
         if (result === undefined) {
@@ -308,7 +379,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
         const files = Array.isArray(result.body)
             ? result.body
                 .filter((entry) => typeof entry === "string")
-                .map((path) => ({ path, type: "file" }))
+                .map((path) => ({ path, type: path.endsWith("/") ? "directory" : "file" }))
             : [];
         json(res, 200, withLocation(files));
         return;
@@ -327,7 +398,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
         json(res, 200, withLocation(services.sessions
             .permissions()
             .filter((permission) => services.sessions.get(permission.sessionID)?.info.directory === directory)
-            .map((permission) => ({ ...toV2Permission(permission), ...permission }))));
+            .map(toV2Permission)));
         return;
     }
     if (path === "/api/question/request" && method === "GET") {
@@ -343,7 +414,10 @@ export async function handleV2(services, req, res, url, path, method, directory)
         return;
     }
     if (path === "/api/form" && method === "GET") {
-        json(res, 200, withLocation(services.sessions.questions().map(toQuestionForm)));
+        json(res, 200, withLocation(services.sessions
+            .questions()
+            .filter((question) => services.sessions.get(question.sessionID)?.info.directory === directory)
+            .map(toQuestionForm)));
         return;
     }
     if (path === "/api/vcs/init" && method === "POST") {
@@ -355,7 +429,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
         return;
     }
     if (path === "/api/vcs" && method === "GET") {
-        const current = await currentGitBranch(directory);
+        const current = await services.vcsBranch(directory);
         json(res, 200, withLocation({ provider: "git", branch: current === undefined ? {} : { current } }));
         return;
     }
@@ -375,15 +449,18 @@ export async function handleV2(services, req, res, url, path, method, directory)
         const dir = url.searchParams.get("directory") ?? url.searchParams.get("location");
         const search = url.searchParams.get("search");
         const parentID = url.searchParams.get("parentID");
+        const archived = url.searchParams.get("archived");
         const order = url.searchParams.get("order") === "asc" ? "asc" : "desc";
         const limit = numberParam(url.searchParams.get("limit"));
         let infos = (dir !== null && dir !== "" ? services.sessions.list(dir) : services.sessions.listAll()).filter(
-        // OmO monitors are a child session only for v1 clients; 2.x shows them in the OmO Work section.
+        // Synthetic monitor sessions stay internal; 2.x shows them in the OmO Work section.
         (session) => !services.sessions.monitors.owns(session.id));
         if (search)
             infos = infos.filter((s) => s.title.toLowerCase().includes(search.toLowerCase()));
         if (parentID !== null)
-            infos = infos.filter((session) => session.parentID === parentID);
+            infos = infos.filter((session) => session.parentID === (parentID === "null" ? undefined : parentID));
+        if (archived === "true" || archived === "false")
+            infos = infos.filter((session) => (session.time.archived !== undefined) === (archived === "true"));
         let sessions = infos.map((info) => v2Session(services, info));
         sessions.sort((left, right) => compareSessions(left, right, order));
         const cursor = decodeSessionCursor(url.searchParams.get("cursor"));
@@ -430,6 +507,36 @@ export async function handleV2(services, req, res, url, path, method, directory)
         json(res, 200, { data });
         return;
     }
+    const instructionEntry = path.match(/^\/api\/experimental\/session\/([^/]+)\/instructions\/entries\/([^/]+)$/);
+    if (instructionEntry && (method === "PUT" || method === "DELETE")) {
+        const sessionId = decodeURIComponent(instructionEntry[1]);
+        const key = decodeURIComponent(instructionEntry[2]);
+        if (services.sessions.get(sessionId) === undefined) {
+            json(res, 404, errorBody("NotFoundError", `session not found: ${sessionId}`));
+            return;
+        }
+        if (!/^[a-z0-9][a-z0-9._-]*$/.test(key)) {
+            json(res, 400, errorBody("InvalidRequestError", "instruction entry key is invalid"));
+            return;
+        }
+        if (method === "PUT") {
+            const body = await services.body(req);
+            if (typeof body !== "object" || body === null || Array.isArray(body) || !("value" in body)) {
+                json(res, 400, errorBody("InvalidRequestError", "instruction entry requires a JSON value"));
+                return;
+            }
+            if (Buffer.byteLength(JSON.stringify(body.value), "utf8") > 256 * 1024) {
+                json(res, 413, errorBody("InstructionEntryValueTooLargeError", "instruction entry exceeds 256 KiB"));
+                return;
+            }
+            services.sessions.putInstruction(sessionId, key, body.value);
+        }
+        else {
+            services.sessions.removeInstruction(sessionId, key);
+        }
+        res.writeHead(204).end();
+        return;
+    }
     const sessionMatch = path.match(/^\/api\/session\/([^/]+)(\/.+)?$/);
     if (sessionMatch) {
         const sessionId = decodeURIComponent(sessionMatch[1]);
@@ -553,6 +660,16 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 json(res, 200, { data: v2Session(services, managed.info) });
                 return;
             }
+            case "POST /view": {
+                const body = (await services.body(req));
+                if (typeof body.idle !== "number" || !Number.isFinite(body.idle)) {
+                    json(res, 400, errorBody("InvalidRequestError", "idle must be a finite epoch-millisecond number"));
+                    return;
+                }
+                services.sessions.view(sessionId, body.idle);
+                res.writeHead(204).end();
+                return;
+            }
             case "PATCH ": {
                 const body = (await services.body(req));
                 // OpenCode 2.1 takes `archived: boolean` (repeating the current state is a no-op);
@@ -578,7 +695,35 @@ export async function handleV2(services, req, res, url, path, method, directory)
             case "GET /message": {
                 const order = url.searchParams.get("order");
                 const limit = numberParam(url.searchParams.get("limit"));
-                let messages = (services.sessions.messages(sessionId) ?? []).map((m) => toV2Message(m));
+                const history = services.sessions.messages(sessionId) ?? [];
+                const messagesWithTurns = history.flatMap((message) => {
+                    if (message.parts.some((part) => part.type === "compaction")) {
+                        const item = services.sessions.compaction(sessionId, message.info.id);
+                        return item === undefined ? [] : [item];
+                    }
+                    if (message.info.role === "assistant" && message.info.summary === true)
+                        return [];
+                    const item = toV2Message(message);
+                    const boundary = managed.tree.idleBoundaries?.[message.info.id];
+                    if (boundary === undefined)
+                        return [item];
+                    return [
+                        item,
+                        {
+                            id: `msg_idle_${message.info.id.replace(/^msg_/, "")}`,
+                            type: "idle",
+                            time: { created: boundary.at },
+                            outcome: boundary.outcome,
+                            ...(boundary.error !== undefined ? { error: boundary.error } : {}),
+                        },
+                    ];
+                });
+                if (managed.compactionID && !messagesWithTurns.some((message) => message.id === managed.compactionID)) {
+                    const item = services.sessions.compaction(sessionId, managed.compactionID);
+                    if (item !== undefined)
+                        messagesWithTurns.push(item);
+                }
+                let messages = messagesWithTurns;
                 if (order !== "asc")
                     messages = messages.reverse(); // v2 default is newest-first
                 const cursor = url.searchParams.get("cursor");
@@ -597,14 +742,52 @@ export async function handleV2(services, req, res, url, path, method, directory)
             }
             case "POST /compact":
             case "POST /summarize": {
-                await services.body(req);
-                const result = await compactSession(services.sessions, sessionId);
-                if (result.kind === "error") {
-                    announceSessionError({ sessions: services.sessions, session: managed, emit: services.broadcast }, "BadRequestError", result.message);
-                    json(res, 400, errorBody("BadRequestError", result.message));
+                const body = (await services.body(req));
+                if (body.delivery !== undefined && body.delivery !== "steer" && body.delivery !== "queue")
+                    throw new RequestBodyError(400, 'delivery must be "steer" or "queue"');
+                if (body.id !== undefined && (typeof body.id !== "string" || !body.id.startsWith("msg_")))
+                    throw new RequestBodyError(400, "id must be a message ID");
+                const inputID = body.id ?? `msg_${randomUUID().replaceAll("-", "")}`;
+                const admission = services.sessions.admitCompaction(sessionId, inputID);
+                if (admission.kind === "conflict") {
+                    json(res, 409, errorBody("ConflictError", "Message ID already in use"));
                     return;
                 }
-                json(res, 200, { data: true });
+                if (admission.kind === "existing") {
+                    json(res, 200, { data: admission.item });
+                    return;
+                }
+                // The agent can stop before compaction_end: if the compaction is still this request's, no event closed it,
+                // so the client's card would stay "running" unless it is failed here.
+                const fail = (message) => {
+                    if (managed.compactionID !== inputID)
+                        return;
+                    delete managed.compactionID;
+                    delete managed.compactionReason;
+                    services.broadcast(managed.info.directory, {
+                        type: "session.compaction.failed",
+                        properties: {
+                            sessionID: sessionId,
+                            inputID,
+                            reason: "manual",
+                            error: { name: "CompactionError", data: { message } },
+                        },
+                    });
+                };
+                void compactSession(services.sessions, sessionId)
+                    .then((result) => {
+                    if (result.kind === "error") {
+                        fail(result.message);
+                        announceSessionError({ sessions: services.sessions, session: managed, emit: services.broadcast }, "BadRequestError", result.message);
+                    }
+                    if (managed.compactionID === inputID)
+                        delete managed.compactionID;
+                })
+                    .catch((error) => {
+                    fail(error instanceof Error ? error.message : String(error));
+                    announceSessionError({ sessions: services.sessions, session: managed, emit: services.broadcast }, error instanceof Error ? error.name : "UnknownError", error instanceof Error ? error.message : String(error));
+                });
+                json(res, 200, { data: admission.item });
                 return;
             }
             case "POST /shell": {
@@ -626,10 +809,14 @@ export async function handleV2(services, req, res, url, path, method, directory)
             }
             case "POST /command": {
                 const body = (await services.body(req));
+                if (body.delivery !== undefined && body.delivery !== "steer" && body.delivery !== "queue")
+                    throw new RequestBodyError(400, 'delivery must be "steer" or "queue"');
                 const result = await runSessionSlash(services, sessionId, {
                     command: body.name,
                     arguments: body.text ?? "",
                     messageID: body.id,
+                    parts: [...parsePromptParts(body.parts), ...v2PromptParts("", body.files, body.agents)],
+                    delivery: body.delivery,
                 });
                 if (result.kind === "input") {
                     json(res, 400, errorBody("BadRequestError", "command is required"));
@@ -720,6 +907,10 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 }
                 const messageID = typeof body.id === "string" && body.id !== "" ? body.id : `msg_${randomUUID().replaceAll("-", "")}`;
                 const text = body.text;
+                if (body.description !== undefined && typeof body.description !== "string")
+                    throw new RequestBodyError(400, "description must be a string");
+                if (body.description !== undefined)
+                    (managed.tree.promptDescriptions ??= {})[messageID] = body.description;
                 promptAsync(services, managed, text, undefined, true, messageID, body.delivery ?? "steer", undefined, metadata);
                 // OpenChamber 2.3.2 treats anything but 200 + the admitted record as a failed send (captured OpenCode shape).
                 json(res, 200, {
@@ -729,6 +920,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
                         time: { created: Date.now() },
                         type: "synthetic",
                         payload: { text },
+                        ...(body.description !== undefined ? { description: body.description } : {}),
                     },
                 });
                 return;
@@ -835,7 +1027,33 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 return;
             }
             case "GET /inbox": {
-                json(res, 200, { data: [] });
+                const messages = services.sessions.messages(sessionId) ?? [];
+                json(res, 200, {
+                    data: [...(managed.inputs ?? [])].flatMap(([id, input]) => {
+                        if (!input.accepted || input.delivered)
+                            return [];
+                        const message = messages.find((item) => item.info.id === id);
+                        if (message?.info.role !== "user")
+                            return [];
+                        return [
+                            {
+                                id,
+                                sessionID: sessionId,
+                                time: { created: message.info.time.created },
+                                type: "user",
+                                delivery: input.delivery,
+                                payload: {
+                                    text: message.parts
+                                        .filter((part) => part.type === "text")
+                                        .map((part) => part.text)
+                                        .join("\n"),
+                                    ...v2PromptAttachments(message.parts.filter((part) => part.type === "file" || part.type === "agent")),
+                                    ...(message.info.metadata !== undefined ? { metadata: message.info.metadata } : {}),
+                                },
+                            },
+                        ];
+                    }),
+                });
                 return;
             }
             case "GET /diff":

package/dist/self-update.d.ts

@@ -22,10 +22,11 @@ export interface SelfUpdateResult {
     readonly to: string;
     readonly method: InstallMethod;
 }
+export declare const MANAGED_UPDATE_HINT = "antechamber is managed by its OpenChamber extension: update the extension in Settings -> Extensions";
 export declare function installMethod(location: InstallLocation, npmRoot: () => string): InstallMethod;
 export declare function isNewerVersion(a: string, b: string): boolean;
 export declare function fetchLatestVersion(env?: NodeJS.ProcessEnv): Promise<string>;
-/** Prefers the npm shipped beside the running node: service PATHs often lack the user's tool directories. */
+/** Prefers an npm beside the running runtime (bun or node): service PATHs often lack the user's tool directories. */
 export declare function npmBinaryFor(execPath?: string): string;
 export declare function defaultSelfUpdateDeps(env?: NodeJS.ProcessEnv, home?: string): SelfUpdateDeps;
 /** Installs the latest release when it is newer; concurrent callers in this process share one attempt. */

package/dist/self-update.js

@@ -4,6 +4,7 @@ import { existsSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { managedByExtension } from "./config.js";
 import { ADAPTER_VERSION } from "./version.js";
 export class SelfUpdateUnsupportedError extends Error {
     name = "SelfUpdateUnsupportedError";
@@ -21,7 +22,10 @@ function tryRealpath(path, location) {
 function bunInstallDir(location) {
     return location.env.BUN_INSTALL ?? join(location.home, ".bun");
 }
+export const MANAGED_UPDATE_HINT = "antechamber is managed by its OpenChamber extension: update the extension in Settings -> Extensions";
 function locate(location) {
+    if (managedByExtension(location.env))
+        throw new SelfUpdateUnsupportedError(MANAGED_UPDATE_HINT);
     const root = tryRealpath(location.packageRoot, location) ?? location.packageRoot;
     if (basename(root) !== "antechamber" || basename(dirname(root)) !== "node_modules")
         throw notGlobal(root);
@@ -139,7 +143,7 @@ function run(binary, args, env, timeout) {
         child.stdin?.end();
     });
 }
-/** Prefers the npm shipped beside the running node: service PATHs often lack the user's tool directories. */
+/** Prefers an npm beside the running runtime (bun or node): service PATHs often lack the user's tool directories. */
 export function npmBinaryFor(execPath = process.execPath) {
     const sibling = join(dirname(execPath), process.platform === "win32" ? "npm.cmd" : "npm");
     return existsSync(sibling) ? sibling : "npm";

package/dist/server.d.ts

@@ -1,13 +1,10 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
-import { type SelfUpdateResult } from "./self-update.js";
 export { isLoopbackHost, serverPassword } from "./http.js";
 interface AdapterServerOptions {
     port: number;
     host: string;
     /** Fallback directory when requests carry no ?directory= param. */
     defaultDirectory: string;
-    /** Replaces the npm self-update behind POST /global/upgrade (tests). */
-    selfUpdate?: () => Promise<SelfUpdateResult>;
 }
 export declare class AdapterServer {
     private options;
@@ -19,12 +16,29 @@ export declare class AdapterServer {
     private webSocketEvents;
     private nextWebSocketEventID;
     private catalogPromise;
+    private catalogExpiresAt;
+    private catalogColdExpiresAt;
+    private readonly commandSnapshots;
+    private readonly commandColdReads;
+    private readonly branchSnapshots;
+    private readonly branchWatchers;
+    private readonly branchChecks;
+    private readonly projectDirectories;
+    private readonly fileWatches;
+    private readonly pendingRefreshes;
+    private readonly textGeneration;
+    private readonly latency;
+    private stopping;
     private actualPort;
     /** Bearer token for the `/antechamber/work-status` routes, published in the run record for the OmO Work extension. */
     readonly extensionToken: string;
     private readonly http;
     constructor(options: AdapterServerOptions);
     private catalog;
+    private commands;
+    private watchBranch;
+    private vcsBranch;
+    private readBranch;
     start(): Promise<void>;
     get url(): string;
     stop(): Promise<void>;