slack-term 1.48.0 → 1.49.1

package/ts/inbox.ts

@@ -0,0 +1,191 @@
+// .slack-term/ inbox and outbox: one file per message, written tmp + rename.
+//
+// inbox/<channel>-<ts>.yml  a text-only notification (who, where, text,
+//   permalink; attachments only counted). Secrets are redacted before it is
+//   written — `slack read <permalink>` fetches the real thing live.
+//   Handled = moved to archived/: by `slack done`, or by an outbox message
+//   sent with in_reply_to: <its ts>.
+// outbox/<name>.yml  {to, text, in_reply_to?}. `slack outbox flush` sends
+//   them (behind the --code gate) and moves each to sent/ with its ts and
+//   permalink; a failure stays in outbox/ with `error` and `attempts`.
+import { existsSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { redact } from "./redact.ts";
+import { atomicWrite, readSettings, registeredScopes, setAlias, whoSubscribes, type Alias, type Scope } from "./scope.ts";
+
+export type InboxEntry = {
+  ts: string;
+  channel: string;
+  channel_name?: string;
+  /** The thread root; absent for a top-level message. */
+  thread_ts?: string;
+  user: string;
+  user_name?: string;
+  text: string;
+  /** Rule ids of what was redacted from `text`. */
+  redacted?: string[];
+  /** Attachments are never downloaded, only counted. */
+  files?: number;
+  permalink: string;
+  /** The subscription that routed it here. */
+  alias: string;
+  received_at: string;
+};
+
+/** What a stream hands over (its StreamMatch, plus the attachment count). */
+export type Incoming = {
+  channel: { id: string; name: string };
+  ts: string;
+  thread_ts: string | null;
+  user: { id: string; name: string };
+  text: string;
+  permalink: string;
+  files?: number;
+};
+
+const TS_RE = /^\d{10}\.\d{6}$/;
+
+export function inboxFileName(channel: string, ts: string): string {
+  return `${channel}-${ts}.yml`;
+}
+
+function yaml(v: unknown): string {
+  return Bun.YAML.stringify(v, null, 2) + "\n";
+}
+
+/** Write one entry, redacted. False when it is already there (inbox/ or archived/). */
+export function writeInbox(scope: Scope, e: Omit<InboxEntry, "redacted">, known: readonly string[] = []): boolean {
+  const name = inboxFileName(e.channel, e.ts);
+  if (existsSync(join(scope.dir, "inbox", name)) || existsSync(join(scope.dir, "archived", name))) return false;
+  const r = redact(e.text, { known });
+  const entry: InboxEntry = { ...e, text: r.text, ...(r.kinds.length ? { redacted: r.kinds } : {}) };
+  atomicWrite(join(scope.dir, "inbox", name), yaml(entry));
+  return true;
+}
+
+/** Fan one incoming message out to every scope that subscribes it. A new
+ *  top-level message in an `auto_subscribe` channel nobody subscribes is
+ *  first subscribed (as `t-<ts>`) in the scopes that ask for it. Returns the
+ *  scope dirs it was written to. */
+export function deliver(m: Incoming, scopes = registeredScopes(), now = new Date(), known: readonly string[] = []): string[] {
+  const root = m.thread_ts ?? m.ts;
+  let subs: Alias[] = whoSubscribes(m.channel.id, root, scopes);
+  if (!subs.length && !m.thread_ts) {
+    for (const s of scopes) {
+      if (!readSettings(s).auto_subscribe?.includes(m.channel.id)) continue;
+      // settings.yml: auto_subscribe is the owner's own rule, so it writes as the owner.
+      setAlias(s, `t-${m.ts}`, { channel: m.channel.id, thread_ts: m.ts, note: "auto: new top-level message" }, { shared: true, asOwner: true });
+    }
+    subs = whoSubscribes(m.channel.id, root, scopes);
+  }
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const a of subs) {
+    if (seen.has(a.scope.dir)) continue; // one file per scope, however many aliases match
+    seen.add(a.scope.dir);
+    const wrote = writeInbox(a.scope, {
+      ts: m.ts, channel: m.channel.id, channel_name: m.channel.name,
+      ...(m.thread_ts ? { thread_ts: m.thread_ts } : {}),
+      user: m.user.id, user_name: m.user.name, text: m.text,
+      ...(m.files ? { files: m.files } : {}),
+      permalink: m.permalink, alias: a.name, received_at: now.toISOString(),
+    }, known);
+    if (wrote) out.push(a.scope.dir);
+  }
+  return out;
+}
+
+export type Listed<T> = { file: string; entry: T; mtimeMs: number };
+
+function listDir<T>(dir: string, parse: (v: unknown) => T | undefined): Listed<T>[] {
+  let names: string[];
+  try {
+    names = readdirSync(dir).filter((f) => f.endsWith(".yml"));
+  } catch {
+    return [];
+  }
+  const out: Listed<T>[] = [];
+  for (const f of names.sort()) {
+    const p = join(dir, f);
+    try {
+      const entry = parse(Bun.YAML.parse(readFileSync(p, "utf8")));
+      if (entry) out.push({ file: p, entry, mtimeMs: statSync(p).mtimeMs });
+    } catch { /* half-moved or hand-broken: skip */ }
+  }
+  return out;
+}
+
+function asInbox(v: unknown): InboxEntry | undefined {
+  const o = v as Partial<InboxEntry> | null;
+  return o && typeof o.ts === "string" && typeof o.channel === "string" && typeof o.text === "string" ? (o as InboxEntry) : undefined;
+}
+
+export function listInbox(scope: Scope): Listed<InboxEntry>[] {
+  return listDir(join(scope.dir, "inbox"), asInbox).sort((a, b) => Number(a.entry.ts) - Number(b.entry.ts));
+}
+
+/** Move an inbox entry to archived/: by file name/path, or by message ts. */
+export function markDone(scope: Scope, ref: string): string | undefined {
+  const items = listInbox(scope);
+  const hit = TS_RE.test(ref)
+    ? items.find((i) => i.entry.ts === ref)
+    : items.find((i) => i.file === ref || i.file.endsWith(`/${ref}`) || i.file.endsWith(`/${ref}.yml`));
+  if (!hit) return undefined;
+  const to = join(scope.dir, "archived", hit.file.slice(hit.file.lastIndexOf("/") + 1));
+  renameSync(hit.file, to);
+  return to;
+}
+
+// --- outbox ---
+
+export type OutboxEntry = {
+  /** alias | permalink | #chan:<ts> | C…:<ts> */
+  to: string;
+  text: string;
+  /** ts of the inbox message this answers: archived once this is sent. */
+  in_reply_to?: string;
+  attempts?: number;
+  error?: string;
+};
+
+function asOutbox(v: unknown): OutboxEntry | undefined {
+  const o = v as Partial<OutboxEntry> | null;
+  return o && typeof o.to === "string" && typeof o.text === "string" ? (o as OutboxEntry) : undefined;
+}
+
+export function listOutbox(scope: Scope): Listed<OutboxEntry>[] {
+  return listDir(join(scope.dir, "outbox"), asOutbox);
+}
+
+/** Queue one message. The file name sorts by time, so flush keeps the order. */
+export function addOutbox(scope: Scope, e: OutboxEntry, now = new Date()): { file: string; redacted: string[] } {
+  const p = join(scope.dir, "outbox", `${now.toISOString().replace(/[:.]/g, "-")}-${process.pid}.yml`);
+  // Redacted before it is written, like the inbox: a secret never reaches
+  // the disk — nor, then, Slack.
+  const r = redact(e.text);
+  atomicWrite(p, yaml({ ...e, text: r.text }));
+  return { file: p, redacted: r.kinds };
+}
+
+/** After Slack returned a ts: the sent/ record (text redacted), the outbox
+ *  file gone, and the answered inbox entry archived. */
+export function recordSent(scope: Scope, item: Listed<OutboxEntry>, sent: { ts: string; permalink: string; channel: string; thread_ts: string }, now = new Date()): string {
+  const name = item.file.slice(item.file.lastIndexOf("/") + 1);
+  const r = redact(item.entry.text);
+  const { error: _e, ...rest } = item.entry;
+  atomicWrite(join(scope.dir, "sent", name), yaml({ ...rest, text: r.text, ...(r.kinds.length ? { redacted: r.kinds } : {}), ...sent, sent_at: now.toISOString() }));
+  unlinkSync(item.file);
+  if (item.entry.in_reply_to) markDone(scope, item.entry.in_reply_to);
+  return join(scope.dir, "sent", name);
+}
+
+/** A failed send stays in outbox/, with why and how often. */
+export function recordFailure(item: Listed<OutboxEntry>, error: string): void {
+  atomicWrite(item.file, yaml({ ...item.entry, attempts: (item.entry.attempts ?? 0) + 1, error }));
+}
+
+/** Inbox entries older than the scope's `nudge_after_min` (default 30). */
+export function overdue(scope: Scope, nowMs = Date.now()): Listed<InboxEntry>[] {
+  const min = readSettings(scope).nudge_after_min ?? 30;
+  return listInbox(scope).filter((i) => nowMs - i.mtimeMs >= min * 60_000);
+}

package/ts/locales.ts

@@ -0,0 +1,113 @@
+// Language packs: locales/<lang>.json in the package, overridden key by key by
+// the nearest .slack-term/locales/<lang>.json. They hold only what slack-term
+// posts to PEOPLE (slack ask's copy) and the patterns it looks for in their
+// messages (the choice-question hint); the CLI's own text is English, in code.
+//
+// Read at call time and cached by mtime, so editing a pack takes effect on the
+// next command (and the next access in a long-running one): no rebuild.
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { findScope } from "./scope.ts";
+
+export type Pack = {
+  lang: string;
+  /** Slack / POSIX locales that pick this pack (`ja` matches ja-JP, ja_JP.UTF-8). */
+  locale_prefixes?: string[];
+  ask?: Record<string, string>;
+  /** Regex sources (flags iu) for "this text is a choice question". */
+  choice_patterns?: string[];
+};
+
+// fileURLToPath, not .pathname: a path with spaces or non-ASCII stays
+// percent-encoded in .pathname, and a Windows one comes out as /C:/….
+const PACKAGE_DIR = fileURLToPath(new URL("../locales/", import.meta.url));
+
+const cache = new Map<string, { mtimeMs: number; pack: Pack | undefined }>();
+
+function readPack(path: string): Pack | undefined {
+  let mtimeMs: number;
+  try {
+    mtimeMs = statSync(path).mtimeMs;
+  } catch {
+    return undefined;
+  }
+  const hit = cache.get(path);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.pack;
+  let pack: Pack | undefined;
+  try {
+    const v = JSON.parse(readFileSync(path, "utf8")) as Pack;
+    pack = v && typeof v.lang === "string" ? v : undefined;
+  } catch {
+    pack = undefined; // a broken override must not take the CLI down: the package pack stands
+  }
+  cache.set(path, { mtimeMs, pack });
+  return pack;
+}
+
+function overrideDir(): string | undefined {
+  const s = findScope();
+  return s.global ? undefined : join(s.dir, "locales");
+}
+
+/** Every language with a pack, package or override. */
+export function packLangs(): string[] {
+  const out = new Set<string>();
+  for (const d of [PACKAGE_DIR, overrideDir()]) {
+    if (!d) continue;
+    try {
+      for (const f of readdirSync(d)) if (f.endsWith(".json")) out.add(f.slice(0, -5));
+    } catch { /* no such dir */ }
+  }
+  return [...out].sort();
+}
+
+/** The pack for `lang`: the package's, with the override's keys on top. */
+export function pack(lang: string): Pack | undefined {
+  const base = readPack(join(PACKAGE_DIR, `${lang}.json`));
+  const od = overrideDir();
+  const over = od ? readPack(join(od, `${lang}.json`)) : undefined;
+  if (!over) return base;
+  if (!base) return over;
+  return {
+    ...base, ...over,
+    ask: { ...base.ask, ...over.ask },
+    choice_patterns: over.choice_patterns ?? base.choice_patterns ?? [],
+  };
+}
+
+/** One ask string, `{name}` placeholders filled. Keys may carry a ` (WIRE)`
+ *  note in the JSON; looked up with or without it. */
+export function askString(lang: string, key: string, vars: Record<string, string | number> = {}): string {
+  const a = pack(lang)?.ask ?? {};
+  const raw = a[key] ?? a[`${key} (WIRE)`] ?? pack("en")?.ask?.[key] ?? pack("en")?.ask?.[`${key} (WIRE)`];
+  if (raw === undefined) throw new Error(`language pack ${lang}: no ask.${key}`);
+  return raw.replace(/\{(\w+)\}/g, (m, k: string) => (k in vars ? String(vars[k]) : m));
+}
+
+/** The pack whose locale prefix `locale` names, or undefined. */
+export function langOfLocale(locale: string | undefined): string | undefined {
+  const v = (locale ?? "").toLowerCase();
+  if (!v) return undefined;
+  for (const l of packLangs()) {
+    for (const p of pack(l)?.locale_prefixes ?? [l]) {
+      const q = p.toLowerCase();
+      if (v === q || (v.startsWith(q) && /^[_.\-@]/.test(v.slice(q.length)))) return l;
+    }
+  }
+  return undefined;
+}
+
+/** Compiled choice patterns of every pack: a choice question is spotted in
+ *  any language, whatever the sender's own. */
+export function choicePatterns(): { lang: string; re: RegExp }[] {
+  const out: { lang: string; re: RegExp }[] = [];
+  for (const l of packLangs()) {
+    for (const src of pack(l)?.choice_patterns ?? []) {
+      try {
+        out.push({ lang: l, re: new RegExp(src, "iu") });
+      } catch { /* a broken pattern in an override is skipped, not fatal */ }
+    }
+  }
+  return out;
+}

package/ts/readback.ts

@@ -0,0 +1,102 @@
+// Did Slack store what we sent? Ported from the earlier thread tool's read-back check
+// (2026-10-14 / 10-30), for `pinlog set`.
+//
+// Slack rewrites text when it stores it:
+//   * unicode emoji become :shortcodes: (🧭 → :compass:, 1️⃣ → :one:, a skin
+//     tone as :+1::skin-tone-4:); the rich_text block Slack generates keeps
+//     the mapping as {type: "emoji", name, unicode: "1f9ed"};
+//   * & < > that are not markup become &amp; &lt; &gt;;
+//   * a bare URL becomes <url>; a bare domain or e-mail <http://d|d> / <mailto:a|a>.
+// So a read-back is compared normalised, never byte for byte: Slack's own
+// wrappers undone (an explicit <url|label> is kept), shortcodes mapped back to
+// emoji through the message's rich_text, variation selectors and skin tones
+// dropped, whitespace runs as one space.
+
+type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
+
+const EMOJI_SHORTCODE = /:([a-z0-9_+'-]+):((?::skin-tone-[2-6]:)?)/g;
+// No "<" inside: Slack escapes one in a link as &lt;, and allowing it makes
+// the match quadratic on "<a:<a:<a:…".
+const SLACK_LINK = /<([A-Za-z][A-Za-z0-9+.-]*:[^|<>\s]*)(?:\|([^<>]*))?>/g;
+const ENTITY = /&(amp|lt|gt);/g;
+const VARIATION = /[︎️]/gu;
+const SKIN_TONE = /[\u{1F3FB}-\u{1F3FF}]/gu;
+const SC = String.raw`:[a-z0-9_+'-]+:(?::skin-tone-[2-6]:)?`;
+const EMOJI_BASE = String.raw`©®‼⁉™ℹ←-⇿⌀-⏿Ⓜ■-➿⤀-⥿⬀-⯿〰〽㊗㊙\u{1F000}-\u{1FAFF}`;
+const PICT = String.raw`[${EMOJI_BASE}][\u{E0020}-\u{E007F}]*`;
+const PIECE = new RegExp(
+  String.raw`(?<sc>${SC}(?:‍${SC})*)|(?<emoji>[0-9#*]⃣|[\u{1F1E6}-\u{1F1FF}]{2}|${PICT}(?:‍${PICT})*)|(?<char>[\s\S])`,
+  "gu",
+);
+
+/** {shortcode name: emoji} from the rich_text emoji elements of a message. */
+export function emojiMap(blocks: Json | undefined): Map<string, string> {
+  const out = new Map<string, string>();
+  const stack: Json[] = [blocks ?? null];
+  let seen = 0;
+  while (stack.length && seen++ < 100_000) {
+    const o = stack.pop();
+    if (Array.isArray(o)) stack.push(...o);
+    else if (o && typeof o === "object") {
+      const name = o.name;
+      const uni = o.unicode;
+      if (o.type === "emoji" && typeof name === "string" && typeof uni === "string") {
+        try {
+          out.set(name.split("::")[0]!, uni.split("-").filter(Boolean).map((h) => String.fromCodePoint(parseInt(h, 16))).join(""));
+        } catch { /* a bad code point: no mapping */ }
+      }
+      stack.push(...Object.values(o));
+    }
+  }
+  return out;
+}
+
+function unlink(all: string, url: string, label: string | undefined): string {
+  if (label === undefined) return url; // <url>: Slack's wrapper around a bare URL
+  // Slack's own links around a bare domain / e-mail. Any other <url|label> is
+  // explicit: <https://d|d> ≠ <http://d|d>, and /x ≠ /x/.
+  for (const auto of ["http://", "mailto:"]) {
+    if (url.slice(0, auto.length).toLowerCase() === auto && label === url.slice(auto.length)) return label;
+  }
+  return all;
+}
+
+export function normText(text: string, names: Map<string, string>): string {
+  let s = text.normalize("NFC");
+  s = s.replace(SLACK_LINK, (all, url: string, label: string | undefined) => unlink(all, url, label));
+  s = s.replace(ENTITY, (_, e: string) => ({ amp: "&", lt: "<", gt: ">" })[e as "amp" | "lt" | "gt"]);
+  s = s.replace(EMOJI_SHORTCODE, (all, name: string) => names.get(name) ?? all);
+  s = s.replace(VARIATION, "").replace(SKIN_TONE, "");
+  return s.split(/\s+/).filter(Boolean).join(" ");
+}
+
+function tokens(s: string): [string, string][] {
+  return [...s.matchAll(PIECE)].map((m) => {
+    const g = m.groups!;
+    return g.sc !== undefined ? ["sc", g.sc] : g.emoji !== undefined ? ["emoji", g.emoji] : ["char", g.char!];
+  });
+}
+
+/** True when the stored message (its text and rich_text blocks) carries `sent`. */
+export function storedAsSent(sent: string, msg: { text?: Json; blocks?: Json }): boolean {
+  const names = emojiMap(msg.blocks);
+  const a = normText(sent, names);
+  const b = normText(typeof msg.text === "string" ? msg.text : "", names);
+  if (a === b) return true;
+  // A :shortcode: no rich_text element maps back stays as :name:. Then compare
+  // piece by piece: such a stored shortcode may stand for exactly one emoji we
+  // sent; every other piece must be equal.
+  EMOJI_SHORTCODE.lastIndex = 0;
+  if (!EMOJI_SHORTCODE.test(b)) return false;
+  const ta = tokens(a);
+  const tb = tokens(b);
+  return ta.length === tb.length && ta.every(([ka, va], i) => va === tb[i]![1] || (tb[i]![0] === "sc" && ka === "emoji"));
+}
+
+/** Where two normalised texts first differ, for the error line. */
+export function firstDifference(sent: string, stored: string): string {
+  let i = 0;
+  while (i < sent.length && i < stored.length && sent[i] === stored[i]) i++;
+  const lo = Math.max(0, i - 10);
+  return `char ${i}: sent ${JSON.stringify(sent.slice(lo, i + 30))}, stored ${JSON.stringify(stored.slice(lo, i + 30))}`;
+}

package/ts/redact.ts

@@ -0,0 +1,225 @@
+// Secret redaction for anything slack-term writes to disk (the .slack-term/
+// inbox/outbox): each secret becomes `[redacted:<rule id>]`, and the original
+// never touches the file. `slack read` fetches the real text live.
+//
+// Rules: gitleaks' default set (ts/vendor/gitleaks.toml, v8.30.1, MIT — see
+// ts/vendor/gitleaks.LICENSE), run in-process by the JS regex engine, plus
+// our own for what it does not cover (OWN_RULES). Measured 2026-11-02 on
+// 1,000 synthetic messages (tests/redact.test.ts builds the same set):
+// 0.1 ms and ~60 MB RSS per process, against ~0.9 s and ~62 MB per message
+// for spawning the gitleaks binary, with the same catches.
+import { readFileSync } from "node:fs";
+
+export type SecretRule = {
+  id: string;
+  re: RegExp;
+  /** Lowercase; the rule runs only when the text contains one of them. */
+  keywords: string[];
+  /** Minimum Shannon entropy of the secret (gitleaks' `entropy`). */
+  entropy?: number;
+  /** Which capture group is the secret (gitleaks' `secretGroup`). */
+  group?: number;
+  /** Allowlist regexes tested against the secret (gitleaks' regexTarget = secret, the default)… */
+  allow: RegExp[];
+  /** …against the whole match (regexTarget = match)… */
+  allowMatch?: RegExp[];
+  /** …and against the line the match is on (regexTarget = line). */
+  allowLine?: RegExp[];
+  stop: string[];
+};
+
+/** Go RE2 → JS. A leading `(?i)`/`(?s)` becomes a flag; a mid-pattern `(?i)`
+ *  a scoped `(?i:…)` to the end of its group (JS has scoped modifiers, not
+ *  RE2's open-ended ones); `(?P<n>` → `(?<n>`; POSIX classes spelled out;
+ *  `\z` → `$`. */
+export function goToJs(src: string): { source: string; flags: string } {
+  let flags = "";
+  for (;;) {
+    const m = /^\(\?([is]+)\)/.exec(src);
+    if (!m) break;
+    flags += m[1];
+    src = src.slice(m[0].length);
+  }
+  src = src.replaceAll("(?P<", "(?<").replaceAll("\\z", "$")
+    .replaceAll("[[:alnum:]]", "[A-Za-z0-9]").replaceAll("[:alnum:]", "A-Za-z0-9")
+    .replaceAll("[:alpha:]", "A-Za-z").replaceAll("[:digit:]", "0-9").replaceAll("[:space:]", "\\s");
+  let out = "";
+  const closers: number[] = []; // per open group: the scoped (?i: opened inside it
+  let extra = 0;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i]!;
+    if (c === "\\") { out += c + (src[i + 1] ?? ""); i++; continue; }
+    if (c === "[") { // a character class, verbatim
+      let j = i + 1;
+      if (src[j] === "^") j++;
+      if (src[j] === "]") j++;
+      while (j < src.length && src[j] !== "]") { if (src[j] === "\\") j++; j++; }
+      out += src.slice(i, j + 1);
+      i = j;
+      continue;
+    }
+    if (src.startsWith("(?i)", i)) { out += "(?i:"; extra++; i += 3; continue; }
+    if (c === "(") { closers.push(extra); extra = 0; out += c; continue; }
+    if (c === ")") { out += ")".repeat(extra); extra = closers.pop() ?? 0; out += c; continue; }
+    // RE2's (?i) lasts to the end of its group, across `|`: close the scoped
+    // groups before the bar and reopen them after it, or the text before the
+    // first (?i) would bind to every alternative (rechrome 4b5f849:
+    // curl-auth-header missed -H 'Authorization: …').
+    if (c === "|" && extra) { out += ")".repeat(extra) + "|" + "(?i:".repeat(extra); continue; }
+    out += c;
+  }
+  out += ")".repeat(extra);
+  return { source: out, flags: [...new Set(flags)].join("") };
+}
+
+type TomlAllow = { regexTarget?: string; regexes?: string[]; stopwords?: string[] };
+type TomlRule = { id: string; regex?: string; keywords?: string[]; entropy?: number; secretGroup?: number; allowlists?: TomlAllow[]; allowlist?: TomlAllow };
+
+/** gitleaks' rules TOML → rules. Path-only rules (no regex) are skipped. */
+export function loadGitleaksRules(toml: string): SecretRule[] {
+  const c = Bun.TOML.parse(toml) as { rules: TomlRule[]; allowlist?: TomlAllow };
+  const compile = (r: string): RegExp => { const j = goToJs(r); return new RegExp(j.source, j.flags); };
+  const gAllow = (c.allowlist?.regexes ?? []).map(compile);
+  const gStop = (c.allowlist?.stopwords ?? []).map((s) => s.toLowerCase());
+  const rules: SecretRule[] = [];
+  for (const r of c.rules) {
+    if (!r.regex) continue;
+    const allow = [...gAllow];
+    const allowMatch: RegExp[] = [];
+    const allowLine: RegExp[] = [];
+    const stop = [...gStop];
+    for (const a of [...(r.allowlists ?? []), ...(r.allowlist ? [r.allowlist] : [])]) {
+      // Each allowlist is tested against what it names, not always the secret
+      // (generic-api-key's api_version exclusion is a regexTarget = match one).
+      const into = a.regexTarget === "match" ? allowMatch : a.regexTarget === "line" ? allowLine : allow;
+      for (const x of a.regexes ?? []) into.push(compile(x));
+      for (const s of a.stopwords ?? []) stop.push(String(s).toLowerCase());
+    }
+    const j = goToJs(r.regex);
+    rules.push({
+      id: r.id, re: new RegExp(j.source, j.flags + "gd"), keywords: (r.keywords ?? []).map((k) => k.toLowerCase()),
+      ...(r.entropy ? { entropy: r.entropy } : {}), ...(r.secretGroup ? { group: r.secretGroup } : {}), allow,
+      ...(allowMatch.length ? { allowMatch } : {}), ...(allowLine.length ? { allowLine } : {}), stop,
+    });
+  }
+  return rules;
+}
+
+/** Ours, for what gitleaks' set leaves out. */
+export const OWN_RULES: SecretRule[] = [
+  // ?token=… / &sig=… in a URL; `<your token>` and xxx-style placeholders are not secrets.
+  { id: "url-secret-param", re: /[?&](?:access_token|token|key|api_key|apikey|secret|client_secret|password|passwd|pwd|sig|signature)=([^&\s#<>"'|]{6,})/gid, group: 1, keywords: ["="], allow: [/^(?:x+|\*+|\.\.\.|your[-_]?\w*|xxx\w*)$/i], stop: [] },
+  // OpenAI / Anthropic / OpenRouter style keys, whatever their exact layout.
+  { id: "sk-key", re: /\b(sk-(?:proj-|ant-|or-v1-|svcacct-)?[A-Za-z0-9_-]{20,})/gd, group: 1, keywords: ["sk-"], entropy: 3.5, allow: [], stop: [] },
+  // A 6-digit code only right after a word that says it is one: a bare
+  // 6-digit number is far more often an amount, an order or a build.
+  { id: "otp-code", re: /(?:code|コード|otp|pin|passcode|認証|確認番号|ワンタイム)[^\d\n]{0,20}(?<![\d.])(\d{6})(?![\d.])/gid, group: 1, keywords: [], allow: [], stop: [] },
+];
+
+let cached: SecretRule[] | undefined;
+/** gitleaks' rules + ours, loaded once. */
+export function secretRules(): SecretRule[] {
+  cached ??= [...loadGitleaksRules(readFileSync(new URL("./vendor/gitleaks.toml", import.meta.url), "utf8")), ...OWN_RULES];
+  return cached;
+}
+
+function shannon(s: string): number {
+  const f = new Map<string, number>();
+  for (const ch of s) f.set(ch, (f.get(ch) ?? 0) + 1);
+  let h = 0;
+  for (const n of f.values()) { const p = n / s.length; h -= p * Math.log2(p); }
+  return h;
+}
+
+export type SecretHit = { id: string; start: number; end: number };
+
+/** Every span of an exact value the caller knows is secret (its own token, a
+ *  value it filled in), longest first, plus the value's JSON-string spelling
+ *  (a `"` or `\\` in it is escaped there). The 4th rule, after rechrome's
+ *  fill-secret scrub; values shorter than 6 are ignored as unsafe to match. */
+function findKnown(text: string, known: readonly string[]): SecretHit[] {
+  const forms = new Set<string>();
+  for (const v of known) {
+    if (v.length < 6) continue;
+    forms.add(v);
+    forms.add(JSON.stringify(v).slice(1, -1));
+  }
+  const out: SecretHit[] = [];
+  for (const f of [...forms].sort((a, b) => b.length - a.length)) {
+    for (let i = text.indexOf(f); i >= 0; i = text.indexOf(f, i + f.length)) out.push({ id: "known-secret", start: i, end: i + f.length });
+  }
+  return out;
+}
+
+export type RedactOptions = { rules?: SecretRule[]; known?: readonly string[] };
+
+/** Every secret span in `text`. */
+export function findSecrets(text: string, opts: RedactOptions = {}): SecretHit[] {
+  const rules = opts.rules ?? secretRules();
+  const lower = text.toLowerCase();
+  const out: SecretHit[] = opts.known?.length ? findKnown(text, opts.known) : [];
+  for (const r of rules) {
+    if (r.keywords.length && !r.keywords.some((k) => lower.includes(k))) continue;
+    for (const m of text.matchAll(r.re)) {
+      // What gitleaks calls the secret — the configured group, else the first
+      // that matched — decides entropy and the secret allowlist. What is
+      // MASKED is that group only when the rule names it; otherwise the whole
+      // match, since the first group can be a harmless fragment (a webhook's
+      // UUID, a JWT's fixed header) and the real secret would stay visible.
+      // Spans come from the match's own indices (the `d` flag): looking a
+      // value up in m[0] finds an EARLIER copy (`?secret=secret`, rechrome #55).
+      const gi = r.group ?? m.findIndex((g, i) => i > 0 && !!g);
+      const secret = gi > 0 ? m[gi] : m[0];
+      if (!secret) continue;
+      if (r.entropy && shannon(secret) < r.entropy) continue;
+      if (r.allow.some((a) => a.test(secret))) continue;
+      if (r.allowMatch?.some((a) => a.test(m[0]))) continue;
+      if (r.allowLine) {
+        const ls = text.lastIndexOf("\n", m.index) + 1;
+        const le = text.indexOf("\n", m.index + m[0].length);
+        if (r.allowLine.some((a) => a.test(text.slice(ls, le < 0 ? undefined : le)))) continue;
+      }
+      const sl = secret.toLowerCase();
+      if (r.stop.some((s) => sl.includes(s))) continue;
+      const span = r.group ? m.indices?.[r.group] : undefined;
+      if (span) out.push({ id: r.id, start: span[0], end: span[1] });
+      else {
+        // gitleaks' patterns end (and some start) with a boundary — space,
+        // quote, `;`, a literal \n — that is context, not secret: keep it.
+        let a = m.index;
+        let b = m.index + m[0].length;
+        const edge = /[\s'"`;=:,]/;
+        while (a < b && edge.test(text[a]!)) a++;
+        for (;;) {
+          if (b > a && edge.test(text[b - 1]!)) b--;
+          else if (b - 2 >= a && /\\[nr]/.test(text.slice(b - 2, b))) b -= 2;
+          else break;
+        }
+        out.push({ id: r.id, start: a, end: b });
+      }
+    }
+  }
+  return out;
+}
+
+/** `text` with every secret replaced by `[redacted:<rule id>]`. Overlapping
+ *  hits merge into one span, named by the longest. */
+export function redact(text: string, opts: RedactOptions = {}): { text: string; kinds: string[] } {
+  const hits = findSecrets(text, opts).sort((a, b) => a.start - b.start || b.end - a.end);
+  if (!hits.length) return { text, kinds: [] };
+  const spans: SecretHit[] = [];
+  for (const h of hits) {
+    const last = spans[spans.length - 1];
+    if (last && h.start < last.end) {
+      if (h.end - h.start > last.end - last.start) last.id = h.id;
+      last.end = Math.max(last.end, h.end);
+    } else spans.push({ ...h });
+  }
+  let out = "";
+  let at = 0;
+  for (const s of spans) {
+    out += text.slice(at, s.start) + `[redacted:${s.id}]`;
+    at = s.end;
+  }
+  return { text: out + text.slice(at), kinds: [...new Set(spans.map((s) => s.id))] };
+}