@verax-ai/proxy 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { createProxy, LedgerDenyUnrecorded } from "./proxy.ts";
+export { loadPolicy } from "./policy.ts";
+export { FileLedger, MemoryLedger } from "./ledger.ts";
+export { explain } from "./explain.ts";
+export { approvePending, approvalsLogFor, enqueueApprovalCommand, loadApprovalsFromDir } from "./approvals.ts";
+export { loadEffectsFromDir, parseCardCsv, parseChannelJsonl, reconcile } from "./reconcile.ts";
+export { tenantKey } from "./tenant.ts";
+export { diskProbe } from "./disk.ts";
+export { checkpointsPath } from "./checkpoints.ts";
+export { signEffectAttestation } from "./ledger.ts";
+export { spokenReason } from "./spoken-reason.ts";
+export type { ApprovalRow, ApproveResult } from "./approvals.ts";
+export type { CardCsvOpts, ChannelRow, ReconcileReport } from "./reconcile.ts";
+export type { EffectSigner, ExplainChain, ExplainPair, ExplainFinding, ExplainOpts, ExplainResult, ExplainTrustRoot, ExplainWarning, ExtractWindow, Ledger, LedgerEffect, Policy, PolicyDecision, Principal, ProxyDeps, RecordSigner, ToolCall, ToolResult, WitnessClass, } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,17 @@
+export { createProxy, LedgerDenyUnrecorded } from "./proxy.js";
+export { loadPolicy } from "./policy.js";
+export { FileLedger, MemoryLedger } from "./ledger.js";
+export { explain } from "./explain.js";
+export { approvePending, approvalsLogFor, enqueueApprovalCommand, loadApprovalsFromDir } from "./approvals.js";
+export { loadEffectsFromDir, parseCardCsv, parseChannelJsonl, reconcile } from "./reconcile.js";
+export { tenantKey } from "./tenant.js";
+// The body writes checkpoints and signs its own effect attestations. Both were
+// reached through a relative path into this package, which only exists inside
+// this repository: a published body would have imported a file that is not there.
+// The disk seam is public for the same reason: a caller that drives the body
+// through this package must be able to inject a full disk into the very
+// instance the proxy uses. Deep imports are not in the exports map.
+export { diskProbe } from "./disk.js";
+export { checkpointsPath } from "./checkpoints.js";
+export { signEffectAttestation } from "./ledger.js";
+export { spokenReason } from "./spoken-reason.js";

package/dist/inputs.d.ts

@@ -0,0 +1,13 @@
+import type { DecisionInputs, InputsLog } from "./types.ts";
+export declare class MemoryInputsLog implements InputsLog {
+    private readonly rows;
+    append(ref: string, inputs: DecisionInputs): Promise<void>;
+    get(ref: string): Promise<DecisionInputs | null>;
+}
+export declare class FileInputsLog implements InputsLog {
+    private readonly dir;
+    constructor(dir: string);
+    append(ref: string, inputs: DecisionInputs): Promise<void>;
+    get(ref: string): Promise<DecisionInputs | null>;
+}
+export declare function inputsLogFor(ledger: object): InputsLog;

package/dist/inputs.js

@@ -0,0 +1,49 @@
+import { join } from "node:path";
+import { appendDurable, ledgerFs } from "./ledger.js";
+export class MemoryInputsLog {
+    rows = new Map();
+    async append(ref, inputs) {
+        this.rows.set(ref, inputs);
+    }
+    async get(ref) {
+        return this.rows.get(ref) ?? null;
+    }
+}
+export class FileInputsLog {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    async append(ref, inputs) {
+        await appendDurable(join(this.dir, "inputs.jsonl"), `${JSON.stringify({ ref, inputs })}\n`);
+    }
+    async get(ref) {
+        let text;
+        try {
+            text = await ledgerFs.readFile(join(this.dir, "inputs.jsonl"), "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return null;
+            throw err;
+        }
+        let found = null;
+        for (const line of text.split("\n")) {
+            if (line === "")
+                continue;
+            const row = JSON.parse(line);
+            if (row.ref === ref)
+                found = row.inputs;
+        }
+        return found;
+    }
+}
+const STASH = Symbol.for("verax.inputsLog");
+export function inputsLogFor(ledger) {
+    const bag = ledger;
+    if (bag[STASH])
+        return bag[STASH];
+    const log = typeof bag.dir === "string" ? new FileInputsLog(bag.dir) : new MemoryInputsLog();
+    bag[STASH] = log;
+    return log;
+}

package/dist/ledger.d.ts

@@ -0,0 +1,130 @@
+import { open, readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+/** I/O seam so append-cost tests can count rereads without mocking node:fs. */
+export declare const ledgerFs: {
+    readFile: typeof readFile;
+    readFileSync: typeof readFileSync;
+    open: typeof open;
+};
+import { type EffectRow, type SignedEffectExtract } from "@cedulon/effect-extract";
+import type { EffectSigner, ExtractWindow, Ledger, LedgerEffect, WitnessClass } from "./types.ts";
+import type { DecisionKind, SignedDecisionRecord } from "@cedulon/core";
+export type PermissionCheck = "owner-only" | "not checked on this platform";
+/** Write then fsync so a crash cannot drop a committed line. */
+export declare function appendDurable(path: string, line: string): Promise<void>;
+export type RemoteWitnessSign = (row: EffectRow, resultHash: string | undefined) => Promise<Pick<LedgerEffect, "receipt" | "attestation" | "witnessClass"> | null>;
+export declare function signEffectAttestation(row: EffectRow, witnessClass: WitnessClass, resultHash: string | undefined, signer: EffectSigner): Pick<LedgerEffect, "receipt" | "attestation">;
+/** Slim index row. The Ledger interface stays closed. */
+export type DecisionIndexRow = {
+    ref: string;
+    requestHash: string;
+    decision: DecisionKind;
+    reasonCode: string;
+    subject: string;
+    policyHash: string;
+    timestampMs: number;
+};
+export type ResolutionHit = {
+    ref: string;
+    kind: "allow" | "expired";
+};
+export declare class MemoryLedger implements Ledger {
+    readonly permissionCheck: PermissionCheck;
+    effectSigner?: EffectSigner;
+    private readonly _decisions;
+    private readonly _effects;
+    private readonly byRef;
+    private readonly resolvedBy;
+    private readonly reauthByHash;
+    private readonly countedAt;
+    countsReadable: boolean;
+    private readonly q;
+    lookupByRef(ref: string): DecisionIndexRow | null;
+    noteTenantRef(key: string, ref: string): void;
+    lookupResolvedBy(deferRef: string): ResolutionHit | null;
+    noteResolution(deferRef: string, hit: ResolutionHit): void;
+    lookupReauthByHash(requestHash: string): string | null;
+    countedTimes(): number[];
+    hasPrimaryEffect(ref: string): boolean;
+    appendDecision(signed: SignedDecisionRecord): Promise<void>;
+    appendDecisionChained(build: (prevRecordHash: string | null) => SignedDecisionRecord): Promise<void>;
+    appendEffect(row: EffectRow, witnessClass?: WitnessClass, resultHash?: string): Promise<void>;
+    private appendEffectUnlocked;
+    decisions(): Promise<SignedDecisionRecord[]>;
+    effects(): Promise<LedgerEffect[]>;
+    lastDecisionHash(): Promise<string | null>;
+    exportExtract(window: ExtractWindow, signer: EffectSigner): Promise<SignedEffectExtract>;
+}
+export declare class FileLedger implements Ledger {
+    readonly permissionCheck: PermissionCheck;
+    readonly dir: string;
+    effectSigner?: EffectSigner;
+    /** Optional signer in another process. Null means stay `self`. */
+    remoteWitness?: RemoteWitnessSign;
+    private readonly decisionsPath;
+    private readonly effectsPath;
+    private readonly lockPath;
+    private readonly q;
+    private readonly token;
+    private closed;
+    private lost;
+    private tailHash;
+    private readonly effectRefs;
+    private readonly byRef;
+    private readonly resolvedBy;
+    private readonly reauthByHash;
+    private readonly countedAt;
+    countsReadable: boolean;
+    private readonly copyDir;
+    private readonly heartbeatPath;
+    private decisionCount;
+    private effectCount;
+    constructor(dir: string);
+    /** After lock handoff a new instance reloads; the lost owner cannot append. */
+    private loadCaches;
+    /** Pair inputs.jsonl with decisions so a restart keeps per-tenant `_ref` keys. */
+    private loadTenantRefs;
+    /** Single pass over inputs.jsonl. FileInputsLog itself stays cache-less. */
+    private loadResolvedBy;
+    private lockBody;
+    private ownsLock;
+    /** Lock file on disk, not a process counter. */
+    lockStatus(): "held" | "free";
+    private markLost;
+    private assertOwned;
+    private lockedError;
+    private acquireLock;
+    close(): void;
+    appendDecision(signed: SignedDecisionRecord): Promise<void>;
+    appendDecisionChained(build: (prevRecordHash: string | null) => SignedDecisionRecord): Promise<void>;
+    appendEffect(row: EffectRow, witnessClass?: WitnessClass, resultHash?: string): Promise<void>;
+    private appendEffectUnlocked;
+    decisions(): Promise<SignedDecisionRecord[]>;
+    effects(): Promise<LedgerEffect[]>;
+    lastDecisionHash(): Promise<string | null>;
+    private lastDecisionHashUnlocked;
+    exportExtract(window: ExtractWindow, signer: EffectSigner): Promise<SignedEffectExtract>;
+    lookupByRef(ref: string): DecisionIndexRow | null;
+    noteTenantRef(key: string, ref: string): void;
+    lookupResolvedBy(deferRef: string): ResolutionHit | null;
+    noteResolution(deferRef: string, hit: ResolutionHit): void;
+    lookupReauthByHash(requestHash: string): string | null;
+    countedTimes(): number[];
+    hasPrimaryEffect(ref: string): boolean;
+    private pulse;
+    private storeEffect;
+}
+export declare function lookupDecisionByRef(ledger: Ledger, ref: string, key?: string): Promise<DecisionIndexRow | null>;
+export declare function noteTenantRef(ledger: Ledger, key: string, ref: string): void;
+export declare function lookupResolvedBy(ledger: Ledger, deferRef: string): ResolutionHit | null;
+export declare function noteResolution(ledger: Ledger, deferRef: string, hit: ResolutionHit): void;
+export declare function countedWork(ledger: Ledger, nowMs: number): {
+    ok: true;
+    minute: number;
+    day: number;
+} | {
+    ok: false;
+};
+export declare function lookupReauthByHash(ledger: Ledger, requestHash: string): Promise<string | null>;
+export declare function hasPrimaryEffect(ledger: Ledger, ref: string): Promise<boolean>;
+export declare function witnessClassSummary(effects: readonly LedgerEffect[]): Record<WitnessClass, number>;