@join-pantheon/cli 0.32.1 → 0.33.0-rc.1

package/dist/claude-config.js

@@ -0,0 +1,189 @@
+import { chmodSync, closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, writeSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { homedir, platform } from "node:os";
+import { dirname, join, win32 } from "node:path";
+import { eolOf, stripBom, withEol } from "./text-file.js";
+export const claudeJsonFile = (home = homedir()) => join(home, ".claude.json");
+export function claudeHomeConflict(env = process.env, os = platform(), home = homedir()) {
+    if (os !== "win32" || !env.HOME)
+        return null;
+    if (win32.resolve(env.HOME).toLowerCase() === win32.resolve(home).toLowerCase())
+        return null;
+    return `HOME (${env.HOME}) is not your Windows profile (${home}), whose ~/.claude.json Claude Code reads — it was left as it is`;
+}
+export const claudeUserEntryShape = (entry) => ({ type: "stdio", command: entry.command, args: [...entry.args], env: {} });
+const STALE_MS = 10_000;
+const WAIT_MS = 15_000;
+const sleepSync = (ms) => { try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+catch { } };
+export function withClaudeJsonLock(file, fn, waitMs = WAIT_MS) {
+    const lock = `${file}.lock`;
+    mkdirSync(dirname(file), { recursive: true });
+    const deadline = Date.now() + waitMs;
+    for (let first = true;; first = false) {
+        if (!first) {
+            if (Date.now() > deadline)
+                throw new Error(`${file} is being saved by Claude Code right now (${lock}) — try again in a moment`);
+            sleepSync(10 + Math.floor(Math.random() * 20));
+        }
+        try {
+            mkdirSync(lock);
+            break;
+        }
+        catch (e) {
+            const code = e.code;
+            if (code !== "EEXIST" && !(process.platform === "win32" && (code === "EPERM" || code === "EACCES")))
+                throw e;
+        }
+        let st;
+        try {
+            st = lstatSync(lock);
+        }
+        catch {
+            continue;
+        }
+        if (Math.abs(Date.now() - st.mtimeMs) > STALE_MS) {
+            try {
+                if (st.isDirectory())
+                    rmdirSync(lock);
+                else
+                    rmSync(lock, { force: true });
+            }
+            catch { }
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            rmdirSync(lock);
+        }
+        catch { }
+    }
+}
+function readText(path) {
+    let st;
+    try {
+        st = statSync(path);
+    }
+    catch {
+        return null;
+    }
+    if (!st.isFile())
+        throw new Error(`${path} is not a plain file`);
+    return readFileSync(path, "utf8");
+}
+function indentOf(text) {
+    const m = /^\{\r?\n([ \t]+)"/.exec(stripBom(text));
+    return m ? (m[1].includes("\t") ? "\t" : m[1].length) : 2;
+}
+export function updateClaudeJson(file, change) {
+    let target = file;
+    try {
+        if (lstatSync(file).isSymbolicLink())
+            target = realpathSync(file);
+    }
+    catch { }
+    return withClaudeJsonLock(file, () => {
+        for (let attempt = 0;; attempt++) {
+            const was = readText(target);
+            let doc = {};
+            if (was !== null && stripBom(was).trim()) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(stripBom(was));
+                }
+                catch {
+                    throw new Error(`${file} is not valid JSON — Claude Code could not read it either; open Claude Code once (it repairs it), then run pantheon install --user`);
+                }
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                    throw new Error(`${file} does not hold a JSON object — left as it is`);
+                doc = parsed;
+            }
+            const { said, write } = change(doc);
+            if (!write)
+                return said;
+            let next = JSON.stringify(doc, null, was === null ? 2 : indentOf(was)) + "\n";
+            if (was !== null)
+                next = (was.charCodeAt(0) === 0xfeff ? "" : "") + withEol(next, eolOf(was));
+            const tmp = `${target}.pantheon.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+            let mode = 0o600;
+            try {
+                mode = statSync(target).mode & 0o777;
+            }
+            catch { }
+            try {
+                const fd = openSync(tmp, "wx", mode);
+                try {
+                    writeSync(fd, next);
+                    fsyncSync(fd);
+                }
+                finally {
+                    closeSync(fd);
+                }
+                if (process.platform !== "win32")
+                    chmodSync(tmp, mode);
+                if (readText(target) !== was) {
+                    rmSync(tmp, { force: true });
+                    if (attempt < 5)
+                        continue;
+                    throw new Error(`${file} kept changing while it was being written — try again in a moment`);
+                }
+                renameWithRetry(tmp, target);
+            }
+            catch (e) {
+                try {
+                    rmSync(tmp, { force: true });
+                }
+                catch { }
+                throw e;
+            }
+            return said;
+        }
+    });
+}
+function renameWithRetry(from, to) {
+    for (let i = 0;; i++) {
+        try {
+            renameSync(from, to);
+            return;
+        }
+        catch (e) {
+            if (i >= 20 || !["EPERM", "EACCES", "EBUSY"].includes(e.code ?? ""))
+                throw e;
+            sleepSync(10);
+        }
+    }
+}
+export function mergeClaudeUserEntry(file, entry, isOurs) {
+    return updateClaudeJson(file, (doc) => {
+        const had = doc["mcpServers"];
+        const servers = had && typeof had === "object" && !Array.isArray(had) ? had : {};
+        const want = claudeUserEntryShape(entry);
+        const cur = servers["pantheon"];
+        if (cur !== undefined && JSON.stringify(cur) === JSON.stringify(want))
+            return { said: "unchanged", write: false };
+        if (cur !== undefined && !isOurs(cur))
+            return { said: "not ours", write: false };
+        servers["pantheon"] = want;
+        doc["mcpServers"] = servers;
+        return { said: cur === undefined ? "created" : "updated", write: true };
+    });
+}
+export function removeClaudeUserEntry(file, isOurs) {
+    if (readText(file) === null)
+        return "absent";
+    return updateClaudeJson(file, (doc) => {
+        const servers = doc["mcpServers"];
+        if (!servers || typeof servers !== "object" || !("pantheon" in servers))
+            return { said: "absent", write: false };
+        if (!isOurs(servers["pantheon"]))
+            return { said: "not ours", write: false };
+        delete servers["pantheon"];
+        return { said: "removed", write: true };
+    });
+}
+//# sourceMappingURL=claude-config.js.map