@intutic/mcp-governance-proxy 1.9.0 → 1.10.1

package/dist/session.js

@@ -0,0 +1,206 @@
+/**
+ * session.ts — SessionState: a proxy process's anomaly session state, shared
+ * with its sibling processes through Valkey when one is configured.
+ *
+ * ## Scope: one harness session, several processes
+ *
+ * The sync daemon wraps EACH MCP server entry with its own `McpGovernanceProxy`
+ * process (`mcpAutoWrite.ts`'s `wrapWithProxy`, in both `per-session` and
+ * `daemon` mode), so one harness session runs one proxy per wrapped server.
+ * This class holds the tool-call sequence and the per-detector reask counters
+ * the anomaly detectors read. Until Wave 5.3 (TD-437) that state was
+ * per-process only — a cross-server ping-pong was invisible, a reask budget
+ * reset per server and per restart — and the module doc claimed there was
+ * "no second instance to share state with", which was never true of the
+ * wrapping the daemon writes.
+ *
+ * Now, when `SessionState` is given a scope (`sessionScope.ts`: the workspace
+ * plus the parent harness process) and a store (`sessionStore.ts`: the
+ * Rust proxy's Valkey window shape under its own namespace), the sequence,
+ * the 60 s call window and the reask counters are read from and written to
+ * the shared window, so every sibling sees every sibling's calls. The
+ * in-process copy is still kept and is the fallback whenever the store is
+ * absent, not connected, slow or failing — never a hard dependency, and
+ * exactly today's behaviour in every one of those cases.
+ *
+ * Per process, deliberately: `toolsList` and `toolContractChanged` describe
+ * THIS process's server (TOFU pins per {workspace, server}), and `sessionId`
+ * is the random per-process id handed to WASM rules as `session_id`.
+ *
+ * @module
+ */
+import * as node_crypto from 'node:crypto';
+/**
+ * Ported from the Rust proxy's `TOOL_SEQUENCE_CAP` (referenced by
+ * `anchor_projection`'s doc comment in `detectors.rs`, which states the cap
+ * is 60 and that `ANCHOR_FREQ_SLOTS` (256) must exceed it) — same cap, same
+ * "oldest evicted first" rolling-window semantics.
+ */
+export const TOOL_SEQUENCE_CAP = 60;
+/** Rolling window Phase 3's `calls_last_60s` context field is computed over. */
+const CALLS_WINDOW_MS = 60_000;
+export class SessionState {
+    /** The shared-window scope, when this process has one. */
+    scope;
+    store;
+    /** The most recent write-behind, so tests can await it before reading back. */
+    lastWrite = Promise.resolve();
+    constructor(opts = {}) {
+        this.scope = opts.scope;
+        this.store = opts.scope ? opts.store : undefined;
+    }
+    /**
+     * A per-process identifier standing in for `RequestContext.session_id`
+     * (Phase 3, `wasm/context.ts`) — this proxy has no wire-level session id
+     * of its own (unlike the Rust LLM proxy, which reads one off the inbound
+     * request), so a random id generated once at process start is the honest
+     * substitute: stable for this process's lifetime, never claiming to be
+     * anything the harness itself asserted.
+     */
+    sessionId = node_crypto.randomUUID();
+    sequence = [];
+    /** Wall-clock time of each entry in `sequence`, same indices, same cap —
+     *  kept only for `callsInLastMs`; nothing else in this class reads it. */
+    timestamps = [];
+    /**
+     * The most recent TOFU check result for this session's server (tofu.ts,
+     * evaluated in `proxy.ts`'s response-direction `handleServerLine` — TOFU
+     * only ever runs against a `tools/list` RESPONSE, never a `tools/call`
+     * request, so this is the honest way to surface it to Phase 3's WASM
+     * context, which builds from the request-direction `interceptor.decide`
+     * pipeline). `undefined` until at least one `tools/list` response has been
+     * checked; a `'skipped'` TOFU outcome (no tools declared) leaves this
+     * unchanged rather than resetting it, since "skipped" asserts nothing
+     * about whether a mismatch was seen earlier.
+     */
+    toolContractChanged;
+    /**
+     * Reask attempt counts, keyed by detector id (Phase 2) or `wasm:<ruleId>`
+     * (Phase 3 — "a WASM rule's reask counter is independent of an anomaly
+     * detector's," per the Phase 3 spec). A lifetime-per-session count, not a
+     * consecutive-trip count: `mod.rs`'s own doc says "trips of the same
+     * finding in ONE SESSION," not "consecutive trips," and a lifetime count
+     * is also the simpler, harder-to-game reading — an agent alternating
+     * between tripping and briefly correcting could otherwise reset its way
+     * out of ever hardening.
+     */
+    reaskAttempts = new Map();
+    /**
+     * The most recent post-curation `tools/list` response this session saw —
+     * Phase 1's wiring already computes this array (allowlist filtering +
+     * operator overrides applied); the tool-poisoning detector (Phase 2) reads
+     * it from here rather than re-deriving it.
+     */
+    toolsList = [];
+    /**
+     * Append a tool name to the rolling window, evicting the oldest past the
+     * cap — locally always, and to the shared window as a write-behind when
+     * there is one (the tool-call path does not wait on it).
+     */
+    recordCall(toolName) {
+        const now = Date.now();
+        this.sequence.push(toolName);
+        this.timestamps.push(now);
+        if (this.sequence.length > TOOL_SEQUENCE_CAP) {
+            const drop = this.sequence.length - TOOL_SEQUENCE_CAP;
+            this.sequence.splice(0, drop);
+            this.timestamps.splice(0, drop);
+        }
+        if (this.store && this.scope) {
+            this.lastWrite = this.store.recordCall(this.scope, toolName, now).catch(() => false);
+        }
+    }
+    /**
+     * The window `decide()` evaluates against: the shared sequence plus the
+     * candidate when the shared window answers, else the per-process copy.
+     * `callsLast60s` excludes the candidate either way, matching what
+     * `callsInLastMs()` returns before the call is recorded.
+     */
+    async loadWindow(toolName) {
+        if (this.store && this.scope) {
+            const snapshot = await this.store.readWindow(this.scope, Date.now(), CALLS_WINDOW_MS);
+            if (snapshot) {
+                const next = [...snapshot.sequence, toolName];
+                return {
+                    prospective: next.length > TOOL_SEQUENCE_CAP ? next.slice(next.length - TOOL_SEQUENCE_CAP) : next,
+                    callsLast60s: snapshot.callsLast60s,
+                    shared: true,
+                };
+            }
+        }
+        return { prospective: this.prospectiveSequence(toolName), callsLast60s: this.callsInLastMs(), shared: false };
+    }
+    /**
+     * The reask ladder's counter, shared when the store answers. The local map
+     * is always bumped too, so a mid-ladder fallback keeps counting from where
+     * it was rather than restarting at one.
+     */
+    async incrReaskAttemptShared(key) {
+        const local = this.incrReaskAttempt(key);
+        if (this.store && this.scope) {
+            const shared = await this.store.incrReaskAttempt(this.scope, key);
+            if (shared !== undefined)
+                return shared;
+        }
+        return local;
+    }
+    /** Awaits the most recent write-behind; tests only. */
+    async flush() {
+        await this.lastWrite;
+    }
+    /**
+     * Calls recorded within the last `windowMs` — Phase 3's `calls_last_60s`
+     * context field. Bounded by `TOOL_SEQUENCE_CAP`'s own window like every
+     * other read of `sequence`/`timestamps`: a burst that outlasts 60 real
+     * calls undercounts, the same honest limit `TOOL_SEQUENCE_CAP` already
+     * imposes on every sequence-based detector.
+     */
+    callsInLastMs(windowMs = CALLS_WINDOW_MS) {
+        const cutoff = Date.now() - windowMs;
+        let count = 0;
+        for (const t of this.timestamps)
+            if (t >= cutoff)
+                count += 1;
+        return count;
+    }
+    setToolContractChanged(changed) {
+        this.toolContractChanged = changed;
+    }
+    /** `undefined` until at least one `tools/list` response has been TOFU-checked. */
+    getToolContractChanged() {
+        return this.toolContractChanged;
+    }
+    /** The recorded sequence, oldest first. */
+    getSequence() {
+        return this.sequence;
+    }
+    /**
+     * The sequence AS IF `toolName` were the next call — used to evaluate
+     * anomaly detectors BEFORE a decision is made, without mutating state.
+     * `interceptor.decide()` calls this to detect (e.g.) a fifth consecutive
+     * repeat on the call that WOULD BE the fifth, not the one after it;
+     * `recordCall` only actually persists the entry once the call is allowed
+     * (see `handleHarnessLine`, proxy.ts).
+     */
+    prospectiveSequence(toolName) {
+        const next = [...this.sequence, toolName];
+        return next.length > TOOL_SEQUENCE_CAP ? next.slice(next.length - TOOL_SEQUENCE_CAP) : next;
+    }
+    /** Increment and return this key's reask attempt count. */
+    incrReaskAttempt(key) {
+        const next = (this.reaskAttempts.get(key) ?? 0) + 1;
+        this.reaskAttempts.set(key, next);
+        return next;
+    }
+    /** Current reask attempt count for a key, `0` if it has never tripped. */
+    getReaskAttempts(key) {
+        return this.reaskAttempts.get(key) ?? 0;
+    }
+    setToolsList(tools) {
+        this.toolsList = [...tools];
+    }
+    getToolsList() {
+        return this.toolsList;
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/session.js.map

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

package/dist/sessionScope.d.ts

@@ -0,0 +1,51 @@
+/**
+ * sessionScope.ts — the shared-window scope a proxy process derives for
+ * itself (TD-437, Wave 5.3).
+ *
+ * The sync daemon wraps EACH MCP server entry with its own proxy process, so
+ * one harness session runs several `McpGovernanceProxy` processes at once —
+ * and the proxy has no wire-level session id: it never inspects `initialize`,
+ * no harness sets one, and the daemon writes static config files so it cannot
+ * inject a per-session value. What the sibling processes DO share is their
+ * parent: the harness process that spawned them (`wrapWithProxy` emits
+ * `command: 'node'` with no shell in between, and the MCP SDK spawns with
+ * `shell: false`). So the scope is the workspace plus the parent pid, plus a
+ * best-effort token derived from the parent's start time so a recycled pid on
+ * a long-lived machine cannot inherit a finished session's window.
+ *
+ * `undefined` means "no shareable identity" and the proxy keeps today's
+ * per-process window. A shell wrapper somewhere would give each proxy a
+ * distinct parent and degrade to exactly that — never merge two sessions.
+ *
+ * @module
+ */
+/** An explicit scope, for tests and for harnesses that can set one per session. */
+export declare const SESSION_SCOPE_ENV = "INTUTIC_MCP_SESSION_SCOPE";
+export interface SessionScopeInput {
+    workspaceId: string;
+    ppid: number;
+    parentStartToken?: string;
+    envOverride?: string;
+}
+/**
+ * Pure. Builds the scope string from its inputs, or `undefined` when there is
+ * no shareable identity (an orphaned process, `ppid <= 1`).
+ */
+export declare function buildSessionScope(input: SessionScopeInput): string | undefined;
+/**
+ * A short token identifying WHEN the parent process started, so that pid
+ * reuse cannot alias two sessions. Linux reads `/proc/<pid>/stat` field 22
+ * (starttime, in clock ticks since boot); macOS asks `ps` for `lstart`. Never
+ * throws and never takes longer than {@link START_TOKEN_TIMEOUT_MS}; any
+ * failure returns `undefined` and the scope goes without the token.
+ */
+export declare function readParentStartToken(ppid: number, platform?: NodeJS.Platform): Promise<string | undefined>;
+/**
+ * `/proc/<pid>/stat` is `pid (comm) state ppid …`; the comm may itself contain
+ * spaces and parentheses, so the fields are split AFTER the last `)`. Field 22
+ * (starttime) is index 19 of that remainder.
+ */
+export declare function startTokenFromProcStat(stat: string): string | undefined;
+/** The scope this process shares with its sibling proxies, or `undefined`. */
+export declare function deriveSessionScope(workspaceId: string): Promise<string | undefined>;
+//# sourceMappingURL=sessionScope.d.ts.map

package/dist/sessionScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionScope.d.ts","sourceRoot":"","sources":["../src/sessionScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AASH,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,8BAA8B,CAAA;AAK5D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS,CAS9E;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAelI;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMvE;AAMD,8EAA8E;AAC9E,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAKzF"}

package/dist/sessionScope.js

@@ -0,0 +1,94 @@
+/**
+ * sessionScope.ts — the shared-window scope a proxy process derives for
+ * itself (TD-437, Wave 5.3).
+ *
+ * The sync daemon wraps EACH MCP server entry with its own proxy process, so
+ * one harness session runs several `McpGovernanceProxy` processes at once —
+ * and the proxy has no wire-level session id: it never inspects `initialize`,
+ * no harness sets one, and the daemon writes static config files so it cannot
+ * inject a per-session value. What the sibling processes DO share is their
+ * parent: the harness process that spawned them (`wrapWithProxy` emits
+ * `command: 'node'` with no shell in between, and the MCP SDK spawns with
+ * `shell: false`). So the scope is the workspace plus the parent pid, plus a
+ * best-effort token derived from the parent's start time so a recycled pid on
+ * a long-lived machine cannot inherit a finished session's window.
+ *
+ * `undefined` means "no shareable identity" and the proxy keeps today's
+ * per-process window. A shell wrapper somewhere would give each proxy a
+ * distinct parent and degrade to exactly that — never merge two sessions.
+ *
+ * @module
+ */
+import * as node_crypto from 'node:crypto';
+import * as node_fs from 'node:fs/promises';
+import { execFile as node_execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(node_execFile);
+/** An explicit scope, for tests and for harnesses that can set one per session. */
+export const SESSION_SCOPE_ENV = 'INTUTIC_MCP_SESSION_SCOPE';
+/** How long the parent-start lookup may take before the scope goes without it. */
+const START_TOKEN_TIMEOUT_MS = 500;
+/**
+ * Pure. Builds the scope string from its inputs, or `undefined` when there is
+ * no shareable identity (an orphaned process, `ppid <= 1`).
+ */
+export function buildSessionScope(input) {
+    const override = input.envOverride?.trim();
+    if (override) {
+        const safe = override.replace(/[^A-Za-z0-9._-]/g, '').slice(0, 64);
+        if (safe)
+            return `${input.workspaceId}:mcp:env:${safe}`;
+    }
+    if (!Number.isInteger(input.ppid) || input.ppid <= 1)
+        return undefined;
+    const token = input.parentStartToken?.trim();
+    return token ? `${input.workspaceId}:mcp:${input.ppid}:${token}` : `${input.workspaceId}:mcp:${input.ppid}`;
+}
+/**
+ * A short token identifying WHEN the parent process started, so that pid
+ * reuse cannot alias two sessions. Linux reads `/proc/<pid>/stat` field 22
+ * (starttime, in clock ticks since boot); macOS asks `ps` for `lstart`. Never
+ * throws and never takes longer than {@link START_TOKEN_TIMEOUT_MS}; any
+ * failure returns `undefined` and the scope goes without the token.
+ */
+export async function readParentStartToken(ppid, platform = process.platform) {
+    try {
+        if (platform === 'linux') {
+            const stat = await node_fs.readFile(`/proc/${ppid}/stat`, 'utf8');
+            return startTokenFromProcStat(stat);
+        }
+        if (platform === 'darwin') {
+            const { stdout } = await execFile('ps', ['-o', 'lstart=', '-p', String(ppid)], { timeout: START_TOKEN_TIMEOUT_MS });
+            const lstart = stdout.trim();
+            return lstart ? hashToken(lstart) : undefined;
+        }
+    }
+    catch {
+        // Best effort: a missing /proc entry, a `ps` that is not there, a timeout.
+    }
+    return undefined;
+}
+/**
+ * `/proc/<pid>/stat` is `pid (comm) state ppid …`; the comm may itself contain
+ * spaces and parentheses, so the fields are split AFTER the last `)`. Field 22
+ * (starttime) is index 19 of that remainder.
+ */
+export function startTokenFromProcStat(stat) {
+    const close = stat.lastIndexOf(')');
+    if (close < 0)
+        return undefined;
+    const fields = stat.slice(close + 1).trim().split(/\s+/);
+    const starttime = fields[19];
+    return starttime && /^\d+$/.test(starttime) ? hashToken(starttime) : undefined;
+}
+function hashToken(raw) {
+    return node_crypto.createHash('sha256').update(raw).digest('hex').slice(0, 12);
+}
+/** The scope this process shares with its sibling proxies, or `undefined`. */
+export async function deriveSessionScope(workspaceId) {
+    const envOverride = process.env[SESSION_SCOPE_ENV];
+    const ppid = process.ppid;
+    const parentStartToken = envOverride ? undefined : await readParentStartToken(ppid);
+    return buildSessionScope({ workspaceId, ppid, parentStartToken, envOverride });
+}
+//# sourceMappingURL=sessionScope.js.map

package/dist/sessionScope.js.map

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

package/dist/sessionStore.d.ts

@@ -0,0 +1,69 @@
+/**
+ * sessionStore.ts — the Valkey-backed session window the sibling proxy
+ * processes of one harness session share (TD-437, Wave 5.3).
+ *
+ * The Rust LLM proxy keeps a session's tool-call history in Valkey
+ * (`store/valkey.rs`: a capped LIST for the sequence, a ZSET for the 60 s
+ * call window, an INCR counter per reask key). This is the same shape under
+ * its own namespace — `v2:mcpsession:` rather than the Rust `v2:session:` —
+ * because the two lists carry different things (harness-level tool names vs.
+ * LLM-proposed tool calls plus `action:` tokens) and must never read each
+ * other.
+ *
+ * Never a hard dependency. Every operation fails open to `undefined`/`false`
+ * and the caller (`SessionState`) falls back to its in-process window: when
+ * no URL is configured, when the client is not connected (`status !==
+ * 'ready'`, so an absent Valkey adds no latency), when a call takes longer
+ * than {@link SHARED_WINDOW_TIMEOUT_MS}, or on any error. The proxy behaves
+ * exactly as before Wave 5.3 in every one of those cases.
+ *
+ * @module
+ */
+/** A shared read or write that takes longer than this loses to the local window. */
+export declare const SHARED_WINDOW_TIMEOUT_MS = 200;
+/** Sliding lifetime of the sequence and call-window keys — the Rust `TOOL_SEQUENCE_TTL_SECS`. */
+export declare const SESSION_WINDOW_TTL_SECS = 86400;
+/** Lifetime of a reask allowance, set when the counter is created and never refreshed —
+ *  the Rust `REASK_WINDOW_SECS`. A slow drip must not become immortal. */
+export declare const REASK_WINDOW_SECS = 3600;
+export declare const sessionKeys: {
+    readonly tools: (scope: string) => string;
+    readonly calls: (scope: string) => string;
+    readonly reask: (scope: string, key: string) => string;
+};
+export interface SharedWindowSnapshot {
+    /** Oldest first, at most {@link TOOL_SEQUENCE_CAP} entries. */
+    sequence: string[];
+    /** Calls recorded in the window ending now, across every sibling process. */
+    callsLast60s: number;
+}
+export interface SharedSessionStore {
+    /** `undefined` = unavailable; the caller uses its local window. */
+    readWindow(scope: string, nowMs: number, windowMs: number): Promise<SharedWindowSnapshot | undefined>;
+    /** `false` = not recorded remotely; the local window still has it. */
+    recordCall(scope: string, toolName: string, nowMs: number): Promise<boolean>;
+    /** The count including this trip, or `undefined` when unavailable. */
+    incrReaskAttempt(scope: string, key: string): Promise<number | undefined>;
+    close(): Promise<void>;
+}
+export interface ValkeySessionStoreOptions {
+    timeoutMs?: number;
+}
+export declare class ValkeySessionStore implements SharedSessionStore {
+    private readonly client;
+    private readonly timeoutMs;
+    private warned;
+    constructor(url: string, opts?: ValkeySessionStoreOptions);
+    readWindow(scope: string, nowMs: number, windowMs: number): Promise<SharedWindowSnapshot | undefined>;
+    recordCall(scope: string, toolName: string, nowMs: number): Promise<boolean>;
+    incrReaskAttempt(scope: string, key: string): Promise<number | undefined>;
+    close(): Promise<void>;
+    /**
+     * The fail-open wrapper every operation goes through: nothing is attempted
+     * unless the client is connected, nothing waits longer than the timeout,
+     * and any failure is `undefined`.
+     */
+    private guarded;
+    private warnOnce;
+}
+//# sourceMappingURL=sessionStore.d.ts.map

package/dist/sessionStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStore.d.ts","sourceRoot":"","sources":["../src/sessionStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAUH,oFAAoF;AACpF,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAC3C,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,QAAS,CAAA;AAC7C;0EAC0E;AAC1E,eAAO,MAAM,iBAAiB,OAAQ,CAAA;AAEtC,eAAO,MAAM,WAAW;4BACP,MAAM;4BACN,MAAM;4BACN,MAAM,OAAO,MAAM;CAC1B,CAAA;AAEV,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAAA;IACrG,sEAAsE;IACtE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5E,sEAAsE;IACtE,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IACzE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,kBAAmB,YAAW,kBAAkB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAO;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,MAAM,CAAQ;gBAEV,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,yBAA8B;IAevD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAcrG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB5E,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IASzE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;;OAIG;YACW,OAAO;IAiBrB,OAAO,CAAC,QAAQ;CASjB"}

package/dist/sessionStore.js

@@ -0,0 +1,143 @@
+/**
+ * sessionStore.ts — the Valkey-backed session window the sibling proxy
+ * processes of one harness session share (TD-437, Wave 5.3).
+ *
+ * The Rust LLM proxy keeps a session's tool-call history in Valkey
+ * (`store/valkey.rs`: a capped LIST for the sequence, a ZSET for the 60 s
+ * call window, an INCR counter per reask key). This is the same shape under
+ * its own namespace — `v2:mcpsession:` rather than the Rust `v2:session:` —
+ * because the two lists carry different things (harness-level tool names vs.
+ * LLM-proposed tool calls plus `action:` tokens) and must never read each
+ * other.
+ *
+ * Never a hard dependency. Every operation fails open to `undefined`/`false`
+ * and the caller (`SessionState`) falls back to its in-process window: when
+ * no URL is configured, when the client is not connected (`status !==
+ * 'ready'`, so an absent Valkey adds no latency), when a call takes longer
+ * than {@link SHARED_WINDOW_TIMEOUT_MS}, or on any error. The proxy behaves
+ * exactly as before Wave 5.3 in every one of those cases.
+ *
+ * @module
+ */
+import * as node_crypto from 'node:crypto';
+import { Redis } from 'ioredis';
+import { createStderrLogger } from './stderrLog.js';
+import { describeConnectionError } from './valkeyErrors.js';
+import { TOOL_SEQUENCE_CAP } from './session.js';
+const log = createStderrLogger('mcp-proxy.sessionStore');
+/** A shared read or write that takes longer than this loses to the local window. */
+export const SHARED_WINDOW_TIMEOUT_MS = 200;
+/** Sliding lifetime of the sequence and call-window keys — the Rust `TOOL_SEQUENCE_TTL_SECS`. */
+export const SESSION_WINDOW_TTL_SECS = 86_400;
+/** Lifetime of a reask allowance, set when the counter is created and never refreshed —
+ *  the Rust `REASK_WINDOW_SECS`. A slow drip must not become immortal. */
+export const REASK_WINDOW_SECS = 3_600;
+export const sessionKeys = {
+    tools: (scope) => `v2:mcpsession:${scope}:tools`,
+    calls: (scope) => `v2:mcpsession:${scope}:calls`,
+    reask: (scope, key) => `v2:mcpsession:${scope}:reask:${key}`,
+};
+export class ValkeySessionStore {
+    client;
+    timeoutMs;
+    warned = false;
+    constructor(url, opts = {}) {
+        this.timeoutMs = opts.timeoutMs ?? SHARED_WINDOW_TIMEOUT_MS;
+        this.client = new Redis(url, {
+            lazyConnect: true,
+            // No offline queue: a command issued before the connection is up must
+            // fail now, not wait for a Valkey that may never answer.
+            enableOfflineQueue: false,
+            maxRetriesPerRequest: 1,
+            connectTimeout: 1000,
+            retryStrategy: (times) => Math.min(1000 * 2 ** Math.min(times, 5), 30_000),
+        });
+        this.client.on('error', (err) => this.warnOnce('Valkey session store unreachable', err));
+        void this.client.connect().catch((err) => this.warnOnce('Valkey session store connect failed', err));
+    }
+    async readWindow(scope, nowMs, windowMs) {
+        return this.guarded(async () => {
+            const results = await this.client
+                .pipeline()
+                .lrange(sessionKeys.tools(scope), 0, -1)
+                .zcount(sessionKeys.calls(scope), nowMs - windowMs, '+inf')
+                .exec();
+            const sequence = results?.[0]?.[1];
+            const calls = results?.[1]?.[1];
+            if (!Array.isArray(sequence) || results?.[0]?.[0] || results?.[1]?.[0])
+                return undefined;
+            return { sequence: sequence.map(String), callsLast60s: Number(calls ?? 0) || 0 };
+        });
+    }
+    async recordCall(scope, toolName, nowMs) {
+        const done = await this.guarded(async () => {
+            const tools = sessionKeys.tools(scope);
+            const calls = sessionKeys.calls(scope);
+            await this.client
+                .pipeline()
+                .rpush(tools, toolName)
+                .ltrim(tools, -TOOL_SEQUENCE_CAP, -1)
+                .expire(tools, SESSION_WINDOW_TTL_SECS)
+                .zremrangebyscore(calls, '-inf', nowMs - 60_000)
+                // A unique member per call, so two calls in the same millisecond are
+                // both counted.
+                .zadd(calls, nowMs, `${nowMs}-${node_crypto.randomUUID()}`)
+                .expire(calls, SESSION_WINDOW_TTL_SECS)
+                .exec();
+            return true;
+        });
+        return done === true;
+    }
+    async incrReaskAttempt(scope, key) {
+        return this.guarded(async () => {
+            const k = sessionKeys.reask(scope, key);
+            const n = await this.client.incr(k);
+            if (n === 1)
+                await this.client.expire(k, REASK_WINDOW_SECS);
+            return n;
+        });
+    }
+    async close() {
+        try {
+            await this.client.quit();
+        }
+        catch {
+            this.client.disconnect();
+        }
+    }
+    /**
+     * The fail-open wrapper every operation goes through: nothing is attempted
+     * unless the client is connected, nothing waits longer than the timeout,
+     * and any failure is `undefined`.
+     */
+    async guarded(op) {
+        if (this.client.status !== 'ready')
+            return undefined;
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(undefined), this.timeoutMs);
+            timer.unref();
+        });
+        try {
+            return await Promise.race([op(), timeout]);
+        }
+        catch (err) {
+            this.warnOnce('Valkey session store operation failed', err);
+            return undefined;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    warnOnce(msg, err) {
+        const detail = { err: describeConnectionError(err) };
+        if (this.warned) {
+            log.debug(detail, msg);
+            return;
+        }
+        this.warned = true;
+        log.warn(detail, `${msg} — falling back to the per-process session window`);
+    }
+}
+//# sourceMappingURL=sessionStore.js.map

package/dist/sessionStore.js.map

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