crbro-memory 2.9.1 → 2.11.0

package/dist/engine/hookrefresh.js

@@ -0,0 +1,296 @@
+"use strict";
+// ─── Installed hooks stay current on their own ───────────────────
+//
+// install-hooks and install-boot copy hooks/*.mjs out of the package into a
+// stable folder — <Claude config>/crbro-hooks, <CODEX_HOME>/crbro-hooks —
+// because the npx cache moves with every release. Until 2.11 nothing ever
+// updated those copies: an update of CRBRO left the old guard (silent once the
+// trigger index format moved) and the old lifecycle hook (an older copy of the
+// secret filter) running for good.
+//
+// Each of those folders now keeps a manifest of what CRBRO put there: the
+// version and the LF SHA-256 of every file. When the running package is a
+// different build, a copy that is still byte for byte what CRBRO installed —
+// by the manifest, or by the list of every hook CRBRO ever shipped for copies
+// installed before manifests existed — is replaced by the package's. A copy
+// that matches neither was edited by someone: it is left alone and reported,
+// by doctor always and by the boot once (hooks_notice).
+//
+// Runs from crbro_boot (beside the mod's automatic install) and from every
+// install command. Never creates a folder, never adds a hook to a client's
+// settings: it only keeps current what is already there.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIPPED_HASHES = exports.HOOK_MANIFEST = void 0;
+exports.compareVersions = compareVersions;
+exports.hookDirs = hookDirs;
+exports.packageHooksDir = packageHooksDir;
+exports.readManifest = readManifest;
+exports.shippedHashes = shippedHashes;
+exports.writtenBy = writtenBy;
+exports.installHookFile = installHookFile;
+exports.refreshHooks = refreshHooks;
+exports.hooksNotice = hooksNotice;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const installio_js_1 = require("./installio.js");
+exports.HOOK_MANIFEST = 'crbro-hooks.manifest.json';
+exports.SHIPPED_HASHES = 'crbro-hooks.shipped.json';
+/**
+ * -1, 0 or 1 on x.y.z; a prerelease is below its release; anything that is
+ * not x.y.z compares equal, which never counts as newer (same as modinstall).
+ */
+function compareVersions(a, b) {
+    const parse = (v) => /^(\d+)\.(\d+)\.(\d+)(-)?/.exec(v);
+    const x = parse(a);
+    const y = parse(b);
+    if (!x || !y)
+        return 0;
+    for (let i = 1; i <= 3; i++)
+        if (Number(x[i]) !== Number(y[i]))
+            return Number(x[i]) < Number(y[i]) ? -1 : 1;
+    if (!!x[4] !== !!y[4])
+        return x[4] ? -1 : 1;
+    return 0;
+}
+function hookDirs(home, env = process.env) {
+    return [
+        { client: 'claude-code', dir: path_1.default.join((0, installio_js_1.claudeDir)(home, env), 'crbro-hooks') },
+        { client: 'codex', dir: path_1.default.join((0, installio_js_1.codexHome)(home, env), 'crbro-hooks') },
+    ];
+}
+/** The hooks/ folder of the package this code runs from. */
+function packageHooksDir() {
+    return path_1.default.join(__dirname, '..', '..', 'hooks');
+}
+function readManifest(dir) {
+    try {
+        const m = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(dir, exports.HOOK_MANIFEST), 'utf8'));
+        if (m && typeof m === 'object' && m.files && typeof m.files === 'object') {
+            const files = {};
+            for (const [k, v] of Object.entries(m.files)) {
+                if (v && typeof v.sha256 === 'string')
+                    files[k] = { sha256: v.sha256, version: String(v.version ?? '') };
+            }
+            return { version: String(m.version ?? ''), files, ...(Array.isArray(m.noticed) ? { noticed: m.noticed } : {}) };
+        }
+    }
+    catch { /* none yet */ }
+    return null;
+}
+function writeManifest(dir, m) {
+    const file = path_1.default.join(dir, exports.HOOK_MANIFEST);
+    const tmp = `${file}.${process.pid}.tmp`;
+    (0, fs_1.writeFileSync)(tmp, JSON.stringify(m, null, 2) + '\n', 'utf8');
+    (0, fs_1.renameSync)(tmp, file);
+}
+/** Every LF hash CRBRO shipped for a hook before manifests existed, with the last version that shipped it. */
+function shippedHashes(pkgHooks) {
+    try {
+        const raw = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(pkgHooks, exports.SHIPPED_HASHES), 'utf8'));
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (!v || typeof v !== 'object' || Array.isArray(v))
+                continue;
+            out[k] = Object.fromEntries(Object.entries(v).filter(([, x]) => typeof x === 'string'));
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Which CRBRO version wrote this copy, when it is one CRBRO wrote unmodified:
+ * by the folder's manifest, or by the list of hooks shipped before manifests.
+ * Null when it matches neither: somebody edited it.
+ */
+function writtenBy(name, sha, manifest, shipped) {
+    const m = manifest?.files[name];
+    if (m && m.sha256 === sha)
+        return m.version || '0.0.0';
+    return shipped[name]?.[sha] ?? null;
+}
+function pkgVersion(pkgHooks) {
+    try {
+        return String(JSON.parse((0, fs_1.readFileSync)(path_1.default.join(pkgHooks, '..', 'package.json'), 'utf8')).version || 'unknown');
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function mjsIn(dir) {
+    try {
+        return (0, fs_1.readdirSync)(dir).filter(f => f.endsWith('.mjs') && (0, fs_1.statSync)(path_1.default.join(dir, f)).isFile()).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Copies one packaged hook into a folder (tmp + rename) and records it in that folder's manifest. */
+function installHookFile(pkgHooks, name, targetDir) {
+    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+    const src = (0, fs_1.readFileSync)(path_1.default.join(pkgHooks, name));
+    const target = path_1.default.join(targetDir, name);
+    const version = pkgVersion(pkgHooks);
+    const before = readManifest(targetDir);
+    // A copy somebody edited is kept aside before it is replaced.
+    try {
+        const mine = (0, installio_js_1.lfSha)((0, fs_1.readFileSync)(target));
+        if (mine !== (0, installio_js_1.lfSha)(src) && writtenBy(name, mine, before, shippedHashes(pkgHooks)) === null)
+            (0, installio_js_1.backupFile)(target);
+    }
+    catch { /* not there yet */ }
+    let same = false;
+    try {
+        same = (0, fs_1.readFileSync)(target).equals(src);
+    }
+    catch { /* not there */ }
+    const entry = before?.files[name];
+    if (same && entry?.sha256 === (0, installio_js_1.lfSha)(src) && entry.version === version)
+        return target; // idempotent
+    if (!same) {
+        const tmp = `${target}.${process.pid}.tmp`;
+        try {
+            (0, fs_1.writeFileSync)(tmp, src);
+            (0, fs_1.renameSync)(tmp, target);
+        }
+        catch (e) {
+            (0, fs_1.rmSync)(tmp, { force: true });
+            throw e;
+        }
+    }
+    const m = before ?? { version, files: {} };
+    m.version = version;
+    m.files[name] = { sha256: (0, installio_js_1.lfSha)(src), version };
+    writeManifest(targetDir, m);
+    return target;
+}
+/**
+ * Checks every installed CRBRO hook against the package; refreshes the
+ * unmodified ones unless dryRun. Never throws: a copy it cannot write is
+ * reported with its error and tried again next time.
+ */
+function refreshHooks(opts) {
+    const pkgHooks = opts.pkgHooks ?? packageHooksDir();
+    const shipped = shippedHashes(pkgHooks);
+    const version = pkgVersion(pkgHooks);
+    const out = [];
+    for (const { client, dir } of hookDirs(opts.home, opts.env ?? process.env)) {
+        if (!(0, fs_1.existsSync)(dir))
+            continue;
+        const manifest = readManifest(dir);
+        let manifestChanged = false;
+        const next = manifest ? { ...manifest, files: { ...manifest.files } } : { version, files: {} };
+        for (const name of mjsIn(dir)) {
+            let pkg;
+            try {
+                pkg = (0, fs_1.readFileSync)(path_1.default.join(pkgHooks, name));
+            }
+            catch {
+                continue;
+            } // not a hook of this package
+            let mine;
+            try {
+                mine = (0, fs_1.readFileSync)(path_1.default.join(dir, name));
+            }
+            catch {
+                continue;
+            }
+            const pkgSha = (0, installio_js_1.lfSha)(pkg);
+            const mineSha = (0, installio_js_1.lfSha)(mine);
+            if (mineSha === pkgSha) {
+                out.push({ client, dir, name, state: 'current' });
+                if (next.files[name]?.sha256 !== pkgSha) {
+                    next.files[name] = { sha256: pkgSha, version };
+                    manifestChanged = true;
+                }
+                continue;
+            }
+            const by = writtenBy(name, mineSha, manifest, shipped);
+            if (by === null) {
+                out.push({ client, dir, name, state: 'modified' });
+                continue;
+            }
+            // Only a newer release replaces it.
+            if (compareVersions(version, by) <= 0) {
+                out.push({ client, dir, name, state: 'other_build' });
+                continue;
+            }
+            const row = { client, dir, name, state: 'stale' };
+            if (!opts.dryRun) {
+                const target = path_1.default.join(dir, name);
+                const tmp = `${target}.${process.pid}.tmp`;
+                try {
+                    // Checked once more right before: an edit made since the read is not overwritten.
+                    if ((0, installio_js_1.lfSha)((0, fs_1.readFileSync)(target)) !== mineSha)
+                        throw new Error('changed while being refreshed');
+                    (0, fs_1.writeFileSync)(tmp, pkg);
+                    (0, fs_1.renameSync)(tmp, target);
+                    row.refreshed = true;
+                    next.files[name] = { sha256: pkgSha, version };
+                    manifestChanged = true;
+                }
+                catch (e) {
+                    (0, fs_1.rmSync)(tmp, { force: true });
+                    row.error = e.message;
+                }
+            }
+            out.push(row);
+        }
+        if (!opts.dryRun && manifestChanged) {
+            try {
+                next.version = version;
+                writeManifest(dir, next);
+            }
+            catch { /* the next run writes it */ }
+        }
+    }
+    return out;
+}
+/**
+ * The sentence for the boot, once per edited copy: the copies CRBRO did not
+ * refresh because someone changed them, and refreshes that failed. Null when
+ * there is nothing new to say. Marks what it said in the manifests.
+ */
+function hooksNotice(copies) {
+    const edited = copies.filter(c => c.state === 'modified');
+    const failed = copies.filter(c => c.error);
+    const fresh = [];
+    for (const c of edited) {
+        let sha = '';
+        try {
+            sha = (0, installio_js_1.lfSha)((0, fs_1.readFileSync)(path_1.default.join(c.dir, c.name)));
+        }
+        catch {
+            continue;
+        }
+        const m = readManifest(c.dir);
+        const key = `${c.name}:${sha}`;
+        if (m?.noticed?.includes(key))
+            continue;
+        fresh.push(c);
+        try {
+            const next = m ?? { version: '', files: {} };
+            next.noticed = [...(next.noticed ?? []), key].slice(-50);
+            writeManifest(c.dir, next);
+        }
+        catch { /* said again next time */ }
+    }
+    if (!fresh.length && !failed.length)
+        return null;
+    const parts = [];
+    if (fresh.length) {
+        parts.push(`CRBRO did not update ${fresh.length} installed hook file(s) because they differ from what CRBRO installed (edited by hand?): ` +
+            fresh.map(c => path_1.default.join(c.dir, c.name)).join(', ') + '.');
+        parts.push('They keep running as they are. To take this version\'s copy, run the install command again (npx crbro-memory install-hooks …, or install), which replaces them after a backup; npx crbro-memory doctor lists them.');
+    }
+    if (failed.length) {
+        parts.push(`CRBRO could not refresh ${failed.map(c => path_1.default.join(c.dir, c.name)).join(', ')} (${failed[0].error}); it tries again at the next start.`);
+    }
+    parts.push('Tell the user this once, briefly, in their language.');
+    return parts.join(' ');
+}
+//# sourceMappingURL=hookrefresh.js.map

package/dist/engine/hookverify.js

@@ -24,6 +24,7 @@ const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const hookrefresh_js_1 = require("./hookrefresh.js");
 function sha256(buf) {
     return (0, crypto_1.createHash)('sha256').update(buf).digest('hex');
 }
@@ -89,6 +90,13 @@ function verifyHooks(opts) {
         .flatMap(scriptsIn);
     const referenced = new Set(crbroScripts.map(p => path_1.default.basename(p)));
     const hooks = [];
+    const known = (0, hookrefresh_js_1.shippedHashes)(opts.packageDir);
+    const manifest = (0, hookrefresh_js_1.readManifest)(opts.installedDir);
+    let version = '';
+    try {
+        version = String(JSON.parse((0, fs_1.readFileSync)(path_1.default.join(opts.packageDir, '..', 'package.json'), 'utf8')).version || '');
+    }
+    catch { /* unknown */ }
     for (const name of shipped) {
         const pkg = (0, fs_1.readFileSync)(path_1.default.join(opts.packageDir, name));
         const check = { name, status: 'not_installed', package_sha256: sha256(pkg), in_settings: referenced.has(name) };
@@ -100,8 +108,10 @@ function verifyHooks(opts) {
                 check.status = 'same';
             else if (lfSha(mine) === lfSha(pkg))
                 check.status = 'line_endings_only';
-            else
-                check.status = 'different';
+            else {
+                const by = (0, hookrefresh_js_1.writtenBy)(name, lfSha(mine), manifest, known);
+                check.status = by === null ? 'different' : (0, hookrefresh_js_1.compareVersions)(version, by) > 0 ? 'older_release' : 'other_build';
+            }
         }
         hooks.push(check);
     }
@@ -113,7 +123,7 @@ function verifyHooks(opts) {
     }
     const missing = [...new Set(crbroScripts)].filter(p => !(0, fs_1.existsSync)(p));
     const ok = !settingsUnreadable && missing.length === 0 &&
-        hooks.every(h => h.status === 'same' || h.status === 'line_endings_only' || h.status === 'not_installed');
+        hooks.every(h => h.status === 'same' || h.status === 'line_endings_only' || h.status === 'not_installed' || h.status === 'older_release' || h.status === 'other_build');
     return {
         package_dir: opts.packageDir,
         installed_dir: opts.installedDir,
@@ -127,6 +137,8 @@ function verifyHooks(opts) {
 const STATUS_TEXT = {
     same: '✅ same as the package',
     line_endings_only: '✅ same except line endings (CRLF/LF)',
+    older_release: '⚪ from an older CRBRO release, unmodified: refreshed at the next crbro_boot',
+    other_build: '⚪ unmodified, from another CRBRO build of this version or a newer one',
     different: '⚠️  DIFFERENT from the package',
     not_installed: '⚪ not installed',
     unknown: '⚠️  not a hook of this package',