toolfunnel 0.3.0

package/src/core/hook-runner.js

@@ -0,0 +1,346 @@
+'use strict';
+
+/**
+ * hook-runner.js — run ONE command hook and return a structured result.
+ *
+ * Authoritative contract: docs/HOOK_ENGINE.md §3 (two output protocols) and §4
+ * (the exact result shape). This module is backend-agnostic and has ZERO host-framework
+ * imports so it runs headless under `node --test`.
+ *
+ * Hard guarantee (§4): runHook NEVER rejects. A spawn failure or a timeout always
+ * resolves with the full result object (exitCode:-1, timedOut set appropriately,
+ * blocked:false).
+ */
+
+const { spawn, execFile } = require('node:child_process');
+const path = require('node:path');
+
+// Default HOOKS_DIR: <root>/src/hooks. __dirname is <root>/src/core, so up one.
+const DEFAULT_HOOKS_DIR = path.resolve(__dirname, '..', 'hooks');
+
+// Events whose exit-0 stdout is treated as injected context (§3-A, §1 table).
+const INJECTABLE_EVENTS = new Set(['SessionStart', 'UserPromptSubmit']);
+
+/**
+ * Decide whether a parsed stdout object should be treated as the §3-B JSON
+ * protocol. We only switch to the JSON interpretation when the object actually
+ * carries one of the protocol's known keys — otherwise an arbitrary JSON blob a
+ * hook happens to print should fall through to the exit-code protocol (§3:
+ * "Exit-code protocol wins if stdout is not valid JSON").
+ *
+ * @param {*} parsed
+ * @returns {boolean}
+ */
+function isKnownJsonProtocol(parsed) {
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return false;
+  }
+  return (
+    Object.prototype.hasOwnProperty.call(parsed, 'continue') ||
+    Object.prototype.hasOwnProperty.call(parsed, 'decision') ||
+    Object.prototype.hasOwnProperty.call(parsed, 'reason') ||
+    Object.prototype.hasOwnProperty.call(parsed, 'hookSpecificOutput')
+  );
+}
+
+/**
+ * Try to parse stdout as the JSON protocol. Returns the parsed object only if it
+ * is valid JSON AND carries known protocol keys; otherwise null (use exit-code
+ * protocol).
+ *
+ * @param {string} stdout
+ * @returns {object|null}
+ */
+function tryParseJsonProtocol(stdout) {
+  const trimmed = (stdout || '').trim();
+  if (!trimmed) return null;
+  // Cheap pre-check: protocol output is always a JSON object.
+  if (trimmed[0] !== '{') return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (_e) {
+    return null; // not valid JSON → exit-code protocol wins
+  }
+  return isKnownJsonProtocol(parsed) ? parsed : null;
+}
+
+/**
+ * Run a single command hook.
+ *
+ * @param {object} hookSpec  Resolved spec: { id, event, command, timeout(seconds), ... }.
+ * @param {object} payload   The stdin JSON object (built by events.js buildPayload).
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]              child working directory.
+ * @param {object} [opts.env]             extra env merged over process.env.
+ * @param {string} [opts.projectDir]      value for CLAUDE_PROJECT_DIR.
+ * @param {string} [opts.hooksDir]        value for HOOKS_DIR (default <root>/src/hooks).
+ * @param {AbortSignal} [opts.signal]      external cancellation; aborts the child.
+ * @returns {Promise<object>}  the §4 result shape. Never rejects.
+ */
+function runHook(hookSpec, payload, opts = {}) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+
+    const id = hookSpec && hookSpec.id != null ? hookSpec.id : null;
+    const event = hookSpec && hookSpec.event != null ? hookSpec.event : null;
+
+    // Build the immutable base of every result so any early exit is well-formed.
+    const baseResult = () => ({
+      id,
+      event,
+      exitCode: -1,
+      timedOut: false,
+      stdout: '',
+      stderr: '',
+      blocked: false,
+      stopLoop: false,
+      reason: null,
+      inject: null,
+      durationMs: 0,
+    });
+
+    // Guard: a malformed spec must not throw out of the runner (§4: never reject).
+    if (!hookSpec || typeof hookSpec.command !== 'string' || hookSpec.command.length === 0) {
+      const r = baseResult();
+      r.stderr = 'hook-runner: invalid hookSpec (missing command)';
+      r.durationMs = Date.now() - started;
+      resolve(r);
+      return;
+    }
+
+    // timeout is stored in SECONDS in the manifest → convert to ms (§4).
+    // Fall back to a sane default if absent or non-positive.
+    const timeoutSec =
+      typeof hookSpec.timeout === 'number' && hookSpec.timeout > 0 ? hookSpec.timeout : 60;
+    const timeoutMs = timeoutSec * 1000;
+
+    // Child env: inherit process.env, layer opts.env, then set the two paths the
+    // hook scripts rely on to resolve themselves (§4).
+    const hooksDir = opts.hooksDir || (opts.env && opts.env.HOOKS_DIR) || DEFAULT_HOOKS_DIR;
+    const projectDir =
+      opts.projectDir ||
+      (opts.env && opts.env.CLAUDE_PROJECT_DIR) ||
+      process.env.CLAUDE_PROJECT_DIR ||
+      // Project root is two levels above the hooks dir (<root>/src/hooks → <root>).
+      path.resolve(hooksDir, '..', '..');
+
+    const childEnv = Object.assign({}, process.env, opts.env || {}, {
+      CLAUDE_PROJECT_DIR: projectDir,
+      HOOKS_DIR: hooksDir,
+    });
+
+    // Own AbortController so we can enforce the timeout via kill, and chain any
+    // externally-supplied signal so the engine can cancel us too.
+    const controller = new AbortController();
+    const onExternalAbort = () => killChildTree();
+    if (opts.signal) {
+      if (opts.signal.aborted) controller.abort();
+      else opts.signal.addEventListener('abort', onExternalAbort, { once: true });
+    }
+
+    let child;
+    try {
+      child = spawn(hookSpec.command, {
+        shell: true, // run as a shell command line (bash/PowerShell-launched scripts)
+        cwd: opts.cwd || undefined,
+        env: childEnv,
+        signal: controller.signal,
+        windowsHide: true,
+      });
+    } catch (err) {
+      // Synchronous spawn failure (rare). Resolve, never throw.
+      cleanupSignal();
+      const r = baseResult();
+      r.stderr = `hook-runner: spawn failed: ${err && err.message ? err.message : String(err)}`;
+      r.durationMs = Date.now() - started;
+      resolve(r);
+      return;
+    }
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let settled = false;
+
+    // Kill the WHOLE child tree. On Windows, killing the shell (cmd.exe) does NOT
+    // kill its node/bash grandchildren — they orphan and hold the stdio pipes open,
+    // which prevents the parent process (and node:test) from ever exiting. taskkill
+    // /T tears down the tree so the pipes close and nothing lingers. (Real hooks
+    // that hang would orphan the same way, so this matters beyond the test suite.)
+    function killChildTree() {
+      try {
+        if (child && child.pid != null && process.platform === 'win32') {
+          execFile('taskkill', ['/pid', String(child.pid), '/T', '/F'], () => {});
+        } else if (child) {
+          child.kill('SIGKILL');
+        }
+      } catch (_e) {
+        try {
+          if (child) child.kill();
+        } catch (_e2) {
+          /* nothing more we can do */
+        }
+      }
+      try {
+        controller.abort();
+      } catch (_e) {
+        /* abort backstop */
+      }
+    }
+
+    // Hard timeout: kill the child tree; the 'close'/'error' handler resolves.
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killChildTree();
+    }, timeoutMs);
+    if (typeof timer.unref === 'function') timer.unref();
+
+    function cleanupSignal() {
+      if (opts.signal) opts.signal.removeEventListener('abort', onExternalAbort);
+    }
+
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      cleanupSignal();
+      result.durationMs = Date.now() - started;
+      resolve(result);
+    }
+
+    if (child.stdout) {
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => {
+        stdout += chunk;
+      });
+    }
+    if (child.stderr) {
+      child.stderr.setEncoding('utf8');
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+      });
+    }
+
+    // Write the payload to the child's stdin, then close it. Guard against EPIPE
+    // (child may exit before reading) — that must not throw the runner.
+    if (child.stdin) {
+      child.stdin.on('error', () => {
+        /* swallow EPIPE / write-after-end; the exit code is what matters */
+      });
+      try {
+        child.stdin.write(JSON.stringify(payload == null ? {} : payload));
+        child.stdin.end();
+      } catch (_e) {
+        // ignore — stdin write race; child outcome still resolves below
+      }
+    }
+
+    // Spawn / runtime error (ENOENT, abort, etc.). If it's the timeout abort we
+    // report timedOut; otherwise a non-blocking error with exitCode -1.
+    child.on('error', (err) => {
+      const r = baseResult();
+      r.stdout = stdout;
+      r.stderr = stderr || (err && err.message ? err.message : String(err));
+      if (timedOut) {
+        r.timedOut = true;
+        r.stderr = stderr || `hook-runner: timed out after ${timeoutMs}ms`;
+      }
+      // blocked stays false; exitCode stays -1 (§4).
+      finish(r);
+    });
+
+    child.on('close', (code, sig) => {
+      // If we aborted for the timeout, classify as timeout regardless of code.
+      if (timedOut) {
+        const r = baseResult();
+        r.stdout = stdout;
+        r.stderr = stderr || `hook-runner: timed out after ${timeoutMs}ms`;
+        r.timedOut = true; // exitCode -1, blocked false (§4)
+        finish(r);
+        return;
+      }
+
+      const r = baseResult();
+      r.stdout = stdout;
+      r.stderr = stderr;
+      // On a clean close, code is a number; if killed by signal, code is null.
+      r.exitCode = typeof code === 'number' ? code : -1;
+
+      // --- Protocol interpretation (§3) ---
+      // Exit 2 is ALWAYS stderr-blocking, and stdout/JSON is ignored on any
+      // non-zero exit — this matches real Claude Code (the JSON protocol is
+      // processed ONLY on a clean exit 0; on exit 2 the reason is stderr).
+      if (r.exitCode === 2) {
+        r.blocked = true;
+        r.reason = stderr != null && stderr.trim().length > 0 ? stderr.trim() : '';
+        finish(r);
+        return;
+      }
+
+      // B) Advanced / JSON protocol (§3-B) — honored only on exit 0.
+      const json = r.exitCode === 0 ? tryParseJsonProtocol(stdout) : null;
+
+      if (json) {
+        const hso =
+          json.hookSpecificOutput && typeof json.hookSpecificOutput === 'object'
+            ? json.hookSpecificOutput
+            : null;
+
+        // PreToolUse blocks via hookSpecificOutput.permissionDecision
+        // (allow|deny|ask), NOT top-level decision — this is the real Claude Code
+        // mechanism. "deny" blocks (reason = permissionDecisionReason). "allow"
+        // passes. "ask" has no interactive prompt in the autonomous host, so it
+        // is treated as non-blocking with the reason captured for context.
+        const permDecision =
+          hso && typeof hso.permissionDecision === 'string' ? hso.permissionDecision : null;
+        const permReason =
+          hso && typeof hso.permissionDecisionReason === 'string'
+            ? hso.permissionDecisionReason
+            : null;
+
+        // Top-level decision: real Claude Code defines only "block" here (for
+        // UserPromptSubmit / PostToolUse / Stop / PreCompact). There is no "approve".
+        const decision = json.decision;
+        const cont = json.continue;
+        const jsonReason = typeof json.reason === 'string' ? json.reason : null;
+        const additional =
+          hso && typeof hso.additionalContext === 'string' ? hso.additionalContext : null;
+
+        if (permDecision === 'deny') {
+          r.blocked = true;
+          r.reason = permReason != null ? permReason : jsonReason;
+          if (r.reason == null) r.reason = '';
+        } else if (decision === 'block') {
+          r.blocked = true;
+          r.reason = jsonReason; // block reason from JSON.reason (§4)
+        }
+        if (cont === false) {
+          r.stopLoop = true; // continue:false → stop the whole loop (§3-B, §4)
+        }
+        // additionalContext is the injected text when present (§3-B, §4).
+        if (additional !== null) {
+          r.inject = additional;
+        }
+        finish(r);
+        return;
+      }
+
+      // A) Simple / exit-code protocol (§3-A), exit 0.
+      if (r.exitCode === 0) {
+        // Success. For SessionStart / UserPromptSubmit, stdout IS the injection.
+        // For other events stdout is advisory only (captured, not injected).
+        if (INJECTABLE_EVENTS.has(event)) {
+          const out = stdout != null ? stdout.trim() : '';
+          r.inject = out.length > 0 ? out : null;
+        }
+      }
+      // Any other non-zero (non-2) code → non-blocking error: stderr captured,
+      // blocked stays false, reason stays null (§3-A).
+
+      finish(r);
+    });
+  });
+}
+
+module.exports = { runHook };

package/src/core/logger.js

@@ -0,0 +1,169 @@
+'use strict';
+
+/**
+ * logger.js — a toggleable JSONL activity/audit log for the gateway.
+ *
+ * DEFAULT OFF (privacy + lean). Nothing is written, and no files are created, unless
+ * logging has been explicitly enabled via setConfig(). A MISSING config file means
+ * disabled — the safe default — so a fresh checkout logs nothing.
+ *
+ * Design rules:
+ *   - Zero dependencies. Node built-ins only (fs, path). No transport, no SDK.
+ *   - Config is read FRESH on every call (no caching), so a toggle takes effect for the
+ *     very next event without a reconnect or restart.
+ *   - log() must NEVER throw. A logging failure (bad config, unwritable disk, full FS)
+ *     must never break a tool call or the gate. Everything is wrapped; failures are
+ *     swallowed silently.
+ *
+ * Paths are resolved against the repo root (two dirs up from src/core/). The configured
+ * log `path` may be relative (resolved against root) or absolute.
+ *
+ * Config file: <root>/logs/log.config.json
+ *   { "enabled": false, "path": "logs/toolfunnel.log.jsonl" }
+ *
+ * CommonJS only.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** Repo root: <root>/src/core/logger.js -> two dirs up. */
+const ROOT = path.resolve(__dirname, '..', '..');
+
+/** The toggle/config file. NOT created until setConfig() writes it. */
+const CONFIG_PATH = path.join(ROOT, 'logs', 'log.config.json');
+
+/** Safe defaults — used whenever the config file is absent or unreadable. */
+const DEFAULT_ENABLED = false;
+const DEFAULT_PATH = 'logs/toolfunnel.log.jsonl';
+
+/**
+ * Resolve a (possibly relative) log path against the repo root.
+ * @param {string} p
+ * @returns {string}
+ */
+function resolveLogPath(p) {
+  return path.isAbsolute(p) ? p : path.join(ROOT, p);
+}
+
+/**
+ * getConfig — the resolved { enabled, path }.
+ *
+ * Reads the config file fresh. A missing/unreadable/malformed file resolves to the
+ * safe defaults (disabled). Never throws.
+ *
+ * @returns {{ enabled: boolean, path: string }}
+ */
+function getConfig() {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { enabled: DEFAULT_ENABLED, path: DEFAULT_PATH };
+    }
+    return {
+      enabled: parsed.enabled === true,
+      path:
+        typeof parsed.path === 'string' && parsed.path.length > 0
+          ? parsed.path
+          : DEFAULT_PATH,
+    };
+  } catch (_err) {
+    // Missing file = disabled (the safe default); also covers unreadable/malformed.
+    return { enabled: DEFAULT_ENABLED, path: DEFAULT_PATH };
+  }
+}
+
+/**
+ * log — append one JSONL record IF logging is enabled, else a silent no-op.
+ *
+ * The record is the event fields plus a logger-stamped ISO-8601 "ts" timestamp.
+ * Resolves the configured path against root, mkdir -p its directory, and appends one
+ * line with fs.appendFileSync. NEVER throws — any failure is swallowed.
+ *
+ * @param {object} event arbitrary serialisable fields (e.g. { type, tool, decision }).
+ */
+function log(event) {
+  try {
+    const cfg = getConfig();
+    if (!cfg.enabled) return; // default-off: no-op, no file created.
+
+    const record = Object.assign(
+      { ts: new Date().toISOString() },
+      event && typeof event === 'object' && !Array.isArray(event) ? event : {}
+    );
+
+    const logPath = resolveLogPath(cfg.path);
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, JSON.stringify(record) + '\n');
+  } catch (_err) {
+    // Logging must NEVER break the caller. Swallow everything.
+  }
+}
+
+/**
+ * setConfig — atomically merge a patch into logs/log.config.json (temp + rename).
+ *
+ * Merges with the current resolved config so a partial patch (e.g. { enabled: true })
+ * preserves the existing path. Creates the logs/ dir and the config file if absent —
+ * this is the ONLY function that creates the config file.
+ *
+ * @param {{ enabled?: boolean, path?: string }} patch
+ * @returns {{ enabled: boolean, path: string }} the merged, written config.
+ */
+function setConfig(patch) {
+  const current = getConfig();
+  const p = patch && typeof patch === 'object' && !Array.isArray(patch) ? patch : {};
+
+  const next = {
+    enabled: typeof p.enabled === 'boolean' ? p.enabled : current.enabled,
+    path:
+      typeof p.path === 'string' && p.path.length > 0 ? p.path : current.path,
+  };
+
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  // Atomic write: write a unique temp file, then rename over the target.
+  const tmp = CONFIG_PATH + '.' + process.pid + '.' + Date.now() + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n');
+  fs.renameSync(tmp, CONFIG_PATH);
+
+  return next;
+}
+
+/**
+ * tail — return the last n parsed JSON lines from the configured log.
+ *
+ * Returns [] if the log is missing or unreadable. Unparseable lines are skipped. When
+ * n is not a positive finite number, all lines are returned. Never throws.
+ *
+ * @param {number} [n] how many trailing lines to parse and return.
+ * @returns {object[]}
+ */
+function tail(n) {
+  try {
+    const cfg = getConfig();
+    const logPath = resolveLogPath(cfg.path);
+    const raw = fs.readFileSync(logPath, 'utf8');
+    const lines = raw.split('\n').filter(function (l) {
+      return l.length > 0;
+    });
+
+    const wanted =
+      typeof n === 'number' && isFinite(n) && n > 0 ? Math.floor(n) : lines.length;
+    const slice = lines.slice(-wanted);
+
+    const out = [];
+    for (let i = 0; i < slice.length; i++) {
+      try {
+        out.push(JSON.parse(slice[i]));
+      } catch (_e) {
+        // Skip a corrupt/partial line rather than failing the whole tail.
+      }
+    }
+    return out;
+  } catch (_err) {
+    return [];
+  }
+}
+
+module.exports = { log, setConfig, getConfig, tail };

package/src/core/matcher.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * matcher.js — does a hook's matcher string fire for a given tool? (HOOK_ENGINE.md §5)
+ *
+ * Mirrors Claude Code's matcher semantics:
+ *   - ""  | undefined | "*"  → always fire (wildcard).
+ *   - otherwise the matcher is a regex, anchored as a FULL match against toolName
+ *     (e.g. "Bash|Write|Edit").
+ *   - tool-less events (SessionStart, UserPromptSubmit, Stop, PreCompact) pass
+ *     toolName == null/undefined → always fire (the matcher is ignored).
+ *
+ * CommonJS only. Zero host imports (core/ must run headless under node --test).
+ */
+
+/**
+ * @param {string|undefined|null} matcher  the hook's matcher string.
+ * @param {string|undefined|null} toolName the tool the model requested, or
+ *        null/undefined for events without a tool.
+ * @returns {boolean} true if the hook should fire for this tool.
+ */
+function matches(matcher, toolName) {
+  // Wildcard / unset matcher → always fire, regardless of tool.
+  if (matcher === undefined || matcher === null || matcher === '' || matcher === '*') {
+    return true;
+  }
+
+  // Tool-less events: there is nothing to match against, so the matcher is
+  // ignored and the hook always fires (§5). This is checked AFTER the wildcard
+  // case so a "*" matcher is handled uniformly, and BEFORE we attempt a regex
+  // (which would otherwise need a string to test).
+  if (toolName === undefined || toolName === null) {
+    return true;
+  }
+
+  // Anything else is a regex, anchored as a full match against toolName.
+  // We wrap in ^(?:…)$ so alternations like "Bash|Write" mean "the whole tool
+  // name is one of these", not "contains one of these".
+  let re;
+  try {
+    re = new RegExp(`^(?:${matcher})$`);
+  } catch (err) {
+    // A malformed matcher must never throw out of the engine. Treat an
+    // uncompilable pattern as "does not match" — fail closed, stay defensive.
+    return false;
+  }
+
+  return re.test(toolName);
+}
+
+module.exports = { matches };

package/src/core/metrics.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * metrics.js — in-memory, per-process tool-call counters (lightweight observability).
+ *
+ * A privileged gateway should be able to answer "what has run through me, and how often did it
+ * fail?" without standing up a metrics stack. This is the zero-dependency MVP of that: process-
+ * lifetime counters incremented at the single tools/call chokepoint and surfaced via the HTTP
+ * `/health` endpoint and the admin UI. It is NOT persistent (counts reset when the host restarts)
+ * and NOT a substitute for the JSONL audit log (src/core/logger.js, which records individual events
+ * to disk when enabled) — the two are complementary: the log is the durable per-event record, this
+ * is the cheap live aggregate.
+ *
+ * Design rules (same discipline as logger.js):
+ *   - Zero dependencies. Plain objects + integers.
+ *   - record() / snapshot() NEVER throw — instrumentation must never break a tool call.
+ *   - In-memory only; no files, no timers, no network.
+ *
+ * CommonJS only.
+ */
+
+const state = {
+  startedAt: new Date().toISOString(),
+  calls: 0,
+  errors: 0,
+  byTool: Object.create(null), // name -> { calls, errors }
+};
+
+/**
+ * record — count one tools/call outcome. `ok:false` (an isError result — a tool failure OR a
+ * PreToolUse denial, which both surface as an error envelope) increments the error counters.
+ * @param {{ tool?:string, ok?:boolean }} ev
+ */
+function record(ev) {
+  try {
+    const tool = ev && typeof ev.tool === 'string' && ev.tool.length > 0 ? ev.tool : 'unknown';
+    const ok = !(ev && ev.ok === false);
+    state.calls += 1;
+    if (!ok) state.errors += 1;
+    let t = state.byTool[tool];
+    if (!t) {
+      t = { calls: 0, errors: 0 };
+      state.byTool[tool] = t;
+    }
+    t.calls += 1;
+    if (!ok) t.errors += 1;
+  } catch (_e) {
+    /* instrumentation must never break the caller */
+  }
+}
+
+/**
+ * snapshot — a fresh, mutation-safe copy of the counters for /health + the UI. NEVER throws.
+ * @returns {{ startedAt:string, calls:number, errors:number, byTool:Object<string,{calls:number,errors:number}> }}
+ */
+function snapshot() {
+  try {
+    const byTool = {};
+    for (const k of Object.keys(state.byTool)) {
+      byTool[k] = { calls: state.byTool[k].calls, errors: state.byTool[k].errors };
+    }
+    return { startedAt: state.startedAt, calls: state.calls, errors: state.errors, byTool };
+  } catch (_e) {
+    return { startedAt: state.startedAt, calls: 0, errors: 0, byTool: {} };
+  }
+}
+
+/** reset — zero the counters (tests). The startedAt stamp is left as the process start. */
+function reset() {
+  state.calls = 0;
+  state.errors = 0;
+  state.byTool = Object.create(null);
+}
+
+module.exports = { record, snapshot, reset };