@vividcodeai/embeddedcowork 0.0.22 → 0.0.23

package/dist/server/routes/workspaces.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+import { getWorktreeGitDiff, getWorktreeGitStatus } from "../../workspaces/git-status";
+import { commitWorktreeChanges, isGitMutationError, stageWorktreePaths, unstageWorktreePaths } from "../../workspaces/git-mutations";
+import { isGitAvailable, resolveRepoRoot } from "../../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
+const WorkspaceCreateSchema = z.object({
+    path: z.string(),
+    name: z.string().optional(),
+});
+const WorkspaceFilesQuerySchema = z.object({
+    path: z.string().optional(),
+});
+const WorkspaceFileContentQuerySchema = z.object({
+    path: z.string(),
+});
+const WorkspaceFileContentBodySchema = z.object({
+    contents: z.string(),
+});
+const WorktreeGitDiffQuerySchema = z.object({
+    path: z.string().trim().min(1, "Path is required"),
+    originalPath: z.string().trim().optional(),
+    scope: z.enum(["staged", "unstaged"]),
+});
+const WorktreeGitPathsBodySchema = z.object({
+    paths: z.array(z.string().trim().min(1, "Path is required")).min(1, "At least one path is required"),
+});
+const WorktreeGitCommitBodySchema = z.object({
+    message: z.string().trim().min(1, "Commit message is required"),
+});
+const WorkspaceFileSearchQuerySchema = z.object({
+    q: z.string().trim().min(1, "Query is required"),
+    limit: z.coerce.number().int().positive().max(200).optional(),
+    type: z.enum(["all", "file", "directory"]).optional(),
+    refresh: z
+        .string()
+        .optional()
+        .transform((value) => (value === undefined ? undefined : value === "true")),
+});
+export function registerWorkspaceRoutes(app, deps) {
+    app.get("/api/workspaces", async () => {
+        return deps.workspaceManager.list();
+    });
+    app.post("/api/workspaces", async (request, reply) => {
+        try {
+            const body = WorkspaceCreateSchema.parse(request.body ?? {});
+            const workspace = await deps.workspaceManager.create(body.path, body.name);
+            reply.code(201);
+            return workspace;
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to create workspace");
+            const message = error instanceof Error ? error.message : "Failed to create workspace";
+            reply.code(400).type("text/plain").send(message);
+        }
+    });
+    app.get("/api/workspaces/:id", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        return workspace;
+    });
+    app.delete("/api/workspaces/:id", async (request, reply) => {
+        await deps.workspaceManager.delete(request.params.id);
+        reply.code(204);
+    });
+    app.get("/api/workspaces/:id/files", async (request, reply) => {
+        try {
+            const query = WorkspaceFilesQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.listFiles(request.params.id, query.path ?? ".");
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/search", async (request, reply) => {
+        try {
+            const query = WorkspaceFileSearchQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.searchFiles(request.params.id, query.q, {
+                limit: query.limit,
+                type: query.type,
+                refresh: query.refresh,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/files/content", async (request, reply) => {
+        try {
+            const query = WorkspaceFileContentQuerySchema.parse(request.query ?? {});
+            return deps.workspaceManager.readFile(request.params.id, query.path);
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.put("/api/workspaces/:id/files/content", async (request, reply) => {
+        try {
+            const query = WorkspaceFileContentQuerySchema.parse(request.query ?? {});
+            const body = WorkspaceFileContentBodySchema.parse(request.body ?? {});
+            deps.workspaceManager.writeFile(request.params.id, query.path, body.contents);
+            reply.code(204);
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-status", async (request, reply) => {
+        try {
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitStatus({ workspaceFolder: directory, logger: request.log });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-diff", async (request, reply) => {
+        try {
+            const query = WorktreeGitDiffQuerySchema.parse(request.query ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitDiff({
+                workspaceFolder: directory,
+                path: query.path,
+                originalPath: query.originalPath,
+                scope: query.scope,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-stage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await stageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-unstage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await unstageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-commit", async (request, reply) => {
+        try {
+            const body = WorktreeGitCommitBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            const result = await commitWorktreeChanges({ workspaceFolder: directory, message: body.message });
+            return { ok: true, ...result };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+}
+async function resolveGitWorktreeDirectory(workspaceManager, workspaceId, worktreeSlug, logger, reply) {
+    const workspace = workspaceManager.get(workspaceId);
+    if (!workspace) {
+        reply.code(404);
+        reply.send({ error: "Workspace not found" });
+        return null;
+    }
+    const gitAvailable = await isGitAvailable(workspace.path);
+    if (!gitAvailable) {
+        reply.code(503);
+        reply.send({ error: "Git is not installed or not available in PATH" });
+        return null;
+    }
+    const { isGitRepo } = await resolveRepoRoot(workspace.path, logger);
+    if (!isGitRepo) {
+        reply.code(400);
+        reply.send({ error: "Workspace is not a Git repository" });
+        return null;
+    }
+    const directory = await resolveWorktreeDirectory({
+        workspaceId: workspace.id,
+        workspacePath: workspace.path,
+        worktreeSlug,
+        logger,
+    });
+    if (!directory) {
+        reply.code(404);
+        reply.send({ error: "Worktree not found" });
+        return null;
+    }
+    return directory;
+}
+function handleWorkspaceError(error, reply) {
+    if (isGitMutationError(error)) {
+        reply.code(error.statusCode);
+        return { error: error.message };
+    }
+    if (error instanceof Error && error.message === "Workspace not found") {
+        reply.code(404);
+        return { error: "Workspace not found" };
+    }
+    reply.code(400);
+    return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
+}

package/dist/server/routes/worktrees.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { resolveRepoRoot, listWorktrees, isValidWorktreeSlug, createManagedWorktree, removeWorktree, } from "../../workspaces/git-worktrees";
+import { ensureCodenomadGitExclude, readWorktreeMap, writeWorktreeMap } from "../../workspaces/worktree-map";
+const WorktreeMapSchema = z.object({
+    version: z.literal(1),
+    defaultWorktreeSlug: z.string().min(1).default("root"),
+    parentSessionWorktreeSlug: z.record(z.string(), z.string()).default({}),
+});
+const WorktreeCreateSchema = z.object({
+    slug: z.string().trim().min(1),
+    branch: z.string().trim().min(1).optional(),
+});
+export function registerWorktreeRoutes(app, deps) {
+    app.get("/api/workspaces/:id/worktrees", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+        const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
+        const response = { worktrees, isGitRepo };
+        return response;
+    });
+    app.post("/api/workspaces/:id/worktrees", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        try {
+            const body = WorktreeCreateSchema.parse(request.body ?? {});
+            const slug = body.slug;
+            if (!isValidWorktreeSlug(slug) || slug === "root") {
+                reply.code(400);
+                return { error: "Invalid worktree slug" };
+            }
+            if (body.branch) {
+                if (!isValidWorktreeSlug(body.branch) || body.branch === "root") {
+                    reply.code(400);
+                    return { error: "Invalid worktree branch" };
+                }
+                if (body.branch !== slug) {
+                    reply.code(400);
+                    return { error: "Branch must match slug" };
+                }
+            }
+            const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+            if (!isGitRepo) {
+                reply.code(400);
+                return { error: "Workspace is not a Git repository" };
+            }
+            await ensureCodenomadGitExclude(workspace.path, request.log).catch(() => undefined);
+            const created = await createManagedWorktree({
+                repoRoot,
+                workspaceFolder: workspace.path,
+                slug,
+                logger: request.log,
+            });
+            reply.code(201);
+            return created;
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+    app.delete("/api/workspaces/:id/worktrees/:slug", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        const slug = (request.params.slug ?? "").trim();
+        if (!isValidWorktreeSlug(slug) || slug === "root") {
+            reply.code(400);
+            return { error: "Invalid worktree slug" };
+        }
+        const { repoRoot, isGitRepo } = await resolveRepoRoot(workspace.path, request.log);
+        if (!isGitRepo) {
+            reply.code(400);
+            return { error: "Workspace is not a Git repository" };
+        }
+        const force = (request.query?.force ?? "").toString().toLowerCase() === "true";
+        try {
+            const worktrees = await listWorktrees({ repoRoot, workspaceFolder: workspace.path, logger: request.log });
+            const match = worktrees.find((wt) => wt.slug === slug);
+            if (!match || match.kind === "root") {
+                reply.code(404);
+                return { error: "Worktree not found" };
+            }
+            await removeWorktree({ workspaceFolder: workspace.path, directory: match.directory, force, logger: request.log });
+            // Best-effort: prune any mappings that point at the deleted worktree.
+            const current = await readWorktreeMap(workspace.path, request.log);
+            let changed = false;
+            const nextMapping = { ...(current.parentSessionWorktreeSlug ?? {}) };
+            for (const [sessionId, mapped] of Object.entries(nextMapping)) {
+                if (mapped === slug) {
+                    delete nextMapping[sessionId];
+                    changed = true;
+                }
+            }
+            const nextDefault = current.defaultWorktreeSlug === slug ? "root" : current.defaultWorktreeSlug;
+            if (nextDefault !== current.defaultWorktreeSlug) {
+                changed = true;
+            }
+            if (changed) {
+                await writeWorktreeMap(workspace.path, {
+                    version: 1,
+                    defaultWorktreeSlug: nextDefault,
+                    parentSessionWorktreeSlug: nextMapping,
+                }, request.log);
+            }
+            reply.code(204);
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/map", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        return await readWorktreeMap(workspace.path, request.log);
+    });
+    app.put("/api/workspaces/:id/worktrees/map", async (request, reply) => {
+        const workspace = deps.workspaceManager.get(request.params.id);
+        if (!workspace) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        try {
+            const parsed = WorktreeMapSchema.parse(request.body ?? {});
+            if (!isValidWorktreeSlug(parsed.defaultWorktreeSlug)) {
+                reply.code(400);
+                return { error: "Invalid defaultWorktreeSlug" };
+            }
+            for (const slug of Object.values(parsed.parentSessionWorktreeSlug ?? {})) {
+                if (!isValidWorktreeSlug(slug)) {
+                    reply.code(400);
+                    return { error: "Invalid worktree slug in mapping" };
+                }
+            }
+            await writeWorktreeMap(workspace.path, parsed, request.log);
+            reply.code(204);
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
+}
+function handleError(error, reply) {
+    reply.code(400);
+    return { error: error instanceof Error ? error.message : "Unable to fulfill request" };
+}

package/dist/server/tls.js

@@ -0,0 +1,224 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+function loadForge() {
+    // node-forge is CJS in many installs; require keeps this compatible with our ESM output.
+    return require("node-forge");
+}
+const LEAF_VALIDITY_DAYS = 30;
+const ROTATE_IF_EXPIRES_WITHIN_DAYS = 3;
+const CA_VALIDITY_DAYS = 365;
+export function resolveHttpsOptions(args) {
+    if (!args.enabled) {
+        return null;
+    }
+    const hasProvided = Boolean(args.tlsKeyPath && args.tlsCertPath);
+    if (hasProvided) {
+        const key = fs.readFileSync(args.tlsKeyPath, "utf-8");
+        const cert = fs.readFileSync(args.tlsCertPath, "utf-8");
+        const ca = args.tlsCaPath ? fs.readFileSync(args.tlsCaPath, "utf-8") : undefined;
+        return {
+            httpsOptions: { key, cert, ca },
+            caCertPath: args.tlsCaPath,
+            mode: "provided",
+        };
+    }
+    return ensureGeneratedTls(args);
+}
+function ensureGeneratedTls(args) {
+    const tlsDir = path.join(args.configDir, "tls");
+    const caKeyPath = path.join(tlsDir, "ca-key.pem");
+    const caCertPath = path.join(tlsDir, "ca-cert.pem");
+    const keyPath = path.join(tlsDir, "server-key.pem");
+    const certPath = path.join(tlsDir, "server-cert.pem");
+    fs.mkdirSync(tlsDir, { recursive: true });
+    const shouldRotateLeaf = () => {
+        try {
+            if (!fs.existsSync(certPath))
+                return true;
+            const pem = fs.readFileSync(certPath, "utf-8");
+            const x509 = new crypto.X509Certificate(pem);
+            const validToMs = Date.parse(x509.validTo);
+            if (!Number.isFinite(validToMs))
+                return true;
+            const rotateAt = validToMs - ROTATE_IF_EXPIRES_WITHIN_DAYS * 24 * 60 * 60 * 1000;
+            return Date.now() >= rotateAt;
+        }
+        catch {
+            return true;
+        }
+    };
+    const shouldRotateCa = () => {
+        try {
+            if (!fs.existsSync(caCertPath))
+                return true;
+            const pem = fs.readFileSync(caCertPath, "utf-8");
+            const x509 = new crypto.X509Certificate(pem);
+            const validToMs = Date.parse(x509.validTo);
+            if (!Number.isFinite(validToMs))
+                return true;
+            // CA rotates only when expired.
+            return Date.now() >= validToMs;
+        }
+        catch {
+            return true;
+        }
+    };
+    if (shouldRotateCa() || !fs.existsSync(caKeyPath)) {
+        const { caKeyPem, caCertPem } = generateCaCertificate();
+        writePemFile(caKeyPath, caKeyPem, 0o600);
+        writePemFile(caCertPath, caCertPem, 0o644);
+        args.logger.info({ caCertPath }, "Generated self-signed EmbeddedCowork CA certificate");
+    }
+    if (shouldRotateLeaf() || !fs.existsSync(keyPath)) {
+        const caKeyPem = fs.readFileSync(caKeyPath, "utf-8");
+        const caCertPem = fs.readFileSync(caCertPath, "utf-8");
+        const { keyPem, certPem } = generateServerCertificate({
+            host: args.host,
+            tlsSANs: args.tlsSANs,
+            caKeyPem,
+            caCertPem,
+        });
+        writePemFile(keyPath, keyPem, 0o600);
+        writePemFile(certPath, certPem, 0o644);
+        args.logger.info({ certPath }, "Generated EmbeddedCowork HTTPS certificate");
+    }
+    const key = fs.readFileSync(keyPath, "utf-8");
+    const cert = fs.readFileSync(certPath, "utf-8");
+    const ca = fs.readFileSync(caCertPath, "utf-8");
+    // Present the CA as part of the chain.
+    const chainedCert = `${cert.trim()}\n${ca.trim()}\n`;
+    return {
+        httpsOptions: {
+            key,
+            cert: chainedCert,
+        },
+        caCertPath,
+        mode: "generated",
+    };
+}
+function writePemFile(filePath, content, mode) {
+    fs.writeFileSync(filePath, content, { encoding: "utf-8", mode });
+    try {
+        fs.chmodSync(filePath, mode);
+    }
+    catch {
+        // best effort on platforms that ignore chmod
+    }
+}
+function generateCaCertificate() {
+    const forge = loadForge();
+    const keys = forge.pki.rsa.generateKeyPair(2048);
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = crypto.randomBytes(16).toString("hex");
+    const now = new Date();
+    const notBefore = new Date(now.getTime() - 60000);
+    const notAfter = new Date(now.getTime() + CA_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
+    cert.validity.notBefore = notBefore;
+    cert.validity.notAfter = notAfter;
+    const attrs = [{ name: "commonName", value: "EmbeddedCowork Local CA" }];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([
+        { name: "basicConstraints", cA: true },
+        { name: "keyUsage", keyCertSign: true, cRLSign: true, digitalSignature: true },
+        { name: "subjectKeyIdentifier" },
+    ]);
+    cert.sign(keys.privateKey, forge.md.sha256.create());
+    return {
+        caKeyPem: forge.pki.privateKeyToPem(keys.privateKey),
+        caCertPem: forge.pki.certificateToPem(cert),
+    };
+}
+function generateServerCertificate(args) {
+    const forge = loadForge();
+    const caKey = forge.pki.privateKeyFromPem(args.caKeyPem);
+    const caCert = forge.pki.certificateFromPem(args.caCertPem);
+    const keys = forge.pki.rsa.generateKeyPair(2048);
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = crypto.randomBytes(16).toString("hex");
+    const now = new Date();
+    const notBefore = new Date(now.getTime() - 60000);
+    const notAfter = new Date(now.getTime() + LEAF_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
+    cert.validity.notBefore = notBefore;
+    cert.validity.notAfter = notAfter;
+    const commonName = pickCommonName(args.host);
+    cert.setSubject([{ name: "commonName", value: commonName }]);
+    cert.setIssuer(caCert.subject.attributes);
+    const san = buildSubjectAltNames(args.host, args.tlsSANs);
+    cert.setExtensions([
+        { name: "basicConstraints", cA: false },
+        { name: "keyUsage", digitalSignature: true, keyEncipherment: true },
+        { name: "extKeyUsage", serverAuth: true },
+        { name: "subjectAltName", altNames: san },
+        { name: "subjectKeyIdentifier" },
+    ]);
+    cert.sign(caKey, forge.md.sha256.create());
+    return {
+        keyPem: forge.pki.privateKeyToPem(keys.privateKey),
+        certPem: forge.pki.certificateToPem(cert),
+    };
+}
+function pickCommonName(host) {
+    if (!host || host === "0.0.0.0") {
+        return "localhost";
+    }
+    if (host === "127.0.0.1") {
+        return "localhost";
+    }
+    return host;
+}
+function buildSubjectAltNames(host, tlsSANs) {
+    const dns = new Set();
+    const ips = new Set();
+    dns.add("localhost");
+    ips.add("127.0.0.1");
+    if (host && host !== "0.0.0.0") {
+        if (isIPv4(host)) {
+            ips.add(host);
+        }
+        else {
+            dns.add(host);
+        }
+    }
+    for (const token of splitList(tlsSANs)) {
+        if (isIPv4(token)) {
+            ips.add(token);
+        }
+        else if (token) {
+            dns.add(token);
+        }
+    }
+    const altNames = [];
+    // 2 = DNS, 7 = IP
+    for (const name of Array.from(dns)) {
+        altNames.push({ type: 2, value: name });
+    }
+    for (const ip of Array.from(ips)) {
+        altNames.push({ type: 7, ip });
+    }
+    return altNames;
+}
+function splitList(input) {
+    if (!input)
+        return [];
+    return input
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function isIPv4(value) {
+    const parts = value.split(".");
+    if (parts.length !== 4)
+        return false;
+    return parts.every((part) => {
+        if (!/^[0-9]+$/.test(part))
+            return false;
+        const num = Number(part);
+        return Number.isInteger(num) && num >= 0 && num <= 255;
+    });
+}

package/dist/settings/binaries.js

@@ -0,0 +1,37 @@
+function prettyLabel(p) {
+    const parts = p.split(/[\\/]/);
+    const last = parts[parts.length - 1] || p;
+    return last || p;
+}
+function readUiBinaries(settings) {
+    const ui = settings.getOwner("state", "ui");
+    const list = ui?.opencodeBinaries;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((item) => item && typeof item === "object" && typeof item.path === "string");
+}
+function readDefaultBinaryPath(settings) {
+    const server = settings.getOwner("config", "server");
+    const value = server?.opencodeBinary;
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export class BinaryResolver {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    list() {
+        return readUiBinaries(this.settings);
+    }
+    resolveDefault() {
+        const binaries = this.list();
+        const configuredDefault = readDefaultBinaryPath(this.settings);
+        const fallback = binaries[0]?.path;
+        const path = configuredDefault ?? fallback ?? "opencode";
+        const entry = binaries.find((b) => b.path === path);
+        return {
+            path,
+            label: entry?.label ?? prettyLabel(path),
+            version: entry?.version,
+        };
+    }
+}

package/dist/settings/merge-patch.js

@@ -0,0 +1,33 @@
+export function isPlainObject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * RFC 7396-ish merge patch with explicit null deletes.
+ * - Objects merge recursively
+ * - Arrays/scalars replace
+ * - null deletes keys
+ */
+export function applyMergePatch(current, patch) {
+    if (!isPlainObject(patch)) {
+        return patch;
+    }
+    const base = isPlainObject(current) ? { ...current } : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete base[key];
+            continue;
+        }
+        const existing = base[key];
+        if (isPlainObject(value) && isPlainObject(existing)) {
+            base[key] = applyMergePatch(existing, value);
+            continue;
+        }
+        base[key] = value;
+    }
+    return base;
+}