@join-pantheon/cli 0.29.1 → 0.30.0

package/dist/install.js

@@ -10,6 +10,7 @@ import { loadProfile } from "./profile.js";
 import { agentSpawn, onPathNamed, which } from "./which.js";
 import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { kiroDir, kiroAgentFile, refreshKiroAgentAllowed } from "./kiro-files.js";
+import { eolOf, isJsonc, stripBom, stripJsonc, withEol } from "./text-file.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export function onPath() {
     return onPathNamed("pantheon");
@@ -23,42 +24,65 @@ export function launcher(force, os = platform()) {
         : { command: process.execPath, args: [resolve(HERE, "cli.js"), "mcp"], portable: false };
 }
 function readConfigJson(file) {
+    return readConfigDoc(file).doc;
+}
+function readConfigDoc(file) {
     if (!existsSync(file))
-        return {};
+        return { doc: {}, text: null, jsonc: false };
     const text = readFileSync(file, "utf8");
-    if (!text.trim())
-        return {};
+    const body = stripBom(text);
+    if (!body.trim())
+        return { doc: {}, text, jsonc: false };
+    const asObject = (d) => (d && typeof d === "object" && !Array.isArray(d) ? d : null);
     try {
-        const doc = JSON.parse(text);
-        if (doc && typeof doc === "object" && !Array.isArray(doc))
-            return doc;
+        const d = asObject(JSON.parse(body));
+        if (d)
+            return { doc: d, text, jsonc: false };
     }
     catch { }
+    if (isJsonc(body)) {
+        try {
+            const d = asObject(JSON.parse(stripJsonc(body)));
+            if (d)
+                return { doc: d, text, jsonc: true };
+        }
+        catch { }
+    }
     throw new Error(`${file} is not valid JSON — fix or move it, then re-run`);
 }
+function writeConfigJson(file, doc, was) {
+    mkdirSync(dirname(file), { recursive: true });
+    const next = JSON.stringify(doc, null, 2) + "\n";
+    writeFileSync(file, was === null ? next : (was.charCodeAt(0) === 0xfeff ? "\uFEFF" : "") + withEol(next, eolOf(was)));
+}
 function mergeMcpJson(file, entry, shape = {}) {
-    const doc = readConfigJson(file);
+    const read = readConfigDoc(file);
+    const doc = read.doc;
     const existed = existsSync(file);
     doc.mcpServers ??= {};
     const before = JSON.stringify(doc.mcpServers["pantheon"] ?? null);
     doc.mcpServers["pantheon"] = { ...shape, ...entry, env: shape.env ?? {} };
     if (before === JSON.stringify(doc.mcpServers["pantheon"]))
         return "unchanged";
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+    if (read.jsonc)
+        return `left as it is: ${jsoncNote(file, "mcpServers", doc.mcpServers["pantheon"])}`;
+    writeConfigJson(file, doc, read.text);
     return existed ? "updated" : "created";
 }
+const jsoncNote = (file, key, entry) => `${file} has comments or trailing commas (JSONC), so it was left exactly as it is rather than rewritten without them — add this under "${key}" yourself: "pantheon": ${JSON.stringify(entry)}`;
 export const COPILOT_ENTRY_SHAPE = { type: "local", tools: ["*"] };
 export function mergeVsCodeMcpJson(file, entry) {
-    const doc = readConfigJson(file);
+    const read = readConfigDoc(file);
+    const doc = read.doc;
     const existed = existsSync(file);
     doc.servers ??= {};
     const before = JSON.stringify(doc.servers["pantheon"] ?? null);
     doc.servers["pantheon"] = { type: "stdio", command: entry.command, args: entry.args };
     if (before === JSON.stringify(doc.servers["pantheon"]))
         return "unchanged";
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+    if (read.jsonc)
+        return `left as it is: ${jsoncNote(file, "servers", doc.servers["pantheon"])}`;
+    writeConfigJson(file, doc, read.text);
     return existed ? "updated" : "created";
 }
 export const copilotMcpConfigFile = (home = homedir(), env = process.env) => join(env.COPILOT_HOME || join(home, ".copilot"), "mcp-config.json");
@@ -112,14 +136,16 @@ function upsertBrief(file, cfg) {
         return "created";
     }
     const cur = readFileSync(file, "utf8");
+    const eol = eolOf(cur);
+    const ours = withEol(block, eol);
     if (cur.includes(BRIEF_MARK)) {
-        const next = cur.replace(/<!-- pantheon:begin -->[\s\S]*?<!-- pantheon:end -->/, block);
+        const next = cur.replace(/<!-- pantheon:begin -->[\s\S]*?<!-- pantheon:end -->/, () => ours);
         if (next === cur)
             return "unchanged";
         writeFileSync(file, next);
         return "updated";
     }
-    writeFileSync(file, cur.trimEnd() + "\n\n" + block + "\n");
+    writeFileSync(file, cur.trimEnd() + eol + eol + ours + eol);
     return "updated";
 }
 export function install(projectDir, cfg, force, os = platform(), claudeLocal = claudeLocalScope) {
@@ -196,8 +222,25 @@ function userEntry(os = platform()) {
     const l = launcher();
     return { command: l.command, args: l.args };
 }
-function isVersionManagedPath(p) {
-    return /[\/\\]\.nvm[\/\\]versions[\/\\]node[\/\\]|[\/\\]\.fnm[\/\\]|[\/\\]\.asdf[\/\\]installs[\/\\]nodejs[\/\\]|[\/\\]n[\/\\]versions[\/\\]node[\/\\]|[\/\\]\.volta[\/\\]tools[\/\\]/.test(p);
+export function isVersionManagedPath(p) {
+    const s = "[\\/\\\\]";
+    return new RegExp([
+        `${s}\\.nvm${s}versions${s}node${s}`,
+        `${s}\\.fnm${s}`,
+        `${s}fnm${s}node-versions${s}`,
+        `${s}\\.local${s}share${s}fnm${s}`,
+        `${s}fnm_multishells${s}`,
+        `${s}(?:mise|rtx)${s}installs${s}node(?:js)?${s}`,
+        `${s}\\.asdf${s}installs${s}nodejs${s}`,
+        `${s}n${s}versions${s}node${s}`,
+        `${s}\\.volta${s}tools${s}`,
+    ].join("|")).test(p);
+}
+export function claudeAddFailed(e, command) {
+    const err = e;
+    const said = String(err.stderr ?? "").trim().split("\n").map((l) => l.trim()).filter(Boolean).slice(-2).join(" ").slice(0, 300);
+    const why = said || (err.message ?? "failed").split("\n")[0];
+    return `failed: claude mcp add did not work (${why}) — fix: run \`${command}\` yourself to see why, then pantheon install --user`;
 }
 function claudeUserScope(entry) {
     const tool = "claude code";
@@ -211,11 +254,11 @@ function claudeUserScope(entry) {
             execFileSync(remove.command, remove.args, { stdio: "ignore", ...remove.options });
         }
         catch { }
-        execFileSync(add.command, add.args, { stdio: "ignore", ...add.options });
+        execFileSync(add.command, add.args, { stdio: ["ignore", "ignore", "pipe"], ...add.options });
         return { tool, where: "user scope", status: "ready in every project and every Conductor window" };
     }
     catch (e) {
-        return { tool, where: "user scope", status: `failed: ${e.message.split("\n")[0]}` };
+        return { tool, where: "user scope", status: claudeAddFailed(e, `claude mcp add pantheon -s user -- ${[entry.command, ...entry.args].join(" ")}`) };
     }
 }
 function claudeLocalScope(entry, projectDir) {
@@ -230,11 +273,11 @@ function claudeLocalScope(entry, projectDir) {
             execFileSync(remove.command, remove.args, { stdio: "ignore", cwd: projectDir, ...remove.options });
         }
         catch { }
-        execFileSync(add.command, add.args, { stdio: "ignore", cwd: projectDir, ...add.options });
+        execFileSync(add.command, add.args, { stdio: ["ignore", "ignore", "pipe"], cwd: projectDir, ...add.options });
         return { tool, where: "local scope, this folder", status: "local override written — Claude Code starts pantheon here with this machine's node, and nothing in the repo changed" };
     }
     catch (e) {
-        return { tool, where: "local scope", status: `failed: ${e.message.split("\n")[0]}` };
+        return { tool, where: "local scope", status: claudeAddFailed(e, `claude mcp add pantheon -s local -- ${[entry.command, ...entry.args].join(" ")}`) };
     }
 }
 export function agentPresence(home = homedir(), onPath = onPathNamed) {
@@ -328,7 +371,7 @@ const TOOL_TABLE = /^mcp_servers\.pantheon\.tools\.(pantheon_[a-z_]+)$/;
 const OUR_SERVER_KEYS = /^\s*(command|args|env|default_tools_approval_mode)\s*=/;
 function parseTables(current) {
     const tables = [{ name: null, lines: [] }];
-    for (const line of current.split("\n")) {
+    for (const line of stripBom(current).replace(/\r\n/g, "\n").split("\n")) {
         const h = HEADER.exec(line);
         if (h)
             tables.push({ name: h[1].trim(), lines: [line] });
@@ -506,8 +549,9 @@ export function upsertCodexToml(current, entry, approval = "approve") {
     let body = out.join("\n").trimEnd();
     if (!placed)
         body = (body ? body + "\n\n" : "") + ourBlock().join("\n").trimEnd();
-    return body + "\n";
+    return sameShape(current, body + "\n");
 }
+const sameShape = (original, next) => (original.charCodeAt(0) === 0xfeff ? "\uFEFF" : "") + withEol(next, eolOf(original));
 export function removeCodexToml(current) {
     const out = [];
     for (const t of parseTables(current)) {
@@ -528,7 +572,7 @@ export function removeCodexToml(current) {
         out.push(...t.lines);
     }
     const body = out.join("\n").trimEnd();
-    return body ? body + "\n" : "";
+    return body ? sameShape(current, body + "\n") : "";
 }
 export const codexConfigFile = () => join(homedir(), ".codex", "config.toml");
 export function codexApprovalOf(current) {
@@ -569,7 +613,10 @@ function codexUserScope(entry, approval, present = true) {
         const cur = readFileSync(file, "utf8");
         const had = codexApprovalOf(cur).present;
         const kept = codexKept(cur, approval);
-        writeFileSync(file, upsertCodexToml(cur, entry, approval));
+        const next = upsertCodexToml(cur, entry, approval);
+        if (next === cur)
+            return { tool: "codex", where: file, status: `unchanged — ${said} is already there` };
+        writeFileSync(file, next);
         const notes = [
             kept.toolTables.length ? `kept your own [mcp_servers.pantheon.tools.*] settings for ${kept.toolTables.join(", ")}` : "",
             kept.serverKeys.length ? `kept your own ${kept.serverKeys.join(", ")} in the server table` : "",
@@ -636,14 +683,17 @@ export function removeMcpJsonEntry(file, key = "mcpServers") {
     try {
         if (!existsSync(file))
             return "absent";
-        const doc = readConfigJson(file);
+        const read = readConfigDoc(file);
+        const doc = read.doc;
         const servers = doc[key];
         if (!servers || !("pantheon" in servers))
             return "absent";
         if (!isOurMcpEntry(servers["pantheon"]))
             return "not ours";
+        if (read.jsonc)
+            return `failed: it has comments or trailing commas (JSONC), so it was left exactly as it is`;
         delete servers["pantheon"];
-        writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+        writeConfigJson(file, doc, read.text);
         return "removed";
     }
     catch (e) {

package/dist/kiro-files.js

@@ -35,7 +35,7 @@ export function readKiroAgent(file, tracked = gitTracks) {
     if (!existsSync(file))
         return null;
     try {
-        const doc = JSON.parse(readFileSync(file, "utf8"));
+        const doc = JSON.parse(readFileSync(file, "utf8").replace(/^\uFEFF/, ""));
         const hooks = Object.entries(doc.hooks && typeof doc.hooks === "object" ? doc.hooks : {});
         const events = hooks.filter(([, es]) => Array.isArray(es) && es.some((h) => isOurKiroHook(h?.command))).map(([e]) => e);
         const onlyOurs = hooks.every(([, es]) => Array.isArray(es) && es.every((h) => isOurKiroHook(h?.command)));
@@ -64,7 +64,7 @@ export function refreshKiroAgentAllowed(file, allowed) {
 }
 export function kiroDefaultIsPantheon(base = kiroDir()) {
     try {
-        return JSON.parse(readFileSync(join(base, "settings", "cli.json"), "utf8"))["chat.defaultAgent"] === KIRO_AGENT_NAME;
+        return JSON.parse(readFileSync(join(base, "settings", "cli.json"), "utf8").replace(/^\uFEFF/, ""))["chat.defaultAgent"] === KIRO_AGENT_NAME;
     }
     catch {
         return false;

package/dist/ledger.js

@@ -1,41 +1,121 @@
-import { appendFileSync, mkdirSync, readFileSync, existsSync, writeFileSync, renameSync } from "node:fs";
+import { mkdirSync, existsSync, openSync, readSync, writeSync, fsyncSync, closeSync, fstatSync, copyFileSync, truncateSync, chmodSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { load } from "./config.js";
+import { fsyncDir, renameRetrying, writeFileAtomic } from "./store.js";
+export class SpaceFull extends Error {
+    bytes;
+    cap;
+    constructor(bytes, cap) {
+        super(`this team's history is at the relay's limit (${(bytes / 1e6).toFixed(1)} of ${(cap / 1e6).toFixed(1)} MB)`);
+        this.bytes = bytes;
+        this.cap = cap;
+        this.name = "SpaceFull";
+    }
+}
+import { signedRead } from "./reads.js";
 export class Ledger {
     records = [];
+    byId = new Map();
     seq = 0;
+    fileBytes = 0;
+    outOfOrder = 0;
+    firstOutOfOrder = null;
     file;
     constructor(dir, space) {
         this.file = join(dir, `${space}.jsonl`);
-        mkdirSync(dirname(this.file), { recursive: true });
-        if (existsSync(this.file)) {
-            let text = readFileSync(this.file, "utf8");
-            if (text.length && !text.endsWith("\n")) {
-                const keep = text.lastIndexOf("\n") + 1;
-                text = text.slice(0, keep);
-                writeFileSync(this.file, text);
-            }
-            for (const line of text.split("\n")) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const r = JSON.parse(line);
-                    this.records.push(r);
-                    if (r.seq > this.seq)
-                        this.seq = r.seq;
-                }
-                catch {
+        mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
+        if (existsSync(this.file))
+            this.read();
+    }
+    read() {
+        const fd = openSync(this.file, "r");
+        let size = 0, lastNl = -1;
+        try {
+            size = fstatSync(fd).size;
+            const buf = Buffer.allocUnsafe(1 << 20);
+            let pos = 0;
+            let carry = [];
+            for (let n = readSync(fd, buf, 0, buf.length, pos); n > 0; n = readSync(fd, buf, 0, buf.length, pos)) {
+                let start = 0;
+                for (let i = buf.indexOf(10, 0); i !== -1 && i < n; i = buf.indexOf(10, i + 1)) {
+                    const part = buf.subarray(start, i);
+                    const line = carry.length ? Buffer.concat([...carry, part]).toString("utf8") : part.toString("utf8");
+                    carry = [];
+                    this.take(line);
+                    start = i + 1;
+                    lastNl = pos + i;
                 }
+                if (start < n)
+                    carry.push(Buffer.from(buf.subarray(start, n)));
+                pos += n;
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        this.fileBytes = size;
+        const keep = lastNl + 1;
+        if (keep < size) {
+            const tmp = `${this.file}.tmp`;
+            copyFileSync(this.file, tmp);
+            truncateSync(tmp, keep);
+            const fd2 = openSync(tmp, "r+");
+            try {
+                fsyncSync(fd2);
+            }
+            finally {
+                closeSync(fd2);
             }
+            renameRetrying(tmp, this.file);
+            fsyncDir(dirname(this.file));
+            this.fileBytes = keep;
+        }
+        try {
+            chmodSync(this.file, 0o600);
+        }
+        catch { }
+    }
+    take(line) {
+        if (!line.trim())
+            return;
+        try {
+            const r = JSON.parse(line);
+            this.records.push(r);
+            if (typeof r.id === "string" && !this.byId.has(r.id))
+                this.byId.set(r.id, r);
+            if (r.seq > this.seq)
+                this.seq = r.seq;
+            else if (this.records.length > 1) {
+                this.outOfOrder++;
+                this.firstOutOfOrder ??= r.seq;
+            }
+        }
+        catch {
         }
     }
     get head() {
         return this.seq;
     }
-    append(rec) {
-        const full = { ...rec, seq: ++this.seq };
-        appendFileSync(this.file, JSON.stringify(full) + "\n");
+    get bytes() {
+        return this.fileBytes;
+    }
+    append(rec, cap = 0) {
+        const full = { ...rec, seq: this.seq + 1 };
+        const line = Buffer.from(JSON.stringify(full) + "\n");
+        if (cap > 0 && this.fileBytes + line.length > cap)
+            throw new SpaceFull(this.fileBytes, cap);
+        const fd = openSync(this.file, "a", 0o600);
+        try {
+            writeSync(fd, line);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        this.seq = full.seq;
+        this.fileBytes += line.length;
         this.records.push(full);
+        this.byId.set(full.id, full);
         return full;
     }
     since(seq, limit = 500) {
@@ -49,7 +129,7 @@ export class Ledger {
         return hits.slice(Math.max(0, hits.length - limit));
     }
     find(id) {
-        return this.records.find((r) => r.id === id);
+        return this.byId.get(id);
     }
     all() {
         return this.records;
@@ -65,10 +145,14 @@ export class Ledger {
         const dropped = this.records.length - kept.length;
         if (dropped === 0)
             return { dropped: 0, kept: kept.length };
-        const tmp = `${this.file}.tmp`;
-        writeFileSync(tmp, kept.map((r) => JSON.stringify(r)).join("\n") + "\n");
-        renameSync(tmp, this.file);
+        const text = kept.map((r) => JSON.stringify(r)).join("\n") + "\n";
+        writeFileAtomic(this.file, text);
         this.records = kept;
+        this.byId = new Map();
+        for (const r of kept)
+            if (!this.byId.has(r.id))
+                this.byId.set(r.id, r);
+        this.fileBytes = Buffer.byteLength(text);
         return { dropped, kept: kept.length };
     }
 }
@@ -105,10 +189,9 @@ export async function findDelivered(actId, opts) {
     if (!cfg)
         throw new LedgerUnreachable("no pantheon config — run `pantheon join` or `pantheon init` first");
     const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
-    const url = `${base}/history?space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
     let acts;
     try {
-        const res = await fetch(url);
+        const res = await signedRead(cfg, "/history");
         if (!res.ok)
             throw new LedgerUnreachable(`relay ${base} answered ${res.status} for /history`);
         acts = (await res.json()).acts ?? [];