antechamber 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.4] - 2026-10-15
+
+### Added
+
+- feat(cli): `antechamber setup --auto-update` points OpenChamber at a launcher that installs the latest release in the background on every start; it is now the recommended install path
+- feat(cli): `antechamber upgrade` installs the latest release with the package manager that owns the global install, so OpenChamber 2.3.2's Update button now upgrades antechamber
+- feat(api): `POST /global/upgrade` upgrades antechamber itself instead of returning `UnsupportedError`
+- feat(config): `ANTECHAMBER_AUTO_UPDATE=1` enables the post-start background update
+
 ## [0.2.3] - 2026-10-15
 
 ### Fixed

package/README.md

@@ -73,13 +73,23 @@ Needs Node.js 22+ and OmO's `omo` command on PATH (`bun add -g omo-ai`).
 npm i -g antechamber
 # or: bun add -g antechamber
 antechamber doctor
-antechamber setup
+antechamber setup --auto-update
 ```
 
 `setup` updates OpenChamber's `opencodeBinary`, preserves all other settings,
 and backs up an existing settings file before changing it. Restart OpenChamber
 after setup. Preview changes with `antechamber setup --dry-run`.
 
+`--auto-update` keeps antechamber current without any action from you. It
+writes a small launcher, `~/.config/antechamber/opencode-antechamber`, and points
+OpenChamber at it. Each time OpenChamber starts antechamber, the launcher
+checks npm for a newer release once the server is up and installs it with the
+package manager that owns the global install. The new version runs from the
+next start; startup never waits on the network, and an offline start just
+skips the check. It needs a global npm or bun install, so it is refused for
+source checkouts and `npx`. Drop the flag (plain `antechamber setup`) to point
+OpenChamber back at the `antechamber` bin and stop auto-updates.
+
 Optionally, add the bundled [OmO Graph extension](#openchamber-extension-omo-graph):
 `setup` ends by printing its folder
 (`$(npm root -g)/antechamber/extensions/omo-dag`). In OpenChamber, open
@@ -131,28 +141,33 @@ antechamber serve --hostname 127.0.0.1 --port 4096
 | Command | Purpose / options |
 |---|---|
 | `antechamber serve` | OpenCode-compatible server; `--hostname`/`--host`, `--port`, `--directory`. Bare `antechamber` also starts the server. |
-| `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`. |
+| `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`, `--auto-update`. |
 | `antechamber doctor` | Read-only Node, backend, agent/state directories, teardown, OpenChamber and auth checks; `--json`, `--settings <file>`, `--profile <dir>`. Exits 1 on any FAIL; warnings do not fail. |
+| `antechamber upgrade` | Install the latest release over a global npm or bun install, with the package manager that owns it. Refused for source checkouts and `npx`. |
 | `antechamber version` | Package version plus OpenCode API contract version. `--version`/`-v` deliberately print exactly `opencode v2.0.20` for OpenChamber. |
 | `antechamber help` | Usage and options; also `--help`/`-h`. |
 
 ## Upgrade, uninstall and rollback
 
+With `setup --auto-update` there is nothing to do: each start installs the
+latest release for the next one. Otherwise:
+
 ```bash
-npm update -g antechamber
-# or: bun add -g antechamber
+antechamber upgrade
+# equivalent: npm update -g antechamber (or: bun add -g antechamber)
 ```
 
 Restart OpenChamber, or `systemctl --user restart openchamber.service` for a
 managed service. Run `antechamber doctor` again. If the executable moved,
 rerun `antechamber setup`.
 
-OpenChamber 2.3.2 may announce a newer OpenCode release. antechamber reports
-OpenCode API 2.0.20, the minimum OpenChamber accepts, and OpenChamber offers
-no signal that keeps that check while hiding the notice. Dismiss it or turn off
-OpenCode update notifications in OpenChamber. Its Update action runs
-`opencode-antechamber upgrade`, which refuses; upgrade antechamber with the
-commands above.
+OpenChamber 2.3.2 shows an "OpenCode update" notice because antechamber
+reports OpenCode API 2.0.20, the minimum OpenChamber accepts. The notice names
+an OpenCode version, but its **Update** button runs `<opencodeBinary> upgrade`,
+which upgrades antechamber itself (a no-op when it is already current). Click
+**Reload OpenCode** afterwards to restart onto the new version. OpenChamber
+1.x shows no notice; its `POST /global/upgrade` call upgrades antechamber the
+same way.
 
 To roll back wiring, copy the backup printed by setup over the settings file:
 

package/bin/opencode-antechamber

@@ -1,7 +1,8 @@
 #!/bin/sh
 # OpenChamber launcher: point `settings.opencodeBinary` (or $OPENCODE_BINARY)
 # at this file. OpenChamber runs `<binary> serve --hostname H --port P` and
-# `<binary> --version`; anything else is rejected.
+# `<binary> --version`, and OpenChamber 2.x's Update action runs `<binary> upgrade`;
+# anything else is rejected.
 # Requires a build (`npm run build`) so that dist/cli.js exists.
 set -eu
 SCRIPT_PATH=$0
@@ -22,10 +23,7 @@ fi
 case "${1:-}" in
   serve) shift; exec node "$CLI" serve "$@" ;;
   --version|-v) exec node "$CLI" --version ;;
-  upgrade)
-    echo "opencode-antechamber: OpenChamber cannot upgrade antechamber; run 'npm update -g antechamber' (or 'bun add -g antechamber') instead" >&2
-    exit 1
-    ;;
+  upgrade) exec node "$CLI" upgrade ;;
 esac
-echo "opencode-antechamber: unsupported command '${1:-}' (only 'serve' and '--version' are implemented)" >&2
+echo "opencode-antechamber: unsupported command '${1:-}' (only 'serve', '--version' and 'upgrade' are implemented)" >&2
 exit 1

package/dist/cli.js

@@ -26,6 +26,7 @@ try {
                 systemd: { type: "boolean" },
                 "pi-binary": { type: "string" },
                 restart: { type: "boolean" },
+                "auto-update": { type: "boolean" },
                 json: { type: "boolean" },
             },
         });
@@ -49,8 +50,15 @@ try {
                 ...(values.systemd ? { systemd: positionals[1] ?? "openchamber.service" } : {}),
                 dryRun: values["dry-run"] ?? false,
                 restart: values.restart ?? false,
+                autoUpdate: values["auto-update"] ?? false,
             });
         }
+        else if (command === "upgrade") {
+            if (positionals.length > 1)
+                throw new Error("Unexpected upgrade argument");
+            const { upgrade } = await import("./commands/upgrade.js");
+            await upgrade();
+        }
         else if (command === "doctor") {
             const { doctor, formatDoctor } = await import("./commands/doctor.js");
             const report = doctor({

package/dist/commands/context.d.ts

@@ -22,4 +22,8 @@ export interface SettingsOptions {
 export declare function settingsPath(options: SettingsOptions, ctx: CommandContext): string;
 export declare function readSettings(path: string, ctx: CommandContext): Record<string, unknown>;
 export declare function shellQuote(value: string): string;
+/** OpenChamber launcher written by `setup --auto-update`, kept beside the session registry. */
+export declare function autoUpdateLauncherPath(ctx: CommandContext): string;
+export declare function autoUpdateLauncherText(binary: string): string;
+export declare function autoUpdateLauncherTarget(text: string): string | undefined;
 export declare function isPackageBinary(binary: string, ctx: CommandContext): boolean;

package/dist/commands/context.js

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { defaultStateDir, envSetting } from "../config.js";
 export function createContext(overrides = {}) {
     const env = overrides.env ?? process.env;
     const cwd = overrides.cwd ?? process.cwd();
@@ -80,6 +81,24 @@ export function readSettings(path, ctx) {
 export function shellQuote(value) {
     return /^[\w./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
+/** OpenChamber launcher written by `setup --auto-update`, kept beside the session registry. */
+export function autoUpdateLauncherPath(ctx) {
+    return resolve(ctx.cwd, envSetting("STATE_DIR", ctx.env) ?? defaultStateDir(ctx.home, ctx.fs.existsSync), "opencode-antechamber");
+}
+export function autoUpdateLauncherText(binary) {
+    return [
+        "#!/bin/sh",
+        "# Written by `antechamber setup --auto-update`; rerun `antechamber setup` without it to stop auto-updates.",
+        "ANTECHAMBER_AUTO_UPDATE=1",
+        "export ANTECHAMBER_AUTO_UPDATE",
+        `exec '${binary.replaceAll("'", "'\\''")}' "$@"`,
+        "",
+    ].join("\n");
+}
+export function autoUpdateLauncherTarget(text) {
+    const match = /^exec '((?:[^']|'\\'')*)' "\$@"$/m.exec(text);
+    return match?.[1]?.replaceAll("'\\''", "'");
+}
 export function isPackageBinary(binary, ctx) {
     const resolved = resolveBinary(binary, ctx);
     if (resolved === undefined)

package/dist/commands/doctor.js

@@ -3,7 +3,7 @@ import { piAgentDir } from "../agent-dir.js";
 import { detectAgentName } from "../agent-name.js";
 import { agentBinary, defaultStateDir, envSetting, isPlainPi } from "../config.js";
 import { findPidfdPython } from "../pidfd.js";
-import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, } from "./context.js";
+import { autoUpdateLauncherPath, autoUpdateLauncherTarget, createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, } from "./context.js";
 /** Checks capabilities with access/stat only, never creating state or config files. */
 export function doctor(options = {}, ctx = createContext()) {
     const checks = [];
@@ -75,8 +75,13 @@ export function doctor(options = {}, ctx = createContext()) {
     else {
         try {
             const configured = readSettings(settings, ctx).opencodeBinary;
-            const matches = typeof configured === "string" && isPackageBinary(configured, ctx);
-            add("openchamber-settings", matches ? "PASS" : "WARN", `${settings}: opencodeBinary=${JSON.stringify(configured ?? null)}${matches ? "" : "; does not point at this antechamber installation"}`);
+            const launcher = autoUpdateLauncherPath(ctx);
+            const launcherTarget = configured === launcher && ctx.fs.existsSync(launcher)
+                ? autoUpdateLauncherTarget(ctx.fs.readFileSync(launcher, "utf8"))
+                : undefined;
+            const viaLauncher = launcherTarget !== undefined && isPackageBinary(launcherTarget, ctx);
+            const matches = viaLauncher || (typeof configured === "string" && isPackageBinary(configured, ctx));
+            add("openchamber-settings", matches ? "PASS" : "WARN", `${settings}: opencodeBinary=${JSON.stringify(configured ?? null)}${viaLauncher ? ` (auto-update launcher for ${launcherTarget})` : matches ? "" : "; does not point at this antechamber installation"}`);
         }
         catch (error) {
             add("openchamber-settings", "WARN", error instanceof Error ? error.message : String(error));

package/dist/commands/help.d.ts

@@ -1 +1 @@
-export declare const help = "Usage: antechamber [command] [options]\n\nCommands:\n  serve       Run the OpenCode-compatible HTTP/SSE server (also the default)\n  setup       Point OpenChamber at this installation; back up changed files\n  doctor      Read-only installation and backend checks (exit 1 on FAIL)\n  version     Print the npm package and OpenCode API versions\n  help        Show this help (--help, -h)\n\nServe:   --port 4096 --host 127.0.0.1 (or --hostname) --directory <path>\n         --insecure-no-auth\nSetup:   --settings <file> | --profile <dir>\n         --binary <path> --dry-run --systemd [unit] --pi-binary <path> --restart\nDoctor:  --settings <file> | --profile <dir> --json\nProbe:   --version, -v prints the OpenCode compatibility version for OpenChamber";
+export declare const help = "Usage: antechamber [command] [options]\n\nCommands:\n  serve       Run the OpenCode-compatible HTTP/SSE server (also the default)\n  setup       Point OpenChamber at this installation; back up changed files\n  doctor      Read-only installation and backend checks (exit 1 on FAIL)\n  upgrade     Install the latest release over a global npm or bun install\n  version     Print the npm package and OpenCode API versions\n  help        Show this help (--help, -h)\n\nServe:   --port 4096 --host 127.0.0.1 (or --hostname) --directory <path>\n         --insecure-no-auth\nSetup:   --settings <file> | --profile <dir>\n         --binary <path> --dry-run --systemd [unit] --pi-binary <path> --restart\n         --auto-update (launch through a wrapper that upgrades on each start)\nDoctor:  --settings <file> | --profile <dir> --json\nProbe:   --version, -v prints the OpenCode compatibility version for OpenChamber";

package/dist/commands/help.js

@@ -4,6 +4,7 @@ Commands:
   serve       Run the OpenCode-compatible HTTP/SSE server (also the default)
   setup       Point OpenChamber at this installation; back up changed files
   doctor      Read-only installation and backend checks (exit 1 on FAIL)
+  upgrade     Install the latest release over a global npm or bun install
   version     Print the npm package and OpenCode API versions
   help        Show this help (--help, -h)
 
@@ -11,5 +12,6 @@ Serve:   --port 4096 --host 127.0.0.1 (or --hostname) --directory <path>
          --insecure-no-auth
 Setup:   --settings <file> | --profile <dir>
          --binary <path> --dry-run --systemd [unit] --pi-binary <path> --restart
+         --auto-update (launch through a wrapper that upgrades on each start)
 Doctor:  --settings <file> | --profile <dir> --json
 Probe:   --version, -v prints the OpenCode compatibility version for OpenChamber`;

package/dist/commands/serve.js

@@ -1,4 +1,5 @@
 import { envSetting } from "../config.js";
+import { selfUpdate } from "../self-update.js";
 import { AdapterServer, isLoopbackHost, serverPassword } from "../server.js";
 export async function serve(options) {
     const { port, host, directory, insecureNoAuth, compatible } = options;
@@ -26,4 +27,17 @@ export async function serve(options) {
         console.log(`antechamber listening on ${server.url}`);
         console.log(`default directory: ${directory}`);
     }
+    // After the listening line: OpenChamber's startup timeout must not wait on the registry.
+    if (envSetting("AUTO_UPDATE") === "1")
+        void autoUpdate();
+}
+async function autoUpdate() {
+    try {
+        const result = await selfUpdate();
+        if (result.updated)
+            console.error(`antechamber: auto-update installed ${result.to} (running ${result.from}); it starts next time`);
+    }
+    catch (error) {
+        console.error(`antechamber: auto-update skipped: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }

package/dist/commands/setup.d.ts

@@ -5,6 +5,7 @@ interface SetupOptions extends SettingsOptions {
     readonly systemd?: string;
     readonly piBinary?: string;
     readonly restart?: boolean;
+    readonly autoUpdate?: boolean;
     /** User-unit root, overridable without touching the real systemd configuration. */
     readonly systemdDir?: string;
 }

package/dist/commands/setup.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
-import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, shellQuote, } from "./context.js";
+import { installMethod, npmBinaryFor } from "../self-update.js";
+import { autoUpdateLauncherPath, autoUpdateLauncherText, createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, shellQuote, } from "./context.js";
 function systemdValue(value) {
     if (/[\r\n\0]/.test(value))
         throw new Error("systemd environment values cannot contain newlines or NUL");
@@ -40,8 +41,24 @@ export function setup(options, ctx = createContext()) {
     if (binary === ctx.cliPath && !ctx.fs.readFileSync(binary, "utf8").startsWith("#!/usr/bin/env node\n")) {
         throw new Error(`Package CLI ${binary} is missing its node shebang; run npm run build`);
     }
-    const updated = `${JSON.stringify({ ...data, opencodeBinary: binary }, null, 2)}\n`;
-    const changed = data.opencodeBinary !== binary;
+    let launcher;
+    let launcherText;
+    let oldLauncher;
+    if (options.autoUpdate) {
+        installMethod({
+            packageRoot: resolve(dirname(ctx.cliPath), ".."),
+            env: ctx.env,
+            home: ctx.home,
+            realpath: (path) => ctx.fs.realpathSync(path),
+        }, () => ctx.exec(npmBinaryFor(), ["root", "-g"]));
+        launcher = autoUpdateLauncherPath(ctx);
+        launcherText = autoUpdateLauncherText(binary);
+        if (ctx.fs.existsSync(launcher))
+            oldLauncher = ctx.fs.readFileSync(launcher, "utf8");
+    }
+    const configured = launcher ?? binary;
+    const updated = `${JSON.stringify({ ...data, opencodeBinary: configured }, null, 2)}\n`;
+    const changed = data.opencodeBinary !== configured;
     let dropIn;
     let dropInText;
     let oldDropIn;
@@ -102,10 +119,22 @@ export function setup(options, ctx = createContext()) {
             report(`Made ${binary} executable`);
         }
     }
+    if (launcher !== undefined && launcherText !== undefined) {
+        if (oldLauncher === launcherText && (ctx.fs.statSync(launcher).mode & 0o111) !== 0)
+            report(`Already configured: ${launcher}`);
+        else if (options.dryRun)
+            report(`Would write auto-update launcher ${launcher} for ${binary}`);
+        else {
+            ctx.fs.mkdirSync(dirname(launcher), { recursive: true });
+            writeAtomically(launcher, launcherText, ctx);
+            ctx.fs.chmodSync(launcher, 0o755);
+            report(`Wrote auto-update launcher ${launcher} for ${binary}`);
+        }
+    }
     if (changed) {
         report(`${options.dryRun ? "Would update" : "Updating"} ${settings}`);
         report(`- opencodeBinary: ${JSON.stringify(data.opencodeBinary ?? null)}`);
-        report(`+ opencodeBinary: ${JSON.stringify(binary)}`);
+        report(`+ opencodeBinary: ${JSON.stringify(configured)}`);
         if (existing)
             backup(settings);
         if (!options.dryRun) {
@@ -115,7 +144,7 @@ export function setup(options, ctx = createContext()) {
         }
     }
     else
-        report(`Already configured: ${settings} points at ${binary}`);
+        report(`Already configured: ${settings} points at ${configured}`);
     if (dropIn !== undefined && dropInText !== undefined) {
         if (oldDropIn === dropInText)
             report(`Already configured: ${dropIn}`);

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,2 @@
+import { type SelfUpdateResult } from "../self-update.js";
+export declare function upgrade(update?: () => Promise<SelfUpdateResult>, output?: (line: string) => void): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,7 @@
+import { selfUpdate } from "../self-update.js";
+export async function upgrade(update = selfUpdate, output = console.log) {
+    const result = await update();
+    output(result.updated
+        ? `Updated antechamber ${result.from} -> ${result.to} with ${result.method}; restart OpenChamber to use it.`
+        : `antechamber ${result.from} is already the latest release.`);
+}

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

@@ -6,6 +6,7 @@ import { miscRoute } from "./misc-routes.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 +20,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,7 +61,7 @@ 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;
     // --- sessions ---
     const misc = await miscRoute(method, path, url, directory);

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;
+}

package/dist/server.d.ts

@@ -1,10 +1,13 @@
 /** 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;

package/dist/server.js

@@ -8,6 +8,7 @@ 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";
 export { isLoopbackHost, serverPassword } from "./http.js";
 export class AdapterServer {
     options;
@@ -203,6 +204,7 @@ export class AdapterServer {
             body: (request) => this.http.body(request),
             catalog: () => this.catalog(),
             broadcast: (dir, event) => this.broadcast(dir, event),
+            selfUpdate: this.options.selfUpdate ?? (() => selfUpdate()),
         };
         if (path === "/api" || path.startsWith("/api/")) {
             await handleV2(services, req, res, url, path, method, directory);

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",