@neuralnomads/codenomad-dev 0.18.0-dev-20260715-07e8ce68 → 0.18.0-dev-20260718-8f6aa44b

package/README.md

@@ -217,3 +217,15 @@ When running as a server CodeNomad can also be installed as a PWA from any suppo
 
 - **Config**: `~/.config/codenomad/config.json`
 - **Instance Data**: `~/.config/codenomad/instances` (chat history, etc.)
+
+### Provider Plan Usage
+
+The Status panel automatically displays quota information for the provider used by the active session. CodeNomad reads existing OpenCode credentials and never returns provider secrets through its API.
+
+Some optional usage integrations require credentials that OpenCode does not expose. They can be enabled without UI configuration through these environment variables:
+
+- Google token refresh: `GOOGLE_OAUTH_CLIENT_ID` and `GOOGLE_OAUTH_CLIENT_SECRET`
+- Antigravity token refresh: `ANTIGRAVITY_OAUTH_CLIENT_ID` and `ANTIGRAVITY_OAUTH_CLIENT_SECRET`
+- Cursor: `CURSOR_ACCESS_TOKEN` or `CURSOR_TOKEN`, with optional `CURSOR_REFRESH_TOKEN`
+- Ollama Cloud: `OLLAMA_CLOUD_COOKIE`
+- OpenCode Go: `OPENCODE_GO_WORKSPACE_ID` and `OPENCODE_GO_AUTH_COOKIE`

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,26 @@
+# Third-Party Notices
+
+The provider usage adapters are derived from OpenChamber:
+https://github.com/openchamber/openchamber
+
+MIT License
+
+Copyright (c) 2025 Bohdan Triapitsyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/auth/manager.js

@@ -26,7 +26,7 @@ export class AuthManager {
             password: init.password,
             allowBootstrapWithoutPassword: init.generateToken,
         });
-        this.tokenManager = init.generateToken ? new TokenManager(60000) : null;
+        this.tokenManager = init.generateToken ? new TokenManager(60_000) : null;
     }
     isAuthEnabled() {
         return this.authEnabled;

package/dist/events/bus.js

@@ -3,8 +3,19 @@ export class EventBus extends EventEmitter {
     constructor(logger) {
         super();
         this.logger = logger;
+        this.instanceStatuses = new Map();
     }
     publish(event) {
+        if (event.type === "instance.eventStatus") {
+            const terminal = event.status === "disconnected"
+                && (event.reason === "workspace stopped" || event.reason === "workspace error");
+            if (terminal) {
+                this.instanceStatuses.delete(event.instanceId);
+            }
+            else {
+                this.instanceStatuses.set(event.instanceId, event);
+            }
+        }
         if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
             this.logger?.debug({ type: event.type }, "Publishing workspace event");
             if (this.logger?.isLevelEnabled("trace")) {
@@ -29,6 +40,8 @@ export class EventBus extends EventEmitter {
         this.on("instance.eventStatus", handler);
         this.on("yolo.stateChanged", handler);
         this.on("yolo.autoAccepted", handler);
+        for (const status of this.instanceStatuses.values())
+            listener(status);
         return () => {
             this.off("workspace.created", handler);
             this.off("workspace.started", handler);

package/dist/events/bus.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { EventBus } from "./bus";
+describe("event bus instance status replay", () => {
+    it("replays the latest instance status to a late subscriber", () => {
+        const bus = new EventBus();
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connecting" });
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" });
+        const received = [];
+        bus.onEvent((event) => received.push(event));
+        assert.deepEqual(received, [
+            { type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" },
+        ]);
+    });
+    it("delivers terminal disconnects live without replaying stopped workspaces", () => {
+        const bus = new EventBus();
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" });
+        const live = [];
+        bus.onEvent((event) => live.push(event));
+        live.length = 0;
+        bus.publish({
+            type: "instance.eventStatus",
+            instanceId: "workspace-1",
+            status: "disconnected",
+            reason: "workspace stopped",
+        });
+        assert.deepEqual(live, [{
+                type: "instance.eventStatus",
+                instanceId: "workspace-1",
+                status: "disconnected",
+                reason: "workspace stopped",
+            }]);
+        const replayed = [];
+        bus.onEvent((event) => replayed.push(event));
+        assert.deepEqual(replayed, []);
+    });
+});

package/dist/filesystem/__tests__/search-cache.test.js

@@ -7,7 +7,7 @@ describe("workspace search cache", () => {
     });
     it("expires cached candidates after the TTL", () => {
         const workspacePath = "/tmp/workspace";
-        const startTime = 1000;
+        const startTime = 1_000;
         refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
         const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
         assert.ok(beforeExpiry);
@@ -18,12 +18,12 @@ describe("workspace search cache", () => {
     });
     it("replaces cached entries when manually refreshed", () => {
         const workspacePath = "/tmp/workspace";
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
-        const initial = getWorkspaceCandidates(workspacePath, 5001);
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5_000);
+        const initial = getWorkspaceCandidates(workspacePath, 5_001);
         assert.ok(initial);
         assert.equal(initial[0].name, "file-a");
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
-        const refreshed = getWorkspaceCandidates(workspacePath, 6001);
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6_000);
+        const refreshed = getWorkspaceCandidates(workspacePath, 6_001);
         assert.ok(refreshed);
         assert.equal(refreshed[0].name, "file-b");
     });

package/dist/filesystem/search-cache.js

@@ -1,5 +1,5 @@
 import path from "path";
-export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30000;
+export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30_000;
 const workspaceCandidateCache = new Map();
 export function getWorkspaceCandidates(rootDir, now = Date.now()) {
     const key = normalizeKey(rootDir);

package/dist/index.js

@@ -31,6 +31,7 @@ import { ClientConnectionManager } from "./clients/connection-manager";
 import { PluginChannelManager } from "./plugins/channel";
 import { VoiceModeManager } from "./plugins/voice-mode";
 import { runCliUpgrade } from "./cli-upgrade";
+import { createServerShutdownHandler, orchestrateServerShutdown } from "./shutdown";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -40,6 +41,29 @@ const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_CONFIG_PATH = "~/.config/codenomad/config.json";
 const DEFAULT_HTTPS_PORT = 9898;
 const DEFAULT_HTTP_PORT = 9899;
+export const STDIN_SHUTDOWN_COMMAND = "codenomad:shutdown";
+export function installShutdownSignalHandlers(source, shutdown) {
+    source.on("SIGINT", () => void shutdown("SIGINT"));
+    source.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+export function installShutdownStdinHandler(source, shutdown) {
+    let buffer = "";
+    let requested = false;
+    const onData = (chunk) => {
+        if (requested)
+            return;
+        buffer += chunk.toString();
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        if (!lines.some((line) => line.trim() === STDIN_SHUTDOWN_COMMAND))
+            return;
+        requested = true;
+        source.off?.("data", onData);
+        source.destroy?.();
+        void shutdown("stdin");
+    };
+    source.on("data", onData);
+}
 function parseCliOptions(argv) {
     const program = new Command()
         .name("codenomad")
@@ -424,61 +448,39 @@ async function main() {
     if (options.launch) {
         await launchInBrowser(serverMeta.localUrl, logger.child({ component: "launcher" }));
     }
-    let shuttingDown = false;
-    const shutdown = async () => {
-        if (shuttingDown) {
-            logger.info("Shutdown already in progress, ignoring signal");
-            return;
-        }
-        shuttingDown = true;
-        logger.info("Received shutdown signal, stopping workspaces and server");
-        const shutdownWorkspaces = (async () => {
-            try {
-                instanceEventBridge.shutdown();
-            }
-            catch (error) {
-                logger.warn({ err: error }, "Instance event bridge shutdown failed");
-            }
-            try {
-                await sidecarManager.shutdown();
-            }
-            catch (error) {
-                logger.error({ err: error }, "SideCar manager shutdown failed");
-            }
-            try {
-                clientConnectionManager.shutdown();
-            }
-            catch (error) {
-                logger.warn({ err: error }, "Client connection manager shutdown failed");
-            }
-            try {
-                await workspaceManager.shutdown();
-                logger.info("Workspace manager shutdown complete");
-            }
-            catch (error) {
-                logger.error({ err: error }, "Workspace manager shutdown failed");
-            }
-        })();
-        const shutdownHttp = (async () => {
-            try {
-                await Promise.allSettled(servers.map((srv) => srv.stop()));
+    const shutdown = createServerShutdownHandler({
+        logger,
+        holdAfterFailure: () => new Promise(() => { setInterval(() => undefined, 60_000); }),
+        setExitCode: (code) => {
+            process.stdin.destroy();
+            process.exitCode = code;
+        },
+        shutdown: () => orchestrateServerShutdown({
+            stopInstanceEventBridge: () => instanceEventBridge.shutdown(),
+            stopSidecars: () => sidecarManager.shutdown(),
+            stopClientConnections: () => clientConnectionManager.shutdown(),
+            stopRemoteProxySessions: () => remoteProxySessionManager.shutdown(),
+            stopWorkspaces: () => workspaceManager.shutdown(),
+            stopHttpServers: async () => {
+                const results = await Promise.allSettled(servers.map((srv) => srv.stop()));
+                const failures = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
+                if (failures.length > 0) {
+                    const error = new Error("One or more HTTP servers failed to stop");
+                    error.failures = failures;
+                    throw error;
+                }
                 logger.info("HTTP server(s) stopped");
-            }
-            catch (error) {
-                logger.error({ err: error }, "Failed to stop HTTP server");
-            }
-        })();
-        await Promise.allSettled([shutdownWorkspaces, shutdownHttp]);
-        // no-op: remote UI manifest replaces GitHub release monitor
-        devReleaseMonitor?.stop();
-        logger.info("Exiting process");
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+            },
+            stopReleaseMonitor: () => devReleaseMonitor?.stop(),
+        }, logger),
+    });
+    installShutdownSignalHandlers(process, shutdown);
+    installShutdownStdinHandler(process.stdin, shutdown);
+}
+if (path.resolve(process.argv[1] ?? "") === __filename) {
+    main().catch((error) => {
+        const logger = createLogger({ component: "app" });
+        logger.error({ err: error }, "CLI server crashed");
+        process.exit(1);
+    });
 }
-main().catch((error) => {
-    const logger = createLogger({ component: "app" });
-    logger.error({ err: error }, "CLI server crashed");
-    process.exit(1);
-});

package/dist/index.test.js

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { describe, it } from "node:test";
+import { installShutdownSignalHandlers, installShutdownStdinHandler, STDIN_SHUTDOWN_COMMAND } from "./index";
+import { createServerShutdownHandler } from "./shutdown";
+describe("CLI shutdown signal registration", () => {
+    it("routes a second process signal to forced nonzero escalation", async () => {
+        const listeners = new Map();
+        let finishCleanup;
+        const cleanup = new Promise((resolve) => {
+            finishCleanup = resolve;
+        });
+        const exits = [];
+        let handled;
+        const shutdown = createServerShutdownHandler({
+            shutdown: () => cleanup,
+            logger: { info() { }, warn() { }, error() { } },
+            forceExit: (code) => exits.push(code),
+            setExitCode: () => undefined,
+            reportStatus: () => undefined,
+        });
+        installShutdownSignalHandlers({ on: (signal, listener) => listeners.set(signal, listener) }, (signal) => (handled = shutdown(signal)));
+        listeners.get("SIGINT")?.();
+        listeners.get("SIGTERM")?.();
+        assert.deepEqual(exits, [1]);
+        finishCleanup();
+        await handled;
+    });
+    it("coalesces chunked and repeated stdin shutdown commands through the same handler", async () => {
+        const listeners = new Map();
+        const triggers = [];
+        let destroys = 0;
+        const source = {
+            on: (event, listener) => listeners.set(event, listener),
+            off: (event, listener) => {
+                if (listeners.get(event) === listener)
+                    listeners.delete(event);
+            },
+            destroy: () => { destroys++; },
+        };
+        installShutdownStdinHandler(source, async (trigger) => { triggers.push(trigger); });
+        const listener = listeners.get("data");
+        listener(STDIN_SHUTDOWN_COMMAND.slice(0, 8));
+        listener(`${STDIN_SHUTDOWN_COMMAND.slice(8)}\n${STDIN_SHUTDOWN_COMMAND}\n`);
+        listener(`${STDIN_SHUTDOWN_COMMAND}\n`);
+        await Promise.resolve();
+        assert.deepEqual(triggers, ["stdin"]);
+        assert.equal(destroys, 1);
+        assert.equal(listeners.has("data"), false);
+    });
+    it("allows a real piped process to exit naturally after the shutdown command", { timeout: 5_000 }, async () => {
+        const moduleUrl = new URL("./index.ts", import.meta.url).href;
+        const child = spawn(process.execPath, ["--import", "tsx", "--input-type=module", "-e", `
+      import { installShutdownStdinHandler } from ${JSON.stringify(moduleUrl)}
+      installShutdownStdinHandler(process.stdin, async () => { process.exitCode = 0 })
+    `], { stdio: ["pipe", "ignore", "inherit"] });
+        child.stdin.end(`${STDIN_SHUTDOWN_COMMAND}\n`);
+        const [code] = await once(child, "exit");
+        assert.equal(code, 0);
+    });
+});

package/dist/opencode-update/service.js

@@ -0,0 +1,150 @@
+import { fetch } from "undici";
+import { BinaryResolver } from "../settings/binaries";
+import { createInstanceClient } from "../workspaces/instance-client";
+import { probeBinaryVersion } from "../workspaces/spawn";
+import { compareVersionStrings, stripTagPrefix } from "../releases/release-monitor";
+const OPENCODE_LATEST_URL = "https://registry.npmjs.org/opencode-ai/latest";
+const LATEST_VERSION_CACHE_MS = 5 * 60_000;
+const UPGRADE_TIMEOUT_MS = 10 * 60_000;
+const inFlightUpgrades = new Map();
+export class OpenCodeUpdateError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "OpenCodeUpdateError";
+    }
+}
+export class OpenCodeUpdateService {
+    constructor(deps) {
+        this.deps = deps;
+        this.latestVersionCache = null;
+    }
+    async getStatus() {
+        const binary = this.deps.resolveBinary();
+        const currentVersion = this.readCurrentVersion(binary.path);
+        let latestVersion;
+        try {
+            latestVersion = await this.readLatestVersion();
+        }
+        catch (error) {
+            if (!(error instanceof OpenCodeUpdateError) || error.code !== "update_check_failed")
+                throw error;
+            return {
+                currentVersion,
+                latestVersion: null,
+                updateAvailable: null,
+                canUpgrade: false,
+                checkError: "update_check_failed",
+            };
+        }
+        const updateAvailable = compareVersionStrings(latestVersion, currentVersion) > 0;
+        const readyInstanceId = this.deps.findReadyInstanceId(binary.path);
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable,
+            canUpgrade: updateAvailable && Boolean(readyInstanceId),
+        };
+    }
+    upgrade() {
+        const binary = this.deps.resolveBinary();
+        const existing = inFlightUpgrades.get(binary.path);
+        if (existing)
+            return existing;
+        const pending = this.performUpgrade(binary).finally(() => {
+            if (inFlightUpgrades.get(binary.path) === pending)
+                inFlightUpgrades.delete(binary.path);
+        });
+        inFlightUpgrades.set(binary.path, pending);
+        return pending;
+    }
+    async performUpgrade(binary) {
+        const currentVersion = this.readCurrentVersion(binary.path);
+        const latestVersion = await this.readLatestVersion();
+        if (compareVersionStrings(latestVersion, currentVersion) <= 0) {
+            return { success: true, version: currentVersion };
+        }
+        const instanceId = this.deps.findReadyInstanceId(binary.path);
+        if (!instanceId) {
+            throw new OpenCodeUpdateError("no_ready_instance", "No running OpenCode instance uses the configured binary");
+        }
+        try {
+            const result = await this.deps.upgradeInstance(instanceId, latestVersion);
+            if (!result.success) {
+                throw new OpenCodeUpdateError("upgrade_failed", result.error);
+            }
+            const installedVersion = this.readCurrentVersion(binary.path);
+            if (compareVersionStrings(installedVersion, latestVersion) !== 0) {
+                throw new OpenCodeUpdateError("upgrade_verification_failed", `OpenCode reported ${result.version}, but the configured binary is still ${installedVersion}`);
+            }
+            return { success: true, version: installedVersion };
+        }
+        catch (error) {
+            if (error instanceof OpenCodeUpdateError)
+                throw error;
+            throw new OpenCodeUpdateError("upgrade_failed", error instanceof Error ? error.message : "OpenCode upgrade failed");
+        }
+    }
+    readCurrentVersion(binaryPath) {
+        if (process.platform === "win32" && /["\r\n]/.test(binaryPath)) {
+            throw new OpenCodeUpdateError("binary_unavailable", "The configured OpenCode binary path is invalid");
+        }
+        const result = this.deps.probeBinary(binaryPath);
+        const version = stripTagPrefix(result.version);
+        if (!result.valid || !version) {
+            throw new OpenCodeUpdateError("binary_unavailable", result.error ?? "Unable to read OpenCode version");
+        }
+        return version;
+    }
+    async readLatestVersion() {
+        const now = (this.deps.now ?? Date.now)();
+        if (this.latestVersionCache && this.latestVersionCache.expiresAt > now) {
+            return this.latestVersionCache.version;
+        }
+        try {
+            const version = stripTagPrefix(await this.deps.fetchLatestVersion());
+            if (!version || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
+                throw new Error("OpenCode registry returned an invalid version");
+            }
+            this.latestVersionCache = { version, expiresAt: now + LATEST_VERSION_CACHE_MS };
+            return version;
+        }
+        catch (error) {
+            throw new OpenCodeUpdateError("update_check_failed", error instanceof Error ? error.message : "Unable to check the latest OpenCode version");
+        }
+    }
+}
+export async function fetchLatestOpenCodeVersion() {
+    const response = await fetch(OPENCODE_LATEST_URL, {
+        headers: { Accept: "application/json", "User-Agent": "CodeNomad-CLI" },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenCode registry responded with ${response.status}`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.version !== "string") {
+        throw new Error("OpenCode registry response did not include a version");
+    }
+    return payload.version;
+}
+export function createOpenCodeUpdateService(settings, workspaceManager) {
+    const binaryResolver = new BinaryResolver(settings);
+    return new OpenCodeUpdateService({
+        resolveBinary: () => {
+            const binary = binaryResolver.resolveDefault();
+            return { ...binary, path: workspaceManager.resolveBinaryPath(binary.path) };
+        },
+        probeBinary: probeBinaryVersion,
+        findReadyInstanceId: (binaryPath) => workspaceManager.findReadyInstanceIdByBinary(binaryPath),
+        fetchLatestVersion: fetchLatestOpenCodeVersion,
+        upgradeInstance: async (instanceId, target) => {
+            const client = createInstanceClient(workspaceManager, instanceId, { timeoutMs: UPGRADE_TIMEOUT_MS });
+            if (!client) {
+                throw new OpenCodeUpdateError("no_ready_instance", "OpenCode instance is not ready");
+            }
+            const { data } = await client.global.upgrade({ target }, { throwOnError: true });
+            return data;
+        },
+    });
+}

package/dist/opencode-update/service.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { OpenCodeUpdateError, OpenCodeUpdateService } from "./service";
+function createDeps(overrides = {}) {
+    let currentVersion = "1.0.0";
+    return {
+        resolveBinary: () => ({ path: "opencode", label: "OpenCode" }),
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        findReadyInstanceId: () => "workspace-1",
+        fetchLatestVersion: async () => "1.1.0",
+        upgradeInstance: async (_instanceId, target) => {
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+        ...overrides,
+    };
+}
+test("reports an available update and caches the latest version", async () => {
+    let checks = 0;
+    const service = new OpenCodeUpdateService(createDeps({
+        fetchLatestVersion: async () => {
+            checks += 1;
+            return "1.1.0";
+        },
+    }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        canUpgrade: true,
+    });
+    await service.getStatus();
+    assert.equal(checks, 1);
+});
+test("keeps the update visible when no matching instance is ready", async () => {
+    const service = new OpenCodeUpdateService(createDeps({ findReadyInstanceId: () => undefined }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        canUpgrade: false,
+    });
+});
+test("preserves the installed version when the registry check fails", async () => {
+    const service = new OpenCodeUpdateService(createDeps({
+        fetchLatestVersion: async () => {
+            throw new Error("registry unavailable");
+        },
+    }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: null,
+        updateAvailable: null,
+        canUpgrade: false,
+        checkError: "update_check_failed",
+    });
+});
+test("upgrades through the matching OpenCode instance to the advertised version", async () => {
+    const calls = [];
+    let currentVersion = "1.0.0";
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        upgradeInstance: async (instanceId, target) => {
+            calls.push({ instanceId, target });
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+    }));
+    assert.deepEqual(await service.upgrade(), { success: true, version: "1.1.0" });
+    assert.deepEqual(calls, [{ instanceId: "workspace-1", target: "1.1.0" }]);
+});
+test("rejects success when the configured binary was not updated", async () => {
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: "1.0.0" }),
+        upgradeInstance: async (_instanceId, target) => ({ success: true, version: target }),
+    }));
+    await assert.rejects(() => service.upgrade(), (error) => error instanceof OpenCodeUpdateError && error.code === "upgrade_verification_failed");
+});
+test("joins concurrent upgrades for the same binary", async () => {
+    let currentVersion = "1.0.0";
+    let upgrades = 0;
+    let finishUpgrade;
+    const gate = new Promise((resolve) => {
+        finishUpgrade = resolve;
+    });
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        upgradeInstance: async (_instanceId, target) => {
+            upgrades += 1;
+            await gate;
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+    }));
+    const first = service.upgrade();
+    const second = service.upgrade();
+    finishUpgrade?.();
+    assert.deepEqual(await Promise.all([first, second]), [
+        { success: true, version: "1.1.0" },
+        { success: true, version: "1.1.0" },
+    ]);
+    assert.equal(upgrades, 1);
+});
+test("rejects an upgrade when no matching OpenCode instance is running", async () => {
+    const service = new OpenCodeUpdateService(createDeps({ findReadyInstanceId: () => undefined }));
+    await assert.rejects(() => service.upgrade(), (error) => error instanceof OpenCodeUpdateError && error.code === "no_ready_instance");
+});