whatileaked 0.1.0 → 0.3.0

package/README.md

@@ -192,8 +192,18 @@ npx whatileaked scan || echo "found something"
 
 | Agent | Folder |
 | --- | --- |
-| Claude Code | `~/.claude/projects/` |
-| Codex | `~/.codex/sessions/` |
+| Claude Code | `~/.claude/projects/` · `~/.claude/CLAUDE.md` |
+| Codex | `~/.codex/sessions/` · `~/.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.
 
 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

@@ -52,9 +52,20 @@ function home() {
 }
 
 // src/report/paths.ts
+import { realpathSync } from "fs";
 function shorten(file) {
   const home2 = process.env.HOME;
-  return home2 !== void 0 && file.startsWith(home2) ? `~${file.slice(home2.length)}` : file;
+  if (home2 === void 0) return file;
+  if (file.startsWith(home2)) return `~${file.slice(home2.length)}`;
+  const real = realHome(home2);
+  return file.startsWith(real) ? `~${file.slice(real.length)}` : file;
+}
+function realHome(home2) {
+  try {
+    return realpathSync(home2);
+  } catch {
+    return home2;
+  }
 }
 function plural(count2, noun) {
   return `${count2.toLocaleString("en-US")} ${noun}${count2 === 1 ? "" : "s"}`;
@@ -71,12 +82,12 @@ var Progress = class {
     this.#write = write;
     this.#enabled = enabled2;
   }
-  advance(transcripts, project) {
+  advance(files, project) {
     if (!this.#enabled) return;
-    if (transcripts % 8 !== 0) return;
+    if (files % 8 !== 0) return;
     const spinner = SPINNER[this.#frame % SPINNER.length] ?? "|";
     this.#frame++;
-    this.#write(`\r${CLEAR_LINE}  ${spinner} reading ${transcripts} transcripts \u2014 ${clip(project)}`);
+    this.#write(`\r${CLEAR_LINE}  ${spinner} reading ${files} files \u2014 ${clip(project)}`);
   }
   done() {
     if (this.#enabled) this.#write(`\r${CLEAR_LINE}`);
@@ -86,6 +97,9 @@ function clip(project) {
   return project.length > 40 ? `${project.slice(0, 39)}\u2026` : project;
 }
 
+// src/sources/source.ts
+var FileKind = { transcript: "transcript", memory: "memory" };
+
 // src/report/aggregate.ts
 function aggregate(findings) {
   const byRule = /* @__PURE__ */ new Map();
@@ -94,21 +108,22 @@ function aggregate(findings) {
     totals.set(finding.rule, (totals.get(finding.rule) ?? 0) + 1);
     const sites = byRule.get(finding.rule) ?? /* @__PURE__ */ new Map();
     byRule.set(finding.rule, sites);
-    const key = `${finding.fingerprint}:${finding.project}`;
+    const where2 = finding.kind === FileKind.memory ? finding.file : finding.project;
+    const key = `${finding.fingerprint}:${where2}:${finding.kind}`;
     const site = sites.get(key);
     if (site) {
       site.occurrences++;
-      site.firstEntryIndex = Math.min(site.firstEntryIndex, finding.entryIndex);
+      site.firstAt = Math.min(site.firstAt, finding.at);
       continue;
     }
     sites.set(key, {
       fingerprint: finding.fingerprint,
+      kind: finding.kind,
       project: finding.project,
-      sessionId: finding.sessionId,
       file: finding.file,
       context: finding.context,
       occurrences: 1,
-      firstEntryIndex: finding.entryIndex
+      firstAt: finding.at
     });
   }
   return [...byRule.entries()].map(([rule, sites]) => ({
@@ -135,9 +150,12 @@ var TerminalReporter = class {
   }
   report(findings, stats) {
     const totals = aggregate(findings);
-    const secrets = totals.reduce((sum, total) => sum + total.distinct, 0);
+    const sent = distinct(totals, FileKind.transcript);
+    const onDisk = distinct(totals, FileKind.memory);
     this.#write(
-      dim(`  scanned ${count(stats.transcripts)} transcripts \xB7 ${count(stats.entries)} messages`)
+      dim(
+        `  scanned ${count(stats.transcripts)} transcripts \xB7 ${count(stats.entries)} messages \xB7 ${count(stats.memoryFiles)} memory files`
+      )
     );
     this.#write("");
     if (totals.length === 0) {
@@ -149,16 +167,24 @@ var TerminalReporter = class {
     for (const total of totals) {
       this.#write(`${red("*")} ${bold(total.rule)}  ${dim(plural(total.distinct, "secret"))}`);
       for (const site of total.sites) {
-        const times = site.occurrences === 1 ? "sent once" : `sent ${count(site.occurrences)} times`;
+        const times = occurrences(site);
         this.#write(
           `    ${yellow(site.fingerprint.slice(0, FINGERPRINT_CHARS))}  ${site.project.padEnd(PROJECT_COLUMN)} ${dim(times)}`
         );
         if (site.context !== "") this.#write(`              ${dim(`${site.context}***`)}`);
-        this.#write(`              ${dim(shorten(site.file))}`);
+        this.#write(`              ${dim(where(site))}`);
       }
       this.#write("");
     }
-    this.#write(bold(red(`${plural(secrets, "credential")} sent to a model provider.`)));
+    this.#write(bold(red(`${plural(sent, "credential")} sent to a model provider.`)));
+    if (onDisk > 0) {
+      this.#write(
+        bold(red(`${plural(onDisk, "credential")} still on disk, in files your agent reads.`))
+      );
+      this.#write(
+        red("Remove them there as well as rotating, or the next session sends them again.")
+      );
+    }
     if (stats.unscannable > 0) {
       this.#write(
         yellow(`${plural(stats.unscannable, "message")} could not be scanned and are not counted.`)
@@ -175,6 +201,22 @@ var TerminalReporter = class {
 function count(value) {
   return value.toLocaleString("en-US");
 }
+function occurrences(site) {
+  if (site.kind === FileKind.memory) {
+    return site.occurrences === 1 ? "on one line" : `on ${count(site.occurrences)} lines`;
+  }
+  return site.occurrences === 1 ? "sent once" : `sent ${count(site.occurrences)} times`;
+}
+function where(site) {
+  const path = shorten(site.file);
+  return site.kind === FileKind.memory ? `${path}:${site.firstAt}` : path;
+}
+function distinct(totals, kind) {
+  return totals.reduce((sum, total) => {
+    const matching = total.sites.filter((site) => site.kind === kind);
+    return sum + new Set(matching.map((site) => site.fingerprint)).size;
+  }, 0);
+}
 
 // src/scan/keyword-index.ts
 var WINDOW_CHARS = 512;
@@ -2319,16 +2361,36 @@ var SECRET_RULE_SOURCES = [
   }
 ];
 
-// src/transcript/reader.ts
+// src/memory/reader.ts
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
+async function* readLines(path) {
+  const stream = createReadStream(path, "utf8");
+  stream.on("error", () => {
+  });
+  const lines = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  let number = 0;
+  try {
+    for await (const text of lines) {
+      number++;
+      if (text.trim().length === 0) continue;
+      yield { number, text };
+    }
+  } catch {
+    return;
+  }
+}
+
+// src/transcript/reader.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { createInterface as createInterface2 } from "readline";
 var TranscriptReader = class {
   stats = { entries: 0, skipped: 0 };
   async *read(path) {
-    const stream = createReadStream(path, "utf8");
+    const stream = createReadStream2(path, "utf8");
     stream.on("error", () => {
     });
-    const lines = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+    const lines = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
     let index = -1;
     try {
       for await (const line of lines) {
@@ -2366,48 +2428,65 @@ var ScanRun = class {
    *  re-deriving it from the reporter's output. */
   async run() {
     const findings = [];
-    const stats = { transcripts: 0, entries: 0, skipped: 0, unscannable: 0 };
+    const stats = {
+      transcripts: 0,
+      memoryFiles: 0,
+      entries: 0,
+      skipped: 0,
+      unscannable: 0
+    };
     for (const source of this.#sources) {
       for await (const file of source.discover()) {
-        stats.transcripts++;
-        this.#progress.advance(stats.transcripts, file.project);
-        const reader = new TranscriptReader();
-        for await (const entry of reader.read(file.path)) {
-          let matches = [];
-          try {
-            matches = this.#scanner.scan(entry.line);
-          } catch {
-            stats.unscannable++;
-            continue;
+        if (file.kind === FileKind.transcript) {
+          stats.transcripts++;
+          const reader = new TranscriptReader();
+          for await (const entry of reader.read(file.path)) {
+            this.#collect(file, entry.line, entry.index, findings, stats);
           }
-          for (const match of matches) {
-            findings.push({
-              rule: match.rule,
-              fingerprint: match.fingerprint,
-              context: match.context,
-              source: file.source,
-              project: file.project,
-              sessionId: file.sessionId,
-              file: file.path,
-              entryIndex: entry.index
-            });
+          stats.entries += reader.stats.entries;
+          stats.skipped += reader.stats.skipped;
+        } else {
+          stats.memoryFiles++;
+          for await (const line of readLines(file.path)) {
+            this.#collect(file, line.text, line.number, findings, stats);
           }
         }
-        stats.entries += reader.stats.entries;
-        stats.skipped += reader.stats.skipped;
+        this.#progress.advance(stats.transcripts + stats.memoryFiles, file.project);
       }
     }
     this.#progress.done();
     this.#reporter.report(findings, stats);
     return findings.length;
   }
+  /** One entry the engine chokes on must not cost the other 700,000. */
+  #collect(file, text, at, findings, stats) {
+    let matches = [];
+    try {
+      matches = this.#scanner.scan(text);
+    } catch {
+      stats.unscannable++;
+      return;
+    }
+    for (const match of matches) {
+      findings.push({
+        rule: match.rule,
+        fingerprint: match.fingerprint,
+        context: match.context,
+        source: file.source,
+        kind: file.kind,
+        project: file.project,
+        file: file.path,
+        at
+      });
+    }
+  }
 };
 
 // src/sources/claude-code-source.ts
 import { basename, join as join2 } from "path";
 
 // src/sources/listing.ts
-import { readdir } from "fs/promises";
+import { readdir, realpath, stat } from "fs/promises";
 import { join } from "path";
 async function listDirectories(root) {
   try {
@@ -2417,14 +2496,23 @@ async function listDirectories(root) {
     return [];
   }
 }
-async function listJsonl(dir) {
+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(".jsonl")).map((entry) => entry.name);
+    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)) {
@@ -2436,7 +2524,8 @@ async function walkDirectories(root) {
 // src/transcript/entry.ts
 var SourceName = {
   "claude-code": "claude-code",
-  codex: "codex"
+  codex: "codex",
+  cursor: "cursor"
 };
 
 // src/transcript/shape.ts
@@ -2460,28 +2549,46 @@ var ClaudeCodeSource = class {
     this.#home = home2;
   }
   async *discover() {
+    const instructions = await resolveFile(join2(this.#home, ".claude", "CLAUDE.md"));
+    if (instructions !== null) {
+      yield { source: this.name, kind: FileKind.memory, path: instructions, project: this.name };
+    }
     const root = join2(this.#home, ".claude", "projects");
     for (const slug of await listDirectories(root)) {
       const dir = join2(root, slug);
-      for (const file of await listJsonl(dir)) {
-        const path = join2(dir, file);
-        const meta = await firstMeta(path);
-        yield {
-          source: this.name,
-          path,
-          sessionId: meta === null ? basename(file, ".jsonl") : meta.sessionId,
-          project: meta === null ? slug : basename(meta.cwd)
-        };
+      let project = slug;
+      for (const nested of await walkDirectories(dir)) {
+        for (const file of await listFiles(nested, FileExtension.jsonl)) {
+          const path = join2(nested, file);
+          const cwd = await firstCwd(path);
+          if (cwd !== null) project = basename(cwd);
+          yield {
+            source: this.name,
+            kind: FileKind.transcript,
+            path,
+            project: cwd === null ? slug : basename(cwd)
+          };
+        }
+      }
+      for (const nested of await walkDirectories(join2(dir, "memory"))) {
+        for (const file of await listFiles(nested, FileExtension.markdown)) {
+          yield {
+            source: this.name,
+            kind: FileKind.memory,
+            path: join2(nested, file),
+            project
+          };
+        }
       }
     }
   }
 };
-async function firstMeta(path) {
+async function firstCwd(path) {
   const reader = new TranscriptReader();
   for await (const entry of reader.read(path)) {
     const sessionId = stringField(entry.payload, "sessionId");
     const cwd = stringField(entry.payload, "cwd");
-    if (sessionId !== null && cwd !== null) return { sessionId, cwd };
+    if (sessionId !== null && cwd !== null) return cwd;
   }
   return null;
 }
@@ -2495,40 +2602,99 @@ var CodexSource = class {
     this.#home = home2;
   }
   async *discover() {
+    const instructions = await resolveFile(join3(this.#home, ".codex", "AGENTS.md"));
+    if (instructions !== null) {
+      yield { source: this.name, kind: FileKind.memory, path: instructions, project: this.name };
+    }
     const root = join3(this.#home, ".codex", "sessions");
     for (const dir of await walkDirectories(root)) {
-      for (const file of await listJsonl(dir)) {
+      for (const file of await listFiles(dir, FileExtension.jsonl)) {
         const path = join3(dir, file);
-        const meta = await firstMeta2(path);
+        const cwd = await firstCwd2(path);
         yield {
           source: this.name,
+          kind: FileKind.transcript,
           path,
-          sessionId: meta === null ? basename2(file, ".jsonl") : meta.id,
-          project: meta === null ? basename2(dir) : basename2(meta.cwd)
+          project: cwd === null ? basename2(dir) : basename2(cwd)
         };
       }
     }
   }
 };
-async function firstMeta2(path) {
+async function firstCwd2(path) {
   const reader = new TranscriptReader();
   for await (const entry of reader.read(path)) {
     if (stringField(entry.payload, "type") !== "session_meta") continue;
     const payload = objectField(entry.payload, "payload");
     const id = stringField(payload, "id");
     const cwd = stringField(payload, "cwd");
-    if (id !== null && cwd !== null) return { id, cwd };
+    if (id !== null && cwd !== null) return cwd;
   }
   return null;
 }
 
+// src/sources/cursor-source.ts
+import { stat as stat2 } from "fs/promises";
+import { basename as basename3, join as join4 } from "path";
+var CursorSource = class {
+  name = SourceName.cursor;
+  #home;
+  constructor(home2) {
+    this.#home = home2;
+  }
+  async *discover() {
+    const root = join4(this.#home, ".cursor", "projects");
+    for (const slug of await listDirectories(root)) {
+      const project = await projectName(slug);
+      for (const dir of await walkDirectories(join4(root, slug, "agent-transcripts"))) {
+        for (const file of await listFiles(dir, FileExtension.jsonl)) {
+          yield {
+            source: this.name,
+            kind: FileKind.transcript,
+            path: join4(dir, file),
+            project
+          };
+        }
+      }
+    }
+  }
+};
+async function projectName(slug) {
+  const path = await resolveSlug(slug);
+  return path === null ? slug : basename3(path);
+}
+async function resolveSlug(slug) {
+  const parts = slug.split("-");
+  let path = "";
+  let index = 0;
+  while (index < parts.length) {
+    let end = index;
+    let candidate = `${path}/${parts[index]}`;
+    while (!await isDirectory(candidate) && end + 1 < parts.length) {
+      end++;
+      candidate = `${candidate}-${parts[end]}`;
+    }
+    if (!await isDirectory(candidate)) return null;
+    path = candidate;
+    index = end + 1;
+  }
+  return path === "" ? null : path;
+}
+async function isDirectory(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 // src/wipe/confirm.ts
-import { createInterface as createInterface2 } from "readline/promises";
+import { createInterface as createInterface3 } from "readline/promises";
 var CONFIRMATION = "wipe";
 var TerminalPrompt = class {
   async ask(question) {
     if (process.stdin.isTTY !== true) return "";
-    const readline = createInterface2({ input: process.stdin, output: process.stdout });
+    const readline = createInterface3({ input: process.stdin, output: process.stdout });
     try {
       return (await readline.question(question)).trim();
     } finally {
@@ -2538,7 +2704,7 @@ var TerminalPrompt = class {
 };
 
 // src/wipe/wipe-run.ts
-import { readFile, rename, writeFile } from "fs/promises";
+import { readFile, rename, stat as stat3, writeFile } from "fs/promises";
 
 // src/wipe/redact.ts
 function placeholder(rule) {
@@ -2588,20 +2754,31 @@ var WipeRun = class {
     const plans = [];
     for (const source of this.#sources) {
       for await (const file of source.discover()) {
-        const reader = new TranscriptReader();
         let lines = 0;
         let secrets = 0;
-        for await (const entry of reader.read(file.path)) {
-          const found = this.#scanner.secretsOf(entry.line);
+        for await (const text of this.#textOf(file)) {
+          const found = this.#scanner.secretsOf(text);
           if (found.size === 0) continue;
           lines++;
           secrets += found.size;
         }
-        if (lines > 0) plans.push({ file: file.path, project: file.project, lines, secrets });
+        if (lines > 0) {
+          plans.push({ file: file.path, project: file.project, kind: file.kind, lines, secrets });
+        }
       }
     }
     return plans;
   }
+  /** 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) {
+      for await (const line of readLines(file.path)) yield line.text;
+      return;
+    }
+    const reader = new TranscriptReader();
+    for await (const entry of reader.read(file.path)) yield entry.line;
+  }
   /** Rewrites through a temporary file and a rename, so an interrupted run
    *  leaves the original intact rather than half a transcript. */
   async #rewrite(file) {
@@ -2615,8 +2792,9 @@ var WipeRun = class {
       redacted += secrets.size;
       return redactLine(line, secrets);
     });
+    const { mode } = await stat3(file);
     const temporary = `${file}.whatileaked-tmp`;
-    await writeFile(temporary, rewritten.join("\n"), "utf8");
+    await writeFile(temporary, rewritten.join("\n"), { encoding: "utf8", mode });
     await rename(temporary, file);
     return redacted;
   }
@@ -2626,8 +2804,9 @@ var WipeRun = class {
     this.#write(dim(`  ${plural(secrets, "secret")} across ${plural(plans.length, "file")}`));
     this.#write("");
     for (const plan of plans) {
+      const unit = plan.kind === FileKind.memory ? "line" : "message";
       this.#write(
-        `  ${yellow("*")} ${bold(plan.project.padEnd(project))}  ${dim(`${plural(plan.secrets, "secret")} in ${plural(plan.lines, "message")}`)}`
+        `  ${yellow("*")} ${bold(plan.project.padEnd(project))}  ${dim(`${plural(plan.secrets, "secret")} in ${plural(plan.lines, unit)}`)}`
       );
       this.#write(`      ${dim(shorten(plan.file))}`);
     }
@@ -2653,7 +2832,11 @@ async function main(argv) {
     for (const line of home()) write(line);
     return 0;
   }
-  const sources = [new ClaudeCodeSource(homedir()), new CodexSource(homedir())];
+  const sources = [
+    new ClaudeCodeSource(homedir()),
+    new CodexSource(homedir()),
+    new CursorSource(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);
 }
@@ -2661,6 +2844,9 @@ function colorful() {
   return process.stdout.isTTY === true && process.env.NO_COLOR === void 0;
 }
 async function scan(sources, scanner, write) {
+  write(`  ${dim("Welcome to whatileaked \u2014 built by Selan")} ${cyan("(selan.ai)")}`);
+  write(dim("  checking what you have already sent to a model provider"));
+  write("");
   const progress = new Progress((text) => process.stderr.write(text), colorful());
   return await new ScanRun(sources, scanner, new TerminalReporter(write), progress).run();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "whatileaked",
-  "version": "0.1.0",
-  "description": "Scan your local Claude Code and Codex transcripts for credentials you already sent to a model provider.",
+  "version": "0.3.0",
+  "description": "Scan your local Claude Code, Codex and Cursor transcripts for credentials you already sent to a model provider.",
   "type": "module",
   "imports": {
     "#scripts/*": "./scripts/*.ts",
@@ -21,6 +21,7 @@
   "scripts": {
     "dev": "node src/cli.ts",
     "build": "tsc --noEmit && tsup",
+    "prepublishOnly": "npm run lint && npm test && npm run build",
     "typecheck": "tsc --noEmit",
     "test": "node --test \"src/**/*.test.ts\"",
     "format": "biome check --write",