antechamber 0.2.3 → 0.2.5

package/dist/monitor-sessions.js

@@ -0,0 +1,295 @@
+/**
+ * OmO terminal monitors as read-only child sessions. OpenChamber has no surface for
+ * background watches, but it already lists child sessions under Subagents and gives each
+ * a live dot, so a watch is busy while OmO reports it and idle once it ends.
+ */
+import { getAgentName } from "./agent-name.js";
+import { ocIdFor } from "./session-store.js";
+/** Names OmO's terminal extension passes to `pi.rpc.emit` (core/extensions/builtin/monitor-state-event.js). */
+export const MONITOR_STATE_EVENT = "terminal_monitor_state";
+export const MONITOR_ENDED_EVENT = "terminal_monitor_ended";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function text(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+export function parseMonitor(value) {
+    if (!record(value) || typeof value.id !== "string" || value.id === "")
+        return undefined;
+    const startedAtMs = finite(value.startedAtMs);
+    if (startedAtMs === null)
+        return undefined;
+    return {
+        id: value.id,
+        description: text(value.description) ?? value.id,
+        command: text(value.command),
+        filter: text(value.filter),
+        paused: value.paused === true,
+        persistent: value.persistent === true,
+        startedAtMs,
+        deadlineMs: finite(value.deadlineMs),
+        fireCount: finite(value.fireCount) ?? 0,
+        lastFiredAtMs: finite(value.lastFiredAtMs),
+    };
+}
+function endingLabel(ending) {
+    switch (ending.reason) {
+        case "exit":
+            return ending.exitCode === null ? "command exited" : `command exited with code ${ending.exitCode}`;
+        case "timeout":
+            return "deadline reached";
+        case "killed":
+            return "stopped";
+        case "disposed":
+            return "suspended by an OmO shutdown or reload";
+        case "agent-exit":
+            return "OmO process exited";
+        default:
+            return "ended";
+    }
+}
+function iso(ms) {
+    return ms === null ? undefined : new Date(ms).toISOString();
+}
+export function monitorSummary(monitor, ending) {
+    const deadline = monitor.persistent ? "none (persistent)" : iso(monitor.deadlineMs);
+    return [
+        `Status: ${ending ? endingLabel(ending) : monitor.paused ? "paused" : "watching"}`,
+        monitor.filter !== null ? `Filter: ${monitor.filter}` : undefined,
+        `Events: ${monitor.fireCount}`,
+        monitor.lastFiredAtMs !== null ? `Last event: ${iso(monitor.lastFiredAtMs)}` : undefined,
+        `Started: ${iso(monitor.startedAtMs)}`,
+        ending ? `Ended: ${iso(ending.endedAtMs)}` : deadline !== undefined ? `Deadline: ${deadline}` : undefined,
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+}
+export class MonitorSessions {
+    sessions;
+    emit;
+    watches = new Map();
+    /** Children the user deleted; a later snapshot of the same watch must not resurrect them. */
+    dismissed = new Set();
+    constructor(sessions, emit) {
+        this.sessions = sessions;
+        this.emit = emit;
+    }
+    wire(parent) {
+        parent.hasBackgroundWork = () => this.running(parent.info.id);
+    }
+    owns(id) {
+        return this.watches.has(id);
+    }
+    messages(id) {
+        return this.watches.get(id)?.session.messages ?? [];
+    }
+    observe(parent, ev) {
+        if (!record(ev.data))
+            return;
+        if (ev.name === MONITOR_STATE_EVENT && Array.isArray(ev.data.monitors))
+            this.applyState(parent, ev.data.monitors);
+        else if (ev.name === MONITOR_ENDED_EVENT)
+            this.applyEnded(parent, ev.data);
+    }
+    /** The agent process is gone: OmO's in-process watches died with it. */
+    stopParent(parentID) {
+        for (const watch of this.watches.values()) {
+            if (watch.session.info.parentID !== parentID || watch.ending !== undefined)
+                continue;
+            this.end(watch, { reason: "agent-exit", exitCode: null, endedAtMs: Date.now() });
+        }
+    }
+    /** Forget a deleted child, or every child of a deleted parent. */
+    remove(id) {
+        for (const [childID, watch] of this.watches) {
+            if (childID !== id && watch.session.info.parentID !== id)
+                continue;
+            this.watches.delete(childID);
+            this.dismissed.add(childID);
+            if (this.sessions.get(childID) !== watch.session)
+                continue;
+            this.sessions.delete(childID);
+            this.emit(watch.session.info.directory, { type: "session.deleted", properties: { info: watch.session.info } });
+        }
+    }
+    running(parentID) {
+        for (const watch of this.watches.values()) {
+            if (watch.session.info.parentID === parentID && watch.ending === undefined)
+                return true;
+        }
+        return false;
+    }
+    childID(parent, monitorID) {
+        return ocIdFor(`${parent.info.id}/monitor/${monitorID}`);
+    }
+    applyState(parent, entries) {
+        const live = new Set();
+        for (const entry of entries) {
+            const monitor = parseMonitor(entry);
+            if (!monitor)
+                continue;
+            const id = this.childID(parent, monitor.id);
+            live.add(id);
+            if (this.dismissed.has(id))
+                continue;
+            const watch = this.watches.get(id);
+            if (watch === undefined)
+                this.create(parent, id, monitor);
+            else {
+                watch.monitor = monitor;
+                delete watch.ending;
+                this.publish(watch);
+            }
+        }
+        // A snapshot lists every live watch; one that is missing has ended. Its reason may follow.
+        for (const [id, watch] of this.watches) {
+            if (watch.session.info.parentID !== parent.info.id || watch.ending !== undefined || live.has(id))
+                continue;
+            this.end(watch, { reason: "ended", exitCode: null, endedAtMs: Date.now() });
+        }
+    }
+    applyEnded(parent, data) {
+        if (typeof data.id !== "string")
+            return;
+        const watch = this.watches.get(this.childID(parent, data.id));
+        if (!watch)
+            return;
+        const fireCount = finite(data.fireCount);
+        if (fireCount !== null)
+            watch.monitor.fireCount = fireCount;
+        this.end(watch, {
+            reason: typeof data.reason === "string" ? data.reason : "ended",
+            exitCode: finite(data.exitCode),
+            endedAtMs: finite(data.endedAtMs) ?? Date.now(),
+        });
+    }
+    end(watch, ending) {
+        watch.ending = ending;
+        this.publish(watch);
+    }
+    create(parent, id, monitor) {
+        const now = Date.now();
+        const session = {
+            info: {
+                id,
+                parentID: parent.info.id,
+                projectID: parent.info.projectID,
+                directory: parent.info.directory,
+                title: `Monitor: ${monitor.description}`,
+                version: parent.info.version,
+                time: { created: monitor.startedAtMs, updated: now },
+            },
+            pi: undefined,
+            messages: [],
+            model: parent.model,
+            streaming: undefined,
+            status: { type: "idle" },
+            toolByCallId: new Map(),
+            tree: { messageEntries: {} },
+            hasPendingInteraction: () => false,
+            hasRunningChildren: () => false,
+        };
+        const watch = { session, monitor };
+        this.watches.set(id, watch);
+        this.sessions.set(id, session);
+        this.emit(session.info.directory, { type: "session.created", properties: { info: session.info } });
+        this.publish(watch);
+    }
+    publish(watch) {
+        const { session, monitor, ending } = watch;
+        const directory = session.info.directory;
+        const sessionID = session.info.id;
+        const base = sessionID.replace(/^ses_/, "");
+        const model = session.model ?? { providerID: "omo", modelID: "monitor" };
+        const started = monitor.startedAtMs;
+        const command = monitor.command ?? monitor.description;
+        const input = { command, description: monitor.description };
+        const output = monitorSummary(monitor, ending);
+        const tool = {
+            id: `prt_${base}_tool`,
+            sessionID,
+            messageID: `msg_${base}_1`,
+            type: "tool",
+            callID: `call_${base}`,
+            tool: "bash",
+            state: ending
+                ? {
+                    status: "completed",
+                    input,
+                    output,
+                    title: monitor.description,
+                    metadata: { monitor, ending },
+                    time: { start: started, end: ending.endedAtMs },
+                }
+                : {
+                    status: "running",
+                    input,
+                    title: monitor.description,
+                    metadata: { monitor, output },
+                    time: { start: started },
+                },
+        };
+        const messages = [
+            {
+                info: {
+                    id: `msg_${base}_0`,
+                    sessionID,
+                    role: "user",
+                    time: { created: started },
+                    agent: getAgentName(),
+                    model,
+                },
+                parts: [
+                    {
+                        id: `prt_${base}_request`,
+                        sessionID,
+                        messageID: `msg_${base}_0`,
+                        type: "text",
+                        text: "The agent started a background monitor",
+                        synthetic: true,
+                        time: { start: started, end: started },
+                    },
+                ],
+            },
+            {
+                info: {
+                    id: `msg_${base}_1`,
+                    sessionID,
+                    role: "assistant",
+                    time: { created: started, ...(ending ? { completed: ending.endedAtMs } : {}) },
+                    parentID: `msg_${base}_0`,
+                    modelID: model.modelID,
+                    providerID: model.providerID,
+                    mode: getAgentName(),
+                    path: { cwd: directory, root: directory },
+                    cost: 0,
+                    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                    ...(ending ? { finish: "stop" } : {}),
+                },
+                parts: [tool],
+            },
+        ];
+        const before = new Map((session.messages ?? []).map((message) => [message.info.id, JSON.stringify(message)]));
+        session.messages = messages;
+        for (const message of messages) {
+            if (before.get(message.info.id) === JSON.stringify(message))
+                continue;
+            this.emit(directory, { type: "message.updated", properties: { info: message.info } });
+            for (const part of message.parts)
+                this.emit(directory, { type: "message.part.updated", properties: { part } });
+        }
+        const status = ending ? "idle" : "busy";
+        if (session.status.type === status)
+            return;
+        session.status = { type: status };
+        session.info.time.updated = Date.now();
+        this.emit(directory, { type: "session.updated", properties: { info: session.info } });
+        this.emit(directory, { type: "session.status", properties: { sessionID, status: session.status } });
+        if (status === "idle")
+            this.emit(directory, { type: "session.idle", properties: { sessionID } });
+    }
+}

package/dist/pi-event-translation.d.ts

@@ -3,6 +3,7 @@ import type { OCAssistantMessage, OCMessageWithParts, OCModelRef, OCEvent, OCSes
 import type { ManagedSession } from "./sessions.js";
 import type { SessionStore } from "./session-store.js";
 import type { SubagentBridge } from "./subagents.js";
+import type { MonitorSessions } from "./monitor-sessions.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
     input?: number;
@@ -38,6 +39,7 @@ export declare function compactionMessages(s: ManagedSession, key: string, summa
 interface PiEventServices {
     readonly emit: (directory: string, event: OCEvent | TodoUpdated) => void;
     readonly subagents: SubagentBridge;
+    readonly monitors: MonitorSessions;
     readonly store: Pick<SessionStore, "update">;
     readonly dirtyDiffs: Set<string>;
     readonly ensureMessages: (s: ManagedSession) => OCMessageWithParts[];

package/dist/pi-event-translation.js

@@ -284,6 +284,9 @@ export class PiEventTranslator {
             case "compaction_end":
                 this.onCompactionEvent(s, ev);
                 break;
+            case "extension_event":
+                this.services.monitors.observe(s, ev);
+                break;
             default:
                 break; // turn_start, queue_update — future milestones
         }

package/dist/pi-rpc.js

@@ -93,6 +93,8 @@ export class PiRpcClient extends EventEmitter {
                 ...(process.env.SENPI_RPC_CLIENT_CAPABILITIES ?? "").split(","),
                 "auto_title_sessions",
                 "question",
+                // Extension `pi.rpc.emit` frames, e.g. the terminal extension's monitor state.
+                "extension_events",
             ]
                 .map((value) => value.trim())
                 .filter(Boolean)),

package/dist/route-services.d.ts

@@ -5,6 +5,7 @@ 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";
 export interface RouteServices {
     readonly sessions: SessionManager;
     readonly defaultDirectory: string;
@@ -12,6 +13,7 @@ export interface RouteServices {
     readonly body: (req: IncomingMessage) => Promise<unknown>;
     readonly catalog: () => Promise<Catalog>;
     readonly broadcast: (directory: string, event: OCEvent | TodoUpdated) => void;
+    readonly selfUpdate: () => Promise<SelfUpdateResult>;
 }
 export declare const OPENCODE_COMPAT_VERSION: string | null;
 export declare function numberParam(value: string | null): number | undefined;

package/dist/routes-v1.js

@@ -3,9 +3,11 @@ import { execFile } from "node:child_process";
 import { homedir } from "node:os";
 import { errorBody, json } from "./http.js";
 import { miscRoute } from "./misc-routes.js";
+import { mcpRoute } from "./mcp.js";
 import { getAgentName } from "./agent-name.js";
 import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
 import { RequestBodyError } from "./http.js";
+import { SelfUpdateUnsupportedError } from "./self-update.js";
 import { announceSessionError, compactSession, getCommands, unsupportedShare } from "./session-commands.js";
 import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 /**
@@ -19,13 +21,26 @@ function applyArchivedFilter(sessions, archived) {
         return sessions.filter((s) => s.time.archived === undefined);
     return sessions;
 }
-function handleV1GlobalRoute(res, path, method) {
+async function handleV1GlobalRoute(services, res, path, method) {
     if (method === "GET" && path === "/global/health") {
         json(res, 200, OPENCODE_COMPAT_VERSION === null ? { healthy: true } : { healthy: true, version: OPENCODE_COMPAT_VERSION });
         return true;
     }
-    if ((method === "POST" || method === "GET") && path === "/global/upgrade") {
-        json(res, 409, errorBody("UnsupportedError", "This endpoint is served by antechamber (a pi adapter), not a real opencode install — there is nothing to upgrade."));
+    if (method === "POST" && path === "/global/upgrade") {
+        // The requested OpenCode `target` does not apply: this upgrades antechamber itself.
+        try {
+            const result = await services.selfUpdate();
+            json(res, 200, { success: true, version: result.to, updated: result.updated });
+        }
+        catch (error) {
+            if (!(error instanceof SelfUpdateUnsupportedError))
+                throw error;
+            json(res, 409, errorBody("UnsupportedError", error.message));
+        }
+        return true;
+    }
+    if (method === "GET" && path === "/global/upgrade") {
+        json(res, 409, errorBody("UnsupportedError", "Upgrade antechamber with POST /global/upgrade."));
         return true;
     }
     return false;
@@ -47,8 +62,13 @@ function parseV1Prompt(body, defaultModel) {
     return { text, model, parts, delivery: body.delivery ?? "steer" };
 }
 export async function handleV1(services, req, res, url, path, method, directory) {
-    if (handleV1GlobalRoute(res, path, method))
+    if (await handleV1GlobalRoute(services, res, path, method))
         return;
+    const mcp = await mcpRoute(services, method, path, directory, () => services.body(req));
+    if (mcp !== undefined) {
+        json(res, mcp.status, mcp.body);
+        return;
+    }
     // --- sessions ---
     const misc = await miscRoute(method, path, url, directory);
     if (misc !== undefined) {
@@ -362,10 +382,6 @@ export async function handleV1(services, req, res, url, path, method, directory)
         json(res, 200, []);
         return;
     }
-    if (path === "/mcp" && method === "GET") {
-        json(res, 200, {});
-        return;
-    }
     if (path === "/command" && method === "GET") {
         json(res, 200, (await getCommands(directory)).map((command) => ({
             ...command,

package/dist/routes-v2.js

@@ -6,6 +6,7 @@ import { promisify } from "node:util";
 import { errorBody, json, RequestBodyError } from "./http.js";
 import { nativePromptInput, parsePromptParts, v2PromptAttachments, v2PromptParts } from "./prompt-parts.js";
 import { debugLog, miscRoute } from "./misc-routes.js";
+import { mcpRouteV2 } from "./mcp.js";
 import { OPENCODE_API_VERSION } from "./version.js";
 import { toV2Permission } from "./approvals.js";
 import { formQuestionAnswer, questionFormID, toQuestionForm } from "./question-forms.js";
@@ -192,8 +193,12 @@ export async function handleV2(services, req, res, url, path, method, directory)
         res.writeHead(204).end();
         return;
     }
-    if (path === "/api/integration" && method === "GET") {
-        json(res, 200, withLocation([]));
+    const mcp = await mcpRouteV2(services, method, path, directory, () => services.body(req));
+    if (mcp !== undefined) {
+        if (mcp.status === 204)
+            res.writeHead(204).end();
+        else
+            json(res, mcp.status, mcp.body);
         return;
     }
     const integrationMatch = path.match(/^\/api\/integration\/([^/]+)$/);
@@ -226,9 +231,10 @@ export async function handleV2(services, req, res, url, path, method, directory)
         });
         return;
     }
-    // Read-only inventories OpenChamber loads at bootstrap: OmO has no background shells,
-    // web-search providers or MCP servers, so each is an honest empty list (mutations stay 400).
-    if ((path === "/api/shell" || path === "/api/websearch/provider" || path === "/api/mcp") && method === "GET") {
+    // Read-only inventories OpenChamber loads at bootstrap. OmO has no OpenCode-style shells or
+    // web-search providers, so each is an honest empty list (mutations stay 400);
+    // OmO monitors appear as child sessions instead (monitor-sessions.ts).
+    if ((path === "/api/shell" || path === "/api/websearch/provider") && method === "GET") {
         json(res, 200, withLocation([]));
         return;
     }

package/dist/self-update.d.ts

@@ -0,0 +1,32 @@
+export type InstallMethod = "npm" | "bun";
+export declare class SelfUpdateUnsupportedError extends Error {
+    readonly name = "SelfUpdateUnsupportedError";
+}
+export interface InstallLocation {
+    readonly packageRoot: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly home: string;
+    readonly realpath: (path: string) => string;
+}
+export interface SelfUpdateDeps extends InstallLocation {
+    readonly npmBinary: string;
+    readonly bunBinary: string;
+    readonly npmRoot: () => Promise<string>;
+    readonly currentVersion: string;
+    readonly latestVersion: () => Promise<string>;
+    readonly install: (binary: string, args: readonly string[]) => Promise<void>;
+}
+export interface SelfUpdateResult {
+    readonly updated: boolean;
+    readonly from: string;
+    readonly to: string;
+    readonly method: InstallMethod;
+}
+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. */
+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. */
+export declare function selfUpdate(deps?: SelfUpdateDeps): Promise<SelfUpdateResult>;

package/dist/self-update.js

@@ -0,0 +1,188 @@
+/** Upgrades a global npm or bun install of antechamber to the latest published release. */
+import { execFile } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ADAPTER_VERSION } from "./version.js";
+export class SelfUpdateUnsupportedError extends Error {
+    name = "SelfUpdateUnsupportedError";
+}
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+const VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+function tryRealpath(path, location) {
+    try {
+        return location.realpath(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function bunInstallDir(location) {
+    return location.env.BUN_INSTALL ?? join(location.home, ".bun");
+}
+function locate(location) {
+    const root = tryRealpath(location.packageRoot, location) ?? location.packageRoot;
+    if (basename(root) !== "antechamber" || basename(dirname(root)) !== "node_modules")
+        throw notGlobal(root);
+    const bunPackage = join(bunInstallDir(location), "install", "global", "node_modules", "antechamber");
+    return { root, bun: tryRealpath(bunPackage, location) === root };
+}
+function notGlobal(root) {
+    return new SelfUpdateUnsupportedError(`${root} is not a global npm or bun install of antechamber; update it the way it was installed (source checkout: git pull && npm ci && npm run build)`);
+}
+function npmOwns(location, root, npmGlobal) {
+    const global = npmGlobal.trim();
+    if (global !== "" && tryRealpath(join(global, "antechamber"), location) === root)
+        return "npm";
+    throw notGlobal(root);
+}
+function npmUnavailable(error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return new SelfUpdateUnsupportedError(`cannot run npm root -g to confirm a global npm install (${reason})`);
+}
+export function installMethod(location, npmRoot) {
+    const { root, bun } = locate(location);
+    if (bun)
+        return "bun";
+    let global;
+    try {
+        global = npmRoot();
+    }
+    catch (error) {
+        throw npmUnavailable(error);
+    }
+    return npmOwns(location, root, global);
+}
+async function installMethodAsync(deps) {
+    const { root, bun } = locate(deps);
+    if (bun)
+        return "bun";
+    let global;
+    try {
+        global = await deps.npmRoot();
+    }
+    catch (error) {
+        throw npmUnavailable(error);
+    }
+    return npmOwns(deps, root, global);
+}
+export function isNewerVersion(a, b) {
+    const left = VERSION_PATTERN.exec(a);
+    const right = VERSION_PATTERN.exec(b);
+    if (left === null || right === null)
+        return false;
+    for (let index = 1; index <= 3; index += 1) {
+        const diff = Number(left[index]) - Number(right[index]);
+        if (diff !== 0)
+            return diff > 0;
+    }
+    if (left[4] === right[4])
+        return false;
+    if (left[4] === undefined)
+        return true;
+    if (right[4] === undefined)
+        return false;
+    const leftParts = left[4].split(".");
+    const rightParts = right[4].split(".");
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+        const l = leftParts[index];
+        const r = rightParts[index];
+        if (l === undefined)
+            return false;
+        if (r === undefined)
+            return true;
+        if (l === r)
+            continue;
+        const ln = /^\d+$/.test(l) ? Number(l) : undefined;
+        const rn = /^\d+$/.test(r) ? Number(r) : undefined;
+        if (ln !== undefined && rn !== undefined)
+            return ln > rn;
+        if (ln !== undefined)
+            return false;
+        if (rn !== undefined)
+            return true;
+        return l > r;
+    }
+    return false;
+}
+export async function fetchLatestVersion(env = process.env) {
+    const url = new URL(`${(env.npm_config_registry ?? "https://registry.npmjs.org").replace(/\/+$/, "")}/antechamber/latest`);
+    // Registry URLs can embed a token; fetch rejects them and its error would echo the URL.
+    url.username = "";
+    url.password = "";
+    let response;
+    try {
+        response = await fetch(url, { headers: { Accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
+    }
+    catch {
+        throw new Error(`cannot reach the npm registry at ${url.host}`);
+    }
+    if (!response.ok)
+        throw new Error(`npm registry at ${url.host} answered ${response.status} for antechamber`);
+    const payload = await response.json().catch(() => undefined);
+    const version = typeof payload === "object" && payload !== null && "version" in payload ? String(payload.version) : "";
+    if (!VERSION_PATTERN.test(version))
+        throw new Error("npm registry returned no valid antechamber version");
+    return version;
+}
+function run(binary, args, env, timeout) {
+    return new Promise((resolve, reject) => {
+        const child = execFile(binary, [...args], { env, timeout, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => {
+            // Installer output can contain registry credentials, so it is never echoed.
+            if (error)
+                reject(new Error(`${basename(binary)} ${args.join(" ")} failed; run it in a terminal for details`));
+            else
+                resolve(stdout);
+        });
+        // Package managers must see EOF instead of waiting for interactive input.
+        child.stdin?.end();
+    });
+}
+/** Prefers the npm shipped beside the running 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";
+}
+function bunBinaryFor(env, home) {
+    const installed = join(bunInstallDir({ env, home }), "bin", "bun");
+    return existsSync(installed) ? installed : "bun";
+}
+export function defaultSelfUpdateDeps(env = process.env, home = homedir()) {
+    const npmBinary = npmBinaryFor();
+    return {
+        // src/self-update.ts (tsx) and dist/self-update.js both sit one level below the package root.
+        packageRoot: fileURLToPath(new URL("..", import.meta.url)),
+        env,
+        home,
+        realpath: realpathSync,
+        npmBinary,
+        bunBinary: bunBinaryFor(env, home),
+        npmRoot: () => run(npmBinary, ["root", "-g"], env, 10_000),
+        currentVersion: ADAPTER_VERSION,
+        latestVersion: () => fetchLatestVersion(env),
+        install: async (binary, args) => {
+            await run(binary, args, env, INSTALL_TIMEOUT_MS);
+        },
+    };
+}
+let inFlight;
+/** Installs the latest release when it is newer; concurrent callers in this process share one attempt. */
+export function selfUpdate(deps = defaultSelfUpdateDeps()) {
+    inFlight ??= (async () => {
+        const method = await installMethodAsync(deps);
+        const latest = await deps.latestVersion();
+        const from = deps.currentVersion;
+        if (!isNewerVersion(latest, from))
+            return { updated: false, from, to: from, method };
+        const spec = `antechamber@${latest}`;
+        if (method === "npm")
+            await deps.install(deps.npmBinary, ["install", "-g", spec]);
+        else
+            await deps.install(deps.bunBinary, ["add", "-g", spec]);
+        return { updated: true, from, to: latest, method };
+    })().finally(() => {
+        inFlight = undefined;
+    });
+    return inFlight;
+}