@dyyz1993/codenomad 0.15.0

package/dist/background-processes/manager.js

@@ -0,0 +1,576 @@
+import { spawn, spawnSync } from "child_process";
+import { createWriteStream, existsSync, promises as fs } from "fs";
+import path from "path";
+import { randomBytes } from "crypto";
+const ROOT_DIR = ".codenomad/background_processes";
+const INDEX_FILE = "index.json";
+const OUTPUT_FILE = "output.txt";
+const STOP_TIMEOUT_MS = 2000;
+const EXIT_WAIT_TIMEOUT_MS = 5000;
+const MAX_OUTPUT_BYTES = 20 * 1024;
+const OUTPUT_PUBLISH_INTERVAL_MS = 1000;
+export class BackgroundProcessManager {
+    constructor(deps) {
+        this.deps = deps;
+        this.running = new Map();
+        this.deps.eventBus.on("workspace.stopped", (event) => this.cleanupWorkspace(event.workspaceId));
+        this.deps.eventBus.on("workspace.error", (event) => this.cleanupWorkspace(event.workspace.id));
+    }
+    async list(workspaceId) {
+        const records = await this.readIndex(workspaceId);
+        const enriched = await Promise.all(records.map(async (record) => ({
+            ...this.toPublicProcess(record),
+            outputSizeBytes: await this.getOutputSize(workspaceId, record.id),
+        })));
+        return enriched;
+    }
+    async start(workspaceId, title, command, options = {}) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        const id = this.generateId();
+        const processDir = await this.ensureProcessDir(workspaceId, id);
+        const outputPath = path.join(processDir, OUTPUT_FILE);
+        const outputStream = createWriteStream(outputPath, { flags: "a" });
+        const { shellCommand, shellArgs, spawnOptions } = this.buildShellSpawn(command);
+        const child = spawn(shellCommand, shellArgs, {
+            cwd: workspace.path,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+            ...spawnOptions,
+        });
+        child.on("exit", () => {
+            this.killProcessTree(child, "SIGTERM");
+        });
+        const record = {
+            id,
+            workspaceId,
+            title,
+            command,
+            cwd: workspace.path,
+            status: "running",
+            pid: child.pid,
+            startedAt: new Date().toISOString(),
+            outputSizeBytes: 0,
+            notify: options.notify && options.notification
+                ? {
+                    sessionID: options.notification.sessionID,
+                    directory: options.notification.directory,
+                }
+                : undefined,
+        };
+        const runningState = {
+            id,
+            child,
+            outputPath,
+            exitPromise: Promise.resolve(),
+            workspaceId,
+        };
+        const exitPromise = new Promise((resolve) => {
+            child.on("close", async (code) => {
+                await new Promise((resolve) => outputStream.end(resolve));
+                this.running.delete(id);
+                const completion = runningState.completion ?? this.completionFromExit(code);
+                record.terminalReason = completion.reason;
+                record.status = this.statusFromReason(completion.reason);
+                record.exitCode = code === null ? undefined : code;
+                record.stoppedAt = new Date().toISOString();
+                await this.finalizeRecord(workspaceId, record, completion);
+                resolve();
+            });
+        });
+        runningState.exitPromise = exitPromise;
+        this.running.set(id, runningState);
+        let lastPublishAt = 0;
+        const maybePublishSize = () => {
+            const now = Date.now();
+            if (now - lastPublishAt < OUTPUT_PUBLISH_INTERVAL_MS) {
+                return;
+            }
+            lastPublishAt = now;
+            this.publishUpdate(workspaceId, record);
+        };
+        child.stdout?.on("data", (data) => {
+            outputStream.write(data);
+            record.outputSizeBytes = (record.outputSizeBytes ?? 0) + data.length;
+            maybePublishSize();
+        });
+        child.stderr?.on("data", (data) => {
+            outputStream.write(data);
+            record.outputSizeBytes = (record.outputSizeBytes ?? 0) + data.length;
+            maybePublishSize();
+        });
+        await this.upsertIndex(workspaceId, record);
+        record.outputSizeBytes = await this.getOutputSize(workspaceId, record.id);
+        this.publishUpdate(workspaceId, record);
+        return this.toPublicProcess(record);
+    }
+    async stop(workspaceId, processId) {
+        const record = await this.findProcess(workspaceId, processId);
+        if (!record) {
+            return null;
+        }
+        const running = this.running.get(processId);
+        if (running?.child && !running.child.killed) {
+            running.completion = { reason: "user_stopped", endContext: "normal" };
+            this.killProcessTree(running.child, "SIGTERM");
+            await this.waitForExit(running);
+            const updated = await this.findProcess(workspaceId, processId);
+            return updated ? this.toPublicProcess(updated) : this.toPublicProcess(record);
+        }
+        if (record.status === "running") {
+            record.status = "stopped";
+            record.terminalReason = "user_stopped";
+            record.stoppedAt = new Date().toISOString();
+            await this.finalizeRecord(workspaceId, record, { reason: "user_stopped", endContext: "normal" });
+        }
+        return this.toPublicProcess(record);
+    }
+    async terminate(workspaceId, processId) {
+        const record = await this.findProcess(workspaceId, processId);
+        if (!record)
+            return;
+        const running = this.running.get(processId);
+        if (running?.child && !running.child.killed) {
+            running.completion = { reason: "user_terminated", endContext: "normal", removeAfterFinalize: true };
+            this.killProcessTree(running.child, "SIGTERM");
+            await this.waitForExit(running);
+            return;
+        }
+        record.status = "stopped";
+        record.terminalReason = "user_terminated";
+        record.stoppedAt = new Date().toISOString();
+        await this.finalizeRecord(workspaceId, record, {
+            reason: "user_terminated",
+            endContext: "normal",
+            removeAfterFinalize: true,
+        });
+    }
+    async readOutput(workspaceId, processId, options) {
+        const outputPath = this.getOutputPath(workspaceId, processId);
+        if (!existsSync(outputPath)) {
+            return { id: processId, content: "", truncated: false, sizeBytes: 0 };
+        }
+        const stats = await fs.stat(outputPath);
+        const sizeBytes = stats.size;
+        const method = options.method ?? "full";
+        const lineCount = options.lines ?? 10;
+        const raw = await this.readOutputBytes(outputPath, sizeBytes, options.maxBytes);
+        let content = raw;
+        switch (method) {
+            case "head":
+                content = this.headLines(raw, lineCount);
+                break;
+            case "tail":
+                content = this.tailLines(raw, lineCount);
+                break;
+            case "grep":
+                if (!options.pattern) {
+                    throw new Error("Pattern is required for grep output");
+                }
+                content = this.grepLines(raw, options.pattern);
+                break;
+            default:
+                content = raw;
+        }
+        const effectiveMaxBytes = options.maxBytes;
+        return {
+            id: processId,
+            content,
+            truncated: effectiveMaxBytes !== undefined && sizeBytes > effectiveMaxBytes,
+            sizeBytes,
+        };
+    }
+    async streamOutput(workspaceId, processId, reply) {
+        const outputPath = this.getOutputPath(workspaceId, processId);
+        if (!existsSync(outputPath)) {
+            reply.code(404).send({ error: "Output not found" });
+            return;
+        }
+        reply.raw.setHeader("Content-Type", "text/event-stream");
+        reply.raw.setHeader("Cache-Control", "no-cache");
+        reply.raw.setHeader("Connection", "keep-alive");
+        reply.raw.flushHeaders?.();
+        reply.hijack();
+        const file = await fs.open(outputPath, "r");
+        let position = (await file.stat()).size;
+        const tick = async () => {
+            const stats = await file.stat();
+            if (stats.size <= position)
+                return;
+            const length = stats.size - position;
+            const buffer = Buffer.alloc(length);
+            await file.read(buffer, 0, length, position);
+            position = stats.size;
+            const content = buffer.toString("utf-8");
+            reply.raw.write(`data: ${JSON.stringify({ type: "chunk", content })}\n\n`);
+        };
+        const interval = setInterval(() => {
+            tick().catch((error) => {
+                this.deps.logger.warn({ err: error }, "Failed to stream background process output");
+            });
+        }, 1000);
+        const close = () => {
+            clearInterval(interval);
+            file.close().catch(() => undefined);
+            reply.raw.end?.();
+        };
+        reply.raw.on("close", close);
+        reply.raw.on("error", close);
+    }
+    async cleanupWorkspace(workspaceId) {
+        for (const [, running] of this.running.entries()) {
+            if (running.workspaceId !== workspaceId)
+                continue;
+            running.completion = {
+                reason: "user_terminated",
+                endContext: "workspace_cleanup",
+                removeAfterFinalize: true,
+            };
+            this.killProcessTree(running.child, "SIGTERM");
+            await this.waitForExit(running);
+        }
+        await this.removeWorkspaceDir(workspaceId);
+    }
+    killProcessTree(child, signal) {
+        const pid = child.pid;
+        if (!pid)
+            return;
+        if (process.platform === "win32") {
+            const args = this.buildWindowsTaskkillArgs(pid, signal);
+            try {
+                spawnSync("taskkill", args, { stdio: "ignore" });
+                return;
+            }
+            catch {
+                // Fall back to killing the direct child.
+            }
+        }
+        else {
+            try {
+                process.kill(-pid, signal);
+                return;
+            }
+            catch {
+                // Fall back to killing the direct child.
+            }
+        }
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore
+        }
+    }
+    async waitForExit(running) {
+        let exited = false;
+        const exitPromise = running.exitPromise.finally(() => {
+            exited = true;
+        });
+        const killTimeout = setTimeout(() => {
+            if (!exited) {
+                this.killProcessTree(running.child, "SIGKILL");
+            }
+        }, STOP_TIMEOUT_MS);
+        try {
+            await Promise.race([
+                exitPromise,
+                new Promise((resolve) => {
+                    setTimeout(resolve, EXIT_WAIT_TIMEOUT_MS);
+                }),
+            ]);
+            if (!exited) {
+                this.killProcessTree(running.child, "SIGKILL");
+                this.running.delete(running.id);
+                this.deps.logger.warn({ pid: running.child.pid }, "Timed out waiting for background process to exit");
+            }
+        }
+        finally {
+            clearTimeout(killTimeout);
+        }
+    }
+    buildShellSpawn(command) {
+        if (process.platform === "win32") {
+            const comspec = process.env.ComSpec || "cmd.exe";
+            return {
+                shellCommand: comspec,
+                shellArgs: ["/d", "/s", "/c", command],
+                spawnOptions: { windowsVerbatimArguments: true },
+            };
+        }
+        // Keep bash for macOS/Linux.
+        return { shellCommand: "bash", shellArgs: ["-c", command] };
+    }
+    buildWindowsTaskkillArgs(pid, signal) {
+        // Default to graceful termination (no /F), then force kill when we escalate.
+        const force = signal === "SIGKILL";
+        const args = ["/PID", String(pid), "/T"];
+        if (force) {
+            args.push("/F");
+        }
+        return args;
+    }
+    completionFromExit(code) {
+        if (code === 0) {
+            return { reason: "finished", endContext: "normal" };
+        }
+        return { reason: "failed", endContext: "normal" };
+    }
+    statusFromReason(reason) {
+        if (reason === "failed")
+            return "error";
+        return "stopped";
+    }
+    async readOutputBytes(outputPath, sizeBytes, maxBytes) {
+        if (maxBytes === undefined || sizeBytes <= maxBytes) {
+            return await fs.readFile(outputPath, "utf-8");
+        }
+        const start = Math.max(0, sizeBytes - maxBytes);
+        const file = await fs.open(outputPath, "r");
+        const buffer = Buffer.alloc(sizeBytes - start);
+        await file.read(buffer, 0, buffer.length, start);
+        await file.close();
+        return buffer.toString("utf-8");
+    }
+    headLines(input, lines) {
+        const parts = input.split(/\r?\n/);
+        return parts.slice(0, Math.max(0, lines)).join("\n");
+    }
+    tailLines(input, lines) {
+        const parts = input.split(/\r?\n/);
+        return parts.slice(Math.max(0, parts.length - lines)).join("\n");
+    }
+    grepLines(input, pattern) {
+        let matcher;
+        try {
+            matcher = new RegExp(pattern);
+        }
+        catch {
+            throw new Error("Invalid grep pattern");
+        }
+        return input
+            .split(/\r?\n/)
+            .filter((line) => matcher.test(line))
+            .join("\n");
+    }
+    async ensureProcessDir(workspaceId, processId) {
+        const root = await this.ensureWorkspaceDir(workspaceId);
+        const processDir = path.join(root, processId);
+        await fs.mkdir(processDir, { recursive: true });
+        return processDir;
+    }
+    async ensureWorkspaceDir(workspaceId) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        const root = path.join(workspace.path, ROOT_DIR, workspaceId);
+        await fs.mkdir(root, { recursive: true });
+        return root;
+    }
+    getOutputPath(workspaceId, processId) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        return path.join(workspace.path, ROOT_DIR, workspaceId, processId, OUTPUT_FILE);
+    }
+    async findProcess(workspaceId, processId) {
+        const records = await this.readIndex(workspaceId);
+        return records.find((entry) => entry.id === processId) ?? null;
+    }
+    async readIndex(workspaceId) {
+        const indexPath = await this.getIndexPath(workspaceId);
+        if (!existsSync(indexPath))
+            return [];
+        try {
+            const raw = await fs.readFile(indexPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async upsertIndex(workspaceId, record) {
+        const records = await this.readIndex(workspaceId);
+        const index = records.findIndex((entry) => entry.id === record.id);
+        if (index >= 0) {
+            records[index] = record;
+        }
+        else {
+            records.push(record);
+        }
+        await this.writeIndex(workspaceId, records);
+    }
+    async removeFromIndex(workspaceId, processId) {
+        const records = await this.readIndex(workspaceId);
+        const next = records.filter((entry) => entry.id !== processId);
+        await this.writeIndex(workspaceId, next);
+    }
+    async writeIndex(workspaceId, records) {
+        const indexPath = await this.getIndexPath(workspaceId);
+        await fs.mkdir(path.dirname(indexPath), { recursive: true });
+        await fs.writeFile(indexPath, JSON.stringify(records, null, 2));
+    }
+    async getIndexPath(workspaceId) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        return path.join(workspace.path, ROOT_DIR, workspaceId, INDEX_FILE);
+    }
+    async removeProcessDir(workspaceId, processId) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            return;
+        }
+        const processDir = path.join(workspace.path, ROOT_DIR, workspaceId, processId);
+        await fs.rm(processDir, { recursive: true, force: true });
+    }
+    async removeWorkspaceDir(workspaceId) {
+        const workspace = this.deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            return;
+        }
+        const workspaceDir = path.join(workspace.path, ROOT_DIR, workspaceId);
+        await fs.rm(workspaceDir, { recursive: true, force: true });
+    }
+    async getOutputSize(workspaceId, processId) {
+        const outputPath = this.getOutputPath(workspaceId, processId);
+        if (!existsSync(outputPath)) {
+            return 0;
+        }
+        try {
+            const stats = await fs.stat(outputPath);
+            return stats.size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    publishUpdate(workspaceId, record) {
+        this.deps.eventBus.publish({
+            type: "instance.event",
+            instanceId: workspaceId,
+            event: { type: "background.process.updated", properties: { process: this.toPublicProcess(record) } },
+        });
+    }
+    toPublicProcess(record) {
+        return {
+            id: record.id,
+            workspaceId: record.workspaceId,
+            title: record.title,
+            command: record.command,
+            cwd: record.cwd,
+            status: record.status,
+            pid: record.pid,
+            startedAt: record.startedAt,
+            stoppedAt: record.stoppedAt,
+            exitCode: record.exitCode,
+            outputSizeBytes: record.outputSizeBytes,
+            terminalReason: record.terminalReason,
+            notifyEnabled: Boolean(record.notify),
+        };
+    }
+    async finalizeRecord(workspaceId, record, completion) {
+        if (this.shouldSendCompletionPrompt(record, completion)) {
+            try {
+                await this.sendCompletionPrompt(workspaceId, record);
+                if (record.notify) {
+                    record.notify.sentAt = new Date().toISOString();
+                }
+            }
+            catch (error) {
+                this.deps.logger.warn({ err: error, workspaceId, processId: record.id }, "Failed to send background process completion prompt");
+            }
+        }
+        if (completion.removeAfterFinalize) {
+            await this.removeFromIndex(workspaceId, record.id);
+            await this.removeProcessDir(workspaceId, record.id);
+            this.deps.eventBus.publish({
+                type: "instance.event",
+                instanceId: workspaceId,
+                event: { type: "background.process.removed", properties: { processId: record.id } },
+            });
+            return;
+        }
+        await this.upsertIndex(workspaceId, record);
+        record.outputSizeBytes = await this.getOutputSize(workspaceId, record.id);
+        this.publishUpdate(workspaceId, record);
+    }
+    shouldSendCompletionPrompt(record, completion) {
+        if (completion.endContext === "workspace_cleanup")
+            return false;
+        if (!record.notify)
+            return false;
+        return !record.notify.sentAt;
+    }
+    async sendCompletionPrompt(workspaceId, record) {
+        const notify = record.notify;
+        if (!notify || !record.terminalReason)
+            return;
+        if (!this.deps.workspaceManager.get(workspaceId)) {
+            throw new Error("Workspace not found");
+        }
+        const port = this.deps.workspaceManager.getInstancePort(workspaceId);
+        if (!port) {
+            throw new Error("Workspace instance is not ready");
+        }
+        const targetUrl = `http://127.0.0.1:${port}/session/${encodeURIComponent(notify.sessionID)}/prompt_async`;
+        const headers = {
+            "content-type": "application/json",
+            "x-opencode-directory": /[^\x00-\x7F]/.test(notify.directory) ? encodeURIComponent(notify.directory) : notify.directory,
+        };
+        const authorization = this.deps.workspaceManager.getInstanceAuthorizationHeader(workspaceId);
+        if (authorization) {
+            headers.authorization = authorization;
+        }
+        const response = await fetch(targetUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                parts: [
+                    {
+                        type: "text",
+                        text: this.buildSyntheticCompletionPrompt(record),
+                        synthetic: true,
+                    },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            const message = await response.text().catch(() => "");
+            throw new Error(message || `Prompt request failed with ${response.status}`);
+        }
+    }
+    buildCompletionPrompt(record) {
+        const ref = `Background process "${record.title}" (${record.id})`;
+        switch (record.terminalReason) {
+            case "finished":
+                return `${ref} finished successfully.`;
+            case "failed":
+                return record.exitCode === undefined ? `${ref} failed.` : `${ref} failed with exit code ${record.exitCode}.`;
+            case "user_stopped":
+                return `${ref} was stopped by user.`;
+            case "user_terminated":
+                return `${ref} was terminated by user.`;
+        }
+        return `${ref} ended.`;
+    }
+    buildSyntheticCompletionPrompt(record) {
+        return `<system-message>${this.escapeTaggedText(this.buildCompletionPrompt(record))}</system-message>`;
+    }
+    escapeTaggedText(input) {
+        return input
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+    }
+    generateId() {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "").slice(0, 15);
+        const random = randomBytes(3).toString("hex");
+        return `proc_${timestamp}_${random}`;
+    }
+}

package/dist/bin.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliEntry = path.join(__dirname, "index.js");
+const loaderFileUrl = pathToFileURL(path.join(__dirname, "loader.js")).href;
+const registerScript = `import { register } from "node:module"; import { pathToFileURL } from "node:url"; register("${encodeURI(loaderFileUrl)}", pathToFileURL("./"));`;
+const loaderArg = `data:text/javascript,${registerScript}`;
+const child = spawn(process.execPath, ["--import", loaderArg, cliEntry, ...process.argv.slice(2)], {
+    stdio: "inherit",
+});
+child.on("exit", (code, signal) => {
+    if (signal) {
+        process.kill(process.pid, signal);
+        return;
+    }
+    process.exit(code ?? 0);
+});
+child.on("error", (error) => {
+    console.error("Failed to launch CLI runtime", error);
+    process.exit(1);
+});

package/dist/cli-upgrade.js

@@ -0,0 +1,53 @@
+import { spawn } from "child_process";
+const CODENOMAD_PACKAGE_NAME = "@neuralnomads/codenomad";
+function detectFromText(value) {
+    const lower = (value ?? "").toLowerCase();
+    if (!lower)
+        return null;
+    if (lower.includes("pnpm"))
+        return "pnpm";
+    if (lower.includes("bun"))
+        return "bun";
+    if (lower.includes("npm"))
+        return "npm";
+    return null;
+}
+export function detectPackageManager(env = process.env) {
+    return detectFromText(env.npm_config_user_agent) ?? detectFromText(env.npm_execpath) ?? "npm";
+}
+export function buildUpgradeCommand(version, packageManager = detectPackageManager()) {
+    const targetVersion = (version ?? "").trim() || "latest";
+    const packageSpec = `${CODENOMAD_PACKAGE_NAME}@${targetVersion}`;
+    const args = packageManager === "bun" ? ["add", "-g", packageSpec] : ["install", "-g", packageSpec];
+    return {
+        command: packageManager,
+        args,
+        packageSpec,
+    };
+}
+export function formatUpgradeCommand(command) {
+    return [command.command, ...command.args].join(" ");
+}
+export function runCliUpgrade(version, env = process.env) {
+    const upgrade = buildUpgradeCommand(version, detectPackageManager(env));
+    console.log(`Upgrading CodeNomad with: ${formatUpgradeCommand(upgrade)}`);
+    return new Promise((resolve) => {
+        const child = spawn(upgrade.command, upgrade.args, {
+            env,
+            shell: process.platform === "win32",
+            stdio: "inherit",
+        });
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                console.error(`Upgrade command stopped by signal ${signal}`);
+                resolve(1);
+                return;
+            }
+            resolve(code ?? 0);
+        });
+        child.on("error", (error) => {
+            console.error("Failed to launch upgrade command", error);
+            resolve(1);
+        });
+    });
+}

package/dist/cli-upgrade.test.js

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildUpgradeCommand, detectPackageManager, formatUpgradeCommand } from "./cli-upgrade";
+describe("cli upgrade", () => {
+    it("defaults to npm when no package manager can be detected", () => {
+        assert.equal(detectPackageManager({}), "npm");
+    });
+    it("detects package managers from npm user agent", () => {
+        assert.equal(detectPackageManager({ npm_config_user_agent: "pnpm/9.0.0 node/v22" }), "pnpm");
+        assert.equal(detectPackageManager({ npm_config_user_agent: "bun/1.0.0" }), "bun");
+        assert.equal(detectPackageManager({ npm_config_user_agent: "npm/10.0.0 node/v22" }), "npm");
+    });
+    it("builds latest upgrade command by default", () => {
+        const command = buildUpgradeCommand(undefined, "npm");
+        assert.equal(command.packageSpec, "@neuralnomads/codenomad@latest");
+        assert.deepEqual(command.args, ["install", "-g", "@neuralnomads/codenomad@latest"]);
+        assert.equal(formatUpgradeCommand(command), "npm install -g @neuralnomads/codenomad@latest");
+    });
+    it("builds a versioned upgrade command", () => {
+        const command = buildUpgradeCommand("0.10.5", "pnpm");
+        assert.equal(command.packageSpec, "@neuralnomads/codenomad@0.10.5");
+        assert.deepEqual(command.args, ["install", "-g", "@neuralnomads/codenomad@0.10.5"]);
+        assert.equal(formatUpgradeCommand(command), "pnpm install -g @neuralnomads/codenomad@0.10.5");
+    });
+    it("uses bun add for Bun installs", () => {
+        const command = buildUpgradeCommand("0.10.5", "bun");
+        assert.equal(command.packageSpec, "@neuralnomads/codenomad@0.10.5");
+        assert.deepEqual(command.args, ["add", "-g", "@neuralnomads/codenomad@0.10.5"]);
+        assert.equal(formatUpgradeCommand(command), "bun add -g @neuralnomads/codenomad@0.10.5");
+    });
+});