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

package/dist/workspaces/instance-events.js

@@ -0,0 +1,180 @@
+import { fetch } from "undici";
+import { Agent as UndiciAgent } from "undici";
+const INSTANCE_HOST = "127.0.0.1";
+const STREAM_AGENT = new UndiciAgent({ bodyTimeout: 0, headersTimeout: 0 });
+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, "workspace stopped"));
+        bus.on("workspace.error", (event) => this.stopStream(event.workspace.id, "workspace error"));
+    }
+    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, reason) {
+        const active = this.streams.get(workspaceId);
+        if (!active) {
+            return;
+        }
+        active.controller.abort();
+        this.streams.delete(workspaceId);
+        this.publishStatus(workspaceId, "disconnected", reason);
+    }
+    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}/global/event`;
+        const headers = { Accept: "text/event-stream" };
+        const authHeader = this.options.workspaceManager.getInstanceAuthorizationHeader(workspaceId);
+        if (authHeader) {
+            headers["Authorization"] = authHeader;
+        }
+        const response = await fetch(url, {
+            headers,
+            signal,
+            dispatcher: STREAM_AGENT,
+        });
+        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 parsed = JSON.parse(payload);
+            if (!parsed || typeof parsed !== "object") {
+                this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event");
+                return;
+            }
+            // OpenCode SSE payload shapes vary across versions.
+            // Common variants:
+            // - { type, properties, ... }
+            // - { payload: { type, properties, ... }, directory: "/abs/path" }
+            // - { payload: { type, properties, ... } }
+            const base = parsed.payload && typeof parsed.payload === "object" ? parsed.payload : parsed;
+            const event = base && typeof base === "object" ? { ...base } : null;
+            // Attach directory when available (don't overwrite if already present).
+            if (event && !event.directory && typeof parsed.directory === "string") {
+                ;
+                event.directory = parsed.directory;
+            }
+            if (!event || typeof event.type !== "string") {
+                this.options.logger.warn({ workspaceId, chunk: payload }, "Dropped malformed instance event");
+                return;
+            }
+            this.options.logger.debug({ workspaceId, eventType: event.type }, "Instance SSE event received");
+            if (this.options.logger.isLevelEnabled("trace")) {
+                this.options.logger.trace({ workspaceId, event }, "Instance SSE event 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.logger.debug({ instanceId, status, reason }, "Instance SSE status updated");
+        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

@@ -0,0 +1,375 @@
+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";
+import { buildOpencodeBasicAuthHeader, DEFAULT_OPENCODE_USERNAME, generateOpencodeServerPassword, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, } from "./opencode-auth";
+const STARTUP_STABILITY_DELAY_MS = 1500;
+export class WorkspaceManager {
+    constructor(options) {
+        this.options = options;
+        this.workspaces = new Map();
+        this.opencodeAuth = new Map();
+        this.runtime = new WorkspaceRuntime(this.options.eventBus, this.options.logger);
+        this.opencodeConfigDir = getOpencodeConfigDir();
+    }
+    list() {
+        return Array.from(this.workspaces.values());
+    }
+    get(id) {
+        return this.workspaces.get(id);
+    }
+    getInstancePort(id) {
+        return this.workspaces.get(id)?.port;
+    }
+    getInstanceAuthorizationHeader(id) {
+        return this.opencodeAuth.get(id)?.authorization;
+    }
+    listFiles(workspaceId, relativePath = ".") {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        return browser.list(relativePath);
+    }
+    searchFiles(workspaceId, query, options) {
+        const workspace = this.requireWorkspace(workspaceId);
+        return searchWorkspaceFiles(workspace.path, query, options);
+    }
+    readFile(workspaceId, relativePath) {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        const contents = browser.readFile(relativePath);
+        return {
+            workspaceId,
+            relativePath,
+            contents,
+        };
+    }
+    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: resolvedBinaryPath }, "Creating workspace");
+        const proxyPath = `/workspaces/${id}/worktrees/root/instance`;
+        const descriptor = {
+            id,
+            path: workspacePath,
+            name,
+            status: "starting",
+            proxyPath,
+            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 preferences = this.options.configStore.get().preferences ?? {};
+        const userEnvironment = preferences.environmentVariables ?? {};
+        const opencodeUsername = DEFAULT_OPENCODE_USERNAME;
+        const opencodePassword = generateOpencodeServerPassword();
+        const authorization = buildOpencodeBasicAuthHeader({ username: opencodeUsername, password: opencodePassword });
+        if (!authorization) {
+            throw new Error("Failed to build OpenCode auth header");
+        }
+        this.opencodeAuth.set(id, { username: opencodeUsername, password: opencodePassword, authorization });
+        const environment = {
+            ...userEnvironment,
+            OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
+            CODENOMAD_INSTANCE_ID: id,
+            CODENOMAD_BASE_URL: this.options.getServerBaseUrl(),
+            ...(this.options.nodeExtraCaCertsPath ? { NODE_EXTRA_CA_CERTS: this.options.nodeExtraCaCertsPath } : {}),
+            [OPENCODE_SERVER_USERNAME_ENV]: opencodeUsername,
+            [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,
+        };
+        try {
+            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";
+            descriptor.updatedAt = new Date().toISOString();
+            this.options.eventBus.publish({ type: "workspace.started", workspace: descriptor });
+            this.options.logger.info({ workspaceId: id, port }, "Workspace ready");
+            return descriptor;
+        }
+        catch (error) {
+            descriptor.status = "error";
+            descriptor.error = error instanceof Error ? error.message : String(error);
+            descriptor.updatedAt = new Date().toISOString();
+            this.options.eventBus.publish({ type: "workspace.error", workspace: descriptor });
+            this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed to start");
+            throw error;
+        }
+    }
+    async delete(id) {
+        const workspace = this.workspaces.get(id);
+        if (!workspace)
+            return undefined;
+        this.options.logger.info({ workspaceId: id }, "Stopping workspace");
+        const wasRunning = Boolean(workspace.pid);
+        if (wasRunning) {
+            await this.runtime.stop(id).catch((error) => {
+                this.options.logger.warn({ workspaceId: id, err: error }, "Failed to stop workspace process cleanly");
+            });
+        }
+        this.workspaces.delete(id);
+        this.opencodeAuth.delete(id);
+        clearWorkspaceSearchCache(workspace.path);
+        if (!wasRunning) {
+            this.options.eventBus.publish({ type: "workspace.stopped", workspaceId: id });
+        }
+        return workspace;
+    }
+    async shutdown() {
+        this.options.logger.info("Shutting down all workspaces");
+        const stopTasks = [];
+        for (const [id, workspace] of this.workspaces) {
+            if (!workspace.pid) {
+                this.options.logger.debug({ workspaceId: id }, "Workspace already stopped");
+                continue;
+            }
+            this.options.logger.info({ workspaceId: id }, "Stopping workspace during shutdown");
+            stopTasks.push(this.runtime.stop(id).catch((error) => {
+                this.options.logger.error({ workspaceId: id, err: error }, "Failed to stop workspace during shutdown");
+            }));
+        }
+        if (stopTasks.length > 0) {
+            await Promise.allSettled(stopTasks);
+        }
+        this.workspaces.clear();
+        this.opencodeAuth.clear();
+        this.options.logger.info("All workspaces cleared");
+    }
+    requireWorkspace(id) {
+        const workspace = this.workspaces.get(id);
+        if (!workspace) {
+            throw new Error("Workspace not found");
+        }
+        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 candidates = result.stdout
+                    .split(/\r?\n/)
+                    .map((line) => line.trim())
+                    .filter((line) => line.length > 0)
+                    .filter((line) => !/^INFO:/i.test(line));
+                if (candidates.length > 0) {
+                    const resolved = this.pickBinaryCandidate(candidates);
+                    this.options.logger.debug({ identifier, resolved, candidates }, "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;
+    }
+    pickBinaryCandidate(candidates) {
+        if (process.platform !== "win32") {
+            return candidates[0] ?? "";
+        }
+        const extensionPreference = [".exe", ".cmd", ".bat", ".ps1"];
+        for (const ext of extensionPreference) {
+            const match = candidates.find((candidate) => candidate.toLowerCase().endsWith(ext));
+            if (match) {
+                return match;
+            }
+        }
+        return candidates[0] ?? "";
+    }
+    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;
+    }
+    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 headers = {};
+            const authHeader = this.opencodeAuth.get(workspaceId)?.authorization;
+            if (authHeader) {
+                headers["Authorization"] = authHeader;
+            }
+            const response = await fetch(url, { headers });
+            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)
+            return;
+        this.opencodeAuth.delete(workspaceId);
+        this.options.logger.info({ workspaceId, ...info }, "Workspace process exited");
+        workspace.pid = undefined;
+        workspace.port = undefined;
+        workspace.updatedAt = new Date().toISOString();
+        if (info.requested || info.code === 0) {
+            workspace.status = "stopped";
+            workspace.error = undefined;
+            this.options.eventBus.publish({ type: "workspace.stopped", workspaceId });
+        }
+        else {
+            workspace.status = "error";
+            workspace.error = `Process exited with code ${info.code}`;
+            this.options.eventBus.publish({ type: "workspace.error", workspace });
+        }
+    }
+}

package/dist/workspaces/opencode-auth.js

@@ -0,0 +1,16 @@
+import crypto from "node:crypto";
+export const OPENCODE_SERVER_USERNAME_ENV = "OPENCODE_SERVER_USERNAME";
+export const OPENCODE_SERVER_PASSWORD_ENV = "OPENCODE_SERVER_PASSWORD";
+export const DEFAULT_OPENCODE_USERNAME = "codenomad";
+export function generateOpencodeServerPassword() {
+    return crypto.randomBytes(32).toString("base64url");
+}
+export function buildOpencodeBasicAuthHeader(params) {
+    const username = params.username;
+    const password = params.password;
+    if (!username || !password) {
+        return undefined;
+    }
+    const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
+    return `Basic ${token}`;
+}