rechrome 1.40.0 → 1.42.0

package/rechrome.ts

@@ -5,9 +5,10 @@ import { readListeners, writeListeners as writeListenersFile, listenerAddress, i
 import { file } from "bun";
 import yargs from "yargs";
 import { readExtensionTokenFromProfile } from "./extension-token.ts";
-import { FILL_SECRET_USAGE, SECRET_MASK, parseFillSecretArgs, fillSecretWireArgs, readSecretSource, totpCode, totpWaitMs } from "./fill-secret.ts";
+import { redact } from "./redact.ts";
+import { READ_SECRET_USAGE, parseReadSecretArgs, readSecretWireArgs, FILL_SECRET_USAGE, SECRET_MASK, parseFillSecretArgs, fillSecretWireArgs, readSecretSource, totpCode, totpWaitMs } from "./fill-secret.ts";
 import { createHash, randomBytes } from "crypto";
-import { mkdirSync, appendFileSync, existsSync, realpathSync, accessSync, cpSync, unlinkSync, readFileSync, readdirSync, renameSync, readlinkSync, rmdirSync, constants as fsConstants } from "fs";
+import { mkdirSync, fstatSync, appendFileSync, existsSync, realpathSync, accessSync, cpSync, unlinkSync, readFileSync, readdirSync, renameSync, readlinkSync, rmdirSync, constants as fsConstants } from "fs";
 import { hostname, homedir, networkInterfaces } from "os";
 import { isIPv4 } from "net";
 import { join, basename, dirname, resolve } from "path";
@@ -642,7 +643,7 @@ export async function getOrCreateUrl(persist = true): Promise<string> {
     const envRaw = await file(globalEnvFile).text().catch(() => "");
     const lines = envRaw.trimEnd().split("\n").filter(l => !l.startsWith(`${ENV_KEY}=`));
     const content = [...lines, newLine, ""].join("\n");
-    await Bun.write(globalEnvFile, content);
+    await writeAtomic(globalEnvFile, content, 0o600); // holds the management key
   }
   process.env[ENV_KEY] = url;
   return url;
@@ -1779,7 +1780,7 @@ async function printProfileUri(selector?: string, listener?: string, opts: { loc
     if (!picked.startsWith(SETUP)) return picked;
     const dir = picked.slice(SETUP.length);
     console.error(`[rech] ${dir} isn't set up yet; running rech setup --profile ${JSON.stringify(dir)} first.`);
-    await setup({ profile: dir });
+    await setup({ profile: dir, skipShare: true });
     const after = await readTokenRegistry();
     const key = unregisteredChromeProfiles(after, { [dir]: {} }).length ? undefined : canonicalProfileKeys(after).find(k => after[k].profileDir === dir);
     if (process.exitCode || !key) throw new Error(`Setup didn't register ${dir}; nothing shared. Retry with: rech setup --profile ${JSON.stringify(dir)}`);
@@ -1931,7 +1932,7 @@ async function callServe(
   throwOnFailure = false,
   upload?: UploadPayload,
   secret?: string,
-): Promise<{ status: number; stdout: string; stderr: string; files?: string[]; existingSession?: boolean }> {
+): Promise<{ status: number; stdout: string; stderr: string; files?: string[]; existingSession?: boolean; secretOut?: string }> {
   const { key, host, port, protocol, extensionId, extensionToken, profileDirectory, userDataDir, loadExtension } = parseUrl(url);
   // Reuse the caller's identity when provided — computing it shells out to `git` several times,
   // and run() has already done so for its log line. Recomputing here would double those git
@@ -2168,6 +2169,29 @@ async function run(url: string, args: string[], overrideEnv?: Record<string, str
   let secret: string | undefined;
   let upload: UploadPayload | undefined;
   const cmdIdx = args.findIndex(a => !a.startsWith("-s="));
+  if (args[cmdIdx] === "read-secret") {
+    if (args.some(a => a === "--help" || a === "-h")) { console.log(READ_SECRET_USAGE); process.exit(0); }
+    let wire: string[];
+    try {
+      // Only a pipe: a terminal would show the secret, and a file would keep it. Checked before
+      // asking the host for it.
+      const out = fstatSync(1);
+      if (!out.isFIFO() && !out.isSocket()) throw new Error("read-secret writes the secret to stdout, which must be a pipe into the program that stores it (not a terminal or a file)");
+      wire = readSecretWireArgs(parseReadSecretArgs(args.slice(cmdIdx)));
+    } catch (err) {
+      console.error(`[rech] ${err instanceof Error ? err.message : String(err)}\n${READ_SECRET_USAGE}`);
+      process.exit(2);
+    }
+    const res = await callServe(url, [...args.filter(a => a.startsWith("-s=")), ...wire], overrideEnv, identity);
+    if (res.status !== 0 || typeof res.secretOut !== "string") {
+      process.stderr.write(res.stderr || (res.status === 0 ? "[rech] read-secret: this daemon is older than the client (no value returned)\n" : ""));
+      process.exit(res.status || 1);
+    }
+    // Wait until the pipe has taken all of it before exiting.
+    await new Promise<void>((done, fail) => process.stdout.write(res.secretOut!, e => e ? fail(e) : done()));
+    console.error(`[rech] read-secret: wrote ${res.secretOut.length} characters to stdout`);
+    process.exit(0);
+  }
   if (args[cmdIdx] === "fill-secret") {
     if (args.some(a => a === "--help" || a === "-h")) { console.log(FILL_SECRET_USAGE); process.exit(0); }
     try {
@@ -2188,7 +2212,13 @@ async function run(url: string, args: string[], overrideEnv?: Record<string, str
   }
   const served = await callServe(url, args, overrideEnv, identity, false, upload, secret);
   // The daemon already masks the value; this is a second line of defence for an older daemon.
-  const scrub = (s: string) => secret && s ? s.replaceAll(secret, SECRET_MASK) : s;
+  // Then any secret-shaped string (API keys, tokens) in page text, unless RECH_REDACT=0.
+  const scrub = (s: string) => {
+    if (!s) return s;
+    if (secret) s = s.replaceAll(secret, SECRET_MASK);
+    if (process.env.RECH_REDACT === "0") return s;
+    try { return redact(s).text; } catch { return s; } // missing rules must not swallow output
+  };
   const { files, existingSession } = served;
   const status = served.status, stdout = scrub(served.stdout), stderr = scrub(served.stderr);
   if (!opts.bridgeRetried && isBridgeTimeout(args, { status, stderr })) {
@@ -2730,7 +2760,7 @@ export async function daemonInstall(serveUrl: string): Promise<void> {
   const envRaw = await file(globalEnvFile).text().catch(() => "");
   const lines = envRaw.trimEnd().split("\n");
   const filtered = lines.filter(l => !l.startsWith(`${ENV_KEY}=`));
-  await Bun.write(globalEnvFile, [...filtered, envAssignment(ENV_KEY, keepProfileParam(serveUrl, lines.find(l => l.startsWith(`${ENV_KEY}=`))?.slice(ENV_KEY.length + 1))), ""].join("\n"));
+  await writeAtomic(globalEnvFile, [...filtered, envAssignment(ENV_KEY, keepProfileParam(serveUrl, lines.find(l => l.startsWith(`${ENV_KEY}=`))?.slice(ENV_KEY.length + 1))), ""].join("\n"), 0o600);
 
   const home = HOME;
   const bunBin = Bun.which("bun") ?? process.execPath;
@@ -3338,7 +3368,7 @@ async function rotateKey(name: string): Promise<void> {
   console.log(`New key for ${name}; URLs carrying the old key stop working now. Print new ones with: rech share <profile> --listener ${name}`);
 }
 
-async function setListener(name: string, opts: { publicUrl?: string; clearPublicUrl?: boolean; uploads?: boolean; hostUploadDirs?: string[]; noHostUploads?: boolean }): Promise<void> {
+async function setListener(name: string, opts: { publicUrl?: string; clearPublicUrl?: boolean; uploads?: boolean; hostUploadDirs?: string[]; noHostUploads?: boolean; readSecrets?: boolean }): Promise<void> {
   const config = await requireListeners();
   let listener = config.listeners.find(l => l.name === name);
   if (!listener) throw new Error(`Unknown listener "${name}". See rech listener ls.`);
@@ -3356,7 +3386,12 @@ async function setListener(name: string, opts: { publicUrl?: string; clearPublic
     else policy.hostDirs = [...new Set([...(policy.hostDirs ?? []), ...opts.hostUploadDirs!.map(d => realpathSync(resolve(d)))])];
     listener.uploads = policy;
   }
+  if (opts.readSecrets !== undefined) {
+    if (listener.profiles === "*") throw new Error(`"${name}" is the local management listener: read-secret is always available there.`);
+    if (opts.readSecrets) listener.readSecrets = true; else delete listener.readSecrets;
+  }
   await writeListeners(config);
+  if (opts.readSecrets !== undefined) console.log(opts.readSecrets ? `${name}: read-secret on. Anyone with this link can copy the value of any field (saved passwords included) on any site its profiles have open; --allow-domain only checks the site the caller names. Each read is logged without the value` : `${name}: read-secret off`);
   if (opts.publicUrl !== undefined || opts.clearPublicUrl) console.log(listener.publicUrl ? `${name} is reachable at ${listener.publicUrl}` : `${name}: public URL cleared`);
   if (opts.hostUploadDirs?.length || opts.noHostUploads) {
     const dirs = (listener.uploads || {}).hostDirs;
@@ -3427,7 +3462,6 @@ async function saveGlobalUrl(url: string): Promise<string> {
   return writeEnvUrl(GLOBAL_ENV_FILE, url);
 }
 
-/** Replace RECHROME_URL in an env file, keeping its other lines; owner-only, since the URL holds a key. */
 /** Write a file whole or not at all: a temp file beside it, then rename (atomic on one filesystem). */
 export async function writeAtomic(path: string, data: string, mode?: number): Promise<void> {
   // A symlinked .env.local stays a link: write the file it points to.
@@ -3464,6 +3498,7 @@ export async function ensureProjectDir(dir: string): Promise<void> {
   if (!existsSync(readme)) await writeAtomic(readme, PROJECT_DIR_README);
 }
 
+/** Replace RECHROME_URL in an env file, keeping its other lines; owner-only, since the URL holds a key. */
 async function writeEnvUrl(envPath: string, url: string): Promise<string> {
   const lines = (await file(envPath).text().catch(() => "")).split("\n").filter(l => l.trim() && !l.startsWith(`${ENV_KEY}=`));
   await writeAtomic(envPath, [...lines, envAssignment(ENV_KEY, url), ""].join("\n"), 0o600);
@@ -3974,7 +4009,7 @@ async function setup(opts: SetupOptions = {}): Promise<void> {
     guide?.close();
     console.log(`      Saved token for ${extraDisplay}`);
   }
-  if (bridgeVerified && isTTY && !opts.listen) await setupShareStep(ask, profileEmail);
+  if (bridgeVerified && isTTY && !opts.listen && !opts.skipShare) await setupShareStep(ask, profileEmail);
   rl?.close();
   envWatcher?.close();
   if (bridgeVerified)
@@ -4423,7 +4458,7 @@ async function status(): Promise<void> {
 }
 
 
-export type SetupOptions = { profile?: string; token?: string; listen?: string; prefix?: string; port?: number; yes?: boolean };
+export type SetupOptions = { profile?: string; token?: string; listen?: string; prefix?: string; port?: number; yes?: boolean; /** Called from `rech share`, which shares the profile itself. */ skipShare?: boolean };
 export type RechHandlers = {
   serve(): Promise<void> | void;
   status(): Promise<void>;
@@ -4440,7 +4475,7 @@ export type RechHandlers = {
   allowListener(name: string, profiles: string[]): Promise<void>;
   denyListener(name: string, profiles: string[]): Promise<void>;
   rotateKey(name: string): Promise<void>;
-  setListener(name: string, opts: { publicUrl?: string; clearPublicUrl?: boolean; uploads?: boolean; hostUploadDirs?: string[]; noHostUploads?: boolean }): Promise<void>;
+  setListener(name: string, opts: { publicUrl?: string; clearPublicUrl?: boolean; uploads?: boolean; hostUploadDirs?: string[]; noHostUploads?: boolean; readSecrets?: boolean }): Promise<void>;
   setup(opts: SetupOptions): Promise<void>;
   tray(action?: string): Promise<void>;
   provisionProfile(name: string, opts: { headed: boolean; experimental: boolean }): Promise<void>;
@@ -4473,6 +4508,8 @@ const HELP_EPILOGUE = `Browser commands (sent to this project's Chrome session):
       --isolate      in a throwaway session, e.g. for a login flow
   rech fill-secret <ref> --from-env VAR | --totp-from-env VAR [--env-file f] [--allow-domain '*.example.com']
                      type a password / TOTP code without it reaching argv, logs or output
+  rech read-secret <ref> --allow-domain <host> | <vault command>
+                     copy a field's value (e.g. an API secret) into a pipe, never shown or logged
   rech pw <args>     forward verbatim to playwright-cli, e.g. \`rech pw --version\`
   rech --version     rechrome's version
 
@@ -4588,9 +4625,10 @@ export function rechCli(argv: string[], handlers: RechHandlers) {
         .option("clear-public-url", { type: "boolean", conflicts: "public-url" })
         .option("uploads", { type: "boolean", describe: "Uploads of images the link holder sends (rech upload) are on by default; --no-uploads turns them off" })
         .option("host-upload-dir", { type: "string", array: true, requiresArg: true, describe: "Off by default. Also let links upload files already on this host, from inside this directory (rech upload --host <path>); repeatable" })
+        .option("read-secrets", { type: "boolean", describe: "Off by default. Let this listener's links copy any field's value (saved passwords too) into a pipe (rech read-secret): only for links you trust with those accounts. --no-read-secrets turns it off" })
         .option("host-uploads", { type: "boolean", describe: "--no-host-uploads turns host-path uploads off again" })
-        .check(a => a.publicUrl !== undefined || a.clearPublicUrl || a.uploads !== undefined || a.hostUploadDir?.length || a.hostUploads === false ? true : "Pass --public-url <url>, --clear-public-url, --uploads/--no-uploads, or --host-upload-dir/--no-host-uploads"),
-        a => handlers.setListener(a.name, { publicUrl: a.publicUrl, clearPublicUrl: a.clearPublicUrl, ...(a.uploads !== undefined ? { uploads: a.uploads } : {}), ...(a.hostUploadDir?.length ? { hostUploadDirs: a.hostUploadDir as string[] } : {}), ...(a.hostUploads === false ? { noHostUploads: true } : {}) }))
+        .check(a => a.publicUrl !== undefined || a.clearPublicUrl || a.uploads !== undefined || a.hostUploadDir?.length || a.hostUploads === false || a.readSecrets !== undefined ? true : "Pass --public-url <url>, --clear-public-url, --uploads/--no-uploads, or --host-upload-dir/--no-host-uploads"),
+        a => handlers.setListener(a.name, { publicUrl: a.publicUrl, clearPublicUrl: a.clearPublicUrl, ...(a.uploads !== undefined ? { uploads: a.uploads } : {}), ...(a.hostUploadDir?.length ? { hostUploadDirs: a.hostUploadDir as string[] } : {}), ...(a.hostUploads === false ? { noHostUploads: true } : {}), ...(a.readSecrets !== undefined ? { readSecrets: a.readSecrets } : {}) }))
       .command("port [name]", "Print a listener's port (for a proxy command)", y => y.positional("name", { type: "string" }),
         a => handlers.listenerPort(a.name))
       .command("rotate-key <name>", "Give a listener a new key (old URLs stop working)", y => y.positional("name", { type: "string", demandOption: true }),

package/redact.js

@@ -0,0 +1,236 @@
+// @bun
+// redact.ts
+import { readFileSync } from "fs";
+function goToJs(src) {
+  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 = [];
+  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 === "[") {
+      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;
+    }
+    if (c === "|" && extra) {
+      out += ")".repeat(extra) + "|" + "(?i:".repeat(extra);
+      continue;
+    }
+    out += c;
+  }
+  out += ")".repeat(extra);
+  return { source: out, flags: [...new Set(flags)].join("") };
+}
+function loadGitleaksRules(toml) {
+  const c = Bun.TOML.parse(toml);
+  const compile = (r) => {
+    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 = [];
+  for (const r of c.rules) {
+    if (!r.regex)
+      continue;
+    const allow = [...gAllow];
+    const allowMatch = [];
+    const allowLine = [];
+    const stop = [...gStop];
+    for (const a of [...r.allowlists ?? [], ...r.allowlist ? [r.allowlist] : []]) {
+      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;
+}
+var OWN_RULES = [
+  { 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: [] },
+  { 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: [] },
+  { id: "otp-code", re: /(?:code|\u30B3\u30FC\u30C9|otp|pin|passcode|\u8A8D\u8A3C|\u78BA\u8A8D\u756A\u53F7|\u30EF\u30F3\u30BF\u30A4\u30E0)[^\d\n]{0,20}(?<![\d.])(\d{6})(?![\d.])/gid, group: 1, keywords: [], allow: [], stop: [] }
+];
+var cached;
+function secretRules() {
+  cached ??= [...loadGitleaksRules(readFileSync(new URL("./secret-rules/gitleaks.toml", import.meta.url), "utf8")), ...OWN_RULES];
+  return cached;
+}
+function shannon(s) {
+  const f = new Map;
+  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;
+}
+function findKnown(text, known) {
+  const forms = new Set;
+  for (const v of known) {
+    if (v.length < 6)
+      continue;
+    forms.add(v);
+    forms.add(JSON.stringify(v).slice(1, -1));
+  }
+  const out = [];
+  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;
+}
+var OPAQUE_RUN = /[A-Za-z0-9+/=_-]{4096,}/g;
+function findSecrets(text, opts = {}) {
+  if (text.length >= 4096 && OPAQUE_RUN.test(text)) {
+    OPAQUE_RUN.lastIndex = 0;
+    const out = opts.known?.length ? findKnown(text, opts.known) : [];
+    let at = 0;
+    for (const m of [...text.matchAll(OPAQUE_RUN), { index: text.length, 0: "" }]) {
+      const piece = text.slice(at, m.index);
+      if (piece)
+        for (const h of findSecrets(piece, { ...opts, known: [] }))
+          out.push({ ...h, start: h.start + at, end: h.end + at });
+      at = m.index + m[0].length;
+    }
+    return out;
+  }
+  OPAQUE_RUN.lastIndex = 0;
+  const rules = opts.rules ?? secretRules();
+  const lower = text.toLowerCase();
+  const out = 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)) {
+      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(`
+`, m.index) + 1;
+        const le = text.indexOf(`
+`, 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 {
+        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;
+}
+function redact(text, opts = {}) {
+  const hits = findSecrets(text, opts).sort((a, b) => a.start - b.start || b.end - a.end);
+  if (!hits.length)
+    return { text, kinds: [] };
+  const spans = [];
+  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))] };
+}
+export {
+  OWN_RULES,
+  findSecrets,
+  goToJs,
+  loadGitleaksRules,
+  redact,
+  secretRules
+};

package/redact.ts

@@ -0,0 +1,242 @@
+// Secret redaction, copied from snomiao/slack-term ts/redact.ts (PR #68, 73ae26e); keep
+// the two in sync. rech runs it on every command's stdout/stderr; each secret becomes
+// `[redacted:<rule id>]`. RECH_REDACT=0 turns it off for one call.
+//
+// Rules: gitleaks' default set (secret-rules/gitleaks.toml, v8.30.1, MIT — see
+// secret-rules/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 flag runs to the group's end across `|`; a JS scoped group must not swallow the
+    // alternation, so close it before `|` and reopen it after.
+    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("./secret-rules/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[] };
+
+/** Unbroken runs of base64/hex characters this long are image data or blobs, not secrets (the
+ *  longest gitleaks secret is a few hundred characters). Scanning them costs seconds per MB, as
+ *  short keywords such as `api` or `okta` turn up in random base64 by chance. */
+const OPAQUE_RUN = /[A-Za-z0-9+/=_-]{4096,}/g;
+
+/** Every secret span in `text`. */
+export function findSecrets(text: string, opts: RedactOptions = {}): SecretHit[] {
+  if (text.length >= 4096 && OPAQUE_RUN.test(text)) {
+    OPAQUE_RUN.lastIndex = 0;
+    // Scan the text between the runs only, keeping the original offsets; known values are still
+    // found everywhere, since an exact match is cheap.
+    const out: SecretHit[] = opts.known?.length ? findKnown(text, opts.known) : [];
+    let at = 0;
+    for (const m of [...text.matchAll(OPAQUE_RUN), { index: text.length, 0: '' } as unknown as RegExpExecArray]) {
+      const piece = text.slice(at, m.index);
+      if (piece) for (const h of findSecrets(piece, { ...opts, known: [] })) out.push({ ...h, start: h.start + at, end: h.end + at });
+      at = m.index + m[0].length;
+    }
+    return out;
+  }
+  OPAQUE_RUN.lastIndex = 0;
+  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))] };
+}