@claude-flow/cli 3.56.9 → 3.57.0

package/dist/src/services/policy-anchor-log.js

@@ -0,0 +1,242 @@
+/** Streaming reader/writer for the existing version-1 anchor JSON object.
+ * Every entry is still parsed and authenticated by the caller. This bounds
+ * memory without weakening historical validation or changing the log format.
+ */
+import { closeSync, constants, fstatSync, openSync, readSync, writeSync } from 'node:fs';
+import { TextDecoder } from 'node:util';
+export const ATOMIC_JSON_WRITER = Symbol('policy-atomic-json-writer');
+const CHUNK_BYTES = 64 * 1024;
+const VALUE_LIMIT = 16 * 1024 * 1024;
+const STRING_STRUCTURE = /["\\]/g;
+const VALUE_STRUCTURE = /["\\{}\[\]]/g;
+class JsonReader {
+    fd;
+    buffer = Buffer.allocUnsafe(CHUNK_BYTES);
+    decoder = new TextDecoder('utf-8', { fatal: true });
+    text = '';
+    cursor = 0;
+    position = 0;
+    ended = false;
+    constructor(file) {
+        this.fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+        try {
+            if (!fstatSync(this.fd).isFile())
+                throw new Error('policy-anchor-log-corrupt');
+        }
+        catch (error) {
+            closeSync(this.fd);
+            throw error;
+        }
+    }
+    close() { closeSync(this.fd); }
+    peek() {
+        while (this.cursor >= this.text.length && !this.ended) {
+            const count = readSync(this.fd, this.buffer, 0, this.buffer.length, this.position);
+            this.position += count;
+            this.text = this.decoder.decode(this.buffer.subarray(0, count), { stream: count !== 0 });
+            this.cursor = 0;
+            if (!count)
+                this.ended = true;
+        }
+        return this.text[this.cursor] ?? '';
+    }
+    next() { const character = this.peek(); if (character)
+        this.cursor++; return character; }
+    whitespace() { while (/[ \t\r\n]/.test(this.peek()) && this.peek())
+        this.next(); }
+    expect(character) { this.whitespace(); if (this.next() !== character)
+        throw new Error('policy-anchor-log-corrupt'); }
+    value() {
+        this.whitespace();
+        const first = this.peek();
+        if (!first)
+            throw new Error('policy-anchor-log-corrupt');
+        const compound = first === '{' || first === '[';
+        const string = first === '"';
+        const parts = [];
+        let bytes = 0;
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (;;) {
+            if (!this.peek()) {
+                if (quoted || depth !== 0 || !parts.length)
+                    throw new Error('policy-anchor-log-corrupt');
+                break;
+            }
+            const start = this.cursor;
+            let end = start;
+            let complete = false;
+            // Scan the available segment directly. Avoid per-character method,
+            // regular-expression and string-concatenation overhead on mature logs.
+            for (; end < this.text.length; end++) {
+                if (!escaped && (quoted || compound)) {
+                    const markers = quoted ? STRING_STRUCTURE : VALUE_STRUCTURE;
+                    markers.lastIndex = end;
+                    const next = markers.exec(this.text);
+                    if (!next) {
+                        end = this.text.length;
+                        break;
+                    }
+                    end = next.index;
+                }
+                const code = this.text.charCodeAt(end);
+                if (!quoted && depth === 0 && (parts.length > 0 || end > start) && !compound && !string
+                    && (code === 32 || code === 9 || code === 10 || code === 13 || code === 44 || code === 125 || code === 93)) {
+                    complete = true;
+                    break;
+                }
+                if (quoted) {
+                    if (escaped)
+                        escaped = false;
+                    else if (code === 92)
+                        escaped = true;
+                    else if (code === 34) {
+                        quoted = false;
+                        if (string && depth === 0) {
+                            end++;
+                            complete = true;
+                            break;
+                        }
+                    }
+                }
+                else if (code === 34)
+                    quoted = true;
+                else if (code === 123 || code === 91)
+                    depth++;
+                else if (code === 125 || code === 93) {
+                    depth--;
+                    if (depth < 0)
+                        throw new Error('policy-anchor-log-corrupt');
+                    if (compound && depth === 0) {
+                        end++;
+                        complete = true;
+                        break;
+                    }
+                }
+            }
+            const segment = this.text.slice(start, end);
+            bytes += Buffer.byteLength(segment);
+            if (bytes > VALUE_LIMIT)
+                throw new Error('policy-anchor-log-record-too-large');
+            if (segment)
+                parts.push(segment);
+            this.cursor = end;
+            if (complete)
+                break;
+        }
+        // JSON.parse validates the complete bounded token's grammar, including
+        // bracket kinds, escapes, control characters and scalar spellings.
+        return JSON.parse(parts.join(''));
+    }
+}
+/** Supports property order/whitespace from ordinary JSON writers. Unknown
+ * root values remain bounded and syntax-checked; duplicate known keys fail. */
+export function* anchorEntries(file) {
+    const reader = new JsonReader(file);
+    let version;
+    let seenVersion = false;
+    let seenEntries = false;
+    try {
+        reader.expect('{');
+        reader.whitespace();
+        if (reader.peek() === '}')
+            throw new Error('policy-anchor-log-corrupt');
+        for (;;) {
+            const key = reader.value();
+            if (typeof key !== 'string')
+                throw new Error('policy-anchor-log-corrupt');
+            reader.expect(':');
+            if (key === 'entries') {
+                if (seenEntries)
+                    throw new Error('policy-anchor-log-corrupt');
+                seenEntries = true;
+                reader.expect('[');
+                reader.whitespace();
+                if (reader.peek() !== ']') {
+                    for (;;) {
+                        yield reader.value();
+                        reader.whitespace();
+                        if (reader.peek() === ']')
+                            break;
+                        reader.expect(',');
+                    }
+                }
+                reader.expect(']');
+            }
+            else {
+                const value = reader.value();
+                if (key === 'version') {
+                    if (seenVersion)
+                        throw new Error('policy-anchor-log-corrupt');
+                    seenVersion = true;
+                    version = value;
+                }
+            }
+            reader.whitespace();
+            if (reader.peek() === '}')
+                break;
+            reader.expect(',');
+        }
+        reader.expect('}');
+        reader.whitespace();
+        if (reader.peek() || !seenEntries || !seenVersion || version !== 1)
+            throw new Error('policy-anchor-log-corrupt');
+    }
+    finally {
+        reader.close();
+    }
+}
+function writeText(fd, text) {
+    const bytes = Buffer.from(text);
+    let count = 0;
+    while (count < bytes.length) {
+        const next = writeSync(fd, bytes, count, bytes.length - count);
+        if (!next)
+            throw new Error('policy-anchor-log-short-write');
+        count += next;
+    }
+}
+/** Serialization callback runs inside the runtime's existing durable atomic
+ * writer. Failure removes the temporary file; no partial log is published. */
+export function appendedAnchorLog(file, next, validate) {
+    return { [ATOMIC_JSON_WRITER](fd) {
+            let pending = '';
+            let pendingBytes = 0;
+            const flush = () => { if (pendingBytes)
+                writeText(fd, pending); pending = ''; pendingBytes = 0; };
+            const emit = (text) => {
+                const bytes = Buffer.byteLength(text);
+                if (pendingBytes + bytes > CHUNK_BYTES)
+                    flush();
+                if (bytes >= CHUNK_BYTES)
+                    writeText(fd, text);
+                else {
+                    pending += text;
+                    pendingBytes += bytes;
+                }
+            };
+            emit('{"version":1,"entries":[\n');
+            let count = 0;
+            let previous = null;
+            if (file) {
+                for (const entry of anchorEntries(file)) {
+                    if (!validate(entry, count, previous))
+                        throw new Error('policy-anchor-log-corrupt');
+                    if (count)
+                        emit(',\n');
+                    emit(JSON.stringify(entry));
+                    count++;
+                    previous = entry.hash;
+                }
+            }
+            if (!validate(next, count, previous))
+                throw new Error('policy-anchor-log-corrupt');
+            if (count)
+                emit(',\n');
+            emit(JSON.stringify(next));
+            emit('\n]}\n');
+            flush();
+        } };
+}
+//# sourceMappingURL=policy-anchor-log.js.map

package/dist/src/services/policy-archive-scan.d.ts

@@ -0,0 +1,7 @@
+export interface ReverseRecord {
+    bytes: Buffer;
+    offset: number;
+    terminated: boolean;
+}
+export declare function reverseArchiveRecords(fd: number, size: number, limit: number): Generator<ReverseRecord>;
+//# sourceMappingURL=policy-archive-scan.d.ts.map

package/dist/src/services/policy-archive-scan.js

@@ -0,0 +1,50 @@
+/** Fixed-chunk reverse archive scan used by the synchronous anchor gate.
+ * Memory follows the largest single line, never the entire archive/window.
+ */
+import { readSync } from 'node:fs';
+const CHUNK_BYTES = 64 * 1024;
+export function* reverseArchiveRecords(fd, size, limit) {
+    let position = size;
+    let parts = [];
+    let partBytes = 0;
+    let terminated = false;
+    while (position > 0) {
+        const count = Math.min(CHUNK_BYTES, position);
+        position -= count;
+        const chunk = Buffer.allocUnsafe(count);
+        let read = 0;
+        while (read < count) {
+            const next = readSync(fd, chunk, read, count - read, position + read);
+            if (!next)
+                throw new Error('policy-ledger-archive-changed');
+            read += next;
+        }
+        let end = chunk.length;
+        for (;;) {
+            const newline = chunk.lastIndexOf(10, end - 1);
+            if (newline < 0)
+                break;
+            const piece = chunk.subarray(newline + 1, end);
+            if (piece.length + partBytes > limit)
+                throw new Error(`policy-ledger-archive-record-too-large:${limit}`);
+            const bytes = parts.length ? Buffer.concat([piece, ...parts], piece.length + partBytes) : Buffer.from(piece);
+            yield { bytes, offset: position + newline + 1, terminated };
+            terminated = true;
+            parts = [];
+            partBytes = 0;
+            end = newline;
+            if (end === 0)
+                break;
+        }
+        if (end > 0) {
+            if (partBytes + end > limit)
+                throw new Error(`policy-ledger-archive-record-too-large:${limit}`);
+            const piece = Buffer.from(chunk.subarray(0, end));
+            parts.unshift(piece);
+            partBytes += piece.length;
+        }
+    }
+    if (partBytes > 0)
+        yield { bytes: Buffer.concat(parts, partBytes), offset: 0, terminated };
+}
+//# sourceMappingURL=policy-archive-scan.js.map

package/dist/src/services/policy-ledger-anchor.d.ts

@@ -1,4 +1,5 @@
-import type { PolicyState } from '@claude-flow/security';
+import { type AtomicJsonSource } from './policy-anchor-log.js';
+import { type PolicyState } from '@claude-flow/security/policy/index';
 export type AnchorEvent = 'append' | 'migrated-from-state' | 'establish-anchor';
 export interface AnchorEntry {
     seq: number;
@@ -8,6 +9,15 @@ export interface AnchorEntry {
     ts: number;
     event: AnchorEvent;
     by?: string;
+    /**
+     * How much of the archive this anchor claims (`state.retainedFrom` at
+     * anchor time) and the hash of its newest archived receipt (#3892 Blocker
+     * 1). Absent on anchors written before this field existed, or for a
+     * ledger that has never been pruned — both resolve to a vacuous pass so
+     * the unpruned baseline stays byte-for-byte identical (see `entryHash`).
+     */
+    archivedThrough?: number;
+    archiveHeadHash?: string | null;
     hash: string;
 }
 export type AnchorAssessment = {
@@ -21,6 +31,7 @@ export type AnchorAssessment = {
     error: string;
 };
 export type AnchorWriter = (file: string, value: unknown) => Promise<void>;
+export type StreamingAnchorWriter = (file: string, value: AtomicJsonSource) => Promise<void>;
 export declare const anchorLogPath: (projectRoot: string) => string;
 /**
  * Directory holding per-project trust material (anchor mirror, HMAC key).
@@ -30,19 +41,14 @@ export declare const anchorLogPath: (projectRoot: string) => string;
  * user who already has trust state under the legacy ~/.config keeps using it.
  */
 export declare function policyTrustRoot(): string;
-/**
- * How the stored anchors relate to `state`; read-only. `rebuild` is the
- * explicit-establish path: an unreadable log or mirror is treated as absent, but
- * whatever readable anchor remains must still agree with the chain, so it can
- * never bless a truncation the anchors still remember.
- */
+/** Convert archive record-limit/UTF8 failures into structured gate failures. */
 export declare function assessAnchors(projectRoot: string, state: PolicyState, rebuild?: boolean): AnchorAssessment;
 /**
  * Append an entry for the current state if the newest entry does not already
  * describe it. Must run under the policy lock. Throws if the log is corrupt:
  * only an explicit establish may replace a corrupt log.
  */
-export declare function recordAnchor(projectRoot: string, state: PolicyState, write: AnchorWriter, event?: AnchorEvent, by?: string): Promise<void>;
+export declare function recordAnchor(projectRoot: string, state: PolicyState, write: AnchorWriter, event?: AnchorEvent, by?: string, writeLog?: StreamingAnchorWriter, assessedTip?: AnchorEntry): Promise<void>;
 export declare function anchorPosture(projectRoot: string): {
     log: boolean;
     mirror: boolean;