sparda-mcp 0.5.1 → 0.5.3

package/src/probe/probe.js

@@ -0,0 +1,243 @@
+/**
+ * SPARDA — Runtime Route Probe (orchestrator) v2
+ *
+ * Changes from v1:
+ *   - checkCommand: 1500 ms kill timeout (§A.6 / ANALYSE §4: Windows MS Store hang)
+ *   - FastAPI availability detection: spawnSync cross-platform, no shell string (§A.5.4)
+ *   - Everything else kept verbatim (§B)
+ *
+ * Exports: async probeRoutes({ framework, entryFile, projectRoot, timeoutMs })
+ *
+ * ESM, Node ≥ 18. Zero new dependencies.
+ */
+
+import { fork, spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath }           from 'node:url';
+import { dirname, resolve, extname } from 'node:path';
+import { platform }                from 'node:process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const SHIM_CJS = resolve(__dirname, 'express-shim.cjs');
+const SHIM_ESM = resolve(__dirname, 'express-shim-esm.mjs');
+const PY_PROBE = resolve(__dirname, 'fastapi-probe.py');
+
+const WRITE_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+
+// ── Public API ─────────────────────────────────────────────────────────────────
+
+export async function probeRoutes({ framework, entryFile, projectRoot, timeoutMs = 8000 }) {
+  if (framework === 'express') return probeExpress({ entryFile, projectRoot, timeoutMs });
+  if (framework === 'fastapi') return probeFastAPI({ entryFile, projectRoot, timeoutMs });
+  throw Object.assign(
+    new Error(`Unknown framework: ${framework}`),
+    { code: 'USER', hint: 'framework must be "express" or "fastapi"' }
+  );
+}
+
+// ── Express probe ─────────────────────────────────────────────────────────────
+
+async function probeExpress({ entryFile, projectRoot, timeoutMs }) {
+  const ext = extname(entryFile);
+
+  if (ext === '.ts' || ext === '.mts' || ext === '.cts') {
+    process.stderr.write(
+      '[sparda] --probe skipped: .ts entry needs a runtime loader; static discovery still applied.\n'
+    );
+    return [];
+  }
+
+  const isEsm    = ext === '.mjs';
+  const shimFlag = isEsm ? ['--import', SHIM_ESM] : ['--require', SHIM_CJS];
+
+  const routes = [];
+  let child;
+
+  return new Promise((resolve_) => {
+    let settled = false;
+    let killTimer;
+
+    function settle(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(killTimer);
+      try { child && child.kill('SIGKILL'); } catch {}
+      resolve_(result);
+    }
+
+    killTimer = setTimeout(() => {
+      process.stderr.write('[sparda] --probe: timeout waiting for Express routes; using static floor.\n');
+      settle(routes);
+    }, timeoutMs);
+
+    try {
+      child = fork(entryFile, [], {
+        cwd:      projectRoot,
+        execArgv: shimFlag,
+        silent:   true,
+        env:      { ...process.env, SPARDA_PROBE: '1' },
+      });
+    } catch (spawnErr) {
+      process.stderr.write(`[sparda] --probe: failed to spawn child: ${spawnErr.message}\n`);
+      clearTimeout(killTimer);
+      resolve_([]);
+      return;
+    }
+
+    child.stderr?.on('data', () => {});
+
+    child.on('message', (msg) => {
+      if (!msg || typeof msg !== 'object') return;
+      if (msg.type === '__done__') { settle(routes); return; }
+      if (msg.type === 'route') {
+        const method = normalizeMethod(msg.method);
+        const path   = normalizePath(msg.path);
+        routes.push({
+          method,
+          path,
+          pathParams: extractPathParams(path),
+          source:     'dynamic',
+          writeClass: WRITE_METHODS.has(method) ? 'write' : 'read',
+        });
+      }
+    });
+
+    child.on('error', (err) => {
+      process.stderr.write(`[sparda] --probe: child error: ${err.message}\n`);
+      settle(routes);
+    });
+
+    child.on('exit', () => settle(routes));
+  });
+}
+
+// ── FastAPI probe ─────────────────────────────────────────────────────────────
+
+async function probeFastAPI({ entryFile, projectRoot, timeoutMs }) {
+  const python = await resolvePython();
+  if (!python) {
+    process.stderr.write('[sparda] --probe: python3/python not found; static discovery still applied.\n');
+    return [];
+  }
+
+  return new Promise((resolve_) => {
+    let settled = false;
+    let killTimer;
+    const stdoutChunks = [];
+
+    function settle(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(killTimer);
+      try { child && child.kill(); } catch {}
+      resolve_(result);
+    }
+
+    killTimer = setTimeout(() => {
+      process.stderr.write('[sparda] --probe: FastAPI probe timeout; using static floor.\n');
+      settle(parsePythonOutput(Buffer.concat(stdoutChunks).toString('utf8')));
+    }, timeoutMs);
+
+    let child;
+    try {
+      child = spawn(python, [PY_PROBE, entryFile], {
+        cwd:   projectRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env:   { ...process.env, PYTHONIOENCODING: 'utf-8' },
+      });
+    } catch (err) {
+      process.stderr.write(`[sparda] --probe: failed to spawn python: ${err.message}\n`);
+      clearTimeout(killTimer);
+      resolve_([]);
+      return;
+    }
+
+    child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+    child.stderr?.on('data', () => {});
+    child.on('error', (err) => {
+      process.stderr.write(`[sparda] --probe: python child error: ${err.message}\n`);
+      settle([]);
+    });
+    child.on('exit', () => {
+      settle(parsePythonOutput(Buffer.concat(stdoutChunks).toString('utf8')));
+    });
+  });
+}
+
+function parsePythonOutput(raw) {
+  try {
+    const arr = JSON.parse(raw.trim());
+    if (!Array.isArray(arr)) return [];
+    return arr.map((r) => ({
+      method:     normalizeMethod(r.method),
+      path:       normalizeFastAPIParams(r.path ?? '/'),
+      pathParams: extractPathParams(r.path ?? '/'),
+      source:     'dynamic',
+      writeClass: WRITE_METHODS.has(normalizeMethod(r.method)) ? 'write' : 'read',
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// ── Python resolver (cross-platform, §A.5.4 + §A.6) ──────────────────────────
+//
+// §A.5.4: use spawnSync with separate args array — no shell string, works on
+//         Windows cmd.exe (no `||`, no `2>/dev/null`).
+// §A.6:   1500 ms timeout kills MS Store stub that never returns.
+
+async function resolvePython() {
+  const candidates = platform === 'win32'
+    ? ['python', 'python3']
+    : ['python3', 'python'];
+  for (const cmd of candidates) {
+    if (await checkCommand(cmd)) return cmd;
+  }
+  return null;
+}
+
+function checkCommand(cmd) {
+  return new Promise((res) => {
+    let child;
+    // §A.6: 1500 ms timeout — kills Microsoft Store python stub that hangs
+    const timer = setTimeout(() => {
+      try { child && child.kill(); } catch {}
+      res(false);
+    }, 1500);
+
+    try {
+      child = spawn(cmd, ['--version'], { stdio: 'ignore' });
+    } catch {
+      clearTimeout(timer);
+      res(false);
+      return;
+    }
+
+    child.on('error', () => { clearTimeout(timer); res(false); });
+    child.on('exit',  (code) => { clearTimeout(timer); res(code === 0); });
+  });
+}
+
+// ── Normalization helpers ─────────────────────────────────────────────────────
+
+function normalizeMethod(m) {
+  const upper = (m ?? 'GET').toUpperCase();
+  return upper === 'DEL' ? 'DELETE' : upper;
+}
+
+function normalizePath(p) {
+  return ('/' + (p ?? '').replace(/^\/+/, '')).replace(/\/+/g, '/') || '/';
+}
+
+function normalizeFastAPIParams(path) {
+  return (path ?? '/').replace(/\{([^}]+)\}/g, ':$1').replace(/\/+/g, '/') || '/';
+}
+
+function extractPathParams(path) {
+  const params = [];
+  for (const m of (path ?? '').matchAll(/:([a-zA-Z_]\w*)/g)) params.push(m[1]);
+  for (const m of (path ?? '').matchAll(/\{([^}]+)\}/g)) {
+    if (!params.includes(m[1])) params.push(m[1]);
+  }
+  return params;
+}

package/src/probe/reconcile.js

@@ -0,0 +1,160 @@
+/**
+ * SPARDA — Route Reconciler
+ *
+ * Pure function. No I/O. No side effects.
+ * Merges static (AST floor) + probe (runtime-observed) route sets.
+ *
+ * Contract:
+ *   - Static is the floor: a static route is always kept, never removed.
+ *   - A key in both → source:'static' wins, flagged confirmed:true.
+ *   - A key only in probe → source:'dynamic', pushed to gaps[].
+ *   - Same inputs → identical output (sorted deterministically).
+ *
+ * Canonical key = `${METHOD} ${normalizePath(path)}`
+ * normalizePath collapses :id, {id}, :anything → :param
+ * so Express and FastAPI param styles compare equal.
+ *
+ * ESM, Node ≥ 18. Zero deps.
+ */
+
+/**
+ * @typedef {Object} Route
+ * @property {'GET'|'POST'|'PUT'|'PATCH'|'DELETE'|'OPTIONS'|'HEAD'|'ALL'} method
+ * @property {string}  path         Express-style (/users/:id)
+ * @property {string[]} [pathParams]
+ * @property {'static'|'dynamic'|'hybrid'} source
+ * @property {boolean}  [confirmed]  true when found in both sets
+ * @property {'read'|'write'} [writeClass]
+ */
+
+/**
+ * @param {Route[]} staticRoutes   From parseExpressProject / parseFastAPIProject
+ * @param {Route[]} probedRoutes   From probeRoutes()
+ * @returns {{ routes: Route[], gaps: Route[], staticCount: number, dynamicCount: number }}
+ */
+export function reconcile(staticRoutes, probedRoutes) {
+  // Fast path: probe empty → return static unchanged
+  if (!probedRoutes || probedRoutes.length === 0) {
+    const sorted = sortRoutes([...staticRoutes]);
+    return {
+      routes:       sorted,
+      gaps:         [],
+      staticCount:  staticRoutes.length,
+      dynamicCount: 0,
+    };
+  }
+
+  // Index static routes by canonical key
+  const staticIndex = new Map();
+  for (const r of staticRoutes) {
+    const key = routeKey(r);
+    if (!staticIndex.has(key)) {
+      // Clone so we don't mutate the caller's objects
+      staticIndex.set(key, { ...r });
+    }
+  }
+
+  const gaps = [];
+
+  for (const dyn of probedRoutes) {
+    const key = routeKey(dyn);
+    if (staticIndex.has(key)) {
+      // Confirm: enrich the static entry
+      const existing = staticIndex.get(key);
+      existing.confirmed = true;
+      // source stays 'static' — static wins per spec
+    } else {
+      // Gap: probe found something the AST missed
+      const gap = {
+        method:     (dyn.method ?? 'GET').toUpperCase(),
+        path:       normalizeFastAPIParams(dyn.path ?? '/'),
+        pathParams: extractPathParams(dyn.path ?? '/'),
+        source:     'dynamic',
+        confirmed:  false,
+        writeClass: dyn.writeClass ?? inferWriteClass(dyn.method),
+      };
+      gaps.push(gap);
+    }
+  }
+
+  // Union: all static (some confirmed) + gaps
+  const union = [...staticIndex.values(), ...gaps];
+  const sorted = sortRoutes(union);
+
+  return {
+    routes:       sorted,
+    gaps,
+    staticCount:  staticRoutes.length,
+    dynamicCount: gaps.length,
+  };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Canonical key: METHOD + normalized path.
+ * /users/:id === /users/{id} === /users/:userId (all become /users/:param)
+ */
+function routeKey(route) {
+  const method = (route.method ?? 'GET').toUpperCase();
+  const path   = normalizePath(route.path ?? '/');
+  return `${method} ${path}`;
+}
+
+/**
+ * Collapse :param and {param} to :param, lowercase, deduplicate slashes.
+ * Used only for comparison (key generation).
+ */
+function normalizePath(path) {
+  return (path ?? '/')
+    .replace(/\{[^}]+\}/g,    ':param')   // FastAPI {id}
+    .replace(/:[a-zA-Z_]\w*/g, ':param')  // Express :id
+    .replace(/\*\*[^/]*/g,    ':wildcard') // FastAPI **rest
+    .replace(/\/+/g, '/')
+    .replace(/\/$/, '') // strip trailing slash (except root)
+    .toLowerCase()
+    || '/';
+}
+
+/**
+ * Normalize FastAPI {param} → :param for the stored path field.
+ * Express :param style is already canonical.
+ */
+function normalizeFastAPIParams(path) {
+  return (path ?? '/')
+    .replace(/\{([^}]+)\}/g, ':$1')  // {id} → :id
+    .replace(/\/+/g, '/')
+    || '/';
+}
+
+/** Extract ordered param names from a path (Express or FastAPI style). */
+function extractPathParams(path) {
+  const params = [];
+  // Express :param
+  for (const m of (path ?? '').matchAll(/:([a-zA-Z_]\w*)/g)) {
+    params.push(m[1]);
+  }
+  // FastAPI {param}
+  for (const m of (path ?? '').matchAll(/\{([^}]+)\}/g)) {
+    if (!params.includes(m[1])) params.push(m[1]);
+  }
+  return params;
+}
+
+function inferWriteClass(method) {
+  return ['POST', 'PUT', 'PATCH', 'DELETE'].includes((method ?? '').toUpperCase())
+    ? 'write'
+    : 'read';
+}
+
+/**
+ * Deterministic sort: by canonical key (METHOD path).
+ * Same inputs always produce the same order.
+ */
+function sortRoutes(routes) {
+  return routes.slice().sort((a, b) => {
+    const ka = routeKey(a);
+    const kb = routeKey(b);
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+}

package/src/server/condenser.js

@@ -1,9 +1,10 @@
-// server/condenser.js — ROADMAP round 2, brick 1: call-sequence recording (Labs).
+// server/condenser.js — call-sequence recording (Labs): detect tool-call circuits.
 // Deterministic, zero LLM, default OFF. Observes the session's current of tool
 // calls and detects circuits — an output value of call A feeding an argument of
 // a later call B. Persists STRUCTURE only (tool names, arg names, counts) into
 // sparda.json: payload values can be PII and the manifest is committed to git.
 import fs from 'node:fs';
+import { writeManifestSync } from './persistence.js';
 
 const WINDOW = 20;       // calls remembered per session (ring)
 const MAX_VALUES = 50;   // scalars kept per payload
@@ -80,7 +81,7 @@ export function createSequenceRecorder({ manifest, manifestPath, harvester, onCi
     try {
       const onDisk = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
       onDisk.labs = { ...onDisk.labs, circuits: manifest.labs.circuits };
-      fs.writeFileSync(manifestPath, JSON.stringify(onDisk, null, 2) + '\n');
+      writeManifestSync(manifestPath, onDisk);
     } catch { /* disk briefly unavailable — circuits stay in memory */ }
   }
 

package/src/server/confirmation.js

@@ -0,0 +1,165 @@
+// server/confirmation.js — Signal 2: out-of-band human approval the AI can never forge.
+//
+// Brief #1 (blast-radius). On MCP clients WITHOUT `elicitation`, SPARDA's two-phase write
+// confirmation was forgeable: the AI received a confirm token (Signal 1, over stdio) and
+// replayed it itself via `sparda_confirm`, with no human in the loop. This module adds
+// Signal 2 — a click on a native OS dialog spawned on the operator's desktop, a channel a
+// prompt-injected (or otherwise misbehaving) AI cannot reach. A write proceeds only when
+// BOTH signals are present: Signal 1 is necessary-but-not-sufficient, by construction.
+//
+// Where it lives: the BRIDGE. Framework-agnostic — no template, no Express/FastAPI parity,
+// no R4/R6 surface. The host's confirm token (single-use, already bound host-side to
+// {tool, args}) is the key here, so no second binding is re-implemented in the bridge.
+// R1 (host never pays): the dialog is spawned async, on a *gated write* only — never on a
+// read, never on the request path; confirmWrite() is an O(1) map lookup. R8 (no new dep):
+// node:child_process only. value-free: the dialog shows method+path+token-prefix, never an
+// argument value. R2 (stdout is the protocol): the only log here (headless fail-closed)
+// goes to stderr.
+
+import { spawn } from 'node:child_process';
+
+// the human's approval window. Defaults to the host's confirm-token TTL so the dialog never
+// outlives the token it guards — both read the same env, kept in lockstep without coupling.
+const TIMEOUT_MS = Number(process.env.SPARDA_CONFIRM_TTL_MS ?? 120_000);
+const MAX_PENDING = 64; // R1: bounded RAM — far past any human's concurrent approvals
+const S1 = 'signal1_pending';
+const S2 = 'signal2_received';
+const DENIED = 'denied';
+
+const pendingWrites = new Map(); // token -> { state, expiresAt, label }
+
+// testability: tests inject a provider so `vitest run` never spawns a real dialog.
+let dialogProvider = null;
+
+function evictOldest() {
+  // bounded RAM: drop the entry nearest expiry (Map preserves insertion order).
+  const oldest = pendingWrites.keys().next().value;
+  if (oldest !== undefined) pendingWrites.delete(oldest);
+}
+
+function sweep(now = Date.now()) {
+  for (const [tok, e] of pendingWrites) if (now > e.expiresAt) pendingWrites.delete(tok);
+}
+
+// ── Signal 1: the AI proposed a gated write. Register it and open the dialog (async). ──
+// `token` is the host's single-use confirm nonce (the key); `label` is e.g. "POST /users/42".
+// Returns immediately (R1). Idempotent per token. No-op when token is not a non-empty string.
+export function initiateWrite({ token, label } = {}) {
+  if (typeof token !== 'string' || !token) return;
+  sweep();
+  if (pendingWrites.has(token)) return; // dialog already armed for this token
+  if (pendingWrites.size >= MAX_PENDING) evictOldest();
+  pendingWrites.set(token, { state: S1, expiresAt: Date.now() + TIMEOUT_MS, label: String(label ?? token.slice(0, 12)) });
+  // Signal 2 runs in parallel — it NEVER blocks the MCP response.
+  setImmediate(() => { requestSignal2(token).catch(() => markDenied(token)); });
+}
+
+// ── Pre-approval: the human already said yes out-of-band via native elicitation (client UI). ──
+// Marks Signal 2 satisfied WITHOUT a second prompt — no double-confirmation for elicitation clients.
+export function preapproveWrite(token) {
+  if (typeof token !== 'string' || !token) return;
+  sweep();
+  if (!pendingWrites.has(token) && pendingWrites.size >= MAX_PENDING) evictOldest();
+  pendingWrites.set(token, { state: S2, expiresAt: Date.now() + TIMEOUT_MS, label: 'elicitation' });
+}
+
+async function requestSignal2(token) {
+  const entry = pendingWrites.get(token);
+  if (!entry) return;
+  const approved = dialogProvider
+    ? await dialogProvider(entry.label, token)
+    : await openOSDialog(entry.label, token);
+  const e = pendingWrites.get(token);
+  if (!e || e.state !== S1) return; // consumed, expired, or pre-approved meanwhile
+  if (Date.now() > e.expiresAt) { pendingWrites.delete(token); return; }
+  e.state = approved ? S2 : DENIED;
+}
+
+function markDenied(token) {
+  const e = pendingWrites.get(token);
+  if (e && e.state === S1) e.state = DENIED;
+}
+
+// ── confirmWrite: what `sparda_confirm` calls before forwarding to the host. ──
+// Succeeds ONLY if Signal 2 was received. Burns the token on every terminal answer; an
+// awaiting-human answer is kept so the AI can retry once the operator approves.
+export function confirmWrite(token) {
+  if (typeof token !== 'string' || !token) return { ok: false, reason: 'invalid_input' };
+  sweep();
+  const entry = pendingWrites.get(token);
+  if (!entry) return { ok: false, reason: 'unknown_token' };
+  if (Date.now() > entry.expiresAt) { pendingWrites.delete(token); return { ok: false, reason: 'expired' }; }
+  switch (entry.state) {
+    case S1: return { ok: false, reason: 'awaiting_human' }; // keep — the AI must retry after the click
+    case DENIED: pendingWrites.delete(token); return { ok: false, reason: 'human_denied' };
+    case S2: pendingWrites.delete(token); return { ok: true }; // burn — single use
+    default: pendingWrites.delete(token); return { ok: false, reason: 'invalid_state' };
+  }
+}
+
+// Build the argv for a native yes/no dialog on this platform, or null when there is no
+// reachable display (→ caller fails closed). The message is handed to win32/darwin through
+// the child's env (SPARDA_DLG_MSG), never interpolated into a script — so no argument value
+// or injected string can break out into a shell. Linux passes it as a literal argv element
+// (spawn does not invoke a shell), which is equally injection-safe.
+export function buildDialogSpawn(platform, env, msg, title) {
+  if (platform === 'win32') {
+    // Windows PowerShell 5.1 (powershell.exe, always present) + WinForms MessageBox.
+    // TopMost owner form so the box surfaces; default button = No (deny). Yes → exit 0.
+    const ps = [
+      'Add-Type -AssemblyName System.Windows.Forms;',
+      '$o = New-Object System.Windows.Forms.Form -Property @{TopMost=$true};',
+      '$r = [System.Windows.Forms.MessageBox]::Show($o, $env:SPARDA_DLG_MSG, $env:SPARDA_DLG_TITLE,',
+      '[System.Windows.Forms.MessageBoxButtons]::YesNo, [System.Windows.Forms.MessageBoxIcon]::Warning,',
+      '[System.Windows.Forms.MessageBoxDefaultButton]::Button2);',
+      'if ($r -eq [System.Windows.Forms.DialogResult]::Yes) { exit 0 } else { exit 1 }',
+    ].join(' ');
+    return { cmd: 'powershell', args: ['-NoProfile', '-NonInteractive', '-STA', '-Command', ps] };
+  }
+  if (platform === 'darwin') {
+    // osascript reads the message from the inherited env (system attribute) — no interpolation.
+    const osa = 'display dialog (system attribute "SPARDA_DLG_MSG") with title (system attribute "SPARDA_DLG_TITLE") '
+      + 'buttons {"Deny", "Allow"} default button "Deny" cancel button "Deny" with icon caution';
+    return { cmd: 'osascript', args: ['-e', osa] };
+  }
+  // Linux/BSD: zenity needs an X or Wayland display. Without one, fail closed.
+  if (env.DISPLAY || env.WAYLAND_DISPLAY) {
+    return { cmd: 'zenity', args: ['--question', `--title=${title}`, `--text=${msg}`, '--ok-label=Allow', '--cancel-label=Deny', '--width=420'] };
+  }
+  return null; // headless → caller denies
+}
+
+function openOSDialog(label, token) {
+  return new Promise((resolve) => {
+    const title = 'SPARDA — Write confirmation';
+    const msg = `${label}\nToken: ${token.slice(0, 12)}…\n\nAllow this write on your live app?`;
+    const plan = buildDialogSpawn(process.platform, process.env, msg, title);
+    if (!plan) {
+      // R2: human log to stderr. Fail closed — no approval channel means no write.
+      process.stderr.write(`[sparda] no desktop display — write auto-denied (Signal 2 unreachable): ${label}\n`);
+      return resolve(false);
+    }
+    let proc;
+    try {
+      proc = spawn(plan.cmd, plan.args, {
+        env: { ...process.env, SPARDA_DLG_MSG: msg, SPARDA_DLG_TITLE: title },
+        windowsHide: true, // hide the helper console; the GUI dialog still shows
+      });
+    } catch {
+      return resolve(false); // spawner missing → deny
+    }
+    const timer = setTimeout(() => { try { proc.kill(); } catch { /* already gone */ } resolve(false); }, TIMEOUT_MS);
+    proc.on('close', (code) => { clearTimeout(timer); resolve(code === 0); });
+    proc.on('error', () => { clearTimeout(timer); resolve(false); }); // binary absent (e.g. no zenity) → deny
+  });
+}
+
+// test hooks: inject a fake dialog, inspect/clear the pending map. Never used in production.
+export const _confirmTestHooks = {
+  setDialogProvider: (fn) => { dialogProvider = fn; },
+  clearDialogProvider: () => { dialogProvider = null; },
+  getPendingCount: () => pendingWrites.size,
+  clearAll: () => pendingWrites.clear(),
+  TIMEOUT_MS,
+  MAX_PENDING,
+};