imprint-mcp 0.2.0

package/src/imprint/etld.ts

@@ -0,0 +1,134 @@
+/** Registrable-domain extraction (eTLD+1) for hostname filtering.
+ *
+ *  Naive `split('.').slice(-2)` is wrong for multi-part public suffixes:
+ *    api.example.co.uk → "co.uk"   (wrong; should be "example.co.uk")
+ *  which then over-matches every other .co.uk hostname.
+ *
+ *  We're not pulling in the full Mozilla Public Suffix List — too much
+ *  weight for a CLI tool. Instead, a small allow-list of the common
+ *  multi-part suffixes covers ~all real-world cases. If we ever record
+ *  against an exotic ccTLD we'll add it here. */
+const MULTI_PART_SUFFIXES = new Set([
+  // United Kingdom
+  'co.uk',
+  'org.uk',
+  'me.uk',
+  'ltd.uk',
+  'plc.uk',
+  'net.uk',
+  'sch.uk',
+  'ac.uk',
+  'gov.uk',
+  'nhs.uk',
+  // Australia
+  'com.au',
+  'net.au',
+  'org.au',
+  'edu.au',
+  'gov.au',
+  'asn.au',
+  'id.au',
+  // Japan
+  'co.jp',
+  'ne.jp',
+  'or.jp',
+  'ac.jp',
+  'ad.jp',
+  'go.jp',
+  'gr.jp',
+  // Brazil
+  'com.br',
+  'net.br',
+  'org.br',
+  'gov.br',
+  'edu.br',
+  'mil.br',
+  // South Africa
+  'co.za',
+  'ac.za',
+  'gov.za',
+  'org.za',
+  'net.za',
+  // Mexico
+  'com.mx',
+  'gob.mx',
+  'org.mx',
+  'edu.mx',
+  // India
+  'co.in',
+  'gov.in',
+  'ac.in',
+  'org.in',
+  'net.in',
+  'edu.in',
+  // South Korea
+  'co.kr',
+  'ne.kr',
+  'or.kr',
+  'go.kr',
+  'ac.kr',
+  // China
+  'com.cn',
+  'net.cn',
+  'org.cn',
+  'gov.cn',
+  'edu.cn',
+  'ac.cn',
+  // Hong Kong
+  'com.hk',
+  'org.hk',
+  'gov.hk',
+  'edu.hk',
+  'net.hk',
+  // New Zealand
+  'co.nz',
+  'org.nz',
+  'net.nz',
+  'govt.nz',
+  'ac.nz',
+  // Singapore
+  'com.sg',
+  'org.sg',
+  'gov.sg',
+  'edu.sg',
+  'net.sg',
+  // Israel
+  'co.il',
+  'org.il',
+  'gov.il',
+  'ac.il',
+  'net.il',
+  // Argentina
+  'com.ar',
+  'gov.ar',
+  'edu.ar',
+  'org.ar',
+]);
+
+/** Return the registrable domain (eTLD+1) of a hostname.
+ *  Examples:
+ *    api.example.com    → example.com
+ *    api.example.co.uk  → example.co.uk
+ *    example.com        → example.com
+ *    localhost          → localhost
+ *    192.168.1.1        → 192.168.1.1 (no further reduction)  */
+export function registrableDomain(hostname: string): string {
+  // IPs and bare hosts pass through unchanged.
+  if (hostname.length === 0) return hostname;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) return hostname;
+
+  const parts = hostname.split('.');
+  if (parts.length <= 2) return hostname;
+
+  const lastTwo = parts.slice(-2).join('.');
+  if (MULTI_PART_SUFFIXES.has(lastTwo) && parts.length >= 3) {
+    return parts.slice(-3).join('.');
+  }
+  return parts.slice(-2).join('.');
+}
+
+/** True when `hostname` is the registrable domain `root` or a subdomain
+ *  of it. Used by request-filtering and cookie-scoping. */
+export function isSameRegistrableDomain(hostname: string, root: string): boolean {
+  return hostname === root || hostname.endsWith(`.${root}`);
+}

package/src/imprint/freeform-redact.ts

@@ -0,0 +1,216 @@
+import { Policies, type PolicyName, createRedactum } from 'redactum';
+
+const FREEFORM_POLICIES: PolicyName[] = [
+  Policies.EMAIL_ADDRESS,
+  Policies.PHONE_NUMBER_US,
+  Policies.PHONE_NUMBER_INTERNATIONAL,
+  Policies.PHONE_NUMBER_UK,
+  Policies.PHONE_NUMBER_CANADIAN,
+  Policies.SSN,
+  Policies.CREDIT_CARD,
+  Policies.CREDIT_CARD_WITH_SEPARATORS,
+  Policies.CREDIT_CARD_CVV,
+  Policies.URL_WITH_CREDENTIALS,
+  Policies.JWT_TOKEN,
+  Policies.BASIC_AUTH_HEADER,
+  Policies.BEARER_TOKEN_HEADER,
+  Policies.API_KEY_HEADER,
+  Policies.SESSION_ID_COOKIE,
+  Policies.API_KEY_GENERIC,
+  Policies.OPENAI_API_KEY,
+  Policies.ANTHROPIC_API_KEY,
+  Policies.GOOGLE_API_KEY,
+  Policies.GCP_API_KEY,
+  Policies.GITHUB_TOKEN,
+  Policies.GITHUB_FINE_GRAINED_TOKEN,
+  Policies.GITLAB_TOKEN,
+  Policies.BITBUCKET_TOKEN,
+  Policies.AWS_ACCESS_KEY,
+  Policies.AWS_SECRET_KEY,
+  Policies.AWS_SESSION_TOKEN,
+  Policies.AZURE_STORAGE_CONNECTION_STRING,
+  Policies.DIGITALOCEAN_TOKEN,
+  Policies.HEROKU_API_KEY,
+  Policies.RAILWAY_TOKEN,
+  Policies.CLOUDFLARE_API_TOKEN,
+  Policies.DOCKER_HUB_TOKEN,
+  Policies.DOCKER_REGISTRY_TOKEN,
+  Policies.NPM_TOKEN,
+  Policies.PYPI_TOKEN,
+  Policies.RUBYGEMS_API_KEY,
+  Policies.QUAY_IO_TOKEN,
+  Policies.JFROG_ARTIFACTORY_TOKEN,
+  Policies.NEXUS_REPOSITORY_TOKEN,
+  Policies.SLACK_WEBHOOK,
+  Policies.DISCORD_WEBHOOK,
+  Policies.WEBHOOK_URL,
+  Policies.SLACK_TOKEN,
+  Policies.DISCORD_TOKEN,
+  Policies.TWILIO_AUTH_TOKEN,
+  Policies.TWILIO_API_KEY,
+  Policies.SENDGRID_API_KEY,
+  Policies.STRIPE_KEY,
+  Policies.MAILGUN_API_KEY,
+  Policies.MAILCHIMP_API_KEY,
+  Policies.MONGODB_CONNECTION_STRING,
+  Policies.POSTGRESQL_CONNECTION_STRING,
+  Policies.MYSQL_CONNECTION_STRING,
+  Policies.REDIS_CONNECTION_STRING,
+  Policies.ELASTICSEARCH_URL,
+  Policies.RABBITMQ_CONNECTION_STRING,
+  Policies.KAFKA_CONNECTION_STRING,
+  Policies.CASSANDRA_CONNECTION_STRING,
+  Policies.DATABASE_CONNECTION_STRING,
+  Policies.DATABASE_URL,
+  Policies.LDAP_CONNECTION_STRING,
+  Policies.JDBC_CONNECTION_STRING,
+  Policies.SMTP_CONNECTION_STRING,
+  Policies.SSH_PRIVATE_KEY,
+  Policies.RSA_PRIVATE_KEY,
+  Policies.EC_PRIVATE_KEY,
+  Policies.OPENSSH_PRIVATE_KEY,
+  Policies.GENERIC_PRIVATE_KEY,
+  Policies.PGP_PRIVATE_KEY,
+  Policies.PASSWORD_ASSIGNMENT,
+  Policies.ENVIRONMENT_VARIABLE_SECRET,
+  Policies.GENERIC_PASSWORD,
+  Policies.GENERIC_TOKEN,
+  Policies.GENERIC_CREDENTIAL,
+  Policies.GENERIC_SECRET,
+  Policies.OAUTH_CLIENT_SECRET,
+  Policies.OAUTH_REFRESH_TOKEN,
+  Policies.OAUTH_ACCESS_TOKEN,
+  Policies.OKTA_API_TOKEN,
+  Policies.AUTH0_API_TOKEN,
+  Policies.KEYCLOAK_CLIENT_SECRET,
+  Policies.JENKINS_TOKEN,
+  Policies.CIRCLECI_TOKEN,
+  Policies.TRAVIS_CI_TOKEN,
+  Policies.GITLAB_CI_TOKEN,
+  Policies.AZURE_DEVOPS_TOKEN,
+  Policies.BITBUCKET_TOKEN_ALT,
+  Policies.SENTRY_DSN,
+  Policies.NEW_RELIC_LICENSE_KEY,
+  Policies.DATADOG_API_KEY,
+  Policies.PAGERDUTY_INTEGRATION_KEY,
+  Policies.GRAFANA_API_KEY,
+  Policies.SPLUNK_HEC_TOKEN,
+  Policies.BUGSNAG_API_KEY,
+  Policies.ROLLBAR_ACCESS_TOKEN,
+  Policies.AIRBRAKE_API_KEY,
+  Policies.LOGDNA_INGESTION_KEY,
+  Policies.LOGGLY_TOKEN,
+  Policies.PAPERTRAIL_TOKEN,
+  Policies.TERRAFORM_CLOUD_TOKEN,
+  Policies.HASHICORP_VAULT_TOKEN,
+  Policies.AWS_SECRETS_MANAGER_ARN,
+  Policies.AZURE_KEY_VAULT_SECRET,
+  Policies.GCP_SECRET_MANAGER,
+  Policies.CONSUL_TOKEN,
+  Policies.RANCHER_TOKEN,
+  Policies.AGE_SECRET_KEY,
+  Policies.MASTER_KEY,
+];
+
+const REDACTION_HINT_RE =
+  /@|\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.|\b\d{3}[-.\s]\d{2}[-.\s]\d{4}\b|\b\d{3}[-.\s]\d{3}[-.\s]\d{4}\b|\b\d{4}[-\s]\d{4}[-\s]\d{4}[-\s]\d{4}\b|api[_-]?key|auth|bearer|card|cookie|credential|key|password|postgres|mysql|mongodb|redis|secret|session|sk-|token|-----BEGIN/i;
+
+const PROTECTED_PATTERNS = [
+  /\[REDACTED:\d+\]/g,
+  /\$\{credential\.[A-Za-z0-9_.-]+\}/g,
+  /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi,
+  /\b[0-9a-f]{40}\b/gi,
+];
+
+const REDACTOR = createRedactum({
+  policies: FREEFORM_POLICIES,
+  replacement: () => '[REDACTED]',
+});
+const CACHE_MAX = 512;
+const cache = new Map<string, FreeformRedaction>();
+
+interface FreeformRedaction {
+  redacted: string;
+  redactionsCount: number;
+}
+
+interface Range {
+  start: number;
+  end: number;
+}
+
+export function redactFreeformText(text: string): FreeformRedaction {
+  if (!hasFreeformRedactionHint(text)) {
+    return { redacted: text, redactionsCount: 0 };
+  }
+
+  const protectedRanges = collectProtectedRanges(text);
+  if (protectedRanges.length === 0) {
+    return redactUnprotectedText(text);
+  }
+
+  let redacted = '';
+  let cursor = 0;
+  let redactionsCount = 0;
+  for (const range of protectedRanges) {
+    const segment = text.slice(cursor, range.start);
+    const segmentResult = redactUnprotectedText(segment);
+    redacted += segmentResult.redacted;
+    redactionsCount += segmentResult.redactionsCount;
+    redacted += text.slice(range.start, range.end);
+    cursor = range.end;
+  }
+
+  const tail = redactUnprotectedText(text.slice(cursor));
+  redacted += tail.redacted;
+  redactionsCount += tail.redactionsCount;
+
+  return { redacted, redactionsCount };
+}
+
+function redactUnprotectedText(text: string): FreeformRedaction {
+  if (text.length === 0 || !hasFreeformRedactionHint(text)) {
+    return { redacted: text, redactionsCount: 0 };
+  }
+  const cached = cache.get(text);
+  if (cached) return cached;
+
+  const result = REDACTOR.redactum(text);
+  const redaction = {
+    redacted: result.redactedText,
+    redactionsCount: result.stats.totalFindings,
+  };
+  cache.set(text, redaction);
+  if (cache.size > CACHE_MAX) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+  return redaction;
+}
+
+export function hasFreeformRedactionHint(text: string): boolean {
+  return REDACTION_HINT_RE.test(text);
+}
+
+function collectProtectedRanges(text: string): Range[] {
+  const ranges: Range[] = [];
+  for (const pattern of PROTECTED_PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of text.matchAll(pattern)) {
+      if (match.index === undefined) continue;
+      ranges.push({ start: match.index, end: match.index + match[0].length });
+    }
+  }
+  ranges.sort((a, b) => a.start - b.start || b.end - a.end);
+
+  const merged: Range[] = [];
+  for (const range of ranges) {
+    const previous = merged.at(-1);
+    if (!previous || range.start > previous.end) {
+      merged.push({ ...range });
+    } else if (range.end > previous.end) {
+      previous.end = range.end;
+    }
+  }
+  return merged;
+}

package/src/imprint/inject-listener.ts

@@ -0,0 +1,137 @@
+/**
+ * Injected per-page (Page.addScriptToEvaluateOnNewDocument). Passive
+ * capture-phase listeners emit sentinel-prefixed console.log lines that
+ * the recorder picks up via Runtime.consoleAPICalled. Sentinel
+ * `[IMPRINT]` is exact-match — keep stable.
+ */
+
+export const INJECTED_LISTENER_SOURCE = `
+(function imprintInjector() {
+  if (window.__imprint_injected__) return;
+  window.__imprint_injected__ = true;
+
+  const SENTINEL = '[IMPRINT]';
+  const MAX_VAL = 200;
+
+  function safeStr(v) {
+    try {
+      if (v == null) return null;
+      const s = String(v);
+      return s.length > MAX_VAL ? s.slice(0, MAX_VAL) + '…' : s;
+    } catch (e) { return null; }
+  }
+
+  function selectorFor(el) {
+    try {
+      if (!el || !el.tagName) return null;
+      if (el.id) return '#' + el.id;
+      const parts = [];
+      let node = el;
+      let depth = 0;
+      while (node && node.nodeType === 1 && depth < 5) {
+        let part = node.tagName.toLowerCase();
+        if (node.className && typeof node.className === 'string') {
+          const cls = node.className.trim().split(/\\s+/).slice(0, 2).join('.');
+          if (cls) part += '.' + cls;
+        }
+        parts.unshift(part);
+        node = node.parentElement;
+        depth++;
+      }
+      return parts.join(' > ');
+    } catch (e) { return null; }
+  }
+
+  function describe(el) {
+    try {
+      if (!el || !el.tagName) return {};
+      return {
+        tag: el.tagName.toLowerCase(),
+        id: el.id || null,
+        name: el.getAttribute && el.getAttribute('name') || null,
+        type: el.getAttribute && el.getAttribute('type') || null,
+        text: safeStr((el.textContent || '').trim()),
+        ariaLabel: el.getAttribute && el.getAttribute('aria-label') || null,
+        href: el.tagName === 'A' ? el.getAttribute('href') : null,
+        selector: selectorFor(el),
+      };
+    } catch (e) { return {}; }
+  }
+
+  function emit(type, payload) {
+    try {
+      console.log(SENTINEL, type, JSON.stringify(payload));
+    } catch (e) { /* ignore */ }
+  }
+
+  function onClick(ev) {
+    try {
+      const tgt = ev.target;
+      emit('click', describe(tgt));
+    } catch (e) { /* ignore */ }
+  }
+
+  function onInput(ev) {
+    try {
+      const tgt = ev.target;
+      // For inputs we capture the field name + a TRUNCATED value preview.
+      // Sensitive fields (type=password) get value redacted.
+      const desc = describe(tgt);
+      if (desc.type === 'password') {
+        desc.value = '[redacted password]';
+      } else if (tgt && 'value' in tgt) {
+        desc.value = safeStr(tgt.value);
+      }
+      emit('input', desc);
+    } catch (e) { /* ignore */ }
+  }
+
+  function onChange(ev) {
+    try {
+      const tgt = ev.target;
+      const desc = describe(tgt);
+      if (desc.type === 'password') {
+        desc.value = '[redacted password]';
+      } else if (tgt && 'value' in tgt) {
+        desc.value = safeStr(tgt.value);
+      }
+      emit('change', desc);
+    } catch (e) { /* ignore */ }
+  }
+
+  function onSubmit(ev) {
+    try {
+      const form = ev.target;
+      const fields = [];
+      if (form && form.elements) {
+        for (let i = 0; i < form.elements.length; i++) {
+          const el = form.elements[i];
+          if (!el || !el.name) continue;
+          let value = null;
+          if (el.type === 'password') {
+            value = '[redacted]';
+          } else if ('value' in el) {
+            value = safeStr(el.value);
+          }
+          fields.push({ name: el.name, type: el.type || null, value: value });
+        }
+      }
+      emit('submit', {
+        selector: selectorFor(form),
+        action: form && form.getAttribute && form.getAttribute('action') || null,
+        method: form && form.getAttribute && form.getAttribute('method') || 'get',
+        fields: fields,
+      });
+    } catch (e) { /* ignore */ }
+  }
+
+  // Capture phase = true so we see the event before the site has a chance to
+  // stopPropagation it.
+  document.addEventListener('click', onClick, true);
+  document.addEventListener('input', onInput, true);
+  document.addEventListener('change', onChange, true);
+  document.addEventListener('submit', onSubmit, true);
+})();
+`;
+
+export const IMPRINT_SENTINEL = '[IMPRINT]';