@neuralnomads/codenomad 0.4.0 → 0.5.1

package/dist/server/routes/plugin.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { PluginChannelManager } from "../../plugins/channel";
+import { buildPingEvent, handlePluginEvent } from "../../plugins/handlers";
+const PluginEventSchema = z.object({
+    type: z.string().min(1),
+    properties: z.record(z.unknown()).optional(),
+});
+export function registerPluginRoutes(app, deps) {
+    const channel = new PluginChannelManager(deps.logger.child({ component: "plugin-channel" }));
+    app.get("/workspaces/:id/plugin/events", (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace 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 registration = channel.register(request.params.id, reply);
+        const heartbeat = setInterval(() => {
+            channel.send(request.params.id, buildPingEvent());
+        }, 15000);
+        const close = () => {
+            clearInterval(heartbeat);
+            registration.close();
+            reply.raw.end?.();
+        };
+        request.raw.on("close", close);
+        request.raw.on("error", close);
+    });
+    const handleWildcard = async (request, reply) => {
+        const workspaceId = request.params.id;
+        const workspace = deps.workspaceManager.get(workspaceId);
+        if (!workspace) {
+            reply.code(404).send({ error: "Workspace not found" });
+            return;
+        }
+        const suffix = request.params["*"] ?? "";
+        const normalized = suffix.replace(/^\/+/, "");
+        if (normalized === "event" && request.method === "POST") {
+            const parsed = PluginEventSchema.parse(request.body ?? {});
+            handlePluginEvent(workspaceId, parsed, { workspaceManager: deps.workspaceManager, eventBus: deps.eventBus, logger: deps.logger });
+            reply.code(204).send();
+            return;
+        }
+        reply.code(404).send({ error: "Unknown plugin endpoint" });
+    };
+    app.all("/workspaces/:id/plugin/*", handleWildcard);
+    app.all("/workspaces/:id/plugin", handleWildcard);
+}

package/dist/server/routes/workspaces.js

@@ -23,10 +23,17 @@ export function registerWorkspaceRoutes(app, deps) {
         return deps.workspaceManager.list();
     });
     app.post("/api/workspaces", async (request, reply) => {
-        const body = WorkspaceCreateSchema.parse(request.body ?? {});
-        const workspace = await deps.workspaceManager.create(body.path, body.name);
-        reply.code(201);
-        return workspace;
+        try {
+            const body = WorkspaceCreateSchema.parse(request.body ?? {});
+            const workspace = await deps.workspaceManager.create(body.path, body.name);
+            reply.code(201);
+            return workspace;
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to create workspace");
+            const message = error instanceof Error ? error.message : "Failed to create workspace";
+            reply.code(400).type("text/plain").send(message);
+        }
     });
     app.get("/api/workspaces/:id", async (request, reply) => {
         const workspace = deps.workspaceManager.get(request.params.id);

package/dist/workspaces/manager.js

@@ -1,14 +1,18 @@
 import path from "path";
 import { spawnSync } from "child_process";
+import { connect } from "net";
 import { FileSystemBrowser } from "../filesystem/browser";
 import { searchWorkspaceFiles } from "../filesystem/search";
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
 import { WorkspaceRuntime } from "./runtime";
+import { getOpencodeConfigDir } from "../opencode-config.js";
+const STARTUP_STABILITY_DELAY_MS = 1500;
 export class WorkspaceManager {
     constructor(options) {
         this.options = options;
         this.workspaces = new Map();
         this.runtime = new WorkspaceRuntime(this.options.eventBus, this.options.logger);
+        this.opencodeConfigDir = getOpencodeConfigDir();
     }
     list() {
         return Array.from(this.workspaces.values());
@@ -63,15 +67,23 @@ export class WorkspaceManager {
         }
         this.workspaces.set(id, descriptor);
         this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
-        const environment = this.options.configStore.get().preferences.environmentVariables ?? {};
+        const preferences = this.options.configStore.get().preferences ?? {};
+        const userEnvironment = preferences.environmentVariables ?? {};
+        const environment = {
+            ...userEnvironment,
+            OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
+            CODENOMAD_INSTANCE_ID: id,
+            CODENOMAD_BASE_URL: this.options.getServerBaseUrl(),
+        };
         try {
-            const { pid, port } = await this.runtime.launch({
+            const { pid, port, exitPromise, getLastOutput } = await this.runtime.launch({
                 workspaceId: id,
                 folder: workspacePath,
                 binaryPath: resolvedBinaryPath,
                 environment,
                 onExit: (info) => this.handleProcessExit(info.workspaceId, info),
             });
+            await this.waitForWorkspaceReadiness({ workspaceId: id, port, exitPromise, getLastOutput });
             descriptor.pid = pid;
             descriptor.port = port;
             descriptor.status = "ready";
@@ -189,6 +201,117 @@ export class WorkspaceManager {
         }
         return undefined;
     }
+    async waitForWorkspaceReadiness(params) {
+        await Promise.race([
+            this.waitForPortAvailability(params.port),
+            params.exitPromise.then((info) => {
+                throw this.buildStartupError(params.workspaceId, "exited before becoming ready", info, params.getLastOutput());
+            }),
+        ]);
+        await this.waitForInstanceHealth(params);
+        await Promise.race([
+            this.delay(STARTUP_STABILITY_DELAY_MS),
+            params.exitPromise.then((info) => {
+                throw this.buildStartupError(params.workspaceId, "exited shortly after start", info, params.getLastOutput());
+            }),
+        ]);
+    }
+    async waitForInstanceHealth(params) {
+        const probeResult = await Promise.race([
+            this.probeInstance(params.workspaceId, params.port),
+            params.exitPromise.then((info) => {
+                throw this.buildStartupError(params.workspaceId, "exited during health checks", info, params.getLastOutput());
+            }),
+        ]);
+        if (probeResult.ok) {
+            return;
+        }
+        const latestOutput = params.getLastOutput().trim();
+        if (latestOutput) {
+            throw new Error(latestOutput);
+        }
+        const reason = probeResult.reason ?? "Health check failed";
+        throw new Error(`Workspace ${params.workspaceId} failed health check: ${reason}.`);
+    }
+    async probeInstance(workspaceId, port) {
+        const url = `http://127.0.0.1:${port}/project/current`;
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                const reason = `health probe returned HTTP ${response.status}`;
+                this.options.logger.debug({ workspaceId, status: response.status }, "Health probe returned server error");
+                return { ok: false, reason };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.options.logger.debug({ workspaceId, err: error }, "Health probe failed");
+            return { ok: false, reason };
+        }
+    }
+    buildStartupError(workspaceId, phase, exitInfo, lastOutput) {
+        const exitDetails = this.describeExit(exitInfo);
+        const trimmedOutput = lastOutput.trim();
+        const outputDetails = trimmedOutput ? ` Last output: ${trimmedOutput}` : "";
+        return new Error(`Workspace ${workspaceId} ${phase} (${exitDetails}).${outputDetails}`);
+    }
+    waitForPortAvailability(port, timeoutMs = 5000) {
+        return new Promise((resolve, reject) => {
+            const deadline = Date.now() + timeoutMs;
+            let settled = false;
+            let retryTimer = null;
+            const cleanup = () => {
+                settled = true;
+                if (retryTimer) {
+                    clearTimeout(retryTimer);
+                    retryTimer = null;
+                }
+            };
+            const tryConnect = () => {
+                if (settled) {
+                    return;
+                }
+                const socket = connect({ port, host: "127.0.0.1" }, () => {
+                    cleanup();
+                    socket.end();
+                    resolve();
+                });
+                socket.once("error", () => {
+                    socket.destroy();
+                    if (settled) {
+                        return;
+                    }
+                    if (Date.now() >= deadline) {
+                        cleanup();
+                        reject(new Error(`Workspace port ${port} did not become ready within ${timeoutMs}ms`));
+                    }
+                    else {
+                        retryTimer = setTimeout(() => {
+                            retryTimer = null;
+                            tryConnect();
+                        }, 100);
+                    }
+                });
+            };
+            tryConnect();
+        });
+    }
+    delay(durationMs) {
+        if (durationMs <= 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => setTimeout(resolve, durationMs));
+    }
+    describeExit(info) {
+        if (info.signal) {
+            return `signal ${info.signal}`;
+        }
+        if (info.code !== null) {
+            return `code ${info.code}`;
+        }
+        return "unknown reason";
+    }
     handleProcessExit(workspaceId, info) {
         const workspace = this.workspaces.get(workspaceId);
         if (!workspace)

package/dist/workspaces/runtime.js

@@ -11,8 +11,36 @@ export class WorkspaceRuntime {
         this.validateFolder(options.folder);
         const args = ["serve", "--port", "0", "--print-logs", "--log-level", "DEBUG"];
         const env = { ...process.env, ...(options.environment ?? {}) };
+        let exitResolve = null;
+        const exitPromise = new Promise((resolveExit) => {
+            exitResolve = resolveExit;
+        });
+        // Store recent output for debugging - keep last 50 lines from each stream
+        const MAX_OUTPUT_LINES = 50;
+        const recentStdout = [];
+        const recentStderr = [];
+        const getLastOutput = () => {
+            const combined = [];
+            if (recentStderr.length > 0) {
+                combined.push("Error Stream");
+                combined.push(...recentStderr.slice(-10));
+            }
+            if (recentStdout.length > 0) {
+                combined.push("Output Stream");
+                combined.push(...recentStdout.slice(-10));
+            }
+            return combined.join("\n");
+        };
         return new Promise((resolve, reject) => {
-            this.logger.info({ workspaceId: options.workspaceId, folder: options.folder, binary: options.binaryPath }, "Launching OpenCode process");
+            const commandLine = [options.binaryPath, ...args].join(" ");
+            this.logger.info({
+                workspaceId: options.workspaceId,
+                folder: options.folder,
+                binary: options.binaryPath,
+                args,
+                commandLine,
+                env,
+            }, "Launching OpenCode process");
             const child = spawn(options.binaryPath, args, {
                 cwd: options.folder,
                 env,
@@ -47,12 +75,23 @@ export class WorkspaceRuntime {
                 cleanupStreams();
                 child.removeListener("error", handleError);
                 child.removeListener("exit", handleExit);
+                const exitInfo = {
+                    workspaceId: options.workspaceId,
+                    code,
+                    signal,
+                    requested: managed.requestedStop,
+                };
+                if (exitResolve) {
+                    exitResolve(exitInfo);
+                    exitResolve = null;
+                }
                 if (!portFound) {
-                    const reason = stderrBuffer || `Process exited with code ${code}`;
+                    const recentOutput = getLastOutput().trim();
+                    const reason = recentOutput || stderrBuffer || `Process exited with code ${code}`;
                     reject(new Error(reason));
                 }
                 else {
-                    options.onExit?.({ workspaceId: options.workspaceId, code, signal, requested: managed.requestedStop });
+                    options.onExit?.(exitInfo);
                 }
             };
             const handleError = (error) => {
@@ -60,6 +99,10 @@ export class WorkspaceRuntime {
                 child.removeListener("exit", handleExit);
                 this.processes.delete(options.workspaceId);
                 this.logger.error({ workspaceId: options.workspaceId, err: error }, "Workspace runtime error");
+                if (exitResolve) {
+                    exitResolve({ workspaceId: options.workspaceId, code: null, signal: null, requested: managed.requestedStop });
+                    exitResolve = null;
+                }
                 reject(error);
             };
             child.on("error", handleError);
@@ -70,18 +113,23 @@ export class WorkspaceRuntime {
                 const lines = stdoutBuffer.split("\n");
                 stdoutBuffer = lines.pop() ?? "";
                 for (const line of lines) {
-                    if (!line.trim())
+                    const trimmed = line.trim();
+                    if (!trimmed)
                         continue;
+                    recentStdout.push(trimmed);
+                    if (recentStdout.length > MAX_OUTPUT_LINES) {
+                        recentStdout.shift();
+                    }
                     this.emitLog(options.workspaceId, "info", line);
                     if (!portFound) {
                         const portMatch = line.match(/opencode server listening on http:\/\/.+:(\d+)/i);
                         if (portMatch) {
                             portFound = true;
-                            cleanupStreams();
+                            stopWarningTimer();
                             child.removeListener("error", handleError);
                             const port = parseInt(portMatch[1], 10);
                             this.logger.info({ workspaceId: options.workspaceId, port }, "Workspace runtime allocated port");
-                            resolve({ pid: child.pid, port });
+                            resolve({ pid: child.pid, port, exitPromise, getLastOutput });
                         }
                     }
                 }
@@ -92,8 +140,13 @@ export class WorkspaceRuntime {
                 const lines = stderrBuffer.split("\n");
                 stderrBuffer = lines.pop() ?? "";
                 for (const line of lines) {
-                    if (!line.trim())
+                    const trimmed = line.trim();
+                    if (!trimmed)
                         continue;
+                    recentStderr.push(trimmed);
+                    if (recentStderr.length > MAX_OUTPUT_LINES) {
+                        recentStderr.shift();
+                    }
                     this.emitLog(options.workspaceId, "error", line);
                 }
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "CodeNomad Server",
   "author": {
     "name": "Neural Nomads",
@@ -16,10 +16,11 @@
     "codenomad": "dist/bin.js"
   },
   "scripts": {
-    "build": "npm run build:ui && npm run prepare-ui && tsc -p tsconfig.json",
+    "build": "npm run build:ui && npm run prepare-ui && tsc -p tsconfig.json && npm run prepare-config",
     "build:ui": "npm run build --prefix ../ui",
     "prepare-ui": "node ./scripts/copy-ui-dist.mjs",
-    "dev": "cross-env CLI_UI_DEV_SERVER=http://localhost:3000 tsx src/index.ts",
+    "prepare-config": "node ./scripts/copy-opencode-config.mjs",
+    "dev": "cross-env CODENOMAD_DEV=1 CLI_UI_DEV_SERVER=http://localhost:3000 tsx src/index.ts",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {