whatileaked 0.3.1 → 0.5.0

package/README.md

@@ -105,6 +105,17 @@ same credential always produces the same code, so two rows sharing a code are
 one key you reused in two places, and two different codes are two different
 keys.
 
+### Sharing it
+
+The last line of every scan is made only of counts — no project, path, rule or
+fingerprint — so it is the part you can paste or screenshot anywhere:
+
+```
+whatileaked: 3 credentials sent to a model provider, across 561 transcripts.
+```
+
+A clean scan ends the same way, with `no credentials`.
+
 ---
 
 ## Is it a real key, or just a test fixture?
@@ -194,18 +205,26 @@ npx whatileaked scan || echo "found something"
 
 | Agent | Folder |
 | --- | --- |
-| Claude Code | `~/.claude/projects/` · `~/.claude/CLAUDE.md` |
-| Codex | `~/.codex/sessions/` · `~/.codex/archived_sessions/` · `~/.codex/AGENTS.md` |
+| Claude Code | `~/.claude/projects/` · `~/.claude/history.jsonl` · `~/.claude/paste-cache/` · `~/.claude/CLAUDE.md` |
+| Codex | `~/.codex/sessions/` · `~/.codex/archived_sessions/` · `~/.codex/history.jsonl` · `~/.codex/AGENTS.md` |
 | Cursor | `~/.cursor/projects/*/agent-transcripts/` |
-
-Cursor keeps its older Ask-mode chats in SQLite rather than jsonl, and those are
-not scanned. Reading them needs `node:sqlite`, which arrived in Node 22.5, and
-this runs on Node 20. Agent transcripts are covered; Ask history is not.
-
-Transcripts record credentials that were already sent. Instruction and memory
-files are worse: they are read again at the start of the next session, so a
-credential in one keeps leaking until the file is edited. Both are scanned, and
-`wipe` rewrites both.
+| opencode | `~/.local/share/opencode/opencode.db` |
+
+opencode keeps its sessions in a SQLite database. Reading it needs Node's
+built-in `node:sqlite`, which loads without a flag from Node 22.13. On an older
+Node the scan still finds the file and says, in one line, that it was not
+scanned, so a skipped database never looks clean. Only the messages table is
+read, and `wipe` does not rewrite the database: delete those sessions in
+opencode, and rotate.
+
+Cursor keeps its older Ask-mode chats in SQLite as well, and those are not
+scanned yet. Agent transcripts are covered; Ask history is not.
+
+Transcripts record credentials that were already sent. So does prompt history,
+which keeps every prompt you typed and every long paste after the session itself
+has been cleaned up. Instruction and memory files are worse: they are read again
+at the start of the next session, so a credential in one keeps leaking until the
+file is edited. All of them are scanned, and `wipe` rewrites all of them.
 
 Nowhere else. It does not read your repos, your shell history, or your
 environment. Adding support for another agent is one small file — pull requests

package/dist/cli.js

@@ -161,7 +161,10 @@ var TerminalReporter = class {
     if (totals.length === 0) {
       this.#write(green("No credentials found."));
       this.#write("");
+      this.#unread(stats);
+      if (stats.unread.length > 0) this.#write("");
       this.#write(dim(DISCLOSURE));
+      this.#share(sent, stats);
       return;
     }
     for (const total of totals) {
@@ -190,12 +193,36 @@ var TerminalReporter = class {
         yellow(`${plural(stats.unscannable, "message")} could not be scanned and are not counted.`)
       );
     }
+    this.#unread(stats);
     this.#write("");
     this.#write(dim("The 8-character code is a fingerprint, never the secret: a truncated"));
     this.#write(dim("SHA-256, so one credential shows the same code everywhere it leaked."));
     this.#write(dim("Some findings will be test fixtures \u2014 open the file to tell."));
     this.#write("");
     this.#write(dim(DISCLOSURE));
+    this.#share(sent, stats);
+  }
+  /** One plain line per file found and not read. Printed under a clean result
+   *  too, which is exactly where leaving it out would mislead. */
+  #unread(stats) {
+    for (const file of stats.unread) {
+      this.#write(yellow(`Found ${shorten(file.path)} but did not scan it: ${file.reason}.`));
+    }
+  }
+  /**
+   * The one line meant to be pasted somewhere public. Everything above it names
+   * projects, paths and fingerprints, so nobody shares it; this is counts only,
+   * and stays that way. It is last so a screenshot can crop to it, unstyled so
+   * a copy carries nothing but the words, and it repeats the headline's
+   * transmitted-only count for the same reason the headline keeps memory files
+   * out of it.
+   */
+  #share(sent, stats) {
+    const credentials = sent === 0 ? "no credentials" : plural(sent, "credential");
+    this.#write("");
+    this.#write(
+      `whatileaked: ${credentials} sent to a model provider, across ${plural(stats.transcripts, "transcript")}.`
+    );
   }
 };
 function count(value) {
@@ -2381,6 +2408,50 @@ async function* readLines(path) {
   }
 }
 
+// src/sources/listing.ts
+import { readdir, realpath, stat } from "fs/promises";
+import { join } from "path";
+async function listDirectories(root) {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+var FileExtension = {
+  jsonl: ".jsonl",
+  markdown: ".md",
+  text: ".txt",
+  database: ".db"
+};
+function isJsonl(path) {
+  return path.endsWith(FileExtension.jsonl);
+}
+async function listFiles(dir, extension) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function resolveFile(path) {
+  try {
+    const real = await realpath(path);
+    return (await stat(real)).isFile() ? real : null;
+  } catch {
+    return null;
+  }
+}
+async function walkDirectories(root) {
+  const found = [root];
+  for (const name of await listDirectories(root)) {
+    found.push(...await walkDirectories(join(root, name)));
+  }
+  return found;
+}
+
 // src/transcript/reader.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { createInterface as createInterface2 } from "readline";
@@ -2413,6 +2484,7 @@ var TranscriptReader = class {
 };
 
 // src/scan-run.ts
+var NEEDS_SQLITE = "reading it needs Node 22.13 or newer";
 var ScanRun = class {
   #sources;
   #scanner;
@@ -2433,12 +2505,19 @@ var ScanRun = class {
       memoryFiles: 0,
       entries: 0,
       skipped: 0,
-      unscannable: 0
+      unscannable: 0,
+      unread: []
     };
     for (const source of this.#sources) {
       for await (const file of source.discover()) {
-        if (file.kind === FileKind.transcript) {
-          stats.transcripts++;
+        if (file.messages !== void 0) {
+          await this.#readDatabase(file, file.messages, findings, stats);
+          this.#progress.advance(stats.transcripts + stats.memoryFiles, file.project);
+          continue;
+        }
+        if (file.kind === FileKind.transcript) stats.transcripts++;
+        else stats.memoryFiles++;
+        if (isJsonl(file.path)) {
           const reader = new TranscriptReader();
           for await (const entry of reader.read(file.path)) {
             this.#collect(file, entry.line, entry.index, findings, stats);
@@ -2446,7 +2525,7 @@ var ScanRun = class {
           stats.entries += reader.stats.entries;
           stats.skipped += reader.stats.skipped;
         } else {
-          stats.memoryFiles++;
+          if (file.kind === FileKind.transcript) stats.entries++;
           for await (const line of readLines(file.path)) {
             this.#collect(file, line.text, line.number, findings, stats);
           }
@@ -2458,6 +2537,24 @@ var ScanRun = class {
     this.#reporter.report(findings, stats);
     return findings.length;
   }
+  /** A database counts as one transcript once it has been read. One it could
+   *  not open is listed instead, so a scan that skipped it never reads as clean. */
+  async #readDatabase(file, messages, findings, stats) {
+    if (messages === null) {
+      stats.unread.push({ path: file.path, reason: NEEDS_SQLITE });
+      return;
+    }
+    let index = 0;
+    try {
+      for await (const message of messages()) {
+        stats.entries++;
+        this.#collect({ ...file, project: message.project }, message.text, index++, findings, stats);
+      }
+      stats.transcripts++;
+    } catch {
+      stats.unread.push({ path: file.path, reason: "it could not be opened" });
+    }
+  }
   /** One entry the engine chokes on must not cost the other 700,000. */
   #collect(file, text, at, findings, stats) {
     let matches = [];
@@ -2485,47 +2582,12 @@ var ScanRun = class {
 // src/sources/claude-code-source.ts
 import { basename, join as join2 } from "path";
 
-// src/sources/listing.ts
-import { readdir, realpath, stat } from "fs/promises";
-import { join } from "path";
-async function listDirectories(root) {
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-var FileExtension = { jsonl: ".jsonl", markdown: ".md" };
-async function listFiles(dir, extension) {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-async function resolveFile(path) {
-  try {
-    const real = await realpath(path);
-    return (await stat(real)).isFile() ? real : null;
-  } catch {
-    return null;
-  }
-}
-async function walkDirectories(root) {
-  const found = [root];
-  for (const name of await listDirectories(root)) {
-    found.push(...await walkDirectories(join(root, name)));
-  }
-  return found;
-}
-
 // src/transcript/entry.ts
 var SourceName = {
   "claude-code": "claude-code",
   codex: "codex",
-  cursor: "cursor"
+  cursor: "cursor",
+  opencode: "opencode"
 };
 
 // src/transcript/shape.ts
@@ -2553,6 +2615,19 @@ var ClaudeCodeSource = class {
     if (instructions !== null) {
       yield { source: this.name, kind: FileKind.memory, path: instructions, project: this.name };
     }
+    const history = await resolveFile(join2(this.#home, ".claude", "history.jsonl"));
+    if (history !== null) {
+      yield { source: this.name, kind: FileKind.transcript, path: history, project: this.name };
+    }
+    const pastes = join2(this.#home, ".claude", "paste-cache");
+    for (const file of await listFiles(pastes, FileExtension.text)) {
+      yield {
+        source: this.name,
+        kind: FileKind.transcript,
+        path: join2(pastes, file),
+        project: this.name
+      };
+    }
     const root = join2(this.#home, ".claude", "projects");
     for (const slug of await listDirectories(root)) {
       const dir = join2(root, slug);
@@ -2606,6 +2681,10 @@ var CodexSource = class {
     if (instructions !== null) {
       yield { source: this.name, kind: FileKind.memory, path: instructions, project: this.name };
     }
+    const history = await resolveFile(join3(this.#home, ".codex", "history.jsonl"));
+    if (history !== null) {
+      yield { source: this.name, kind: FileKind.transcript, path: history, project: this.name };
+    }
     for (const root of ["sessions", "archived_sessions"]) {
       for (const dir of await walkDirectories(join3(this.#home, ".codex", root))) {
         for (const file of await listFiles(dir, FileExtension.jsonl)) {
@@ -2689,6 +2768,73 @@ async function isDirectory(path) {
   }
 }
 
+// src/sources/opencode-source.ts
+import { basename as basename4, join as join5 } from "path";
+var OpencodeSource = class {
+  name = SourceName.opencode;
+  #home;
+  #load;
+  constructor(home2, load = loadSqlite) {
+    this.#home = home2;
+    this.#load = load;
+  }
+  async *discover() {
+    const dir = join5(this.#home, ".local", "share", "opencode");
+    for (const file of await listFiles(dir, FileExtension.database)) {
+      const path = join5(dir, file);
+      const sqlite = await this.#load();
+      yield {
+        source: this.name,
+        kind: FileKind.transcript,
+        path,
+        project: this.name,
+        messages: sqlite === null ? null : () => readMessages(sqlite, path, this.name)
+      };
+    }
+  }
+};
+async function* readMessages(sqlite, path, fallback) {
+  const db = new sqlite.DatabaseSync(path, { readOnly: true });
+  try {
+    const directories = /* @__PURE__ */ new Map();
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (?, ?)").all("session", "session_v2");
+    for (const { name } of tables) {
+      for (const row of db.prepare(`SELECT id, directory FROM "${String(name)}"`).iterate()) {
+        if (typeof row.id === "string" && typeof row.directory === "string") {
+          directories.set(row.id, row.directory);
+        }
+      }
+    }
+    for (const row of db.prepare("SELECT session_id, data FROM session_message").iterate()) {
+      if (typeof row.data !== "string") continue;
+      const directory = typeof row.session_id === "string" ? directories.get(row.session_id) : null;
+      yield { project: directory == null ? fallback : basename4(directory), text: row.data };
+    }
+  } finally {
+    db.close();
+  }
+}
+var loading = null;
+function loadSqlite() {
+  loading ??= importSqlite();
+  return loading;
+}
+async function importSqlite() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    if (String(warning).includes("SQLite")) return;
+    Reflect.apply(emitWarning, process, [warning, ...rest]);
+  });
+  try {
+    const specifier = "node:sqlite";
+    return await import(specifier);
+  } catch {
+    return null;
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+}
+
 // src/wipe/confirm.ts
 import { createInterface as createInterface3 } from "readline/promises";
 var CONFIRMATION = "wipe";
@@ -2732,16 +2878,16 @@ var WipeRun = class {
     this.#write = write;
   }
   async run() {
-    const plans = await this.#plan();
+    const { plans, untouched } = await this.#plan();
     if (plans.length === 0) {
-      return { planned: [], filesRewritten: 0, secretsRedacted: 0, confirmed: false };
+      return { planned: [], untouched, filesRewritten: 0, secretsRedacted: 0, confirmed: false };
     }
     this.#preview(plans);
     const answer = await this.#prompt.ask(
       `  Type ${bold(red(CONFIRMATION))} to rewrite these files, or anything else to stop: `
     );
     if (answer !== CONFIRMATION) {
-      return { planned: plans, filesRewritten: 0, secretsRedacted: 0, confirmed: false };
+      return { planned: plans, untouched, filesRewritten: 0, secretsRedacted: 0, confirmed: false };
     }
     let filesRewritten = 0;
     let secretsRedacted = 0;
@@ -2749,12 +2895,18 @@ var WipeRun = class {
       secretsRedacted += await this.#rewrite(plan.file);
       filesRewritten++;
     }
-    return { planned: plans, filesRewritten, secretsRedacted, confirmed: true };
+    return { planned: plans, untouched, filesRewritten, secretsRedacted, confirmed: true };
   }
   async #plan() {
     const plans = [];
+    const untouched = [];
     for (const source of this.#sources) {
       for await (const file of source.discover()) {
+        if (file.messages !== void 0) {
+          if (!await this.#holdsSecret(file.messages)) continue;
+          untouched.push(file.path);
+          continue;
+        }
         let lines = 0;
         let secrets = 0;
         for await (const text of this.#textOf(file)) {
@@ -2768,12 +2920,25 @@ var WipeRun = class {
         }
       }
     }
-    return plans;
+    return { plans, untouched };
+  }
+  /** True for a database that cannot be read: it may hold one, and saying
+   *  nothing about it would let a wipe pass for complete. */
+  async #holdsSecret(messages) {
+    if (messages == null) return true;
+    try {
+      for await (const message of messages()) {
+        if (this.#scanner.secretsOf(message.text).size > 0) return true;
+      }
+      return false;
+    } catch {
+      return true;
+    }
   }
   /** The rewrite below is textual and kind-blind; only counting needs to know
    *  which reader gets the file. */
   async *#textOf(file) {
-    if (file.kind === FileKind.memory) {
+    if (!isJsonl(file.path)) {
       for await (const line of readLines(file.path)) yield line.text;
       return;
     }
@@ -2836,7 +3001,8 @@ async function main(argv) {
   const sources = [
     new ClaudeCodeSource(homedir()),
     new CodexSource(homedir()),
-    new CursorSource(homedir())
+    new CursorSource(homedir()),
+    new OpencodeSource(homedir())
   ];
   const scanner = new Scanner(new KeywordIndex(compileRules(SECRET_RULE_SOURCES)));
   return command === Command.wipe ? await wipe(sources, scanner, write) : await scan(sources, scanner, write);
@@ -2855,7 +3021,13 @@ async function wipe(sources, scanner, write) {
   write(dim("  replacing credentials in your local transcripts with a placeholder"));
   write("");
   const outcome = await new WipeRun(sources, scanner, new TerminalPrompt(), write).run();
+  for (const path of outcome.untouched) {
+    write(yellow(`  Not rewritten: ${shorten(path)} is a database, and wipe only rewrites text.`));
+    write(dim("  Delete those sessions in the agent itself, and rotate what they held."));
+    write("");
+  }
   if (outcome.planned.length === 0) {
+    if (outcome.untouched.length > 0) return 1;
     write(green("  No credentials found. Nothing to wipe."));
     return 0;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "whatileaked",
-  "version": "0.3.1",
-  "description": "Scan your local Claude Code, Codex and Cursor transcripts for credentials you already sent to a model provider.",
+  "version": "0.5.0",
+  "description": "Scan your local Claude Code, Codex, Cursor and opencode transcripts for credentials you already sent to a model provider.",
   "type": "module",
   "imports": {
     "#scripts/*": "./scripts/*.ts",