cc-scrub 0.1.0

package/dist/rules.js

@@ -0,0 +1,96 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "smol-toml";
+function vendorTomlPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, "..", "vendor", "gitleaks.toml");
+}
+/**
+ * Gitleaks regexes are Go RE2 syntax, which differs from JS RegExp in two
+ * ways that show up repeatedly in this ruleset:
+ *
+ * 1. Named capture groups use Python/Go syntax (?P<name>...) instead of
+ *    JS's (?<name>...).
+ * 2. RE2 supports inline flag toggles ((?i), (?i:...), (?-i:...)) that
+ *    apply case-insensitivity from that point to the end of the enclosing
+ *    group. JS has no equivalent scoped toggle, so scoped groups are
+ *    flattened to plain non-capturing groups, and any remaining bare (?i)
+ *    marker is approximated by making the *entire* pattern case-insensitive
+ *    via the `i` flag — looser than RE2's scoping, but keeps the rule
+ *    working rather than dropping it. Documented parity gap.
+ */
+function translatePattern(raw) {
+    let pattern = raw.replace(/\(\?P</g, "(?<");
+    let flags = "g";
+    pattern = pattern.replace(/\(\?-?i:/g, "(?:");
+    if (pattern.includes("(?i)")) {
+        pattern = pattern.split("(?i)").join("");
+        flags += "i";
+    }
+    return { pattern, flags };
+}
+function toRegex(raw) {
+    const { pattern, flags } = translatePattern(raw);
+    return new RegExp(pattern, flags);
+}
+function collectAllowlistRegexes(allowlists) {
+    const regexes = [];
+    for (const allowlist of allowlists ?? []) {
+        for (const raw of allowlist?.regexes ?? []) {
+            try {
+                regexes.push(toRegex(String(raw)));
+            }
+            catch {
+                // skip a malformed/incompatible allowlist regex rather than fail the whole rule
+            }
+        }
+    }
+    return regexes;
+}
+let cached;
+export function loadRuleSet() {
+    if (cached)
+        return cached;
+    const raw = readFileSync(vendorTomlPath(), "utf8");
+    const doc = parse(raw);
+    const globalAllowlistRegexes = collectAllowlistRegexes(doc.allowlist ? [doc.allowlist] : []);
+    const globalStopwords = (doc.allowlist?.stopwords ?? []).map((w) => String(w).toLowerCase());
+    const rules = [];
+    const skipped = [];
+    for (const r of doc.rules ?? []) {
+        const id = typeof r.id === "string" ? r.id : "(unknown)";
+        if (typeof r.regex !== "string") {
+            skipped.push({ id, reason: "no regex field" });
+            continue;
+        }
+        try {
+            rules.push({
+                id,
+                description: typeof r.description === "string" ? r.description : "",
+                regex: toRegex(r.regex),
+                keywords: (r.keywords ?? []).map((k) => String(k).toLowerCase()),
+                entropy: typeof r.entropy === "number" ? r.entropy : undefined,
+                allowlistRegexes: collectAllowlistRegexes(r.allowlists),
+            });
+        }
+        catch (err) {
+            skipped.push({ id, reason: err.message });
+        }
+    }
+    cached = { rules, skipped, globalAllowlistRegexes, globalStopwords };
+    return cached;
+}
+export function shannonEntropy(input) {
+    if (!input)
+        return 0;
+    const counts = new Map();
+    for (const ch of input)
+        counts.set(ch, (counts.get(ch) ?? 0) + 1);
+    let entropy = 0;
+    for (const count of counts.values()) {
+        const p = count / input.length;
+        entropy -= p * Math.log2(p);
+    }
+    return entropy;
+}

package/dist/sessions.js

@@ -0,0 +1,51 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function claudeProjectsDir() {
+    return join(homedir(), ".claude", "projects");
+}
+export function projectKeyForCwd(cwd) {
+    return cwd.replace(/\//g, "-");
+}
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+export function listSessions(opts = {}) {
+    const root = claudeProjectsDir();
+    const projectKeys = opts.cwdOnly
+        ? [projectKeyForCwd(process.cwd())]
+        : safeReaddir(root);
+    const sessions = [];
+    for (const projectKey of projectKeys) {
+        const projectDir = join(root, projectKey);
+        for (const entry of safeReaddir(projectDir)) {
+            if (!entry.endsWith(".jsonl"))
+                continue;
+            const path = join(projectDir, entry);
+            const mtimeMs = statSync(path).mtimeMs;
+            sessions.push({
+                path,
+                projectKey,
+                sessionId: entry.replace(/\.jsonl$/, ""),
+                mtimeMs,
+            });
+        }
+    }
+    return sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+export function findSession(idOrPrefix) {
+    const sessions = listSessions();
+    return (sessions.find((s) => s.sessionId === idOrPrefix) ??
+        sessions.find((s) => s.sessionId.startsWith(idOrPrefix)));
+}
+export function readSessionLines(session) {
+    const raw = readFileSync(session.path, "utf8");
+    const hadTrailingNewline = raw.endsWith("\n");
+    const lines = raw.split("\n");
+    return hadTrailingNewline ? lines.slice(0, -1) : lines;
+}

package/dist/ui.js

@@ -0,0 +1,35 @@
+import * as clack from "@clack/prompts";
+import { maskPreview } from "./redact.js";
+export function banner(action, text) {
+    clack[action](text);
+}
+export function withSpinner(label, fn) {
+    const s = clack.spinner();
+    s.start(label);
+    try {
+        const result = fn();
+        s.stop(label);
+        return result;
+    }
+    catch (err) {
+        s.stop(`${label} (failed)`);
+        throw err;
+    }
+}
+export function printFindings(findings) {
+    for (const f of findings) {
+        clack.log.warn(`${maskPreview(f.secret)}  rule=${f.ruleId}  line=${f.startLine}`);
+    }
+}
+export function printNoFindings() {
+    clack.log.success("No secrets found.");
+}
+export async function confirmRedaction(count) {
+    const result = await clack.confirm({
+        message: `Redact ${count} finding(s) in place? A .bak backup will be written first.`,
+        initialValue: false,
+    });
+    if (clack.isCancel(result))
+        return false;
+    return result;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "cc-scrub",
+  "version": "0.1.0",
+  "description": "Find and remove exposed secrets from Claude Code session history, plus a live hook to catch them before they land in context.",
+  "type": "module",
+  "bin": {
+    "cc-scrub": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsx test/redact.test.ts && tsx test/gitleaks.test.ts && tsx test/localDetect.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "smol-toml": "^1.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "claude-code",
+    "security",
+    "secrets",
+    "gitleaks",
+    "redaction",
+    "plugin"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "vendor",
+    ".claude-plugin",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/vendor/GITLEAKS_VERSION

@@ -0,0 +1 @@
+v8.30.1

package/vendor/NOTICE.md

@@ -0,0 +1,11 @@
+`gitleaks.toml` in this directory is vendored from the [gitleaks](https://github.com/gitleaks/gitleaks) project, pinned to release `v8.30.1`.
+
+```
+MIT License
+
+Copyright (c) 2019 Zachary Rice
+```
+
+Full license: https://github.com/gitleaks/gitleaks/blob/v8.30.1/LICENSE
+
+`cc-scrub` is not affiliated with or endorsed by the gitleaks project. This file is redistributed unmodified except for the regex-dialect translation applied at load time in `src/rules.ts` (JS RegExp doesn't support all Go RE2 syntax) — the vendored `.toml` itself is untouched.