@ouro.bot/cli 0.1.0-alpha.893 → 0.1.0-alpha.894

package/dist/senses/cmux/casebook.js

@@ -0,0 +1,416 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPLY_HISTORY_MS = void 0;
+exports.cmuxCasebookPath = cmuxCasebookPath;
+exports.cmuxDecisionLogPath = cmuxDecisionLogPath;
+exports.storeShape = storeShape;
+exports.isShape = isShape;
+exports.loadCasebook = loadCasebook;
+exports.readCasebook = readCasebook;
+exports.findPrecedent = findPrecedent;
+exports.addCase = addCase;
+exports.withDecisionLock = withDecisionLock;
+exports.appendDecision = appendDecision;
+exports.readDecisionLog = readDecisionLog;
+exports.readDecisions = readDecisions;
+exports.repliesInWindow = repliesInWindow;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const redact_1 = require("./redact");
+const MAX_CASES = 2_000;
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+const LOCK_WAIT_MS = 5_000;
+const STALE_LOCK_MS = 30_000;
+const TOMBSTONE_KEEP_MS = 5 * 60_000;
+const heldLocks = new Set();
+/** How long reply records survive log rotation; the standing grant's window may not be longer. */
+exports.REPLY_HISTORY_MS = 31 * 24 * 60 * 60_000;
+const LOST_TAKEOVER = new Set(["ENOENT", "ENOTEMPTY", "EEXIST"]);
+function cmuxCasebookPath(stateDir) {
+    return path.join(stateDir, "casebook.json");
+}
+function cmuxDecisionLogPath(stateDir) {
+    return path.join(stateDir, "decisions.jsonl");
+}
+function ensurePrivateDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+}
+function storeShape(shape) {
+    return {
+        repoRoot: shape.repoRoot,
+        tool: shape.tool,
+        digest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(shape.tokens)).digest("hex"),
+        preview: (0, redact_1.redactSecrets)(shape.tokens.join(" ")).slice(0, 300),
+    };
+}
+function isShape(value) {
+    const shape = value;
+    return !!shape && typeof shape === "object" && typeof shape.repoRoot === "string" && typeof shape.tool === "string"
+        && typeof shape.digest === "string" && typeof shape.preview === "string";
+}
+/** A schema-1 shape kept the raw command tokens; it migrates to a digest and a redacted preview. */
+function isLegacyShape(value) {
+    const shape = value;
+    return !!shape && typeof shape === "object" && typeof shape.repoRoot === "string" && typeof shape.tool === "string"
+        && Array.isArray(shape.tokens) && shape.tokens.every((token) => typeof token === "string");
+}
+function isVerdict(value) {
+    return value === "once" || value === "ask";
+}
+/**
+ * Reads the casebook. Schema-1 cases are converted to the stored shape (digest and redacted
+ * preview). A casebook that exists but cannot be read, or holds a case that is neither shape, is
+ * reported as a problem instead of being skipped, because a skipped "ask" precedent would let a
+ * request through that the human asked to be asked about.
+ */
+function loadCasebook(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf-8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { cases: [], problem: null, migrated: 0 };
+        return { cases: [], problem: `the cmux casebook cannot be read: ${error.message}`, migrated: 0 };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { cases: [], problem: "the cmux casebook is not valid JSON", migrated: 0 };
+    }
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.cases))
+        return { cases: [], problem: "the cmux casebook has no case list", migrated: 0 };
+    const cases = [];
+    let migrated = 0;
+    for (const value of parsed.cases) {
+        const entry = value;
+        if (!entry || typeof entry !== "object" || !isVerdict(entry.verdict))
+            return { cases: [], problem: "the cmux casebook holds a case it cannot read", migrated: 0 };
+        if (isShape(entry.shape)) {
+            cases.push(entry);
+        }
+        else if (isLegacyShape(entry.shape)) {
+            cases.push({ ...entry, shape: storeShape(entry.shape) });
+            migrated += 1;
+        }
+        else {
+            return { cases: [], problem: "the cmux casebook holds a case it cannot read", migrated: 0 };
+        }
+    }
+    return { cases, problem: null, migrated };
+}
+function writeCasebook(file, cases) {
+    ensurePrivateDir(path.dirname(file));
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify({ schemaVersion: 2, cases }, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+/**
+ * The casebook's cases, with schema-1 cases rewritten on disk as digests so raw command words
+ * leave the file. Throws while the casebook has a problem, so callers fail closed.
+ */
+function readCasebook(file) {
+    const first = loadCasebook(file);
+    if (first.problem)
+        throw new Error(first.problem);
+    if (first.migrated === 0)
+        return first.cases;
+    return withDecisionLock(path.dirname(file), () => {
+        const current = loadCasebook(file);
+        if (current.problem)
+            throw new Error(current.problem);
+        if (current.migrated > 0) {
+            writeCasebook(file, current.cases);
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_casebook_migrated", message: "migrated schema-1 cmux precedents to digests", meta: { migrated: current.migrated } });
+        }
+        return current.cases;
+    });
+}
+/** The newest precedent for exactly this shape; a later "ask" overrides an earlier "once" and the reverse. */
+function findPrecedent(cases, shape) {
+    const want = storeShape(shape);
+    for (let index = cases.length - 1; index >= 0; index -= 1) {
+        const have = cases[index].shape;
+        if (have.repoRoot === want.repoRoot && have.tool === want.tool && have.digest === want.digest)
+            return cases[index];
+    }
+    return null;
+}
+function addCase(file, input) {
+    const entry = { id: `case-${(0, node_crypto_1.randomUUID)()}`, at: input.at, verdict: input.verdict, shape: input.shape, requestId: input.requestId, note: (0, redact_1.redactSecrets)(input.note).slice(0, 500) };
+    withDecisionLock(path.dirname(file), () => {
+        const current = loadCasebook(file);
+        if (current.problem)
+            throw new Error(current.problem);
+        writeCasebook(file, [...current.cases, entry].slice(-MAX_CASES));
+    });
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_case_added", message: "recorded a cmux precedent", meta: { verdict: entry.verdict, tool: entry.shape.tool } });
+    return entry;
+}
+function errorCode(error) {
+    return error.code;
+}
+/**
+ * Takes over a stale lock. Each contender renames the stale directory to its own tombstone, so two
+ * contenders never collide on one name, and then checks that the directory it moved is the stale one
+ * it judged. If a fresh lock replaced the stale one in between, the contender moved someone else's
+ * live lock: it puts that lock back and tries again from the start.
+ */
+function takeOverStaleLock(lock, staleIno) {
+    const tombstone = `${lock}.stale-${staleIno}-${process.pid}-${(0, node_crypto_1.randomUUID)()}`;
+    try {
+        fs.renameSync(lock, tombstone);
+    }
+    catch (error) {
+        // Another contender moved it first; the lock is not ours to take.
+        if (errorCode(error) === "ENOENT")
+            return;
+        throw error;
+    }
+    if (fs.statSync(tombstone).ino !== staleIno) {
+        try {
+            fs.renameSync(tombstone, lock);
+        }
+        catch (error) {
+            if (!LOST_TAKEOVER.has(errorCode(error)))
+                throw error;
+            // A third contender locked in the meantime and its lock is not empty; leave the moved lock as a tombstone.
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_lock_restore_failed", message: "could not put back a cmux decision log lock moved during a takeover", meta: { tombstone } });
+        }
+        return;
+    }
+    fs.writeFileSync(path.join(tombstone, "taken-over"), `${process.pid}\n`);
+    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_stale_lock_taken_over", message: "took over a stale cmux decision log lock", meta: { tombstone } });
+}
+/** Tombstones older than a few minutes can no longer be raced; removing them keeps the folder tidy. */
+function sweepTombstones(stateDir, now) {
+    for (const name of fs.readdirSync(stateDir)) {
+        if (!name.startsWith("decisions.lock.stale-"))
+            continue;
+        const tombstone = path.join(stateDir, name);
+        try {
+            if (now - fs.statSync(tombstone).mtimeMs <= TOMBSTONE_KEEP_MS)
+                continue;
+            // A tombstone holds only its marker file, so it is emptied file by file, never removed recursively.
+            for (const entry of fs.readdirSync(tombstone))
+                fs.unlinkSync(path.join(tombstone, entry));
+            fs.rmdirSync(tombstone);
+        }
+        catch {
+            // Another process swept it first.
+        }
+    }
+}
+/**
+ * Runs `fn` while holding the decision log's lock (an atomic `mkdir`), so the sense process and the
+ * agent's tool never both pass the grant's count cap. A lock older than 30 seconds is taken over
+ * (see `takeOverStaleLock`); a lock that disappears while being checked is simply tried again.
+ */
+function withDecisionLock(stateDir, fn, waitMs = LOCK_WAIT_MS) {
+    ensurePrivateDir(stateDir);
+    const lock = path.join(stateDir, "decisions.lock");
+    // `fn` is synchronous, so a nested call from inside it (an append while reserving a reply) already holds the lock.
+    if (heldLocks.has(lock))
+        return fn();
+    const deadline = Date.now() + waitMs;
+    let held;
+    for (;;) {
+        try {
+            fs.mkdirSync(lock);
+            held = fs.statSync(lock).ino;
+            break;
+        }
+        catch (error) {
+            if (errorCode(error) !== "EEXIST")
+                throw error;
+        }
+        let current = null;
+        try {
+            current = fs.statSync(lock);
+        }
+        catch (error) {
+            if (errorCode(error) !== "ENOENT")
+                throw error;
+        }
+        if (current === null)
+            continue;
+        if (Date.now() - current.mtimeMs > STALE_LOCK_MS) {
+            takeOverStaleLock(lock, current.ino);
+            if (Date.now() < deadline)
+                continue;
+        }
+        if (Date.now() >= deadline)
+            throw new Error("the cmux decision log is locked");
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+    }
+    heldLocks.add(lock);
+    try {
+        return fn();
+    }
+    finally {
+        heldLocks.delete(lock);
+        // Release only the lock this call made; if it was taken over meanwhile, the new holder keeps it.
+        try {
+            if (fs.statSync(lock).ino === held)
+                fs.rmdirSync(lock);
+        }
+        catch (error) {
+            if (errorCode(error) !== "ENOENT")
+                throw error;
+        }
+        sweepTombstones(stateDir, Date.now());
+    }
+}
+/**
+ * Rotates a full log under the lock. The active file becomes `.1`; reply records from the old `.1`
+ * that are younger than `REPLY_HISTORY_MS` start the new active file, so the grant's count never
+ * loses a reply that is still inside its window.
+ */
+function rotateIfFull(file, now) {
+    let size;
+    try {
+        size = fs.statSync(file).size;
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return;
+        throw error;
+    }
+    if (size <= MAX_LOG_BYTES)
+        return;
+    const keep = parseDecisions(readText(`${file}.1`)).filter((record) => record.outcome === "reply_sent" && Date.parse(record.at) > now - exports.REPLY_HISTORY_MS);
+    fs.renameSync(file, `${file}.1`);
+    if (keep.length > 0)
+        fs.writeFileSync(file, keep.map((record) => `${JSON.stringify(record)}\n`).join(""), { mode: 0o600 });
+}
+/**
+ * Appends one record under the decision log's lock. Free-text fields are redacted before the line is
+ * built, so every line stays valid JSON.
+ */
+function appendDecision(file, record) {
+    const safe = {
+        ...record,
+        cwd: record.cwd === null ? null : (0, redact_1.redactSecrets)(record.cwd),
+        floor: { verdict: record.floor.verdict, reason: (0, redact_1.redactSecrets)(record.floor.reason) },
+        authority: (0, redact_1.redactSecrets)(record.authority),
+        detail: (0, redact_1.redactSecrets)(record.detail).slice(0, 2_000),
+    };
+    withDecisionLock(path.dirname(file), () => {
+        rotateIfFull(file, Date.parse(record.at));
+        // A crash mid-append can leave a torn last line; end it first so it cannot swallow this record.
+        if (!endsWithNewline(file))
+            fs.appendFileSync(file, "\n", { mode: 0o600 });
+        fs.appendFileSync(file, `${JSON.stringify(safe)}\n`, { mode: 0o600 });
+        fs.chmodSync(file, 0o600);
+    });
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_decision_logged", message: "logged a cmux prompt decision", meta: { outcome: record.outcome, tool: record.tool, floor: record.floor.verdict } });
+}
+/** True when the file is missing, empty or ends with a newline. */
+function endsWithNewline(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return true;
+        throw error;
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        if (size === 0)
+            return true;
+        const last = Buffer.alloc(1);
+        fs.readSync(fd, last, 0, 1, size - 1);
+        return last[0] === 0x0a;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** A missing file reads as empty. Any other error throws, so a log that cannot be read never counts as having no replies. */
+function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf-8");
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+function parseDecisionLog(text) {
+    const log = { records: [], unreadable: 0 };
+    for (const line of text.split("\n")) {
+        if (line.trim() === "")
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (value && typeof value === "object" && typeof value.requestId === "string") {
+                log.records.push(value);
+                continue;
+            }
+        }
+        catch {
+            // Counted below.
+        }
+        log.unreadable += 1;
+    }
+    return log;
+}
+function parseDecisions(text) {
+    return parseDecisionLog(text).records;
+}
+/** Every logged decision, including the one rotated-out file, with a count of lines that could not be parsed. */
+function readDecisionLog(file) {
+    return parseDecisionLog(`${readText(`${file}.1`)}\n${readText(file)}`);
+}
+/** Every logged decision, oldest first, including the one rotated-out file. */
+function readDecisions(file) {
+    return readDecisionLog(file).records;
+}
+/**
+ * How many replies the sense sent inside the window. Every attempt counts, confirmed or not, and so
+ * does every line that cannot be parsed, because its time and outcome are unknown: the cap fails closed.
+ */
+function repliesInWindow(log, windowMs, now) {
+    return log.records.filter((record) => record.outcome === "reply_sent" && Date.parse(record.at) > now - windowMs).length + log.unreadable;
+}