approval-md 0.0.1 → 0.2.0

package/dist/src/core/log.js

@@ -0,0 +1,546 @@
+/**
+ * Append-only event log writer (SPEC.md §8, `.approval/log/events.jsonl`).
+ *
+ * The log is the truth. This module is the *only* sanctioned way to put a line
+ * into it, and its public API deliberately exposes no mutation, reorder,
+ * rewrite, or truncate operation — there is nothing here to call that could
+ * disturb an existing byte. Reading, verifying, and projecting live elsewhere.
+ *
+ * Guarantees, in the order they are enforced by {@link appendEvent}:
+ *
+ * 1. **Exclusive access.** A dependency-free advisory lockfile (`<log>.lock`,
+ *    created `wx`) serializes the read-tail → compute → write sequence, so two
+ *    concurrent appenders cannot both read seq N and both write seq N+1.
+ * 1b. **Compare-and-append (APRV-20 finding B1).** The lock serializes *writes*,
+ *    but every caller that checks the log before appending — "no live request
+ *    exists", "this token is unspent", "the budget has room" — made that check
+ *    outside the lock, against a log that could have moved on before its own
+ *    append took the lock. {@link AppendOptions.expectedHead} closes that
+ *    window: the caller states the `(seq, hash)` it read, this module compares
+ *    it against the actual tail **under the lock**, and refuses `head-moved`
+ *    when they differ. Nothing is written. The refusal is deliberately *not*
+ *    retried here: only the caller knows whether re-deriving its decision
+ *    against the newer log is safe, so the core reports and stops.
+ * 2. **Refuse to build on a corrupt tail.** If the file's last line is
+ *    truncated (no terminating newline) or unparseable, the append is
+ *    rejected. Chaining onto a half-written record would bake the corruption
+ *    into every subsequent hash. Since APRV-206 that tail is read from the END
+ *    of the file rather than by reading the whole log: an append needs the last
+ *    line and nothing else, and paying one full read of an ever-growing file per
+ *    append put log length into the latency of every grant. Every refusal above
+ *    is unchanged, byte for byte.
+ * 3. **The runtime stamps the chain fields.** Callers supply content only;
+ *    `seq`, `prev`, `alg`, and `hash` are computed here. `alg` is always
+ *    `sha256/jcs` (SPEC.md §8 defines exactly one value at v0.1).
+ * 4. **Validate at the write boundary.** The complete record — chain fields
+ *    included — must pass the `event` JSON Schema before any byte is written.
+ *    On failure the file is left byte-identical and a structured error is
+ *    returned. Fail closed: nothing here throws a validation problem past the
+ *    caller as a partially-written line.
+ * 5. **One line, one write.** The stored line is the JCS canonicalization of
+ *    the complete record (`hash` included); the digest input is that same
+ *    canonicalization minus the `hash` field. One scheme, two inputs — a
+ *    verifier strips `hash` and re-derives. Appended with a single `write(2)`
+ *    on a handle opened `O_APPEND`.
+ *
+ * Determinism: `ts` is supplied by the caller. This module never reads the
+ * clock, because a hash-relevant field sourced from ambient state would make
+ * the log irreproducible.
+ */
+import { createHash } from "node:crypto";
+import { closeSync, fstatSync, mkdirSync, openSync, readSync, unlinkSync, writeSync, } from "node:fs";
+import { dirname } from "node:path";
+import { canonicalize, JcsError } from "./jcs.js";
+import { validate } from "./validate.js";
+/** SPEC.md §8: the hash scheme identifier stamped on every v0.1 record. */
+export const ALG = "sha256/jcs";
+/**
+ * SPEC.md §8: `prev` of the first record in a log. `null`, not a zero digest —
+ * the schema and the `genesis-null-prev` fixture both encode this choice.
+ */
+export const GENESIS_PREV = null;
+/**
+ * Why an append was refused. Every failure is one of these, never a throw.
+ *
+ * Frozen public API in the same sense the gate's refusal codes are: callers
+ * branch on these strings, so adding one is a spec change and renaming one is a
+ * breaking change. `head-moved` is the APRV-20 addition (finding B1), sanctioned
+ * by the human decision of 2026-08-07.
+ */
+export const APPEND_ERROR_CODES = [
+    /** The lockfile was held by another writer for longer than the timeout. */
+    "lock-timeout",
+    /** The file's last line is truncated or unparseable; nothing may chain onto it. */
+    "corrupt-tail",
+    /** The complete record failed the `event` schema at the write boundary. */
+    "validation",
+    /** The record could not be canonicalized (RFC 8785). */
+    "canonicalization",
+    /** The log could not be created, opened, or written. */
+    "io",
+    /**
+     * The caller supplied {@link AppendOptions.expectedHead} and the log's actual
+     * tail, read under the lock, is a different `(seq, hash)`. Someone appended
+     * between the caller's read and this append, so every read-dependent check the
+     * caller made is stale. Nothing was written.
+     */
+    "head-moved",
+];
+const DEFAULT_LOCK_TIMEOUT_MS = 2_000;
+const DEFAULT_LOCK_RETRY_MS = 20;
+/**
+ * Strip `hash` and canonicalize. Exported shape is documented on
+ * {@link computeRecordHash}; kept separate so hashing and verification cannot
+ * drift apart.
+ */
+function hashInput(record) {
+    const clone = { ...record };
+    delete clone["hash"];
+    return clone;
+}
+/**
+ * The record's digest under `alg: "sha256/jcs"`.
+ *
+ * Hash input = **the full record minus its `hash` property**, with `prev`
+ * included, serialized per RFC 8785 (JCS) and digested with SHA-256. Output is
+ * lowercase hex. Passing an already-hashed record is fine: the `hash` field is
+ * removed before canonicalization, so `computeRecordHash(r)` is stable whether
+ * or not `r` carries a digest.
+ */
+export function computeRecordHash(record) {
+    return createHash("sha256").update(canonicalize(hashInput(record)), "utf8").digest("hex");
+}
+/**
+ * Inverse of {@link computeRecordHash}: recompute and compare. Lives beside
+ * the writer so the two can never diverge; the M1 chain verifier consumes it.
+ */
+export function verifyRecordHash(record) {
+    try {
+        return computeRecordHash(record) === record.hash;
+    }
+    catch {
+        // A record that cannot be canonicalized cannot be authentic.
+        return false;
+    }
+}
+/** The stored line for a record: its canonical serialization (no newline). */
+export function serializeRecord(record) {
+    return canonicalize(record);
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function fail(code, message, errors) {
+    return { ok: false, error: errors === undefined ? { code, message } : { code, message, errors } };
+}
+/** Synchronous sleep with no dependency and no busy-spin. */
+function sleepSync(ms) {
+    const buffer = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(buffer, 0, 0, ms);
+}
+/**
+ * Acquire `<logPath>.lock` by `open(…, "wx")` — atomic create-or-fail, which
+ * needs no dependency and works on every platform Node supports. Retries with
+ * a fixed delay until `timeoutMs` elapses, then reports `lock-timeout`. A
+ * stale lock is never stolen: silently breaking someone else's lock is how two
+ * writers end up sharing a `seq`.
+ */
+function acquireLock(logPath, timeoutMs, retryMs) {
+    const path = `${logPath}.lock`;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            closeSync(openSync(path, "wx"));
+            return { ok: true, path };
+        }
+        catch (cause) {
+            const code = cause.code;
+            if (code !== "EEXIST") {
+                return {
+                    ok: false,
+                    error: { code: "io", message: `lockfile ${path} could not be created: ${errorMessage(cause)}` },
+                };
+            }
+            if (Date.now() >= deadline) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "lock-timeout",
+                        message: `another writer holds ${path}; gave up after ${timeoutMs}ms`,
+                    },
+                };
+            }
+            sleepSync(retryMs);
+        }
+    }
+}
+function releaseLock(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // Best effort: the lock is advisory and a failed unlink must not mask the
+        // append's own result.
+    }
+}
+/**
+ * How many bytes of the file's end {@link readLastLine} reads first, doubling
+ * until it has a whole line. One record of this log is a few hundred bytes, so
+ * a single read almost always suffices.
+ */
+const TAIL_WINDOW_BYTES = 64 * 1024;
+/** The byte a log line ends with. */
+const NEWLINE_BYTE = 0x0a;
+/**
+ * The file's final line, read from the END of the file rather than by reading
+ * the whole log (APRV-206).
+ *
+ * An append needs exactly two facts about the existing file: whether it ends
+ * with a newline, and what its last complete line says. Reading the entire log
+ * to learn them made every append — every grant, every tap — pay one full read
+ * of a file that only grows. This reads a window off the tail and doubles it
+ * until the window either contains a newline before the final one (so the last
+ * line is whole inside it) or has reached the start of the file.
+ *
+ * `last` is `null` for an empty file. `terminated` is false when the file's last
+ * byte is not a newline, which is the torn tail {@link readTail} refuses.
+ *
+ * The window is decoded as UTF-8 only after being cut at a newline boundary, so
+ * a multi-byte character can never be split across the cut: every byte of the
+ * returned line came from between two newlines (or from the start of the file).
+ */
+function readLastLine(logPath) {
+    let fd;
+    try {
+        fd = openSync(logPath, "r");
+    }
+    catch (cause) {
+        if (cause.code === "ENOENT") {
+            return { ok: true, last: null, terminated: true };
+        }
+        return {
+            ok: false,
+            error: { code: "io", message: `log ${logPath} could not be read: ${errorMessage(cause)}` },
+        };
+    }
+    try {
+        const size = fstatSync(fd).size;
+        if (size === 0)
+            return { ok: true, last: null, terminated: true };
+        for (let window = TAIL_WINDOW_BYTES;; window *= 2) {
+            const length = Math.min(window, size);
+            const start = size - length;
+            const buffer = Buffer.allocUnsafe(length);
+            // `read(2)` may return short. Loop until the window is full rather than
+            // trusting one call: a short read would leave uninitialised bytes in the
+            // buffer and a garbage "last line" built out of them.
+            for (let filled = 0; filled < length;) {
+                const got = readSync(fd, buffer, filled, length - filled, start + filled);
+                if (got === 0) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "io",
+                            message: `log ${logPath} ended early while reading its tail: wanted ${String(length)} bytes at offset ${String(start)}, got ${String(filled)}`,
+                        },
+                    };
+                }
+                filled += got;
+            }
+            const terminated = buffer[length - 1] === NEWLINE_BYTE;
+            // The last line runs from just after the newline before it, to the end of
+            // the file (minus its own terminator when it has one).
+            const end = terminated ? length - 1 : length;
+            const cut = buffer.lastIndexOf(NEWLINE_BYTE, end - 1);
+            if (cut === -1 && start > 0) {
+                // The line is longer than this window and the window does not reach the
+                // start of the file: widen and look again.
+                continue;
+            }
+            return {
+                ok: true,
+                last: buffer.toString("utf8", cut + 1, end),
+                terminated,
+            };
+        }
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: { code: "io", message: `log ${logPath} could not be read: ${errorMessage(cause)}` },
+        };
+    }
+    finally {
+        try {
+            closeSync(fd);
+        }
+        catch {
+            // Nothing actionable: the read is done and the result stands.
+        }
+    }
+}
+/**
+ * Determine the next `seq`/`prev` from the existing file. Refuses on any tail
+ * that is not a complete, parseable record: a missing trailing newline means a
+ * previous writer died mid-line, and chaining onto it would make the damage
+ * permanent.
+ */
+function readTail(logPath) {
+    const tailRead = readLastLine(logPath);
+    if (!tailRead.ok)
+        return { ok: false, error: tailRead.error };
+    if (tailRead.last === null)
+        return { ok: true, tail: { seq: 0, hash: GENESIS_PREV } };
+    if (!tailRead.terminated) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} ends without a newline: the last line is truncated, refusing to append onto a partial record`,
+            },
+        };
+    }
+    const last = tailRead.last;
+    if (last.trim().length === 0) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} ends with a blank line; refusing to append onto an ambiguous tail`,
+            },
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(last);
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} last line is not valid JSON (${errorMessage(cause)}); refusing to append`,
+            },
+        };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} last line is not a JSON object; refusing to append`,
+            },
+        };
+    }
+    const record = parsed;
+    const seq = record["seq"];
+    const hash = record["hash"];
+    if (typeof seq !== "number" || !Number.isInteger(seq) || seq < 1) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} last line has no usable integer "seq"; refusing to append`,
+            },
+        };
+    }
+    if (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash)) {
+        return {
+            ok: false,
+            error: {
+                code: "corrupt-tail",
+                message: `log ${logPath} last line has no usable 64-hex "hash"; refusing to append`,
+            },
+        };
+    }
+    return { ok: true, tail: { seq, hash } };
+}
+/**
+ * Evaluate the compare-and-append precondition against the tail read under the
+ * lock. Returns the refusal, or `null` when the append may proceed.
+ *
+ * `tail.hash === null` (with `seq` 0) is the empty log, which is exactly what
+ * `expectedHead: null` asserts. Anything else is a head that moved: the message
+ * names both heads because the operator's next question is always "moved to
+ * what?".
+ */
+function headPrecondition(logPath, expected, tail) {
+    const actual = tail.hash === null ? "empty" : `seq ${tail.seq} ${tail.hash}`;
+    if (expected === null) {
+        if (tail.hash === null)
+            return null;
+        return {
+            code: "head-moved",
+            message: `log ${logPath} was expected to be empty but its head is ${actual}; a record was appended between the caller's read and this append, so the checks that authorized it are stale. Nothing was written.`,
+        };
+    }
+    if (tail.seq === expected.seq && tail.hash === expected.hash)
+        return null;
+    return {
+        code: "head-moved",
+        message: `log ${logPath} head moved: expected seq ${expected.seq} ${expected.hash}, found ${actual}. A record was appended between the caller's read and this append, so the checks that authorized it are stale. Nothing was written; re-reading and re-deciding is the caller's choice, never this module's.`,
+    };
+}
+/**
+ * Build a complete record from caller content plus chain state. Property
+ * insertion order is irrelevant to the digest (JCS sorts keys) but is kept
+ * readable here for anyone eyeballing the code.
+ */
+function buildRecord(input, seq, prev) {
+    const record = {
+        seq,
+        ts: input.ts,
+        event: input.event,
+        actor: input.actor,
+        alg: ALG,
+        prev,
+        hash: "",
+    };
+    if (input.task !== undefined)
+        record.task = input.task;
+    if (input.action_key !== undefined)
+        record.action_key = input.action_key;
+    if (input.channel !== undefined)
+        record.channel = input.channel;
+    if (input.payload !== undefined)
+        record.payload = input.payload;
+    record.hash = computeRecordHash(record);
+    return record;
+}
+/**
+ * Append exactly one event to `logPath`, stamping `seq`, `prev`, `alg`, and
+ * `hash`.
+ *
+ * Returns a structured result rather than throwing: an append that cannot be
+ * made safely leaves the file byte-identical and says why.
+ *
+ * Pass {@link AppendOptions.expectedHead} whenever the append is authorized by
+ * something read from the log: the head is compared under the lock and a moved
+ * head refuses `head-moved` without writing.
+ */
+/**
+ * Hold `<logPath>.lock` for the whole of `run`, then release it.
+ *
+ * The lockfile exists so that a read-tail → compute → write sequence cannot
+ * interleave with another writer's. Some operations need that exclusion over a
+ * span much longer than one append: `approval log sync` (APRV-125) reads the
+ * chain, moves the file aside, lets git advance the committed baseline, and
+ * puts the chain back, and an append landing anywhere inside that window is
+ * exactly the interleaving that forked this repository's own log on 2026-08-20.
+ *
+ * The callback is handed no lock handle and no write primitive: this module
+ * still exposes nothing that mutates an existing byte, and a caller holding the
+ * lock has the same append-only API everyone else has. What it gains is the
+ * guarantee that nobody else is appending while it works.
+ */
+export function withAppendLock(logPath, run, options = {}) {
+    try {
+        mkdirSync(dirname(logPath), { recursive: true });
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: {
+                code: "io",
+                message: `log directory for ${logPath} could not be created: ${errorMessage(cause)}`,
+            },
+        };
+    }
+    const lock = acquireLock(logPath, options.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS, options.lockRetryMs ?? DEFAULT_LOCK_RETRY_MS);
+    if (!lock.ok)
+        return { ok: false, error: lock.error };
+    try {
+        return { ok: true, value: run() };
+    }
+    finally {
+        releaseLock(lock.path);
+    }
+}
+/**
+ * Listeners told that this process appended to a log (APRV-217).
+ *
+ * One subscriber exists: the verified-read cache, which marks the log it wrote
+ * for a full re-proof on its next read. It is a registration rather than a call
+ * into `core/state.ts` because a value import that way would close a cycle
+ * through `core/verify.ts`. Nothing a listener does can change what was
+ * appended — the append has already succeeded — and a listener that throws must
+ * not turn a written record into a failed one, so throws are swallowed.
+ */
+const appendListeners = [];
+/** Subscribe to successful appends. Process-wide, memory-only, additive. */
+export function onLogAppended(listener) {
+    appendListeners.push(listener);
+}
+function noteAppend(logPath) {
+    for (const listener of appendListeners) {
+        try {
+            listener(logPath);
+        }
+        catch {
+            // A bookkeeping listener may not un-write a record that is on disk.
+        }
+    }
+}
+export function appendEvent(logPath, input, options = {}) {
+    const held = withAppendLock(logPath, () => {
+        const tail = readTail(logPath);
+        if (!tail.ok)
+            return { ok: false, error: tail.error };
+        // Compare-and-append: the precondition is evaluated here, inside the lock,
+        // against the tail that was just read. Outside the lock it would be exactly
+        // the race it exists to close.
+        if (options.expectedHead !== undefined) {
+            const moved = headPrecondition(logPath, options.expectedHead, tail.tail);
+            if (moved !== null)
+                return { ok: false, error: moved };
+        }
+        let record;
+        let line;
+        try {
+            record = buildRecord(input, tail.tail.seq + 1, tail.tail.hash);
+            // Stored line = JCS of the complete record; digest input excluded `hash`.
+            line = serializeRecord(record);
+        }
+        catch (cause) {
+            if (cause instanceof JcsError) {
+                return fail("canonicalization", `record could not be canonicalized: ${cause.message}`);
+            }
+            return fail("canonicalization", `record could not be prepared: ${errorMessage(cause)}`);
+        }
+        // Write boundary: nothing reaches the file until the schema says yes.
+        const validation = validate("event", record, options.schemaDir === undefined ? {} : { schemaDir: options.schemaDir });
+        if (!validation.ok) {
+            return fail("validation", `event failed schema validation at the write boundary; log left unchanged`, validation.errors);
+        }
+        let fd;
+        try {
+            fd = openSync(logPath, "a");
+        }
+        catch (cause) {
+            return fail("io", `log ${logPath} could not be opened for append: ${errorMessage(cause)}`);
+        }
+        try {
+            // Single write syscall on an O_APPEND handle: the line lands whole or not at all.
+            writeSync(fd, `${line}\n`);
+        }
+        catch (cause) {
+            return fail("io", `log ${logPath} could not be written: ${errorMessage(cause)}`);
+        }
+        finally {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Nothing actionable; the data is already handed to the kernel.
+            }
+        }
+        return { ok: true, record, line };
+    }, options);
+    const result = held.ok ? held.value : { ok: false, error: held.error };
+    // After the lock is released and only for a record that actually landed: the
+    // reader cache must not serve a prefix proof anchored before this write.
+    if (result.ok)
+        noteAppend(logPath);
+    return result;
+}
+//# sourceMappingURL=log.js.map

package/dist/src/core/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sourceRoot":"","sources":["../../../src/core/log.ts"],"names":[],"mappings":"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"}