@amoree-code/ocean 0.0.0-stage → 1.1.0

package/dist/application/clients/registry.js

@@ -0,0 +1,188 @@
+import { jsonEditor, tomlEditor, yamlEditor, yamlListEditor, } from "./editors.js";
+// OpenCode stores `{ type: "local", command: [cmd, ...args], enabled }`.
+const opencodeEditor = jsonEditor(["mcp"], (value) => ({
+    type: "local",
+    command: [value.command, ...(value.args ?? [])],
+    enabled: true,
+}), (node) => {
+    const raw = (node ?? {});
+    const command = Array.isArray(raw.command) ? raw.command : [];
+    const rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !["type", "command", "enabled"].includes(key)));
+    return {
+        ...rest,
+        command: command[0],
+        args: command.slice(1),
+    };
+});
+export const CLIENT_ADAPTERS = [
+    {
+        id: "claude-code",
+        label: "Claude Code (CLI and IDE extensions)",
+        tier: "supported",
+        detect: { binaries: ["claude"], paths: [".claude.json"] },
+        config: { file: ".claude.json", editor: jsonEditor(["mcpServers"]) },
+        nativeMemory: "redirect-staging",
+        mcpClients: [{ name: "claude-code" }],
+    },
+    {
+        id: "claude-desktop",
+        label: "Claude Desktop",
+        tier: "supported",
+        detect: {
+            apps: ["Claude.app"],
+            paths: ["Library/Application Support/Claude"],
+        },
+        config: {
+            file: "Library/Application Support/Claude/claude_desktop_config.json",
+            editor: jsonEditor(["mcpServers"]),
+        },
+        nativeMemory: "capture",
+        // Normal chat uses the claude.ai name although it runs locally; agent mode names its own
+        // `local-agent-mode-<server>` client.
+        mcpClients: [
+            { name: "claude-ai", mode: "chat" },
+            { name: "local-agent-mode-ocean", mode: "agent" },
+        ],
+    },
+    {
+        id: "codex",
+        label: "Codex CLI",
+        tier: "supported",
+        detect: { binaries: ["codex"], paths: [".codex/config.toml"] },
+        config: { file: ".codex/config.toml", editor: tomlEditor("mcp_servers") },
+        nativeMemory: "disable",
+    },
+    {
+        id: "gemini",
+        label: "Gemini CLI",
+        tier: "supported",
+        detect: { binaries: ["gemini"], paths: [".gemini/settings.json"] },
+        config: {
+            file: ".gemini/settings.json",
+            editor: jsonEditor(["mcpServers"]),
+        },
+        nativeMemory: "disable",
+    },
+    {
+        id: "antigravity",
+        label: "Antigravity",
+        tier: "supported",
+        detect: {
+            binaries: ["agy", "antigravity"],
+            apps: ["Antigravity.app"],
+            paths: [".gemini/antigravity/mcp_config.json"],
+        },
+        config: {
+            file: ".gemini/antigravity/mcp_config.json",
+            editor: jsonEditor(["mcpServers"]),
+        },
+        nativeMemory: "harvest",
+    },
+    {
+        id: "cursor",
+        label: "Cursor",
+        tier: "supported",
+        detect: {
+            binaries: ["cursor-agent", "cursor"],
+            apps: ["Cursor.app"],
+            paths: [".cursor/mcp.json"],
+        },
+        config: { file: ".cursor/mcp.json", editor: jsonEditor(["mcpServers"]) },
+        nativeMemory: "uncaptured",
+    },
+    {
+        id: "hermes",
+        label: "Hermes",
+        tier: "supported",
+        detect: { binaries: ["hermes"], paths: [".hermes/config.yaml"] },
+        config: { file: ".hermes/config.yaml", editor: yamlEditor("mcp_servers") },
+        nativeMemory: "disable",
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        tier: "supported",
+        detect: {
+            binaries: ["opencode"],
+            paths: [".config/opencode/opencode.json"],
+        },
+        config: { file: ".config/opencode/opencode.json", editor: opencodeEditor },
+        nativeMemory: "none",
+        mcpClients: [{ name: "opencode" }],
+    },
+    {
+        id: "qwen",
+        label: "Qwen Code",
+        tier: "supported",
+        detect: { binaries: ["qwen"], paths: [".qwen/settings.json"] },
+        config: { file: ".qwen/settings.json", editor: jsonEditor(["mcpServers"]) },
+        nativeMemory: "disable",
+    },
+    {
+        id: "continue",
+        label: "Continue (VS Code)",
+        tier: "supported",
+        detect: { paths: [".continue/config.yaml"] },
+        config: {
+            file: ".continue/config.yaml",
+            editor: yamlListEditor("mcpServers"),
+        },
+        nativeMemory: "none",
+        reason: "its mcpServers is a YAML list; Ocean does not rewrite it",
+    },
+    {
+        id: "aider",
+        label: "Aider",
+        tier: "context-file",
+        detect: { binaries: ["aider"] },
+        nativeMemory: "none",
+        reason: "no MCP support",
+        fallback: "pass an Ocean context file with --read; use `ocean memory …` for memory",
+    },
+    {
+        id: "chatgpt",
+        label: "ChatGPT desktop",
+        tier: "unsupported",
+        detect: { apps: ["ChatGPT.app"] },
+        nativeMemory: "capture",
+        reason: "cannot launch a local MCP server",
+        fallback: "`ocean pull` captures its conversations and memory from the browsers' caches",
+    },
+    {
+        id: "warp",
+        label: "Warp",
+        // Unsupported until its MCP support is verified (T-307), not left as an open question.
+        tier: "unsupported",
+        detect: { apps: ["Warp.app"], paths: [".warp"] },
+        nativeMemory: "unknown",
+        reason: "MCP support not verified",
+        fallback: "use Ocean from a supported client or the `ocean` CLI",
+    },
+    {
+        id: "xcode",
+        label: "Xcode",
+        tier: "unsupported",
+        detect: { apps: ["Xcode.app"] },
+        nativeMemory: "unknown",
+        reason: "AI/MCP support not verified",
+        fallback: "use Ocean from a supported client or the `ocean` CLI",
+    },
+];
+// Which client, and which of its modes, a call-ledger name belongs to; undefined when unknown.
+export function mcpClientOf(name) {
+    for (const adapter of CLIENT_ADAPTERS) {
+        const known = adapter.mcpClients?.find((item) => item.name === name);
+        if (known)
+            return known.mode
+                ? { id: adapter.id, mode: known.mode }
+                : { id: adapter.id };
+    }
+    return undefined;
+}
+export function clientAdapter(id) {
+    const adapter = CLIENT_ADAPTERS.find((item) => item.id === id);
+    if (!adapter)
+        throw new Error(`Unknown client: ${id}`);
+    return adapter;
+}
+//# sourceMappingURL=registry.js.map

package/dist/application/gateway/webhook-gateway.js

@@ -0,0 +1,137 @@
+import { timingSafeEqual } from "node:crypto";
+import { createServer, } from "node:http";
+import { actionFingerprint } from "@ocean/core/domain/mcp/mcp-contract.js";
+import { runAgent } from "@ocean/loop/runs/run-agent.js";
+function sameSecret(expected, actual) {
+    if (actual === undefined)
+        return false;
+    const expectedBytes = Buffer.from(expected);
+    const actualBytes = Buffer.from(actual);
+    return (expectedBytes.length === actualBytes.length &&
+        timingSafeEqual(expectedBytes, actualBytes));
+}
+export const telegramAdapter = {
+    id: "telegram",
+    normalize(input) {
+        if (!input || typeof input !== "object")
+            throw new Error("Invalid Telegram payload");
+        const message = input.message;
+        if (!message?.message_id ||
+            !message.chat?.id ||
+            typeof message.text !== "string" ||
+            !message.text.trim())
+            throw new Error("Invalid Telegram message");
+        const [profile = "default", ...prompt] = message.text
+            .trim()
+            .replace(/^\/run\s+/i, "")
+            .split(/\s+/);
+        return {
+            platform: "telegram",
+            externalId: `${message.chat.id}:${message.message_id}`,
+            profile,
+            prompt: prompt.join(" ") || profile,
+            approved: false,
+        };
+    },
+};
+function createGatewayHandler(expectedToken, cwd, runtime) {
+    const requestTimes = [];
+    return async (input, token) => {
+        const credentials = expectedToken.split(",").map((entry) => {
+            const separator = entry.indexOf("=");
+            if (separator < 1)
+                return { id: "default", token: entry, profiles: undefined };
+            const label = entry.slice(0, separator);
+            const scopeIndex = label.indexOf("@");
+            return {
+                id: scopeIndex < 1 ? label : label.slice(0, scopeIndex),
+                token: entry.slice(separator + 1),
+                profiles: scopeIndex < 1
+                    ? undefined
+                    : new Set(label
+                        .slice(scopeIndex + 1)
+                        .split("|")
+                        .filter(Boolean)),
+            };
+        });
+        const identity = credentials.find((credential) => sameSecret(credential.token, token) &&
+            (!credential.profiles ||
+                (typeof input === "object" &&
+                    input !== null &&
+                    credential.profiles.has(input.profile))))?.id;
+        if (!expectedToken || !identity)
+            return { status: 401, body: "Unauthorized" };
+        const now = Date.now();
+        while (requestTimes[0] !== undefined && requestTimes[0] < now - 60_000)
+            requestTimes.shift();
+        if (requestTimes.length >= 10)
+            return { status: 429, body: "Rate limit exceeded" };
+        requestTimes.push(now);
+        if (!input ||
+            typeof input !== "object" ||
+            typeof input.profile !== "string" ||
+            typeof input.prompt !== "string" ||
+            input.approval?.approved !== true ||
+            typeof input.approval?.fingerprint !== "string" ||
+            input.approval.fingerprint !==
+                actionFingerprint("gateway.run", {
+                    profile: input.profile,
+                    prompt: input.prompt,
+                }))
+            return { status: 400, body: "Invalid or unapproved request" };
+        if (input.prompt.length > 8_000)
+            return { status: 413, body: "Prompt too large" };
+        try {
+            await runtime.loadProfile(input.profile);
+        }
+        catch {
+            return { status: 400, body: "Invalid profile" };
+        }
+        const session = await runAgent({
+            profileName: input.profile,
+            prompt: input.prompt,
+            cwd,
+            actor: `gateway:${identity}`,
+        }, runtime);
+        return {
+            status: 200,
+            body: JSON.stringify({
+                sessionId: session.sessionId,
+                status: session.status,
+            }),
+        };
+    };
+}
+export async function handleGatewayRequest(input, token, expectedToken, cwd, runtime) {
+    return createGatewayHandler(expectedToken, cwd, runtime)(input, token);
+}
+export function createWebhookGateway(cwd, expectedToken, runtime) {
+    const handleRequest = createGatewayHandler(expectedToken, cwd, runtime);
+    return createServer(async (request, response) => {
+        if (request.method !== "POST") {
+            response.writeHead(405);
+            response.end("Method not allowed");
+            return;
+        }
+        let body = "";
+        request.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > 16_000)
+                request.destroy();
+        });
+        request.on("end", async () => {
+            try {
+                const result = await handleRequest(JSON.parse(body), request.headers.authorization?.replace(/^Bearer\s+/i, ""));
+                response.writeHead(result.status, {
+                    "content-type": "application/json",
+                });
+                response.end(result.body);
+            }
+            catch (_error) {
+                response.writeHead(500);
+                response.end("Gateway request failed");
+            }
+        });
+    });
+}
+//# sourceMappingURL=webhook-gateway.js.map

package/dist/application/install/provider-installer.js

@@ -0,0 +1,184 @@
+import { execFile, spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { registryFile } from "@ocean/core/shared/fs-utils.js";
+const execFileAsync = promisify(execFile);
+const catalog = [
+    {
+        provider: {
+            id: "claude",
+            command: "claude",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: {
+            command: "npm",
+            args: ["install", "-g", "@anthropic-ai/claude-code"],
+        },
+        verify: { command: "claude", args: ["--version"] },
+    },
+    {
+        provider: {
+            id: "codex",
+            command: "codex",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: { command: "npm", args: ["install", "-g", "@openai/codex"] },
+        verify: { command: "codex", args: ["--version"] },
+    },
+    {
+        provider: {
+            id: "gemini",
+            command: "gemini",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: {
+            command: "npm",
+            args: ["install", "-g", "@google/gemini-cli"],
+        },
+        verify: { command: "gemini", args: ["--version"] },
+    },
+    {
+        provider: {
+            id: "kilo",
+            command: "kilo",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: { command: "npm", args: ["install", "-g", "@kilocode/cli"] },
+        verify: { command: "kilo", args: ["--version"] },
+    },
+    {
+        provider: {
+            id: "kimi",
+            command: "kimi",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: {
+            command: "uv",
+            args: ["tool", "install", "--force", "--python", "3.13", "kimi-cli"],
+        },
+        verify: { command: "kimi", args: ["--version"] },
+    },
+    {
+        provider: {
+            id: "hermes",
+            command: "hermes",
+            interactive: true,
+            headless: true,
+        },
+        platforms: ["darwin", "linux", "win32"],
+        installer: {
+            command: "uv",
+            args: ["tool", "install", "--force", "hermes-agent"],
+        },
+        verify: { command: "hermes", args: ["--version"] },
+    },
+];
+const installationReceiptPath = () => registryFile("installations.json");
+export function listInstallSpecs() {
+    return catalog.map((spec) => ({
+        ...spec,
+        provider: { ...spec.provider },
+        installer: { ...spec.installer },
+        verify: { ...spec.verify },
+    }));
+}
+export function findInstallSpec(id) {
+    const spec = catalog.find((candidate) => candidate.provider.id === id || candidate.provider.command === id);
+    if (!spec)
+        throw new Error(`No approved installer is registered for provider: ${id}`);
+    return spec;
+}
+export function installPlan(id) {
+    const spec = findInstallSpec(id);
+    return {
+        provider: spec.provider.id,
+        installer: [spec.installer.command, ...spec.installer.args].join(" "),
+        verify: [spec.verify.command, ...spec.verify.args].join(" "),
+    };
+}
+export function assertSupportedPlatform(spec, platform) {
+    if (!spec.platforms.includes(platform)) {
+        throw new Error(`Provider ${spec.provider.id} is not supported on platform: ${platform}`);
+    }
+}
+export async function installProvider(id, approved, wrapperManager, registry) {
+    const spec = findInstallSpec(id);
+    if (!approved)
+        throw new Error(`Installation approval required. Re-run with: ocean install ${spec.provider.id} --yes`);
+    assertSupportedPlatform(spec, process.platform);
+    await runInstaller(spec.installer.command, spec.installer.args);
+    const executable = registry.resolveOriginalExecutable(spec.verify.command);
+    await execFileAsync(spec.verify.command, spec.verify.args, {
+        env: process.env,
+        maxBuffer: 16_000,
+        timeout: 60_000,
+    });
+    const provider = await wrapperManager.registerProvider(spec.provider.id, spec.provider.command);
+    await recordInstallation({
+        provider: provider.id,
+        command: provider.command,
+        executable,
+        installer: JSON.stringify(installPlan(provider.id)),
+        installedAt: new Date().toISOString(),
+    });
+    return { provider, executable };
+}
+export async function updateProvider(id, approved, wrapperManager, registry) {
+    return installProvider(id, approved, wrapperManager, registry);
+}
+export async function removeInstalledProvider(id, approved, wrapperManager) {
+    if (!approved)
+        throw new Error(`Removal approval required. Re-run with: ocean remove ${id} --yes`);
+    const spec = findInstallSpec(id);
+    const provider = await wrapperManager.removeProvider(spec.provider.id);
+    await removeInstallationReceipt(provider.id);
+    return provider;
+}
+function runInstaller(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { env: process.env, stdio: "inherit" });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Installer failed: ${command} (${signal ?? `exit ${code ?? "unknown"}`})`));
+        });
+    });
+}
+async function recordInstallation(record) {
+    let records = [];
+    try {
+        records = JSON.parse(await readFile(installationReceiptPath(), "utf8"));
+    }
+    catch {
+        // First installation or an absent optional receipt.
+    }
+    const next = records.filter((entry) => entry.provider !== record.provider);
+    next.push(record);
+    await mkdir(path.dirname(installationReceiptPath()), { recursive: true });
+    await writeFile(installationReceiptPath(), `${JSON.stringify(next, null, 2)}\n`);
+}
+async function removeInstallationReceipt(provider) {
+    let records;
+    try {
+        records = JSON.parse(await readFile(installationReceiptPath(), "utf8"));
+    }
+    catch {
+        return;
+    }
+    await mkdir(path.dirname(installationReceiptPath()), { recursive: true });
+    await writeFile(installationReceiptPath(), `${JSON.stringify(records.filter((entry) => entry.provider !== provider), null, 2)}\n`);
+}
+//# sourceMappingURL=provider-installer.js.map

package/dist/application/integrations/charter-copies.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { atomicWrite } from "@ocean/core/shared/fs-utils.js";
+import { CHARTER_DIR, oceanPath } from "@ocean/core/shared/paths.js";
+// Clients that cannot @-import a file (Codex, Gemini) carry a verbatim copy of the charter's
+// core.md between these markers in their own rules file. Claude @-imports core.md and needs
+// no copy. Text outside the markers is the owner's and is never touched.
+const BEGIN = "<!-- ai-sync:generated -->";
+const END = "<!-- ai-sync:end -->";
+// Relative to HOME.
+export const CHARTER_COPIES = [
+    { client: "codex", file: ".codex/AGENTS.md" },
+    { client: "gemini", file: ".gemini/GEMINI.md" },
+];
+function hash(text) {
+    return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function block(client, core) {
+    return `${BEGIN}
+<!-- source: ~/ocean/charter/  |  hash: ${hash(core)}  |  client: ${client} -->
+<!-- DO NOT EDIT INSIDE THE MARKERS. Edit ~/ocean/charter/core.md and re-copy it here. -->
+<!-- Anything you write OUTSIDE the markers is yours and is preserved. -->
+
+${core}`;
+}
+// The copy is only rewritten when its body is still exactly what its header hash says was
+// written: an edit inside the markers is reported, never overwritten.
+function handEdited(current) {
+    const recorded = current.match(/\|\s*hash:\s*([0-9a-f]{16})\s*\|/)?.[1];
+    const body = current.split("\n").slice(5).join("\n");
+    return !recorded || hash(body) !== recorded;
+}
+export async function syncCharterCopies(home = os.homedir()) {
+    let core;
+    try {
+        core = `${(await readFile(oceanPath(CHARTER_DIR, "core.md"), "utf8")).trimEnd()}\n`;
+    }
+    catch {
+        return CHARTER_COPIES.map((copy) => ({ ...copy, status: "no-core" }));
+    }
+    const results = [];
+    for (const copy of CHARTER_COPIES) {
+        const file = path.join(home, copy.file);
+        const report = (status) => results.push({ ...copy, status });
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            report("missing");
+            continue;
+        }
+        const start = text.indexOf(BEGIN);
+        const end = text.indexOf(END);
+        if (start === -1 || end < start) {
+            report("no-markers");
+            continue;
+        }
+        const current = text.slice(start, end);
+        const next = block(copy.client, core);
+        if (current === next) {
+            report("current");
+            continue;
+        }
+        if (handEdited(current)) {
+            report("hand-edited");
+            continue;
+        }
+        await atomicWrite(file, `${text.slice(0, start)}${next}${text.slice(end)}`);
+        report("updated");
+    }
+    return results;
+}
+//# sourceMappingURL=charter-copies.js.map

package/dist/application/integrations/claude-vscode.js

@@ -0,0 +1,106 @@
+import { chmod, copyFile, mkdir, readFile, stat, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function defaultClaudeCodeSettingsPath() {
+    if (process.platform === "darwin")
+        return path.join(os.homedir(), "Library", "Application Support", "Code", "User", "settings.json");
+    if (process.platform === "win32")
+        return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "Code", "User", "settings.json");
+    return path.join(os.homedir(), ".config", "Code", "User", "settings.json");
+}
+const WRAPPER_KEY = "claudeCode.claudeProcessWrapper";
+// VS Code settings are JSONC: comments and trailing commas are legal.
+function stripJsonc(source) {
+    let out = "";
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < source.length && source[j] !== '"')
+                j += source[j] === "\\" ? 2 : 1;
+            out += source.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (ch === "/" && source[i + 1] === "/") {
+            while (i < source.length && source[i] !== "\n")
+                i++;
+        }
+        else if (ch === "/" && source[i + 1] === "*") {
+            const end = source.indexOf("*/", i + 2);
+            i = end === -1 ? source.length : end + 2;
+        }
+        else {
+            if (ch === "}" || ch === "]")
+                out = out.replace(/,\s*$/, "");
+            out += ch;
+            i++;
+        }
+    }
+    return out;
+}
+function parseSettings(source) {
+    try {
+        return {
+            settings: JSON.parse(source),
+            strict: true,
+        };
+    }
+    catch {
+        return {
+            settings: JSON.parse(stripJsonc(source)),
+            strict: false,
+        };
+    }
+}
+// Edit the key in place so a JSONC file keeps its comments and formatting.
+function setWrapperKey(source, wrapper) {
+    const entry = `"${WRAPPER_KEY}": ${JSON.stringify(wrapper)}`;
+    const existing = new RegExp(`"${WRAPPER_KEY.replace(".", "\\.")}"\\s*:\\s*"(?:[^"\\\\]|\\\\.)*"`);
+    if (existing.test(source))
+        return source.replace(existing, () => entry);
+    const open = source.indexOf("{");
+    const rest = stripJsonc(source.slice(open + 1)).trim();
+    return `${source.slice(0, open + 1)}\n  ${entry}${rest === "}" ? "" : ","}${source.slice(open + 1)}`;
+}
+export async function configureClaudeCodeWrapper(wrapperManager, settingsPath = defaultClaudeCodeSettingsPath(), apply = false) {
+    const wrapper = wrapperManager.desktopWrapperPath("claude");
+    let source = "{}\n";
+    try {
+        source = await readFile(settingsPath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let parsed;
+    try {
+        parsed = parseSettings(source);
+    }
+    catch {
+        throw new Error(`Claude Code settings are not valid JSON or JSONC: ${settingsPath}`);
+    }
+    const { settings, strict } = parsed;
+    const updated = strict
+        ? `${JSON.stringify({ ...settings, [WRAPPER_KEY]: wrapper }, null, 2)}\n`
+        : setWrapperKey(source, wrapper);
+    const changed = settings[WRAPPER_KEY] !== wrapper;
+    if (!apply || !changed)
+        return { settingsPath, wrapper, apply, changed, backup: null };
+    await mkdir(path.dirname(settingsPath), { recursive: true });
+    let backup = null;
+    try {
+        const metadata = await stat(settingsPath);
+        backup = `${settingsPath}.ocean-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+        await copyFile(settingsPath, backup);
+        await writeFile(settingsPath, updated, "utf8");
+        await chmod(settingsPath, metadata.mode & 0o777);
+    }
+    catch (error) {
+        if (backup)
+            throw error;
+        await writeFile(settingsPath, updated, "utf8");
+    }
+    return { settingsPath, wrapper, apply, changed, backup };
+}
+//# sourceMappingURL=claude-vscode.js.map