@dyyz1993/codenomad 0.15.0

package/dist/workspaces/manager.js

@@ -0,0 +1,368 @@
+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 { OPENCODE_SERVER_BASE_URL_ENV, buildOpencodeBasicAuthHeader, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, resolveOpencodeServerAuth, } 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,
+        };
+    }
+    writeFile(workspaceId, relativePath, contents) {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        browser.writeFile(relativePath, contents);
+    }
+    async create(folder, name) {
+        const id = `${Date.now().toString(36)}`;
+        const binary = this.options.binaryResolver.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(),
+        };
+        this.workspaces.set(id, descriptor);
+        this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
+        const serverConfig = this.options.settings.getOwner("config", "server");
+        const envVars = serverConfig?.environmentVariables;
+        const userEnvironment = envVars && typeof envVars === "object" && !Array.isArray(envVars) ? envVars : {};
+        const serverBaseUrl = this.options.getServerBaseUrl();
+        const normalizedServerBaseUrl = serverBaseUrl.replace(/\/+$/, "");
+        const { username: opencodeUsername, password: opencodePassword } = resolveOpencodeServerAuth({
+            userEnvironment,
+            processEnv: process.env,
+        });
+        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: serverBaseUrl,
+            ...(this.options.nodeExtraCaCertsPath ? { NODE_EXTRA_CA_CERTS: this.options.nodeExtraCaCertsPath } : {}),
+            [OPENCODE_SERVER_BASE_URL_ENV]: `${normalizedServerBaseUrl}${proxyPath}`,
+            [OPENCODE_SERVER_USERNAME_ENV]: opencodeUsername,
+            [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,
+        };
+        const logLevel = serverConfig?.logLevel;
+        try {
+            const { pid, port, exitPromise, getLastOutput } = await this.runtime.launch({
+                workspaceId: id,
+                folder: workspacePath,
+                binaryPath: resolvedBinaryPath,
+                environment,
+                logLevel,
+                onExit: (info) => this.handleProcessExit(info.workspaceId, info),
+            });
+            const runtimeVersion = await this.waitForWorkspaceReadiness({ workspaceId: id, port, exitPromise, getLastOutput });
+            if (runtimeVersion) {
+                descriptor.binaryVersion = runtimeVersion;
+            }
+            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] ?? "";
+    }
+    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());
+            }),
+        ]);
+        const version = 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());
+            }),
+        ]);
+        return version;
+    }
+    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 probeResult.version;
+        }
+        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}/global/health`;
+        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 = `/global/health returned HTTP ${response.status}`;
+                this.options.logger.debug({ workspaceId, status: response.status }, "Health probe returned server error");
+                return { ok: false, reason };
+            }
+            const payload = (await response.json().catch(() => null));
+            const healthy = payload?.healthy === true;
+            const version = typeof payload?.version === "string" ? payload.version.trim() : undefined;
+            if (!healthy) {
+                const reason = "Instance reported unhealthy";
+                this.options.logger.debug({ workspaceId, payload }, "Health probe returned unhealthy response");
+                return { ok: false, reason };
+            }
+            return { ok: true, version: version || undefined };
+        }
+        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,34 @@
+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 OPENCODE_SERVER_BASE_URL_ENV = "OPENCODE_SERVER_BASE_URL";
+export const DEFAULT_OPENCODE_USERNAME = "codenomad";
+export function generateOpencodeServerPassword() {
+    return crypto.randomBytes(32).toString("base64url");
+}
+function readConfiguredValue(key, ...sources) {
+    for (const source of sources) {
+        const value = source?.[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function resolveOpencodeServerAuth(options = {}) {
+    const generatePassword = options.generatePassword ?? generateOpencodeServerPassword;
+    const username = readConfiguredValue(OPENCODE_SERVER_USERNAME_ENV, options.userEnvironment, options.processEnv) ??
+        DEFAULT_OPENCODE_USERNAME;
+    const password = readConfiguredValue(OPENCODE_SERVER_PASSWORD_ENV, options.userEnvironment, options.processEnv) ??
+        generatePassword();
+    return { username, password };
+}
+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}`;
+}

package/dist/workspaces/opencode-auth.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { resolveOpencodeServerAuth } from "./opencode-auth";
+describe("resolveOpencodeServerAuth", () => {
+    it("uses configured OpenCode auth from workspace environment", () => {
+        const auth = resolveOpencodeServerAuth({
+            userEnvironment: {
+                OPENCODE_SERVER_USERNAME: "alice",
+                OPENCODE_SERVER_PASSWORD: "secret",
+            },
+            processEnv: {},
+            generatePassword: () => "generated",
+        });
+        assert.deepEqual(auth, { username: "alice", password: "secret" });
+    });
+    it("uses process environment when workspace environment does not provide credentials", () => {
+        const auth = resolveOpencodeServerAuth({
+            userEnvironment: {},
+            processEnv: {
+                OPENCODE_SERVER_PASSWORD: "process-secret",
+            },
+            generatePassword: () => "generated",
+        });
+        assert.deepEqual(auth, { username: "codenomad", password: "process-secret" });
+    });
+    it("falls back to generated credentials", () => {
+        const auth = resolveOpencodeServerAuth({
+            userEnvironment: {},
+            processEnv: {},
+            generatePassword: () => "generated",
+        });
+        assert.deepEqual(auth, { username: "codenomad", password: "generated" });
+    });
+});