@neuralnomads/codenomad-dev 0.10.3-dev-20260213-ba418a85

package/dist/background-processes/manager.js

@@ -0,0 +1,437 @@
+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) => ({
+            ...record,
+            outputSizeBytes: await this.getOutputSize(workspaceId, record.id),
+        })));
+        return enriched;
+    }
+    async start(workspaceId, title, command) {
+        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,
+        };
+        const exitPromise = new Promise((resolve) => {
+            child.on("close", async (code) => {
+                await new Promise((resolve) => outputStream.end(resolve));
+                this.running.delete(id);
+                record.status = this.statusFromExit(code);
+                record.exitCode = code === null ? undefined : code;
+                record.stoppedAt = new Date().toISOString();
+                await this.upsertIndex(workspaceId, record);
+                record.outputSizeBytes = await this.getOutputSize(workspaceId, record.id);
+                this.publishUpdate(workspaceId, record);
+                resolve();
+            });
+        });
+        this.running.set(id, { id, child, outputPath, exitPromise, workspaceId });
+        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 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) {
+            this.killProcessTree(running.child, "SIGTERM");
+            await this.waitForExit(running);
+        }
+        if (record.status === "running") {
+            record.status = "stopped";
+            record.stoppedAt = new Date().toISOString();
+            await this.upsertIndex(workspaceId, record);
+            record.outputSizeBytes = await this.getOutputSize(workspaceId, record.id);
+            this.publishUpdate(workspaceId, record);
+        }
+        return 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) {
+            this.killProcessTree(running.child, "SIGTERM");
+            await this.waitForExit(running);
+        }
+        await this.removeFromIndex(workspaceId, processId);
+        await this.removeProcessDir(workspaceId, processId);
+        this.deps.eventBus.publish({
+            type: "instance.event",
+            instanceId: workspaceId,
+            event: { type: "background.process.removed", properties: { processId } },
+        });
+    }
+    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;
+            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;
+    }
+    statusFromExit(code) {
+        if (code === null)
+            return "stopped";
+        if (code === 0)
+            return "stopped";
+        return "error";
+    }
+    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: record } },
+        });
+    }
+    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/config/binaries.js

@@ -0,0 +1,148 @@
+import { spawnSync } from "child_process";
+import { buildSpawnSpec } from "../workspaces/runtime";
+export class BinaryRegistry {
+    constructor(configStore, eventBus, logger) {
+        this.configStore = configStore;
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    list() {
+        return this.mapRecords();
+    }
+    resolveDefault() {
+        const binaries = this.mapRecords();
+        if (binaries.length === 0) {
+            this.logger.warn("No configured binaries found, falling back to opencode");
+            return this.buildFallbackRecord("opencode");
+        }
+        return binaries.find((binary) => binary.isDefault) ?? binaries[0];
+    }
+    create(request) {
+        this.logger.debug({ path: request.path }, "Registering OpenCode binary");
+        const entry = {
+            path: request.path,
+            version: undefined,
+            lastUsed: Date.now(),
+            label: request.label,
+        };
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        const deduped = nextConfig.opencodeBinaries.filter((binary) => binary.path !== request.path);
+        nextConfig.opencodeBinaries = [entry, ...deduped];
+        if (request.makeDefault) {
+            nextConfig.preferences.lastUsedBinary = request.path;
+        }
+        this.configStore.replace(nextConfig);
+        const record = this.getById(request.path);
+        this.emitChange();
+        return record;
+    }
+    update(id, updates) {
+        this.logger.debug({ id }, "Updating OpenCode binary");
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        nextConfig.opencodeBinaries = nextConfig.opencodeBinaries.map((binary) => binary.path === id ? { ...binary, label: updates.label ?? binary.label } : binary);
+        if (updates.makeDefault) {
+            nextConfig.preferences.lastUsedBinary = id;
+        }
+        this.configStore.replace(nextConfig);
+        const record = this.getById(id);
+        this.emitChange();
+        return record;
+    }
+    remove(id) {
+        this.logger.debug({ id }, "Removing OpenCode binary");
+        const config = this.configStore.get();
+        const nextConfig = this.cloneConfig(config);
+        const remaining = nextConfig.opencodeBinaries.filter((binary) => binary.path !== id);
+        nextConfig.opencodeBinaries = remaining;
+        if (nextConfig.preferences.lastUsedBinary === id) {
+            nextConfig.preferences.lastUsedBinary = remaining[0]?.path;
+        }
+        this.configStore.replace(nextConfig);
+        this.emitChange();
+    }
+    validatePath(path) {
+        this.logger.debug({ path }, "Validating OpenCode binary path");
+        return this.validateRecord({
+            id: path,
+            path,
+            label: this.prettyLabel(path),
+            isDefault: false,
+        });
+    }
+    cloneConfig(config) {
+        return JSON.parse(JSON.stringify(config));
+    }
+    mapRecords() {
+        const config = this.configStore.get();
+        const configuredBinaries = config.opencodeBinaries.map((binary) => ({
+            id: binary.path,
+            path: binary.path,
+            label: binary.label ?? this.prettyLabel(binary.path),
+            version: binary.version,
+            isDefault: false,
+        }));
+        const defaultPath = config.preferences.lastUsedBinary ?? configuredBinaries[0]?.path ?? "opencode";
+        const annotated = configuredBinaries.map((binary) => ({
+            ...binary,
+            isDefault: binary.path === defaultPath,
+        }));
+        if (!annotated.some((binary) => binary.path === defaultPath)) {
+            annotated.unshift(this.buildFallbackRecord(defaultPath));
+        }
+        return annotated;
+    }
+    getById(id) {
+        return this.mapRecords().find((binary) => binary.id === id) ?? this.buildFallbackRecord(id);
+    }
+    emitChange() {
+        this.logger.debug("Emitting binaries changed event");
+        this.eventBus?.publish({ type: "config.binariesChanged", binaries: this.mapRecords() });
+    }
+    validateRecord(record) {
+        const inputPath = record.path;
+        if (!inputPath) {
+            return { valid: false, error: "Missing binary path" };
+        }
+        const spec = buildSpawnSpec(inputPath, ["--version"]);
+        try {
+            const result = spawnSync(spec.command, spec.args, {
+                encoding: "utf8",
+                windowsVerbatimArguments: Boolean(spec.options.windowsVerbatimArguments),
+            });
+            if (result.error) {
+                return { valid: false, error: result.error.message };
+            }
+            if (result.status !== 0) {
+                const stderr = result.stderr?.trim();
+                const stdout = result.stdout?.trim();
+                const combined = stderr || stdout;
+                const error = combined ? `Exited with code ${result.status}: ${combined}` : `Exited with code ${result.status}`;
+                return { valid: false, error };
+            }
+            const stdout = (result.stdout ?? "").trim();
+            const firstLine = stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
+            const normalized = firstLine?.trim();
+            const versionMatch = normalized?.match(/([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/);
+            const version = versionMatch?.[1];
+            return { valid: true, version };
+        }
+        catch (error) {
+            return { valid: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    buildFallbackRecord(path) {
+        return {
+            id: path,
+            path,
+            label: this.prettyLabel(path),
+            isDefault: true,
+        };
+    }
+    prettyLabel(path) {
+        const parts = path.split(/[\\/]/);
+        const last = parts[parts.length - 1] || path;
+        return last || path;
+    }
+}

package/dist/config/location.js

@@ -0,0 +1,57 @@
+import os from "os";
+import path from "path";
+function resolvePath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return path.resolve(inputPath);
+}
+function isYamlPath(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith(".yaml") || lower.endsWith(".yml");
+}
+function isJsonPath(filePath) {
+    return filePath.toLowerCase().endsWith(".json");
+}
+/**
+ * Resolve CodeNomad's config location into a stable base directory + derived file paths.
+ *
+ * Supported inputs:
+ * - Directory: "~/.config/codenomad"
+ * - YAML file: "~/.config/codenomad/config.yaml" (or any *.yml/*.yaml)
+ * - Legacy JSON file: "~/.config/codenomad/config.json"
+ */
+export function resolveConfigLocation(raw) {
+    const trimmed = (raw ?? "").trim();
+    const fallback = "~/.config/codenomad/config.json";
+    const input = trimmed.length > 0 ? trimmed : fallback;
+    const resolvedInput = resolvePath(input);
+    if (isYamlPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: resolvedInput,
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: path.join(baseDir, "config.json"),
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    if (isJsonPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: path.join(baseDir, "config.yaml"),
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: resolvedInput,
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    const baseDir = resolvedInput;
+    return {
+        baseDir,
+        configYamlPath: path.join(baseDir, "config.yaml"),
+        stateYamlPath: path.join(baseDir, "state.yaml"),
+        legacyJsonPath: path.join(baseDir, "config.json"),
+        instancesDir: path.join(baseDir, "instances"),
+    };
+}