@neuralnomads/codenomad 0.2.0 → 0.2.2-dev

package/dist/events/bus.js

@@ -5,7 +5,9 @@ export class EventBus extends EventEmitter {
         this.logger = logger;
     }
     publish(event) {
-        this.logger?.debug({ event }, "Publishing workspace event");
+        if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
+            this.logger?.debug({ event }, "Publishing workspace event");
+        }
         return super.emit(event.type, event);
     }
     onEvent(listener) {
@@ -18,6 +20,8 @@ export class EventBus extends EventEmitter {
         this.on("config.appChanged", handler);
         this.on("config.binariesChanged", handler);
         this.on("instance.dataChanged", handler);
+        this.on("instance.event", handler);
+        this.on("instance.eventStatus", handler);
         return () => {
             this.off("workspace.created", handler);
             this.off("workspace.started", handler);
@@ -27,6 +31,8 @@ export class EventBus extends EventEmitter {
             this.off("config.appChanged", handler);
             this.off("config.binariesChanged", handler);
             this.off("instance.dataChanged", handler);
+            this.off("instance.event", handler);
+            this.off("instance.eventStatus", handler);
         };
     }
 }

package/dist/index.js

@@ -13,6 +13,7 @@ import { BinaryRegistry } from "./config/binaries";
 import { FileSystemBrowser } from "./filesystem/browser";
 import { EventBus } from "./events/bus";
 import { InstanceStore } from "./storage/instance-store";
+import { InstanceEventBridge } from "./workspaces/instance-events";
 import { createLogger } from "./logger";
 import { launchInBrowser } from "./launcher";
 const require = createRequire(import.meta.url);
@@ -81,6 +82,11 @@ async function main() {
     });
     const fileSystemBrowser = new FileSystemBrowser({ rootDir: options.rootDir, unrestricted: options.unrestrictedRoot });
     const instanceStore = new InstanceStore();
+    const instanceEventBridge = new InstanceEventBridge({
+        workspaceManager,
+        eventBus,
+        logger: logger.child({ component: "instance-events" }),
+    });
     const serverMeta = {
         httpBaseUrl: `http://${options.host}:${options.port}`,
         eventsUrl: `/api/events`,
@@ -123,6 +129,7 @@ async function main() {
             logger.error({ err: error }, "Failed to stop HTTP server");
         }
         try {
+            instanceEventBridge.shutdown();
             await workspaceManager.shutdown();
             logger.info("Workspace manager shutdown complete");
         }

package/dist/server/http-server.js

@@ -31,6 +31,12 @@ export function createHttpServer(deps) {
     });
     app.register(replyFrom, {
         contentTypesToEncode: [],
+        undici: {
+            connections: 16,
+            pipelining: 1,
+            bodyTimeout: 0,
+            headersTimeout: 0,
+        },
     });
     registerWorkspaceRoutes(app, { workspaceManager: deps.workspaceManager });
     registerConfigRoutes(app, { configStore: deps.configStore, binaryRegistry: deps.binaryRegistry });

package/dist/workspaces/instance-events.js

@@ -0,0 +1,147 @@
+import { fetch } from "undici";
+const INSTANCE_HOST = "127.0.0.1";
+const RECONNECT_DELAY_MS = 1000;
+export class InstanceEventBridge {
+    constructor(options) {
+        this.options = options;
+        this.streams = new Map();
+        const bus = this.options.eventBus;
+        bus.on("workspace.started", (event) => this.startStream(event.workspace.id));
+        bus.on("workspace.stopped", (event) => this.stopStream(event.workspaceId));
+        bus.on("workspace.error", (event) => this.stopStream(event.workspace.id));
+    }
+    shutdown() {
+        for (const [id, active] of this.streams) {
+            active.controller.abort();
+            this.publishStatus(id, "disconnected");
+        }
+        this.streams.clear();
+    }
+    startStream(workspaceId) {
+        if (this.streams.has(workspaceId)) {
+            return;
+        }
+        const controller = new AbortController();
+        const task = this.runStream(workspaceId, controller.signal)
+            .catch((error) => {
+            if (!controller.signal.aborted) {
+                this.options.logger.warn({ workspaceId, err: error }, "Instance event stream failed");
+                this.publishStatus(workspaceId, "error", error instanceof Error ? error.message : String(error));
+            }
+        })
+            .finally(() => {
+            const active = this.streams.get(workspaceId);
+            if (active?.controller === controller) {
+                this.streams.delete(workspaceId);
+            }
+        });
+        this.streams.set(workspaceId, { controller, task });
+    }
+    stopStream(workspaceId) {
+        const active = this.streams.get(workspaceId);
+        if (!active) {
+            return;
+        }
+        active.controller.abort();
+        this.streams.delete(workspaceId);
+        this.publishStatus(workspaceId, "disconnected");
+    }
+    async runStream(workspaceId, signal) {
+        while (!signal.aborted) {
+            const port = this.options.workspaceManager.getInstancePort(workspaceId);
+            if (!port) {
+                await this.delay(RECONNECT_DELAY_MS, signal);
+                continue;
+            }
+            this.publishStatus(workspaceId, "connecting");
+            try {
+                await this.consumeStream(workspaceId, port, signal);
+            }
+            catch (error) {
+                if (signal.aborted) {
+                    break;
+                }
+                this.options.logger.warn({ workspaceId, err: error }, "Instance event stream disconnected");
+                this.publishStatus(workspaceId, "error", error instanceof Error ? error.message : String(error));
+                await this.delay(RECONNECT_DELAY_MS, signal);
+            }
+        }
+    }
+    async consumeStream(workspaceId, port, signal) {
+        const url = `http://${INSTANCE_HOST}:${port}/event`;
+        const response = await fetch(url, {
+            headers: { Accept: "text/event-stream" },
+            signal,
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Instance event stream unavailable (${response.status})`);
+        }
+        this.publishStatus(workspaceId, "connected");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!signal.aborted) {
+            const { done, value } = await reader.read();
+            if (done || !value) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            buffer = this.flushEvents(buffer, workspaceId);
+        }
+    }
+    flushEvents(buffer, workspaceId) {
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex >= 0) {
+            const chunk = buffer.slice(0, separatorIndex);
+            buffer = buffer.slice(separatorIndex + 2);
+            this.processChunk(chunk, workspaceId);
+            separatorIndex = buffer.indexOf("\n\n");
+        }
+        return buffer;
+    }
+    processChunk(chunk, workspaceId) {
+        const lines = chunk.split(/\r?\n/);
+        const dataLines = [];
+        for (const line of lines) {
+            if (line.startsWith(":")) {
+                continue;
+            }
+            if (line.startsWith("data:")) {
+                dataLines.push(line.slice(5).trimStart());
+            }
+        }
+        if (dataLines.length === 0) {
+            return;
+        }
+        const payload = dataLines.join("\n").trim();
+        if (!payload) {
+            return;
+        }
+        try {
+            const event = JSON.parse(payload);
+            this.options.eventBus.publish({ type: "instance.event", instanceId: workspaceId, event });
+        }
+        catch (error) {
+            this.options.logger.warn({ workspaceId, chunk: payload, err: error }, "Failed to parse instance SSE payload");
+        }
+    }
+    publishStatus(instanceId, status, reason) {
+        this.options.eventBus.publish({ type: "instance.eventStatus", instanceId, status, reason });
+    }
+    delay(duration, signal) {
+        if (duration <= 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, duration);
+            const onAbort = () => {
+                clearTimeout(timeout);
+                resolve();
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}

package/dist/workspaces/manager.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { spawnSync } from "child_process";
 import { FileSystemBrowser } from "../filesystem/browser";
 import { searchWorkspaceFiles } from "../filesystem/search";
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
@@ -40,9 +41,10 @@ export class WorkspaceManager {
     async create(folder, name) {
         const id = `${Date.now().toString(36)}`;
         const binary = this.options.binaryRegistry.resolveDefault();
+        const resolvedBinaryPath = this.resolveBinaryPath(binary.path);
         const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
         clearWorkspaceSearchCache(workspacePath);
-        this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: binary.path }, "Creating workspace");
+        this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath }, "Creating workspace");
         const proxyPath = `/workspaces/${id}/instance`;
         const descriptor = {
             id,
@@ -50,12 +52,15 @@ export class WorkspaceManager {
             name,
             status: "starting",
             proxyPath,
-            binaryId: binary.id,
+            binaryId: resolvedBinaryPath,
             binaryLabel: binary.label,
             binaryVersion: binary.version,
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         };
+        if (!descriptor.binaryVersion) {
+            descriptor.binaryVersion = this.detectBinaryVersion(resolvedBinaryPath);
+        }
         this.workspaces.set(id, descriptor);
         this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
         const environment = this.options.configStore.get().preferences.environmentVariables ?? {};
@@ -63,7 +68,7 @@ export class WorkspaceManager {
             const { pid, port } = await this.runtime.launch({
                 workspaceId: id,
                 folder: workspacePath,
-                binaryPath: binary.path,
+                binaryPath: resolvedBinaryPath,
                 environment,
                 onExit: (info) => this.handleProcessExit(info.workspaceId, info),
             });
@@ -125,6 +130,65 @@ export class WorkspaceManager {
         }
         return workspace;
     }
+    resolveBinaryPath(identifier) {
+        if (!identifier) {
+            return identifier;
+        }
+        const looksLikePath = identifier.includes("/") || identifier.includes("\\") || identifier.startsWith(".");
+        if (path.isAbsolute(identifier) || looksLikePath) {
+            return identifier;
+        }
+        const locator = process.platform === "win32" ? "where" : "which";
+        try {
+            const result = spawnSync(locator, [identifier], { encoding: "utf8" });
+            if (result.status === 0 && result.stdout) {
+                const resolved = result.stdout
+                    .split(/\r?\n/)
+                    .map((line) => line.trim())
+                    .find((line) => line.length > 0);
+                if (resolved) {
+                    this.options.logger.debug({ identifier, resolved }, "Resolved binary path from system PATH");
+                    return resolved;
+                }
+            }
+            else if (result.error) {
+                this.options.logger.warn({ identifier, err: result.error }, "Failed to resolve binary path via locator command");
+            }
+        }
+        catch (error) {
+            this.options.logger.warn({ identifier, err: error }, "Failed to resolve binary path from system PATH");
+        }
+        return identifier;
+    }
+    detectBinaryVersion(resolvedPath) {
+        if (!resolvedPath) {
+            return undefined;
+        }
+        try {
+            const result = spawnSync(resolvedPath, ["--version"], { encoding: "utf8" });
+            if (result.status === 0 && result.stdout) {
+                const line = result.stdout.split(/\r?\n/).find((entry) => entry.trim().length > 0);
+                if (line) {
+                    const normalized = line.trim();
+                    const versionMatch = normalized.match(/([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/);
+                    if (versionMatch) {
+                        const version = versionMatch[1];
+                        this.options.logger.debug({ binary: resolvedPath, version }, "Detected binary version");
+                        return version;
+                    }
+                    this.options.logger.debug({ binary: resolvedPath, reported: normalized }, "Binary reported version string");
+                    return normalized;
+                }
+            }
+            else if (result.error) {
+                this.options.logger.warn({ binary: resolvedPath, err: result.error }, "Failed to read binary version");
+            }
+        }
+        catch (error) {
+            this.options.logger.warn({ binary: resolvedPath, err: error }, "Failed to detect binary version");
+        }
+        return undefined;
+    }
     handleProcessExit(workspaceId, info) {
         const workspace = this.workspaces.get(workspaceId);
         if (!workspace)

package/dist/workspaces/runtime.js

@@ -12,7 +12,7 @@ export class WorkspaceRuntime {
         const args = ["serve", "--port", "0", "--print-logs", "--log-level", "DEBUG"];
         const env = { ...process.env, ...(options.environment ?? {}) };
         return new Promise((resolve, reject) => {
-            this.logger.info({ workspaceId: options.workspaceId, folder: options.folder }, "Launching OpenCode process");
+            this.logger.info({ workspaceId: options.workspaceId, folder: options.folder, binary: options.binaryPath }, "Launching OpenCode process");
             const child = spawn(options.binaryPath, args, {
                 cwd: options.folder,
                 env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.2.0",
+  "version": "0.2.2-dev",
   "description": "CodeNomad Server",
   "author": {
     "name": "Neural Nomads",