@dyyz1993/codenomad 0.15.0

package/dist/workspaces/git-worktrees.js

@@ -0,0 +1,216 @@
+import path from "path";
+import { spawn } from "child_process";
+import { promises as fsp } from "fs";
+function isGitUnavailableResult(result) {
+    return !result.ok && result.error?.code === "ENOENT";
+}
+function runGit(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            resolve({ ok: false, error, stdout, stderr });
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve({ ok: true, stdout });
+            }
+            else {
+                const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`);
+                resolve({ ok: false, error, stdout, stderr });
+            }
+        });
+    });
+}
+export async function resolveRepoRoot(folder, logger) {
+    const result = await runGit(["rev-parse", "--show-toplevel"], folder);
+    if (isGitUnavailableResult(result)) {
+        throw new Error("Git is not installed or not available in PATH");
+    }
+    if (!result.ok) {
+        logger?.debug?.({ folder, err: result.error }, "Folder is not a Git repository; using workspace folder as root");
+        return { repoRoot: folder, isGitRepo: false };
+    }
+    const repoRoot = result.stdout.trim();
+    if (!repoRoot) {
+        return { repoRoot: folder, isGitRepo: false };
+    }
+    return { repoRoot, isGitRepo: true };
+}
+export async function isGitAvailable(folder) {
+    const result = await runGit(["--version"], folder);
+    return result.ok || !isGitUnavailableResult(result);
+}
+function parseWorktreePorcelain(output) {
+    const records = [];
+    const lines = output.split(/\r?\n/);
+    let current = {};
+    const flush = () => {
+        if (current.worktree) {
+            records.push({ worktree: current.worktree, branch: current.branch });
+        }
+        current = {};
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            flush();
+            continue;
+        }
+        const [key, ...rest] = trimmed.split(" ");
+        const value = rest.join(" ").trim();
+        if (key === "worktree") {
+            current.worktree = value;
+        }
+        else if (key === "branch") {
+            // branch is like refs/heads/foo
+            current.branch = value.replace(/^refs\/heads\//, "");
+        }
+        else if (key === "HEAD") {
+            current.head = value;
+        }
+        else if (key === "detached") {
+            current.detached = true;
+        }
+    }
+    flush();
+    return records;
+}
+export async function listWorktrees(params) {
+    const { repoRoot, workspaceFolder, logger } = params;
+    const result = await runGit(["worktree", "list", "--porcelain"], workspaceFolder);
+    if (!result.ok) {
+        const rootDescriptor = { slug: "root", directory: workspaceFolder, kind: "root" };
+        logger?.debug?.({ repoRoot, err: result.error }, "Failed to list git worktrees; returning root only");
+        return [rootDescriptor];
+    }
+    const records = parseWorktreePorcelain(result.stdout);
+    const rootRecord = records.find((record) => path.resolve(record.worktree) === path.resolve(repoRoot));
+    const rootDescriptor = {
+        slug: "root",
+        directory: workspaceFolder,
+        kind: "root",
+        branch: rootRecord?.branch,
+    };
+    const worktrees = [rootDescriptor];
+    const seen = new Set(["root"]);
+    const normalizeSlug = (record) => {
+        const branch = (record.branch ?? "").trim();
+        if (branch) {
+            return branch;
+        }
+        const head = (record.head ?? "").trim();
+        if (head && /^[0-9a-f]{7,40}$/i.test(head)) {
+            return `detached-${head.slice(0, 7)}`;
+        }
+        // Fallback: stable-ish identifier derived from directory basename.
+        const base = path.basename(record.worktree || "");
+        return base ? `worktree-${base}` : "worktree";
+    };
+    for (const record of records) {
+        const abs = record.worktree;
+        if (!abs || typeof abs !== "string")
+            continue;
+        // Skip the root record (we always expose it as slug="root").
+        if (path.resolve(abs) === path.resolve(repoRoot)) {
+            continue;
+        }
+        const slug = normalizeSlug(record);
+        if (!slug || slug === "root") {
+            continue;
+        }
+        if (seen.has(slug)) {
+            continue;
+        }
+        seen.add(slug);
+        worktrees.push({ slug, directory: abs, kind: "worktree", branch: record.branch });
+    }
+    return worktrees;
+}
+export function isValidWorktreeSlug(slug) {
+    if (!slug)
+        return false;
+    const trimmed = slug.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.length > 200)
+        return false;
+    // Disallow control characters; allow branch-like slugs including '/'.
+    if (/[\x00-\x1F\x7F]/.test(trimmed))
+        return false;
+    return true;
+}
+export async function createManagedWorktree(params) {
+    const { repoRoot, workspaceFolder, logger } = params;
+    const branch = params.slug.trim();
+    if (!branch || branch === "root" || !isValidWorktreeSlug(branch)) {
+        throw new Error("Invalid worktree slug");
+    }
+    const sanitizeDirName = (input) => {
+        const normalized = input
+            .trim()
+            .replace(/[\\/]+/g, "-")
+            .replace(/\s+/g, "-")
+            .replace(/[^a-zA-Z0-9_.-]+/g, "-")
+            .replace(/-{2,}/g, "-")
+            .replace(/^-+|-+$/g, "");
+        return normalized || "worktree";
+    };
+    const worktreesDir = path.join(repoRoot, ".codenomad", "worktrees");
+    const targetDir = path.join(worktreesDir, sanitizeDirName(branch));
+    await fsp.mkdir(worktreesDir, { recursive: true });
+    try {
+        const stat = await fsp.stat(targetDir);
+        if (stat.isDirectory()) {
+            throw new Error("Worktree directory already exists");
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT") {
+            throw error;
+        }
+    }
+    logger?.debug?.({ slug: branch, branch, targetDir }, "Creating managed git worktree");
+    // Prefer creating a new branch from HEAD.
+    const first = await runGit(["worktree", "add", "-b", branch, targetDir, "HEAD"], workspaceFolder);
+    if (first.ok) {
+        return { slug: branch, directory: targetDir, branch };
+    }
+    const message = first.stderr?.toLowerCase() ?? first.error.message.toLowerCase();
+    if (message.includes("already exists")) {
+        // If the branch already exists, add worktree for that branch.
+        const second = await runGit(["worktree", "add", targetDir, branch], workspaceFolder);
+        if (second.ok) {
+            return { slug: branch, directory: targetDir, branch };
+        }
+        throw second.error;
+    }
+    throw first.error;
+}
+export async function removeWorktree(params) {
+    const { workspaceFolder, logger } = params;
+    const directory = (params.directory ?? "").trim();
+    if (!directory) {
+        throw new Error("Invalid worktree directory");
+    }
+    logger?.debug?.({ directory, force: Boolean(params.force) }, "Removing git worktree");
+    const args = ["worktree", "remove"];
+    if (params.force) {
+        args.push("--force");
+    }
+    args.push(directory);
+    const result = await runGit(args, workspaceFolder);
+    if (!result.ok) {
+        throw result.error;
+    }
+    // Best-effort cleanup of stale metadata.
+    await runGit(["worktree", "prune"], workspaceFolder).catch(() => undefined);
+}

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 });
+        });
+    }
+}