crbro-memory 2.9.1 → 2.11.0

package/dist/engine/installio.js

@@ -0,0 +1,279 @@
+"use strict";
+// ─── Where the clients keep their config, and how CRBRO writes to it ─────
+//
+// Every installer in this package writes into files that belong to another
+// program: Claude Code's settings.json, Codex's hooks.json and config.toml,
+// Claude Desktop's and Cursor's MCP lists. Those files are the user's, and an
+// editor, the client itself or a dotfiles manager may be holding them. So
+// every write goes through writeGuarded():
+//
+//   - a timestamped copy of the file as it was is kept beside it first
+//     (<file>.crbro-bak-<UTC stamp>; the newest few per file are kept);
+//   - the file is hashed again right before the rename, and nothing is written
+//     when it changed after it was read (ESETTINGSCHANGED: read and merge again);
+//   - a symlinked file is written at its target, so the link stays a link, and
+//     the permission bits and line endings it had are kept.
+//
+// modinstall.ts grew this first for the Claude Code mod; it now uses this one.
+//
+// The folders honour the variables the clients themselves honour:
+// CLAUDE_CONFIG_DIR (Claude Code) and CODEX_HOME (Codex).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACKUPS_KEPT = exports.BACKUP_TAG = exports.FILE_CHANGED = void 0;
+exports.sha256 = sha256;
+exports.lfSha = lfSha;
+exports.claudeDir = claudeDir;
+exports.claudeJson = claudeJson;
+exports.codexHome = codexHome;
+exports.claudeDesktopConfig = claudeDesktopConfig;
+exports.cursorConfig = cursorConfig;
+exports.engineRoot = engineRoot;
+exports.findOnPath = findOnPath;
+exports.readText = readText;
+exports.fingerprint = fingerprint;
+exports.readJsonObject = readJsonObject;
+exports.backupsOf = backupsOf;
+exports.backupFile = backupFile;
+exports.writeGuarded = writeGuarded;
+exports.jsonText = jsonText;
+exports.updateJsonFile = updateJsonFile;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+function sha256(buf) {
+    return (0, crypto_1.createHash)('sha256').update(buf).digest('hex');
+}
+/** SHA-256 of a text read with LF line endings: a CRLF checkout and the npm copy hash the same. */
+function lfSha(buf) {
+    const text = typeof buf === 'string' ? buf : buf.toString('utf8');
+    return sha256(Buffer.from(text.replace(/\r\n/g, '\n'), 'utf8'));
+}
+// ─── Folders ─────────────────────────────────────────────────────
+function fromEnv(value, home) {
+    const raw = (value || '').trim();
+    if (!raw || /\$\{|%[A-Za-z_][A-Za-z0-9_]*%/.test(raw))
+        return null;
+    if (raw === '~' || raw.startsWith('~/') || raw.startsWith('~\\'))
+        return path_1.default.join(home, raw.slice(1));
+    return path_1.default.resolve(raw);
+}
+/** Claude Code's config folder: CLAUDE_CONFIG_DIR, else ~/.claude. */
+function claudeDir(home, env = process.env) {
+    return fromEnv(env.CLAUDE_CONFIG_DIR, home) ?? path_1.default.join(home, '.claude');
+}
+/** Where Claude Code keeps user-scope MCP servers: <CLAUDE_CONFIG_DIR>/.claude.json, else ~/.claude.json. */
+function claudeJson(home, env = process.env) {
+    const dir = fromEnv(env.CLAUDE_CONFIG_DIR, home);
+    const inHome = path_1.default.join(home, '.claude.json');
+    if (!dir)
+        return inHome;
+    // With CLAUDE_CONFIG_DIR set, Claude Code keeps it in that folder; an older
+    // ~/.claude.json is still read when the folder has none.
+    const inDir = path_1.default.join(dir, '.claude.json');
+    return (0, fs_1.existsSync)(inDir) || !(0, fs_1.existsSync)(inHome) ? inDir : inHome;
+}
+/** Codex's folder: CODEX_HOME, else ~/.codex. */
+function codexHome(home, env = process.env) {
+    return fromEnv(env.CODEX_HOME, home) ?? path_1.default.join(home, '.codex');
+}
+function claudeDesktopConfig(home, env = process.env, platform = process.platform) {
+    if (platform === 'win32')
+        return path_1.default.join(env.APPDATA || path_1.default.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    if (platform === 'darwin')
+        return path_1.default.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    return path_1.default.join(env.XDG_CONFIG_HOME || path_1.default.join(home, '.config'), 'Claude', 'claude_desktop_config.json');
+}
+function cursorConfig(home) {
+    return path_1.default.join(home, '.cursor', 'mcp.json');
+}
+/** The stable engine folder `crbro-memory install` copies the package into. */
+function engineRoot(home, env = process.env) {
+    return fromEnv(env.CRBRO_ENGINE_DIR, home) ?? path_1.default.join(home, '.crbro-engine');
+}
+/** `claude`, `claude.cmd`… on PATH; null when absent. */
+function findOnPath(name, env = process.env, platform = process.platform) {
+    const dirs = (env.PATH || env.Path || '').split(platform === 'win32' ? ';' : ':').filter(Boolean);
+    const exts = platform === 'win32' ? (env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean) : [''];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const p = path_1.default.join(dir.replace(/^"|"$/g, ''), name + ext.toLowerCase());
+            try {
+                if ((0, fs_1.statSync)(p).isFile())
+                    return p;
+            }
+            catch { /* next */ }
+            if (ext) {
+                const upper = path_1.default.join(dir.replace(/^"|"$/g, ''), name + ext);
+                try {
+                    if ((0, fs_1.statSync)(upper).isFile())
+                        return upper;
+                }
+                catch { /* next */ }
+            }
+        }
+    }
+    return null;
+}
+function readText(file) {
+    if (!(0, fs_1.existsSync)(file))
+        return { exists: false, text: '', hash: 'absent', eol: '\n', bom: false };
+    const buf = (0, fs_1.readFileSync)(file);
+    let text = buf.toString('utf8');
+    const bom = text.charCodeAt(0) === 0xfeff;
+    if (bom)
+        text = text.slice(1);
+    return { exists: true, text, hash: sha256(buf), eol: /\r\n/.test(text) ? '\r\n' : '\n', bom };
+}
+/** What a file holds right now, as a hash, or "absent". */
+function fingerprint(file) {
+    try {
+        return sha256((0, fs_1.readFileSync)(file));
+    }
+    catch {
+        return 'absent';
+    }
+}
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** A JSON object file; null when absent. Anything that is not an object is refused, never guessed at. */
+function readJsonObject(file) {
+    let read;
+    try {
+        read = readText(file);
+    }
+    catch (e) {
+        return { ok: false, error: `${file} could not be read — not touching it.\n     ${e.message}` };
+    }
+    if (!read.exists)
+        return { ok: true, value: null, indent: 2, eol: '\n', bom: false, hash: 'absent' };
+    let value;
+    try {
+        value = read.text.trim() ? JSON.parse(read.text) : {};
+    }
+    catch (e) {
+        return { ok: false, error: `${file} exists but could not be parsed — not touching it.\n     ${e.message}` };
+    }
+    if (!isObject(value))
+        return { ok: false, error: `${file} is not a JSON object — not touching it.` };
+    const indent = /\n([ \t]+)"/.exec(read.text)?.[1] ?? 2;
+    return { ok: true, value, indent, eol: read.eol, bom: read.bom, hash: read.hash };
+}
+// ─── Writing ─────────────────────────────────────────────────────
+/** Thrown by writeGuarded when the file changed after it was read: the caller reads and merges again. */
+exports.FILE_CHANGED = 'ESETTINGSCHANGED';
+exports.BACKUP_TAG = '.crbro-bak-';
+/** Backups kept per file; older ones of the same file go. */
+exports.BACKUPS_KEPT = 5;
+function stampOf(d) {
+    return d.toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+}
+/** The backups of one file, oldest first. */
+function backupsOf(file) {
+    const dir = path_1.default.dirname(file);
+    const prefix = path_1.default.basename(file) + exports.BACKUP_TAG;
+    try {
+        return (0, fs_1.readdirSync)(dir).filter(n => n.startsWith(prefix)).sort().map(n => path_1.default.join(dir, n));
+    }
+    catch {
+        return [];
+    }
+}
+/** Copies the file aside, returns the copy's path, or null when there was nothing to copy. */
+function backupFile(file, now = () => new Date()) {
+    if (!(0, fs_1.existsSync)(file))
+        return null;
+    let target = `${file}${exports.BACKUP_TAG}${stampOf(now())}`;
+    for (let i = 1; (0, fs_1.existsSync)(target); i++)
+        target = `${file}${exports.BACKUP_TAG}${stampOf(now())}-${i}`;
+    (0, fs_1.copyFileSync)(file, target);
+    const all = backupsOf(file);
+    for (const old of all.slice(0, Math.max(0, all.length - exports.BACKUPS_KEPT))) {
+        try {
+            (0, fs_1.rmSync)(old, { force: true });
+        }
+        catch { /* the next write tries again */ }
+    }
+    return target;
+}
+/**
+ * Writes text through .tmp + rename, after a backup, and only if the file is
+ * still what was read. Returns the backup path (or null when the file did not
+ * exist before). On Windows the renamed file takes the folder's inherited ACL.
+ */
+function writeGuarded(file, text, opts = {}) {
+    let target = file;
+    try {
+        if ((0, fs_1.lstatSync)(file).isSymbolicLink())
+            target = (0, fs_1.realpathSync)(file);
+    }
+    catch {
+        // Not there yet: written as a plain file.
+    }
+    let mode;
+    try {
+        mode = (0, fs_1.statSync)(target).mode & 0o777;
+    }
+    catch {
+        mode = undefined;
+    }
+    if (opts.expectHash !== undefined && fingerprint(target) !== opts.expectHash)
+        throw changedError(file);
+    const backup = opts.backup === false ? null : backupFile(target, opts.now);
+    const tmp = `${target}.${process.pid}.tmp`;
+    try {
+        (0, fs_1.writeFileSync)(tmp, text, mode === undefined ? 'utf8' : { encoding: 'utf8', mode });
+        if (opts.expectHash !== undefined && fingerprint(target) !== opts.expectHash)
+            throw changedError(file);
+        (0, fs_1.renameSync)(tmp, target);
+    }
+    catch (e) {
+        (0, fs_1.rmSync)(tmp, { force: true });
+        throw e;
+    }
+    return backup;
+}
+function changedError(file) {
+    const changed = new Error(`${file} changed while it was being written.`);
+    changed.code = exports.FILE_CHANGED;
+    return changed;
+}
+/** JSON in the indentation, line endings and BOM the file came with. */
+function jsonText(value, indent = 2, eol = '\n', bom = false) {
+    let text = JSON.stringify(value, null, indent) + '\n';
+    if (eol !== '\n')
+        text = text.replace(/\n/g, eol);
+    return (bom ? '' : '') + text;
+}
+/**
+ * Read, change, write a JSON object file, merging again when somebody else
+ * wrote it in between (three tries). `change` returns false to write nothing.
+ */
+function updateJsonFile(file, change, opts = {}) {
+    for (let attempt = 0;; attempt++) {
+        const read = readJsonObject(file);
+        if (!read.ok)
+            return read;
+        const value = read.value ?? {};
+        let changed;
+        try {
+            changed = change(value, read.value !== null);
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+        if (!changed)
+            return { ok: true, changed: false, backup: null };
+        try {
+            const backup = writeGuarded(file, jsonText(value, read.indent, read.eol, read.bom), { expectHash: read.hash, backup: opts.backup });
+            return { ok: true, changed: true, backup };
+        }
+        catch (e) {
+            if (e.code === exports.FILE_CHANGED && attempt < 2)
+                continue;
+            return { ok: false, error: e.message };
+        }
+    }
+}
+//# sourceMappingURL=installio.js.map