@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

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/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

@@ -32,6 +32,9 @@ import { PluginChannelManager } from "./plugins/channel";
 import { VoiceModeManager } from "./plugins/voice-mode";
 import { runCliUpgrade } from "./cli-upgrade";
 import { createServerShutdownHandler, orchestrateServerShutdown } from "./shutdown";
+import { AutoAcceptManager } from "./permissions/auto-accept-manager";
+import { createOpencodePermissionReplier } from "./permissions/opencode-replier";
+import { createOpencodeYoloPersistence } from "./permissions/opencode-yolo-metadata";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -41,10 +44,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")
@@ -238,6 +260,15 @@ async function main() {
         logger: logger.child({ component: "sidecars" }),
     });
     const previewManager = new PreviewManager();
+    const yoloLogger = logger.child({ component: "yolo" });
+    const sessionMetadataPersistence = createOpencodeYoloPersistence(workspaceManager);
+    const yoloManager = new AutoAcceptManager({
+        eventBus,
+        logger: yoloLogger,
+        replier: createOpencodePermissionReplier({ workspaceManager, logger: yoloLogger }),
+        persistence: sessionMetadataPersistence,
+    });
+    yoloManager.start();
     const instanceEventBridge = new InstanceEventBridge({
         workspaceManager,
         eventBus,
@@ -327,6 +358,8 @@ async function main() {
             pluginChannel,
             voiceModeManager,
             remoteProxySessionManager,
+            yoloManager,
+            sessionMetadataPersistence,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: uiResolution.uiDevServerUrl,
             logger,
@@ -353,6 +386,8 @@ async function main() {
             pluginChannel,
             voiceModeManager,
             remoteProxySessionManager,
+            yoloManager,
+            sessionMetadataPersistence,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: undefined,
             logger,
@@ -431,6 +466,11 @@ async function main() {
     }
     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(),
@@ -438,6 +478,7 @@ async function main() {
             stopRemoteProxySessions: () => remoteProxySessionManager.shutdown(),
             stopWorkspaces: () => workspaceManager.shutdown(),
             stopHttpServers: async () => {
+                yoloManager.stop();
                 const results = await Promise.allSettled(servers.map((srv) => srv.stop()));
                 const failures = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
                 if (failures.length > 0) {
@@ -451,6 +492,7 @@ async function main() {
         }, logger),
     });
     installShutdownSignalHandlers(process, shutdown);
+    installShutdownStdinHandler(process.stdin, shutdown);
 }
 if (path.resolve(process.argv[1] ?? "") === __filename) {
     main().catch((error) => {

package/dist/index.test.js

@@ -1,6 +1,8 @@
 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 } from "./index";
+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 () => {
@@ -10,23 +12,51 @@ describe("CLI shutdown signal registration", () => {
             finishCleanup = resolve;
         });
         const exits = [];
+        let handled;
         const shutdown = createServerShutdownHandler({
             shutdown: () => cleanup,
-            logger: {
-                info: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-            },
+            logger: { info() { }, warn() { }, error() { } },
             forceExit: (code) => exits.push(code),
             setExitCode: () => undefined,
+            reportStatus: () => undefined,
         });
-        installShutdownSignalHandlers({
-            on: (signal, listener) => listeners.set(signal, listener),
-        }, shutdown);
+        installShutdownSignalHandlers({ on: (signal, listener) => listeners.set(signal, listener) }, (signal) => (handled = shutdown(signal)));
         listeners.get("SIGINT")?.();
         listeners.get("SIGTERM")?.();
         assert.deepEqual(exits, [1]);
         finishCleanup();
-        await cleanup;
+        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");
+});