@vividcodeai/embeddedcowork 0.0.22 → 0.0.24

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,432 @@
+import path from "path";
+import os from "os";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync } from "fs";
+import { execSync, 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 { BIN_DIR, BINARY_NAME, triggerBinaryDownload, resolveBinaryPathFromUserShell } from "../opencode-paths";
+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,
+        };
+    }
+    writeFile(workspaceId, relativePath, contents) {
+        const workspace = this.requireWorkspace(workspaceId);
+        const browser = new FileSystemBrowser({ rootDir: workspace.path });
+        browser.writeFile(relativePath, contents);
+    }
+    /**
+     * Compute a deterministic workspace ID based on the folder's content identity.
+     *
+     * - If the folder is inside a git repository: ID is derived from the git root
+     *   commit hash + the folder's relative path from git root. This ensures the
+     *   ID stays the same when the folder is moved/renamed within the repo.
+     * - Otherwise: fall back to hashing the absolute path.
+     */
+    computeWorkspaceId(folder) {
+        const absPath = path.resolve(folder);
+        // Attempt git-based identity
+        try {
+            const topLevel = execSync("git rev-parse --show-toplevel", { cwd: absPath, encoding: "utf8", timeout: 5000 }).trim();
+            const rootHash = execSync("git rev-list --max-parents=0 HEAD", { cwd: absPath, encoding: "utf8", timeout: 5000 })
+                .trim()
+                .split("\n")
+                .filter(Boolean)
+                .sort()[0];
+            if (rootHash) {
+                const relPath = path.relative(topLevel, absPath) || "/";
+                return createHash("sha256").update(`${rootHash}:${relPath}`).digest("hex").slice(0, 12);
+            }
+        }
+        catch {
+            // Not a git repo or git unavailable — fall through
+        }
+        // Fallback: use absolute path hash
+        return createHash("sha256").update(absPath).digest("hex").slice(0, 12);
+    }
+    async create(folder, name) {
+        const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder);
+        const id = this.computeWorkspaceId(workspacePath);
+        const binary = this.options.binaryResolver.resolveDefault();
+        let resolvedBinaryPath = this.resolveBinaryPath(binary.path);
+        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 });
+        if (!existsSync(resolvedBinaryPath)) {
+            this.options.logger.info({ workspaceId: id, binary: resolvedBinaryPath }, "Binary not found, waiting for download");
+            await triggerBinaryDownload(this.options.logger);
+            resolvedBinaryPath = this.resolveBinaryPath(binary.path);
+            if (!existsSync(resolvedBinaryPath)) {
+                throw new Error(`OpenCode binary still not found after auto-download: ${resolvedBinaryPath}`);
+            }
+            descriptor.binaryId = resolvedBinaryPath;
+            descriptor.binaryLabel = "auto-downloaded";
+            this.options.logger.info({ workspaceId: id, path: resolvedBinaryPath }, "Binary ready after auto-download");
+        }
+        const serverConfig = this.options.settings.getOwner("config", "server");
+        const envVars = serverConfig?.environmentVariables;
+        const userEnvironment = envVars && typeof envVars === "object" && !Array.isArray(envVars) ? envVars : {};
+        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 });
+        // Determine session database path based on user preference.
+        //   - "project": place DB inside the workspace folder so it travels with the project
+        //   - "global":  place DB in a centralized directory keyed by workspaceId
+        const sessionStorageMode = serverConfig?.sessionStorageMode ?? "project";
+        let dbPath;
+        if (sessionStorageMode === "global") {
+            dbPath = path.join(os.homedir(), ".embeddedcowork", "session-data", `${id}.db`);
+        }
+        else {
+            dbPath = path.join(workspacePath, ".embeddedcowork", "session", "data.db");
+        }
+        // Ensure parent directory exists before opencode starts; Database(path, { create: true })
+        // only creates the file, not intermediate directories.
+        mkdirSync(path.dirname(dbPath), { recursive: true });
+        const environment = {
+            ...userEnvironment,
+            OPENCODE_CONFIG_DIR: this.opencodeConfigDir,
+            OPENCODE_DB: dbPath,
+            EMBEDDEDCOWORK_INSTANCE_ID: id,
+            EMBEDDEDCOWORK_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,
+        };
+        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");
+        }
+        const shellResolved = resolveBinaryPathFromUserShell(identifier);
+        if (shellResolved) {
+            this.options.logger.debug({ identifier, resolved: shellResolved }, "Resolved binary path from user shell");
+            return shellResolved;
+        }
+        const installedPath = path.join(BIN_DIR, BINARY_NAME);
+        if (existsSync(installedPath)) {
+            this.options.logger.debug({ identifier, resolved: installedPath }, "Resolved binary path from installed directory");
+            return installedPath;
+        }
+        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,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 = "embeddedcowork";
+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}`;
+}