@vividcodeai/embeddedcowork 0.0.22 → 0.0.24

package/dist/ui/remote-ui.js

@@ -0,0 +1,462 @@
+import { createHash } from "crypto";
+import fs from "fs";
+import { promises as fsp } from "fs";
+import os from "os";
+import path from "path";
+import { Readable } from "stream";
+import { fetch } from "undici";
+import yauzl from "yauzl";
+const DEFAULT_MANIFEST_URL = "https://ui.embeddedcowork.vividcode.ai/version.json";
+const MANIFEST_TIMEOUT_MS = 5000;
+const ZIP_TIMEOUT_MS = 30000;
+export async function resolveUi(options) {
+    const manifestUrl = options.manifestUrl ?? DEFAULT_MANIFEST_URL;
+    if (options.uiDevServerUrl) {
+        return {
+            uiDevServerUrl: options.uiDevServerUrl,
+            source: "dev-proxy",
+            supported: true,
+        };
+    }
+    if (options.overrideUiDir) {
+        const resolved = await resolveStaticUiDir(options.overrideUiDir);
+        return {
+            uiStaticDir: resolved ?? options.overrideUiDir,
+            source: "override",
+            uiVersion: await readUiVersion(resolved ?? options.overrideUiDir),
+            supported: true,
+        };
+    }
+    const uiRoot = resolveUiCacheRoot(options.configDir);
+    const currentDir = path.join(uiRoot, "current");
+    const previousDir = path.join(uiRoot, "previous");
+    if (!options.autoUpdate) {
+        return await resolveFromCacheOrBundled({
+            logger: options.logger,
+            bundledUiDir: options.bundledUiDir,
+            currentDir,
+            previousDir,
+            supported: true,
+        });
+    }
+    let manifest = null;
+    try {
+        manifest = await fetchManifest(manifestUrl, options.logger);
+    }
+    catch (error) {
+        options.logger.debug({ err: error }, "Remote UI manifest unavailable; using cached/bundled UI");
+    }
+    if (!manifest) {
+        return await resolveFromCacheOrBundled({
+            logger: options.logger,
+            bundledUiDir: options.bundledUiDir,
+            currentDir,
+            previousDir,
+            supported: true,
+        });
+    }
+    const supported = compareSemverCore(options.serverVersion, manifest.minServerVersion) >= 0;
+    if (!supported) {
+        const message = "Upgrade App to use latest features";
+        return await resolveFromCacheOrBundled({
+            logger: options.logger,
+            bundledUiDir: options.bundledUiDir,
+            currentDir,
+            previousDir,
+            supported: false,
+            message,
+            latestServerVersion: manifest.latestServerVersion,
+            latestServerUrl: manifest.latestServerUrl,
+            minServerVersion: manifest.minServerVersion,
+        });
+    }
+    const bestLocal = await pickBestLocalUi({
+        logger: options.logger,
+        bundledUiDir: options.bundledUiDir,
+        currentDir,
+        previousDir,
+    });
+    const remoteIsNewer = !bestLocal ||
+        compareSemverMaybe(manifest.latestUIVersion, bestLocal.uiVersion) > 0;
+    if (!remoteIsNewer) {
+        return await resolveFromCacheOrBundled({
+            logger: options.logger,
+            bundledUiDir: options.bundledUiDir,
+            currentDir,
+            previousDir,
+            supported: true,
+            latestServerVersion: manifest.latestServerVersion,
+            latestServerUrl: manifest.latestServerUrl,
+            minServerVersion: manifest.minServerVersion,
+        });
+    }
+    try {
+        await installRemoteUi({
+            manifest,
+            uiRoot,
+            currentDir,
+            previousDir,
+            logger: options.logger,
+        });
+    }
+    catch (error) {
+        options.logger.warn({ err: error }, "Failed to install remote UI; falling back");
+        return await resolveFromCacheOrBundled({
+            logger: options.logger,
+            bundledUiDir: options.bundledUiDir,
+            currentDir,
+            previousDir,
+            supported: true,
+            latestServerVersion: manifest.latestServerVersion,
+            latestServerUrl: manifest.latestServerUrl,
+            minServerVersion: manifest.minServerVersion,
+        });
+    }
+    const installed = await resolveStaticUiDir(currentDir);
+    if (installed) {
+        return {
+            uiStaticDir: installed,
+            source: "downloaded",
+            uiVersion: await readUiVersion(installed),
+            supported: true,
+            latestServerVersion: manifest.latestServerVersion,
+            latestServerUrl: manifest.latestServerUrl,
+            minServerVersion: manifest.minServerVersion,
+        };
+    }
+    return await resolveFromCacheOrBundled({
+        logger: options.logger,
+        bundledUiDir: options.bundledUiDir,
+        currentDir,
+        previousDir,
+        supported: true,
+        latestServerVersion: manifest.latestServerVersion,
+        latestServerUrl: manifest.latestServerUrl,
+        minServerVersion: manifest.minServerVersion,
+    });
+}
+function resolveUiCacheRoot(configDir) {
+    if (configDir) {
+        return path.join(configDir, "ui");
+    }
+    return path.join(os.homedir(), ".config", "embeddedcowork", "ui");
+}
+async function resolveFromCacheOrBundled(args) {
+    const bestLocal = await pickBestLocalUi({
+        logger: args.logger,
+        bundledUiDir: args.bundledUiDir,
+        currentDir: args.currentDir,
+        previousDir: args.previousDir,
+    });
+    if (bestLocal) {
+        return {
+            uiStaticDir: bestLocal.uiStaticDir,
+            source: bestLocal.source,
+            uiVersion: bestLocal.uiVersion,
+            supported: args.supported,
+            message: args.message,
+            latestServerVersion: args.latestServerVersion,
+            latestServerUrl: args.latestServerUrl,
+            minServerVersion: args.minServerVersion,
+        };
+    }
+    args.logger.warn({ bundledUiDir: args.bundledUiDir }, "No UI assets found");
+    return {
+        uiStaticDir: args.bundledUiDir,
+        source: "missing",
+        supported: args.supported,
+        message: args.message,
+        latestServerVersion: args.latestServerVersion,
+        latestServerUrl: args.latestServerUrl,
+        minServerVersion: args.minServerVersion,
+    };
+}
+async function pickBestLocalUi(args) {
+    const candidates = [];
+    const currentResolved = await resolveStaticUiDir(args.currentDir);
+    if (currentResolved) {
+        candidates.push({
+            uiStaticDir: currentResolved,
+            source: "downloaded",
+            uiVersion: await readUiVersion(currentResolved),
+            priority: 1,
+        });
+    }
+    const bundledResolved = await resolveStaticUiDir(args.bundledUiDir);
+    if (bundledResolved) {
+        candidates.push({
+            uiStaticDir: bundledResolved,
+            source: "bundled",
+            uiVersion: await readUiVersion(bundledResolved),
+            priority: 2,
+        });
+    }
+    const previousResolved = await resolveStaticUiDir(args.previousDir);
+    if (previousResolved) {
+        candidates.push({
+            uiStaticDir: previousResolved,
+            source: "previous",
+            uiVersion: await readUiVersion(previousResolved),
+            priority: 0,
+        });
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    candidates.sort((a, b) => {
+        const versionCmp = compareSemverMaybe(a.uiVersion, b.uiVersion);
+        if (versionCmp !== 0)
+            return -versionCmp;
+        return b.priority - a.priority;
+    });
+    const best = candidates[0];
+    if (!best)
+        return null;
+    return { uiStaticDir: best.uiStaticDir, source: best.source, uiVersion: best.uiVersion };
+}
+function compareSemverMaybe(a, b) {
+    if (!a && !b)
+        return 0;
+    if (!a)
+        return -1;
+    if (!b)
+        return 1;
+    return compareSemverCore(a, b);
+}
+async function resolveStaticUiDir(uiDir) {
+    try {
+        const indexPath = path.join(uiDir, "index.html");
+        await fsp.access(indexPath, fs.constants.R_OK);
+        return uiDir;
+    }
+    catch {
+        return null;
+    }
+}
+async function readUiVersion(uiDir) {
+    try {
+        const content = await fsp.readFile(path.join(uiDir, "ui-version.json"), "utf-8");
+        const parsed = JSON.parse(content);
+        return parsed.uiVersion ?? parsed.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fetchManifest(url, logger) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MANIFEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "EmbeddedCowork-CLI",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Manifest responded with ${response.status}`);
+        }
+        const json = (await response.json());
+        validateManifest(json);
+        return json;
+    }
+    catch (error) {
+        logger.debug({ err: error, url }, "Failed to fetch remote UI manifest");
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function validateManifest(manifest) {
+    const required = ["minServerVersion", "latestUIVersion", "uiPackageURL", "sha256"];
+    for (const key of required) {
+        const value = manifest[key];
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw new Error(`Manifest missing ${key}`);
+        }
+    }
+    if (!/^https:\/\//i.test(manifest.uiPackageURL)) {
+        throw new Error("uiPackageURL must be https");
+    }
+    if (!/^[a-f0-9]{64}$/i.test(manifest.sha256.trim())) {
+        throw new Error("sha256 must be 64 hex chars");
+    }
+}
+async function installRemoteUi(args) {
+    await fsp.mkdir(args.uiRoot, { recursive: true });
+    const tmpDir = path.join(args.uiRoot, `tmp-${Date.now()}`);
+    const zipPath = path.join(args.uiRoot, `ui-${args.manifest.latestUIVersion}.zip`);
+    try {
+        await downloadFile(args.manifest.uiPackageURL, zipPath, args.logger);
+        const digest = await sha256File(zipPath);
+        if (digest.toLowerCase() !== args.manifest.sha256.toLowerCase()) {
+            throw new Error(`sha256 mismatch for UI zip (expected ${args.manifest.sha256}, got ${digest})`);
+        }
+        await extractZip(zipPath, tmpDir);
+        const indexPath = path.join(tmpDir, "index.html");
+        if (!fs.existsSync(indexPath)) {
+            throw new Error("Extracted UI missing index.html");
+        }
+        await rotateDirs({ currentDir: args.currentDir, previousDir: args.previousDir, logger: args.logger });
+        fs.rmSync(args.currentDir, { recursive: true, force: true });
+        fs.renameSync(tmpDir, args.currentDir);
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        fs.rmSync(zipPath, { force: true });
+    }
+}
+async function rotateDirs(args) {
+    try {
+        if (fs.existsSync(args.previousDir)) {
+            fs.rmSync(args.previousDir, { recursive: true, force: true });
+        }
+        if (fs.existsSync(args.currentDir)) {
+            fs.renameSync(args.currentDir, args.previousDir);
+        }
+    }
+    catch (error) {
+        args.logger.warn({ err: error }, "Failed to rotate UI cache directories");
+    }
+}
+async function downloadFile(url, targetPath, logger) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), ZIP_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                Accept: "application/octet-stream",
+                "User-Agent": "EmbeddedCowork-CLI",
+            },
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`UI zip download failed with ${response.status}`);
+        }
+        await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+        const fileStream = fs.createWriteStream(targetPath);
+        const body = response.body;
+        if (!body) {
+            throw new Error("UI zip response missing body");
+        }
+        const nodeStream = Readable.fromWeb(body);
+        await new Promise((resolve, reject) => {
+            nodeStream.pipe(fileStream);
+            nodeStream.on("error", reject);
+            fileStream.on("error", reject);
+            fileStream.on("finish", () => resolve());
+        });
+        logger.debug({ url, targetPath }, "Downloaded remote UI bundle");
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function sha256File(filePath) {
+    const hash = createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    await new Promise((resolve, reject) => {
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("error", reject);
+        stream.on("end", () => resolve());
+    });
+    return hash.digest("hex");
+}
+async function extractZip(zipPath, targetDir) {
+    await fsp.mkdir(targetDir, { recursive: true });
+    await new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true }, (openErr, zipfile) => {
+            if (openErr || !zipfile) {
+                reject(openErr ?? new Error("Unable to open zip"));
+                return;
+            }
+            const root = path.resolve(targetDir);
+            const closeWithError = (error) => {
+                try {
+                    zipfile.close();
+                }
+                catch {
+                    // ignore
+                }
+                reject(error);
+            };
+            zipfile.readEntry();
+            zipfile.on("entry", (entry) => {
+                // Normalize and guard against zip-slip.
+                const entryPath = entry.fileName.replace(/\\/g, "/");
+                const segments = entryPath.split("/").filter(Boolean);
+                if (segments.some((segment) => segment === "..") || path.isAbsolute(entryPath)) {
+                    closeWithError(new Error(`Invalid zip entry path: ${entry.fileName}`));
+                    return;
+                }
+                const destination = path.resolve(targetDir, entryPath);
+                if (!destination.startsWith(root + path.sep) && destination !== root) {
+                    closeWithError(new Error(`Zip entry escapes target dir: ${entry.fileName}`));
+                    return;
+                }
+                const isDirectory = entry.fileName.endsWith("/");
+                if (isDirectory) {
+                    fsp
+                        .mkdir(destination, { recursive: true })
+                        .then(() => zipfile.readEntry())
+                        .catch((error) => closeWithError(error));
+                    return;
+                }
+                fsp
+                    .mkdir(path.dirname(destination), { recursive: true })
+                    .then(() => {
+                    zipfile.openReadStream(entry, (streamErr, readStream) => {
+                        if (streamErr || !readStream) {
+                            closeWithError(streamErr ?? new Error("Unable to read zip entry"));
+                            return;
+                        }
+                        const writeStream = fs.createWriteStream(destination);
+                        const cleanup = (error) => {
+                            readStream.destroy();
+                            writeStream.destroy();
+                            if (error) {
+                                closeWithError(error);
+                            }
+                        };
+                        readStream.on("error", cleanup);
+                        writeStream.on("error", cleanup);
+                        writeStream.on("finish", () => zipfile.readEntry());
+                        readStream.pipe(writeStream);
+                    });
+                })
+                    .catch((error) => closeWithError(error));
+            });
+            zipfile.on("end", () => {
+                zipfile.close();
+                resolve();
+            });
+            zipfile.on("error", (error) => closeWithError(error));
+        });
+    });
+}
+function compareSemverCore(a, b) {
+    const pa = parseSemverCore(a);
+    const pb = parseSemverCore(b);
+    if (pa.major !== pb.major)
+        return pa.major > pb.major ? 1 : -1;
+    if (pa.minor !== pb.minor)
+        return pa.minor > pb.minor ? 1 : -1;
+    if (pa.patch !== pb.patch)
+        return pa.patch > pb.patch ? 1 : -1;
+    return 0;
+}
+function parseSemverCore(value) {
+    const core = value.trim().replace(/^v/i, "").split("-", 1)[0] ?? "0.0.0";
+    const parts = core.split(".");
+    const parsePart = (input) => {
+        const n = Number.parseInt((input ?? "0").replace(/[^0-9]/g, ""), 10);
+        return Number.isFinite(n) ? n : 0;
+    };
+    return {
+        major: parsePart(parts[0]),
+        minor: parsePart(parts[1]),
+        patch: parsePart(parts[2]),
+    };
+}

package/dist/workspaces/__tests__/spawn.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildWindowsSpawnSpec, buildWslSignalSpec, parseWslUncPath, resolveWslWorkingDirectory } from "../spawn";
+describe("parseWslUncPath", () => {
+    it("parses WSL UNC paths into distro and linux path", () => {
+        assert.deepEqual(parseWslUncPath(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`), {
+            distro: "Ubuntu",
+            linuxPath: "/home/dev/.opencode/bin/opencode",
+        });
+    });
+    it("supports the legacy wsl$ UNC prefix", () => {
+        assert.deepEqual(parseWslUncPath(String.raw `\\wsl$\Ubuntu\home\dev`), {
+            distro: "Ubuntu",
+            linuxPath: "/home/dev",
+        });
+    });
+});
+describe("resolveWslWorkingDirectory", () => {
+    it("keeps WSL workspace folders in the same distro", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`, "Ubuntu")), JSON.stringify({ kind: "linux", path: "/home/dev/workspace" }));
+    });
+    it("keeps Windows drive paths so WSL can resolve them with wslpath", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `C:\Users\dev\workspace`, "Ubuntu")), JSON.stringify({ kind: "windows", path: String.raw `C:\Users\dev\workspace` }));
+    });
+    it("keeps UNC network paths so WSL can resolve them with wslpath", () => {
+        assert.equal(JSON.stringify(resolveWslWorkingDirectory(String.raw `\\server\share\workspace`, "Ubuntu")), JSON.stringify({ kind: "windows", path: String.raw `\\server\share\workspace` }));
+    });
+    it("rejects WSL workspace folders from a different distro", () => {
+        assert.equal(resolveWslWorkingDirectory(String.raw `\\wsl.localhost\Debian\home\dev\workspace`, "Ubuntu"), null);
+    });
+});
+describe("buildWindowsSpawnSpec", () => {
+    it("wraps WSL binaries with wsl.exe and propagates required env vars", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
+            cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
+            env: {
+                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\EmbeddedCowork\opencode-config`,
+                EMBEDDEDCOWORK_INSTANCE_ID: "workspace-123",
+                OPENCODE_SERVER_PASSWORD: "secret",
+            },
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDDEDCOWORK_INSTANCE_ID", "OPENCODE_SERVER_PASSWORD"],
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--cd",
+            "/home/dev/workspace",
+            "--exec",
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+            "--port",
+            "0",
+        ]);
+        assert.equal(spec.cwd, undefined);
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDDEDCOWORK_INSTANCE_ID:OPENCODE_SERVER_PASSWORD");
+    });
+    it("upgrades existing WSLENV path entries to include /p", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            env: {
+                OPENCODE_CONFIG_DIR: String.raw `C:\Users\dev\AppData\Roaming\EmbeddedCowork\opencode-config`,
+                WSLENV: "OPENCODE_CONFIG_DIR:EMBEDDEDCOWORK_INSTANCE_ID/u",
+            },
+            propagateEnvKeys: ["OPENCODE_CONFIG_DIR", "EMBEDDEDCOWORK_INSTANCE_ID"],
+        });
+        assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_DIR/p:EMBEDDEDCOWORK_INSTANCE_ID/u");
+    });
+    it("propagates inherited known path variables even when they are not explicitly requested", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            env: {
+                NODE_EXTRA_CA_CERTS: String.raw `C:\certs\root.pem`,
+            },
+        });
+        assert.equal(spec.env?.WSLENV, "NODE_EXTRA_CA_CERTS/p");
+    });
+    it("uses wslpath for Windows workspace folders instead of assuming /mnt", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
+            cwd: String.raw `C:\Users\dev\workspace`,
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            'cd "$(wslpath -au "$1")" && shift && exec "$@"',
+            "embeddedcowork-wsl-launch",
+            String.raw `C:\Users\dev\workspace`,
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+            "--port",
+            "0",
+        ]);
+    });
+    it("uses wslpath for UNC network workspace folders", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            cwd: String.raw `\\server\share\workspace`,
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            'cd "$(wslpath -au "$1")" && shift && exec "$@"',
+            "embeddedcowork-wsl-launch",
+            String.raw `\\server\share\workspace`,
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+        ]);
+    });
+    it("can wrap WSL launches to emit the Linux PID marker", () => {
+        const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve"], {
+            cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
+            wslPidMarker: "__EMBEDDEDCOWORK_WSL_PID__:",
+        });
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, [
+            "--distribution",
+            "Ubuntu",
+            "--exec",
+            "sh",
+            "-lc",
+            `printf '%s%s\\n' '__EMBEDDEDCOWORK_WSL_PID__:' "$$" && cd "$1" && shift && exec "$@"`,
+            "embeddedcowork-wsl-launch",
+            "/home/dev/workspace",
+            "/home/dev/.opencode/bin/opencode",
+            "serve",
+        ]);
+        assert.equal(spec.wsl?.pidMarker, "__EMBEDDEDCOWORK_WSL_PID__:");
+    });
+    it("builds the WSL kill command for tracked Linux PIDs", () => {
+        const spec = buildWslSignalSpec("Ubuntu", 4321, "SIGTERM");
+        assert.equal(spec.command, "wsl.exe");
+        assert.deepEqual(spec.args, ["--distribution", "Ubuntu", "--exec", "kill", "-TERM", "4321"]);
+    });
+});

package/dist/workspaces/git-mutations.js

@@ -0,0 +1,98 @@
+import { spawn } from "child_process";
+import path from "path";
+class GitMutationError extends Error {
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.name = "GitMutationError";
+        this.statusCode = statusCode;
+    }
+}
+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 function normalizeGitWorktreeRelativePath(input) {
+    const normalized = input.trim().replace(/\\+/g, "/").replace(/^\.\//, "");
+    if (!normalized) {
+        throw new GitMutationError("Path is required", 400);
+    }
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized)) {
+        throw new GitMutationError(`Absolute paths are not allowed: ${input}`, 400);
+    }
+    if (normalized === "." || normalized === "..") {
+        throw new GitMutationError(`Invalid path: ${input}`, 400);
+    }
+    if (normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..")) {
+        throw new GitMutationError(`Path traversal is not allowed: ${input}`, 400);
+    }
+    return normalized;
+}
+function normalizeGitMutationPaths(paths) {
+    const deduped = new Set();
+    for (const rawPath of paths) {
+        deduped.add(normalizeGitWorktreeRelativePath(rawPath));
+    }
+    const normalized = Array.from(deduped);
+    if (normalized.length === 0) {
+        throw new GitMutationError("At least one path is required", 400);
+    }
+    return normalized;
+}
+async function ensureGitCommandSucceeded(resultPromise, fallbackMessage) {
+    const result = await resultPromise;
+    if (!result.ok) {
+        const message = result.stderr?.trim() || result.error.message || fallbackMessage;
+        throw new GitMutationError(message, 409);
+    }
+    return result.stdout;
+}
+export function isGitMutationError(error) {
+    return error instanceof GitMutationError;
+}
+export async function stageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    await ensureGitCommandSucceeded(runGit(["add", "--", ...paths], params.workspaceFolder), "Failed to stage files");
+}
+export async function unstageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    const headResult = await runGit(["rev-parse", "--verify", "HEAD"], params.workspaceFolder);
+    if (headResult.ok) {
+        await ensureGitCommandSucceeded(runGit(["restore", "--staged", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+        return;
+    }
+    await ensureGitCommandSucceeded(runGit(["rm", "--cached", "--quiet", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+}
+export async function commitWorktreeChanges(params) {
+    const message = params.message.trim();
+    if (!message) {
+        throw new GitMutationError("Commit message is required", 400);
+    }
+    await ensureGitCommandSucceeded(runGit(["commit", "-m", message], params.workspaceFolder), "Failed to create commit");
+    const shaResult = await runGit(["rev-parse", "HEAD"], params.workspaceFolder);
+    if (!shaResult.ok) {
+        return {};
+    }
+    const commitSha = shaResult.stdout.trim();
+    return commitSha ? { commitSha } : {};
+}