crbro-memory 2.9.1 → 2.11.0

package/dist/sync/git.js

@@ -11,31 +11,48 @@
 // forever. And it must never rewrite what it stores: git on Windows converts
 // line endings by default, which turns one appended line into two different
 // lines on two machines, and the logs here are append-only.
+//
+// 2.11: a third. Inside the shared daemon a synchronous git call blocks every
+// client for as long as a push takes (up to 30 s). Each multi-step operation is
+// written once as a generator of git calls and driven either synchronously or
+// asynchronously; the server path uses the async drivers.
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GITIGNORE = exports.GITATTRIBUTES = void 0;
+exports.resolveGit = resolveGit;
 exports.git = git;
+exports.gitAsync = gitAsync;
 exports.gitAvailable = gitAvailable;
+exports.gitAvailableAsync = gitAvailableAsync;
 exports.hardenRepo = hardenRepo;
 exports.initSpace = initSpace;
+exports.initSpaceAsync = initSpaceAsync;
 exports.cloneSpace = cloneSpace;
+exports.cloneSpaceAsync = cloneSpaceAsync;
 exports.syncSpace = syncSpace;
+exports.syncSpaceAsync = syncSpaceAsync;
+exports._resetGitMemoForTests = _resetGitMemoForTests;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 /**
  * Everything that could make git stop and ask a person something, turned off.
  * Without this the server hangs on the first private repository it meets.
+ * A GIT_SSH_COMMAND the user set is kept: replacing it silently overrode their
+ * own ssh setup (G16).
  */
-const SILENT_ENV = {
-    GIT_TERMINAL_PROMPT: '0',
-    GIT_ASKPASS: '',
-    SSH_ASKPASS: '',
-    GIT_SSH_COMMAND: 'ssh -o BatchMode=yes -o StrictHostKeyChecking=accept-new',
-    GCM_INTERACTIVE: 'never',
-};
+function silentEnv() {
+    return {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: '0',
+        GIT_ASKPASS: '',
+        SSH_ASKPASS: '',
+        GIT_SSH_COMMAND: process.env['GIT_SSH_COMMAND'] || 'ssh -o BatchMode=yes -o StrictHostKeyChecking=accept-new',
+        GCM_INTERACTIVE: 'never',
+    };
+}
 function classify(stderr) {
     const s = stderr.toLowerCase();
     if (s.includes('could not resolve host') || s.includes('unable to access') ||
@@ -48,38 +65,125 @@ function classify(stderr) {
         return 'conflict';
     return undefined;
 }
+// ─── Which git ───────────────────────────────────────────────────
+//
+// On Windows a bare "git" is looked up in the child's working directory before
+// PATH. Every call here runs with cwd = a space directory, whose contents come
+// from teammates: a git.exe committed at its root would run as the user (G10).
+// So the executable is resolved once, from absolute PATH entries only.
+let resolved = null;
+function resolveGit() {
+    if (process.platform !== 'win32')
+        return 'git';
+    if (resolved && (0, node_fs_1.existsSync)(resolved))
+        return resolved;
+    resolved = null;
+    for (const entry of (process.env['PATH'] || process.env['Path'] || '').split(node_path_1.default.delimiter)) {
+        const d = entry.trim().replace(/^"|"$/g, '');
+        if (!d || !node_path_1.default.isAbsolute(d))
+            continue;
+        const exe = node_path_1.default.join(d, 'git.exe');
+        try {
+            if ((0, node_fs_1.statSync)(exe).isFile()) {
+                resolved = exe;
+                return exe;
+            }
+        }
+        catch { /* not here */ }
+    }
+    // Not on PATH: the bare name fails with ENOENT from a neutral directory
+    // (see git()), which reports no_git rather than running a planted binary.
+    return 'git';
+}
+function neutralCwd(cwd) {
+    // With an absolute executable the space directory is a safe cwd. Without one
+    // (git not found), run from the system directory and pass -C instead.
+    if (process.platform === 'win32' && resolveGit() === 'git') {
+        const root = process.env['SystemRoot'] || 'C:\\Windows';
+        return { cwd: root, args: ['-C', cwd] };
+    }
+    return { cwd, args: [] };
+}
+function toResult(status, signal, stdout, stderr, error) {
+    if (error) {
+        const code = error.code;
+        return { ok: false, stdout: '', stderr: String(error.message || ''), reason: code === 'ENOENT' ? 'no_git' : 'timeout' };
+    }
+    if (signal)
+        return { ok: false, stdout, stderr, reason: 'timeout' };
+    return { ok: status === 0, stdout, stderr, reason: status === 0 ? undefined : classify(stderr) };
+}
 function git(args, cwd, timeoutMs = 20_000) {
-    const r = (0, node_child_process_1.spawnSync)('git', args, {
-        cwd,
+    const where = neutralCwd(cwd);
+    const r = (0, node_child_process_1.spawnSync)(resolveGit(), [...where.args, ...args], {
+        cwd: where.cwd,
         encoding: 'utf-8',
         timeout: timeoutMs,
         windowsHide: true,
-        env: { ...process.env, ...SILENT_ENV },
+        env: silentEnv(),
+    });
+    return toResult(r.status, r.signal, r.stdout || '', r.stderr || '', r.error);
+}
+/** The same call without blocking the event loop. */
+function gitAsync(args, cwd, timeoutMs = 20_000) {
+    return new Promise(resolve => {
+        const where = neutralCwd(cwd);
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        const done = (r) => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(r);
+        } };
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(resolveGit(), [...where.args, ...args], {
+                cwd: where.cwd, windowsHide: true, env: silentEnv(), stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            done(toResult(null, null, '', '', err));
+            return;
+        }
+        const timer = setTimeout(() => { timedOut = true; child.kill(); }, timeoutMs);
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', d => { stdout += d; });
+        child.stderr.on('data', d => { stderr += d; });
+        child.on('error', err => done(toResult(null, null, stdout, stderr, err)));
+        child.on('close', (code, signal) => done(timedOut
+            ? { ok: false, stdout, stderr, reason: 'timeout' }
+            : toResult(code, signal, stdout, stderr)));
     });
-    if (r.error) {
-        const code = r.error.code;
-        return {
-            ok: false,
-            stdout: '',
-            stderr: String(r.error.message || ''),
-            reason: code === 'ENOENT' ? 'no_git' : 'timeout',
-        };
-    }
-    if (r.signal) {
-        return { ok: false, stdout: r.stdout || '', stderr: r.stderr || '', reason: 'timeout' };
-    }
-    const stderr = r.stderr || '';
-    return {
-        ok: r.status === 0,
-        stdout: r.stdout || '',
-        stderr,
-        reason: r.status === 0 ? undefined : classify(stderr),
-    };
+}
+function driveSync(g) {
+    let step = g.next();
+    while (!step.done)
+        step = g.next(git(step.value.args, step.value.cwd, step.value.timeoutMs));
+    return step.value;
+}
+async function driveAsync(g) {
+    let step = g.next();
+    while (!step.done)
+        step = g.next(await gitAsync(step.value.args, step.value.cwd, step.value.timeoutMs));
+    return step.value;
 }
 /** Is git installed at all? */
 function gitAvailable() {
     return git(['--version'], process.cwd(), 5_000).ok;
 }
+// Whether git is installed does not change between two syncs; asking costs a
+// process start. Kept for a minute, failures included.
+let availability = null;
+async function gitAvailableAsync() {
+    if (availability && Date.now() - availability.at < 60_000)
+        return availability.ok;
+    const ok = (await gitAsync(['--version'], process.cwd(), 5_000)).ok;
+    availability = { ok, at: Date.now() };
+    return ok;
+}
 /**
  * Settings that have to be on the repository itself, not on the machine.
  *
@@ -89,18 +193,21 @@ function gitAvailable() {
  * becomes two lines, and the memory quietly duplicates itself. `* -text` in
  * .gitattributes plus this setting stops it at both ends.
  */
-function hardenRepo(dir) {
-    git(['config', 'core.autocrlf', 'false'], dir);
-    git(['config', 'core.safecrlf', 'false'], dir);
-    git(['config', 'merge.ours.driver', 'true'], dir);
+function* hardenGen(dir) {
+    yield { args: ['config', 'core.autocrlf', 'false'], cwd: dir };
+    yield { args: ['config', 'core.safecrlf', 'false'], cwd: dir };
+    yield { args: ['config', 'merge.ours.driver', 'true'], cwd: dir };
     // Identity, so committing works on a machine with no global git config.
-    if (!git(['config', 'user.email'], dir).stdout.trim()) {
-        git(['config', 'user.email', 'crbro@localhost'], dir);
+    if (!(yield { args: ['config', 'user.email'], cwd: dir }).stdout.trim()) {
+        yield { args: ['config', 'user.email', 'crbro@localhost'], cwd: dir };
     }
-    if (!git(['config', 'user.name'], dir).stdout.trim()) {
-        git(['config', 'user.name', 'CRBRO'], dir);
+    if (!(yield { args: ['config', 'user.name'], cwd: dir }).stdout.trim()) {
+        yield { args: ['config', 'user.name', 'CRBRO'], cwd: dir };
     }
 }
+function hardenRepo(dir) {
+    driveSync(hardenGen(dir));
+}
 exports.GITATTRIBUTES = '# CRBRO shared memory. Do not edit.\n' +
     '# -text keeps git from rewriting line endings: these logs are append-only\n' +
     '# and a rewritten ending turns one line into two on the next merge.\n' +
@@ -108,71 +215,95 @@ exports.GITATTRIBUTES = '# CRBRO shared memory. Do not edit.\n' +
     '*.jsonl merge=union\n';
 exports.GITIGNORE = '# Local bookkeeping. Never shared.\n' +
     '.local/\n';
-/** Prepare a brand-new space so the first person to clone finds real history. */
-async function initSpace(dir, remote, branch = 'main') {
-    await node_fs_1.promises.mkdir(dir, { recursive: true });
-    const init = git(['init', '-b', branch], dir);
+function* initGen(dir, remote, branch) {
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const init = yield { args: ['init', '-b', branch], cwd: dir };
     if (!init.ok && !init.stdout.includes('Reinitialized')) {
-        const legacy = git(['init'], dir);
+        const legacy = yield { args: ['init'], cwd: dir };
         if (!legacy.ok)
             return legacy;
-        git(['checkout', '-b', branch], dir);
+        yield { args: ['checkout', '-b', branch], cwd: dir };
     }
-    hardenRepo(dir);
-    await node_fs_1.promises.writeFile(node_path_1.default.join(dir, '.gitattributes'), exports.GITATTRIBUTES, 'utf-8');
-    await node_fs_1.promises.writeFile(node_path_1.default.join(dir, '.gitignore'), exports.GITIGNORE, 'utf-8');
-    git(['remote', 'remove', 'origin'], dir);
-    const add = git(['remote', 'add', 'origin', remote], dir);
+    yield* hardenGen(dir);
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(dir, '.gitattributes'), exports.GITATTRIBUTES, 'utf-8');
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(dir, '.gitignore'), exports.GITIGNORE, 'utf-8');
+    yield { args: ['remote', 'remove', 'origin'], cwd: dir };
+    // "--": a remote that starts with "-" is a URL, never an option.
+    const add = yield { args: ['remote', 'add', '--', 'origin', remote], cwd: dir };
     if (!add.ok)
         return add;
-    git(['add', '-A', '.'], dir);
-    git(['commit', '-q', '-m', 'CRBRO shared space'], dir);
+    yield { args: ['add', '-A', '.'], cwd: dir };
+    yield { args: ['commit', '-q', '-m', 'CRBRO shared space'], cwd: dir };
     // Push the first commit before anyone clones. Skipping this is how two
     // people end up with unrelated histories and a merge that refuses to run —
     // each of them keeping their own half of the memory without noticing.
-    return git(['push', '-u', 'origin', `HEAD:${branch}`], dir, 30_000);
+    return yield { args: ['push', '-u', 'origin', `HEAD:${branch}`], cwd: dir, timeoutMs: 30_000 };
 }
-/** Clone an existing space. */
-function cloneSpace(dir, remote, branch = 'main') {
+/** Prepare a brand-new space so the first person to clone finds real history. */
+async function initSpace(dir, remote, branch = 'main') {
+    return driveSync(initGen(dir, remote, branch));
+}
+function initSpaceAsync(dir, remote, branch = 'main') {
+    return driveAsync(initGen(dir, remote, branch));
+}
+function* cloneGen(dir, remote, branch) {
     const parent = node_path_1.default.dirname(dir);
     const name = node_path_1.default.basename(dir);
-    const r = git(['clone', '--branch', branch, remote, name], parent, 60_000);
+    const r = yield { args: ['clone', '--branch', branch, '--', remote, name], cwd: parent, timeoutMs: 60_000 };
     if (r.ok)
-        hardenRepo(dir);
+        yield* hardenGen(dir);
     return r;
 }
-/**
- * Bring in everyone else's notes and send ours.
- * Offline is a normal outcome, not an error: the work stays local and goes out
- * next time. Nothing here can lose a note, because nobody edits anyone's file.
- */
-function syncSpace(dir, author, branch = 'main', timeoutMs = 30_000) {
-    git(['add', '-A', '.'], dir);
-    const hayCambios = !git(['diff', '--cached', '--quiet'], dir).ok;
+/** Clone an existing space. */
+function cloneSpace(dir, remote, branch = 'main') {
+    return driveSync(cloneGen(dir, remote, branch));
+}
+function cloneSpaceAsync(dir, remote, branch = 'main') {
+    return driveAsync(cloneGen(dir, remote, branch));
+}
+function* syncGen(dir, author, branch, timeoutMs) {
+    yield { args: ['add', '-A', '.'], cwd: dir };
+    const hayCambios = !(yield { args: ['diff', '--cached', '--quiet'], cwd: dir }).ok;
     if (hayCambios) {
-        git(['commit', '-q', '-m', `crbro ${author} ${new Date().toISOString()}`], dir);
+        yield { args: ['commit', '-q', '-m', `crbro ${author} ${new Date().toISOString()}`], cwd: dir };
     }
-    const fetched = git(['fetch', 'origin', branch], dir, timeoutMs);
+    const fetched = yield { args: ['fetch', 'origin', '--', branch], cwd: dir, timeoutMs };
     if (!fetched.ok)
         return { pulled: fetched, pushed: null };
-    const merged = git(['merge', '--no-edit', '--allow-unrelated-histories', `origin/${branch}`], dir, timeoutMs);
+    const merged = yield { args: ['merge', '--no-edit', '--allow-unrelated-histories', `origin/${branch}`], cwd: dir, timeoutMs };
     if (!merged.ok) {
         // Union merging makes this rare, but a hand-edited file could still clash.
         // Keeping both sides and stopping beats guessing.
-        git(['merge', '--abort'], dir);
+        yield { args: ['merge', '--abort'], cwd: dir };
         return { pulled: { ...merged, reason: 'conflict' }, pushed: null };
     }
     // Push, and if someone landed first, take their work and try once more.
-    let pushed = git(['push', 'origin', `HEAD:${branch}`], dir, timeoutMs);
+    let pushed = yield { args: ['push', 'origin', `HEAD:${branch}`], cwd: dir, timeoutMs };
     for (let intento = 0; intento < 2 && !pushed.ok && pushed.reason !== 'auth'; intento++) {
-        if (!git(['fetch', 'origin', branch], dir, timeoutMs).ok)
+        if (!(yield { args: ['fetch', 'origin', '--', branch], cwd: dir, timeoutMs }).ok)
             break;
-        if (!git(['merge', '--no-edit', `origin/${branch}`], dir, timeoutMs).ok) {
-            git(['merge', '--abort'], dir);
+        if (!(yield { args: ['merge', '--no-edit', `origin/${branch}`], cwd: dir, timeoutMs }).ok) {
+            yield { args: ['merge', '--abort'], cwd: dir };
             break;
         }
-        pushed = git(['push', 'origin', `HEAD:${branch}`], dir, timeoutMs);
+        pushed = yield { args: ['push', 'origin', `HEAD:${branch}`], cwd: dir, timeoutMs };
     }
     return { pulled: merged, pushed };
 }
+/**
+ * Bring in everyone else's notes and send ours.
+ * Offline is a normal outcome, not an error: the work stays local and goes out
+ * next time. Nothing here can lose a note, because nobody edits anyone's file.
+ */
+function syncSpace(dir, author, branch = 'main', timeoutMs = 30_000) {
+    return driveSync(syncGen(dir, author, branch, timeoutMs));
+}
+function syncSpaceAsync(dir, author, branch = 'main', timeoutMs = 30_000) {
+    return driveAsync(syncGen(dir, author, branch, timeoutMs));
+}
+/** Tests: forget the resolved executable and the availability memo. */
+function _resetGitMemoForTests() {
+    resolved = null;
+    availability = null;
+}
 //# sourceMappingURL=git.js.map

package/dist/sync/materialize.js

@@ -18,6 +18,7 @@ const fs_js_1 = require("../utils/fs.js");
 const ops_js_1 = require("./ops.js");
 const hash_js_1 = require("../utils/hash.js");
 const shelf_js_1 = require("../engine/shelf.js");
+const evidence_js_1 = require("../engine/evidence.js");
 /**
  * How far along a fact's life it is. Merging takes the maximum, so a fact
  * someone retracted can never come back to life because a stale log still
@@ -50,6 +51,7 @@ function applyOps(base, ops, fallback) {
         tags_added: 0,
         verifications_updated: 0,
         shelf_updated: 0,
+        metadata_updated: 0,
         authors: [],
         divergence: [],
     };
@@ -60,7 +62,7 @@ function applyOps(base, ops, fallback) {
     // reported rather than resolved. Overwriting someone's local name because a
     // teammate spelled it differently is not a merge, it is a stomp.
     const neuron = base
-        ? { ...base, facts: [...base.facts], decisions: [...base.decisions], patterns: [...base.patterns], preferences: [...base.preferences], tags: [...base.tags], connections: [...base.connections], errors: [...(base.errors || [])], debts: [...(base.debts || [])], entry_dates: { ...(base.entry_dates || {}) }, entry_status: { ...(base.entry_status || {}) }, ...(base.entry_source ? { entry_source: { ...base.entry_source } } : {}), ...(base.entry_verified ? { entry_verified: { ...base.entry_verified } } : {}), map: base.map ? { ...base.map } : undefined }
+        ? { ...base, facts: base.facts.map(f => structuredClone(f)), decisions: [...base.decisions], patterns: [...base.patterns], preferences: [...base.preferences], tags: [...base.tags], connections: [...base.connections], errors: [...(base.errors || [])], debts: [...(base.debts || [])], entry_dates: { ...(base.entry_dates || {}) }, entry_status: { ...(base.entry_status || {}) }, ...(base.entry_source ? { entry_source: { ...base.entry_source } } : {}), ...(base.entry_verified ? { entry_verified: { ...base.entry_verified } } : {}), ...(base.entry_verification ? { entry_verification: structuredClone(base.entry_verification) } : {}), map: base.map ? { ...base.map } : undefined }
         : {
             id,
             name: neuronOp && neuronOp.op === 'neuron' ? neuronOp.name : id,
@@ -157,6 +159,10 @@ function applyOps(base, ops, fallback) {
             const fo = op;
             const existing = byFid.get(fo.fid) || byText.get((0, ops_js_1.normalizeText)(fo.text));
             if (existing) {
+                const before = JSON.stringify([existing.reference, existing.temporal, existing.verification_invalidated_at]);
+                (0, evidence_js_1.mergeFactEvidence)(existing, { reference: fo.reference, temporal: fo.temporal, verification_invalidated_at: fo.verification_invalidated_at });
+                if (JSON.stringify([existing.reference, existing.temporal, existing.verification_invalidated_at]) !== before)
+                    report.metadata_updated++;
                 // Same fact from two people. Keep the earliest date so provenance
                 // reflects who knew it first, and the higher confidence.
                 existing.id = existing.id || fo.fid;
@@ -190,6 +196,7 @@ function applyOps(base, ops, fallback) {
                 fact.keys = fo.keys.slice(0, 8);
             if ((0, shelf_js_1.isShelfLife)(fo.shelf))
                 fact.shelf_life = fo.shelf;
+            (0, evidence_js_1.mergeFactEvidence)(fact, { reference: fo.reference, temporal: fo.temporal, verification_invalidated_at: fo.verification_invalidated_at });
             neuron.facts.push(fact);
             byFid.set(fo.fid, fact);
             alias(fact);
@@ -233,9 +240,16 @@ function applyOps(base, ops, fallback) {
         if (!target)
             continue;
         const at = typeof vo.at === 'string' ? vo.at : undefined;
-        const nuevo = (0, shelf_js_1.latestOf)(target.verified, at);
-        if (nuevo && nuevo !== target.verified) {
-            target.verified = nuevo;
+        const verification = (0, evidence_js_1.readVerification)(vo.verification);
+        if (vo.verification !== undefined && (!verification || verification.at !== at))
+            continue;
+        const nuevo = (0, evidence_js_1.mergeCheck)(target, { verified: at, verification });
+        if (nuevo.verified && (nuevo.verified !== target.verified || JSON.stringify(nuevo.verification) !== JSON.stringify(target.verification))) {
+            target.verified = nuevo.verified;
+            if (nuevo.verification)
+                target.verification = nuevo.verification;
+            else
+                delete target.verification;
             report.verifications_updated++;
         }
     }
@@ -348,10 +362,17 @@ function applyOps(base, ops, fallback) {
         if (vo.ekind !== 'entry' || typeof vo.eid !== 'string' || !vo.eid)
             continue;
         const at = typeof vo.at === 'string' ? vo.at : undefined;
-        const previo = neuron.entry_verified?.[vo.eid];
-        const nuevo = (0, shelf_js_1.latestOf)(previo, at);
-        if (nuevo && nuevo !== previo) {
-            (neuron.entry_verified ||= {})[vo.eid] = nuevo;
+        const verification = (0, evidence_js_1.readVerification)(vo.verification);
+        if (vo.verification !== undefined && (!verification || verification.at !== at))
+            continue;
+        const previo = { verified: neuron.entry_verified?.[vo.eid], verification: neuron.entry_verification?.[vo.eid] };
+        const nuevo = (0, evidence_js_1.mergeCheck)(previo, { verified: at, verification });
+        if (nuevo.verified && (nuevo.verified !== previo.verified || JSON.stringify(nuevo.verification) !== JSON.stringify(previo.verification))) {
+            (neuron.entry_verified ||= {})[vo.eid] = nuevo.verified;
+            if (nuevo.verification)
+                (neuron.entry_verification ||= {})[vo.eid] = nuevo.verification;
+            else if (neuron.entry_verification)
+                delete neuron.entry_verification[vo.eid];
             report.verifications_updated++;
         }
     }
@@ -483,6 +504,10 @@ function applyOps(base, ops, fallback) {
             delete neuron.entry_verified;
     }
     report.authors = [...new Set(ops.map(o => o.by).filter(Boolean))].sort();
+    (0, evidence_js_1.mergeEntryEvidence)(neuron, neuron, new Set([
+        ...neuron.decisions.map(d => d.text), ...neuron.patterns, ...neuron.preferences,
+        ...(neuron.errors || []), ...(neuron.debts || []),
+    ].map(ops_js_1.entryId)));
     return { neuron, report };
 }
 //# sourceMappingURL=materialize.js.map