@neuralnomads/codenomad 0.4.0 → 0.5.1

package/dist/background-processes/manager.js

@@ -0,0 +1,364 @@
+import { spawn } 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 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 child = spawn("bash", ["-c", command], {
+            cwd: workspace.path,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        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, { 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) {
+            running.child.kill("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) {
+            running.child.kill("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;
+            running.child.kill("SIGTERM");
+            await this.waitForExit(running);
+        }
+        await this.removeWorkspaceDir(workspaceId);
+    }
+    async waitForExit(running) {
+        let resolved = false;
+        const timeout = setTimeout(() => {
+            if (!resolved) {
+                running.child.kill("SIGKILL");
+            }
+        }, STOP_TIMEOUT_MS);
+        await running.exitPromise.finally(() => {
+            resolved = true;
+            clearTimeout(timeout);
+        });
+    }
+    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/index.js

@@ -79,6 +79,16 @@ async function main() {
     const eventLogger = logger.child({ component: "events" });
     logger.info({ options }, "Starting CodeNomad CLI server");
     const eventBus = new EventBus(eventLogger);
+    const serverMeta = {
+        httpBaseUrl: `http://${options.host}:${options.port}`,
+        eventsUrl: `/api/events`,
+        host: options.host,
+        listeningMode: options.host === "0.0.0.0" ? "all" : "local",
+        port: options.port,
+        hostLabel: options.host,
+        workspaceRoot: options.rootDir,
+        addresses: [],
+    };
     const configStore = new ConfigStore(options.configPath, eventBus, configLogger);
     const binaryRegistry = new BinaryRegistry(configStore, eventBus, configLogger);
     const workspaceManager = new WorkspaceManager({
@@ -87,6 +97,7 @@ async function main() {
         binaryRegistry,
         eventBus,
         logger: workspaceLogger,
+        getServerBaseUrl: () => serverMeta.httpBaseUrl,
     });
     const fileSystemBrowser = new FileSystemBrowser({ rootDir: options.rootDir, unrestricted: options.unrestrictedRoot });
     const instanceStore = new InstanceStore();
@@ -95,16 +106,6 @@ async function main() {
         eventBus,
         logger: logger.child({ component: "instance-events" }),
     });
-    const serverMeta = {
-        httpBaseUrl: `http://${options.host}:${options.port}`,
-        eventsUrl: `/api/events`,
-        host: options.host,
-        listeningMode: options.host === "0.0.0.0" ? "all" : "local",
-        port: options.port,
-        hostLabel: options.host,
-        workspaceRoot: options.rootDir,
-        addresses: [],
-    };
     const releaseMonitor = startReleaseMonitor({
         currentVersion: packageJson.version,
         logger: logger.child({ component: "release-monitor" }),

package/dist/opencode-config/README.md

@@ -0,0 +1,32 @@
+# opencode-config
+
+## TLDR
+Template config + plugins injected into every OpenCode instance that CodeNomad launches. It provides a CodeNomad bridge plugin for local event exchange between the CLI server and opencode.
+
+## What it is
+A packaged config directory that CodeNomad copies into `~/.config/codenomad/opencode-config` for production builds or uses directly in dev. OpenCode autoloads any `plugin/*.ts` or `plugin/*.js` from this directory.
+
+## How it works
+- CodeNomad sets `OPENCODE_CONFIG_DIR` when spawning each opencode instance (`packages/server/src/workspaces/manager.ts`).
+- This template is synced from `packages/opencode-config` (`packages/server/src/opencode-config.ts`, `packages/server/scripts/copy-opencode-config.mjs`).
+- OpenCode autoloads plugins from `plugin/` (`packages/opencode-config/plugin/codenomad.ts`).
+- The `CodeNomadPlugin` reads `CODENOMAD_INSTANCE_ID` + `CODENOMAD_BASE_URL`, connects to `GET /workspaces/:id/plugin/events`, and posts to `POST /workspaces/:id/plugin/event` (`packages/opencode-config/plugin/lib/client.ts`).
+- The server exposes the plugin routes and maps events into the UI SSE pipeline (`packages/server/src/server/routes/plugin.ts`, `packages/server/src/plugins/handlers.ts`).
+
+## Expectations
+- Local-only bridge (no auth/token yet).
+- Plugin must fail startup if it cannot connect after 3 retries.
+- Keep plugin entrypoints thin; put shared logic under `plugin/lib/` to avoid autoloaded helpers.
+- Keep event shapes small and explicit; use `type` + `properties` only.
+
+## Ideas
+- Add feature modules under `plugin/lib/features/` (tool lifecycle, permission prompts, custom commands).
+- Expand `/workspaces/:id/plugin/*` with dedicated endpoints as needed.
+- Promote stable event shapes and version tags once the protocol settles.
+
+## Pointers
+- Plugin entry: `packages/opencode-config/plugin/codenomad.ts`
+- Plugin client: `packages/opencode-config/plugin/lib/client.ts`
+- Plugin server routes: `packages/server/src/server/routes/plugin.ts`
+- Plugin event handling: `packages/server/src/plugins/handlers.ts`
+- Workspace env injection: `packages/server/src/workspaces/manager.ts`

package/dist/opencode-config/opencode.jsonc

@@ -0,0 +1,3 @@
+{
+  "$schema": "https://opencode.ai/config.json"
+}

package/dist/opencode-config/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@codenomad/opencode-config",
+  "version": "0.5.0",
+  "private": true,
+  "dependencies": {
+    "@opencode-ai/plugin": "1.1.1"
+  }
+}

package/dist/opencode-config/plugin/codenomad.ts

@@ -0,0 +1,32 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { createCodeNomadClient, getCodeNomadConfig } from "./lib/client"
+import { createBackgroundProcessTools } from "./lib/background-process"
+
+export async function CodeNomadPlugin(input: PluginInput) {
+  const config = getCodeNomadConfig()
+  const client = createCodeNomadClient(config)
+  const backgroundProcessTools = createBackgroundProcessTools(config, { baseDir: input.directory })
+
+  await client.startEvents((event) => {
+    if (event.type === "codenomad.ping") {
+      void client.postEvent({
+        type: "codenomad.pong",
+        properties: {
+          ts: Date.now(),
+          pingTs: (event.properties as any)?.ts,
+        },
+      }).catch(() => {})
+    }
+  })
+
+  return {
+    tool: {
+      ...backgroundProcessTools,
+    },
+    async event(input: { event: any }) {
+      const opencodeEvent = input?.event
+      if (!opencodeEvent || typeof opencodeEvent !== "object") return
+
+    },
+  }
+}