codiedev 0.10.0-beta.11 → 0.10.0-beta.13

package/dist/localScrub.js

@@ -0,0 +1,689 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUN_INTERVAL_MS = exports.MIN_AGE_MS = void 0;
+exports.sessionStores = sessionStores;
+exports.cursorIdeDb = cursorIdeDb;
+exports.cleanJson = cleanJson;
+exports.cleanJsonl = cleanJsonl;
+exports.cleanText = cleanText;
+exports.cleanYaml = cleanYaml;
+exports.cleanFor = cleanFor;
+exports.cleanFile = cleanFile;
+exports.filesOf = filesOf;
+exports.cleanOpenCodeDb = cleanOpenCodeDb;
+exports.countCursorDb = countCursorDb;
+exports.runLocalScrub = runLocalScrub;
+exports.runAndReport = runAndReport;
+exports.maybeSpawnLocalScrub = maybeSpawnLocalScrub;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const rules_1 = require("./scrub/rules");
+const harnessDirs_1 = require("./harnessDirs");
+const copilotHooks_1 = require("./copilotHooks");
+const configDir_1 = require("./configDir");
+const localScrubReport_1 = require("./localScrubReport");
+exports.MIN_AGE_MS = 60 * 60_000;
+exports.RUN_INTERVAL_MS = 60 * 60_000;
+const MAX_FILE_BYTES = 100 * 1024 * 1024;
+const DEFAULT_BUDGET_MS = 2 * 60_000;
+const STATE_VERSION = 1;
+const isJsonl = (f) => f.endsWith(".jsonl");
+function sessionStores(env = process.env, home = os.homedir(), stateDir = (0, configDir_1.codiedevStateDir)()) {
+    const claude = (0, harnessDirs_1.claudeConfigDir)(env, home);
+    const codex = (0, harnessDirs_1.codexHome)(env, home);
+    const dataHome = env.XDG_DATA_HOME?.trim() ? path.resolve(env.XDG_DATA_HOME.trim()) : path.join(home, ".local", "share");
+    const openCodeData = path.join(dataHome, "opencode");
+    return [
+        { harness: "claude-code", kind: "jsonl", root: path.join(claude, "projects"), match: isJsonl },
+        { harness: "claude-code", kind: "jsonl", root: path.join(claude, "history.jsonl") },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "sessions"), match: isJsonl },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "archived_sessions"), match: isJsonl },
+        { harness: "codex", kind: "jsonl", root: path.join(codex, "history.jsonl") },
+        {
+            harness: "cursor",
+            kind: "jsonl",
+            root: path.join(home, ".cursor", "projects"),
+            match: (f) => isJsonl(f) && f.split(path.sep).includes("agent-transcripts"),
+        },
+        {
+            harness: "copilot",
+            kind: "jsonl",
+            root: path.join((0, copilotHooks_1.copilotHome)(env, home), "session-state"),
+            match: (f) => path.basename(f) === "events.jsonl",
+        },
+        {
+            harness: "copilot",
+            kind: "yaml",
+            root: path.join((0, copilotHooks_1.copilotHome)(env, home), "session-state"),
+            match: (f) => path.basename(f) === "workspace.yaml",
+        },
+        { harness: "pi", kind: "jsonl", root: path.join((0, harnessDirs_1.piAgentDir)(env, home), "sessions"), match: isJsonl },
+        { harness: "pi", kind: "jsonl", root: path.join(stateDir, "managed", "pi", "agent", "sessions"), match: isJsonl },
+        { harness: "opencode", kind: "json", root: path.join(stateDir, "opencode-captures"), match: (f) => f.endsWith(".json") },
+        { harness: "opencode", kind: "text", root: path.join(openCodeData, "tool-output") },
+        { harness: "opencode", kind: "opencode-db", root: path.join(openCodeData, "opencode.db") },
+        {
+            harness: "cursor",
+            kind: "cursor-agent-db",
+            root: path.join(home, ".cursor", "chats"),
+            match: (f) => path.basename(f) === "store.db",
+        },
+        { harness: "cursor", kind: "cursor-ide-db", root: cursorIdeDb(env, home) },
+    ];
+}
+function cursorIdeDb(env = process.env, home = os.homedir(), platform = process.platform) {
+    const base = platform === "darwin"
+        ? path.join(home, "Library", "Application Support")
+        : platform === "win32"
+            ? env.APPDATA || path.join(home, "AppData", "Roaming")
+            : env.XDG_CONFIG_HOME?.trim() || path.join(home, ".config");
+    return path.join(base, "Cursor", "User", "globalStorage", "state.vscdb");
+}
+function cleanValue(value, count) {
+    if (typeof value === "string") {
+        const r = (0, rules_1.scrubSecrets)(value);
+        count.n += r.redactions.length;
+        return r.text;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => cleanValue(v, count));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = cleanValue(v, count);
+        return out;
+    }
+    return value;
+}
+function parses(text) {
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanJson(text) {
+    const raw = (0, rules_1.scrubSecrets)(text);
+    if (raw.redactions.length === 0)
+        return { text, redactions: 0 };
+    if (parses(raw.text) || !parses(text))
+        return { text: raw.text, redactions: raw.redactions.length };
+    const count = { n: 0 };
+    const cleaned = cleanValue(JSON.parse(text), count);
+    return { text: JSON.stringify(cleaned), redactions: count.n };
+}
+function cleanJsonl(text) {
+    const lines = text.split("\n");
+    let redactions = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        const cr = line.endsWith("\r");
+        const body = cr ? line.slice(0, -1) : line;
+        const r = cleanJson(body);
+        if (r.redactions === 0)
+            continue;
+        redactions += r.redactions;
+        lines[i] = cr ? `${r.text}\r` : r.text;
+    }
+    return redactions === 0 ? { text, redactions: 0 } : { text: lines.join("\n"), redactions };
+}
+function cleanText(text) {
+    const r = (0, rules_1.scrubSecrets)(text);
+    return { text: r.text, redactions: r.redactions.length };
+}
+function cleanYaml(text) {
+    let redactions = 0;
+    const lines = text.split("\n").map((line) => {
+        const r = (0, rules_1.scrubSecrets)(line);
+        if (r.redactions.length === 0)
+            return line;
+        redactions += r.redactions.length;
+        const m = r.text.match(/^(\s*[^\s:#][^:]*:\s+)(\[REDACTED:.*?)(\r?)$/);
+        if (!m)
+            return r.text;
+        return `${m[1]}'${m[2].replace(/'/g, "''")}'${m[3]}`;
+    });
+    return redactions === 0 ? { text, redactions: 0 } : { text: lines.join("\n"), redactions };
+}
+function cleanFor(kind, text) {
+    return kind === "jsonl" ? cleanJsonl(text) : kind === "json" ? cleanJson(text) : kind === "yaml" ? cleanYaml(text) : cleanText(text);
+}
+function cleanFile(file, kind, deps) {
+    let before;
+    try {
+        before = fs.statSync(file);
+    }
+    catch {
+        return { outcome: "error", redactions: 0 };
+    }
+    if (deps.now - before.mtimeMs < deps.minAgeMs)
+        return { outcome: "too-recent", redactions: 0 };
+    if (before.size > MAX_FILE_BYTES)
+        return { outcome: "too-large", redactions: 0 };
+    let original;
+    try {
+        original = fs.readFileSync(file);
+    }
+    catch {
+        return { outcome: "error", redactions: 0 };
+    }
+    const originalText = original.toString("utf8");
+    const result = cleanFor(kind, originalText);
+    if (result.redactions === 0)
+        return { outcome: "clean", redactions: 0 };
+    const detail = { keys: (0, localScrubReport_1.keysIn)(originalText), ...(0, localScrubReport_1.describeText)(kind, result.text) };
+    if (deps.dryRun)
+        return { outcome: "would-clean", redactions: result.redactions, detail };
+    const tmp = `${file}.codiedev-scrub-${process.pid}.tmp`;
+    try {
+        fs.writeFileSync(tmp, result.text, { mode: before.mode & 0o777 });
+        deps.beforeSwap?.(file);
+        const now = fs.statSync(file);
+        if (now.size !== before.size || now.mtimeMs !== before.mtimeMs || !fs.readFileSync(file).equals(original)) {
+            fs.rmSync(tmp, { force: true });
+            return { outcome: "changed-while-cleaning", redactions: 0 };
+        }
+        fs.renameSync(tmp, file);
+        fs.utimesSync(file, before.atime, before.mtime);
+        return { outcome: "cleaned", redactions: result.redactions, detail };
+    }
+    catch {
+        try {
+            fs.rmSync(tmp, { force: true });
+        }
+        catch { }
+        return { outcome: "error", redactions: 0 };
+    }
+}
+function* walk(root) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = path.join(root, e.name);
+        if (e.isDirectory())
+            yield* walk(p);
+        else if (e.isFile() && !e.name.includes(".codiedev-scrub-"))
+            yield p;
+    }
+}
+function filesOf(store) {
+    let st;
+    try {
+        st = fs.statSync(store.root);
+    }
+    catch {
+        return [];
+    }
+    if (st.isFile())
+        return [store.root];
+    const out = [];
+    for (const f of walk(store.root))
+        if (!store.match || store.match(f))
+            out.push(f);
+    return out;
+}
+function openSqlite(file, readOnly = false) {
+    try {
+        const { DatabaseSync } = require("node:sqlite");
+        const db = readOnly ? new DatabaseSync(file, { readOnly: true }) : new DatabaseSync(file);
+        db.exec("PRAGMA busy_timeout = 2000");
+        return db;
+    }
+    catch {
+        return null;
+    }
+}
+const OPENCODE_TABLES = [
+    { table: "message", session: "session_id", time: "time_updated" },
+    { table: "part", session: "session_id", time: "time_updated" },
+    { table: "session_message", session: "session_id", time: "time_updated" },
+    { table: "event", session: "aggregate_id" },
+];
+function cleanOpenCodeDb(file, deps) {
+    if (!fs.existsSync(file))
+        return { outcome: "clean", redactions: 0, rows: 0 };
+    const db = openSqlite(file);
+    if (!db)
+        return { outcome: "no-sqlite", redactions: 0, rows: 0 };
+    const sessions = new Map();
+    let redactions = 0;
+    let rows = 0;
+    try {
+        const cutoff = deps.now - deps.minAgeMs;
+        const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((t) => t.name));
+        const recent = new Set();
+        for (const t of OPENCODE_TABLES) {
+            if (!tables.has(t.table) || !t.time)
+                continue;
+            for (const r of db.prepare(`SELECT DISTINCT ${t.session} AS s FROM ${t.table} WHERE ${t.time} >= ?`).all(cutoff)) {
+                recent.add(r.s);
+            }
+        }
+        const updates = [];
+        for (const t of OPENCODE_TABLES) {
+            if (!tables.has(t.table))
+                continue;
+            const all = db.prepare(`SELECT id, ${t.session} AS s, data FROM ${t.table}`).all();
+            for (const row of all) {
+                if (recent.has(row.s) || typeof row.data !== "string")
+                    continue;
+                if (deps.onlySessions && !deps.onlySessions.has(row.s))
+                    continue;
+                const r = cleanJson(row.data);
+                if (r.redactions === 0)
+                    continue;
+                redactions += r.redactions;
+                updates.push({ table: t.table, id: row.id, data: r.text, before: row.data });
+                const cur = sessions.get(row.s) ?? { keys: [] };
+                if (t.table !== "event")
+                    cur.keys = (0, localScrubReport_1.mergeKeys)(cur.keys, (0, localScrubReport_1.keysIn)(row.data));
+                sessions.set(row.s, cur);
+            }
+        }
+        rows = updates.length;
+        if (rows === 0)
+            return { outcome: "clean", redactions: 0, rows: 0 };
+        if (tables.has("session")) {
+            const get = db.prepare("SELECT title, directory FROM session WHERE id = ?");
+            for (const [id, d] of sessions) {
+                const row = get.all(id)[0];
+                if (typeof row?.title === "string")
+                    d.title = (0, rules_1.scrubSecrets)(row.title).text.slice(0, 80);
+                if (typeof row?.directory === "string")
+                    d.cwd = row.directory;
+            }
+        }
+        if (deps.dryRun)
+            return { outcome: "would-clean", redactions, rows, sessions };
+        db.exec("BEGIN IMMEDIATE");
+        try {
+            for (const u of updates) {
+                db.prepare(`UPDATE ${u.table} SET data = ? WHERE id = ? AND data = ?`).run(u.data, u.id, u.before);
+            }
+            db.exec("COMMIT");
+        }
+        catch (e) {
+            try {
+                db.exec("ROLLBACK");
+            }
+            catch { }
+            throw e;
+        }
+        return { outcome: "cleaned", redactions, rows, sessions };
+    }
+    catch {
+        return { outcome: "error", redactions: 0, rows: 0 };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { }
+    }
+}
+function decodeMetaName(hexOrJson) {
+    try {
+        const text = /^[0-9a-f]+$/i.test(hexOrJson) ? Buffer.from(hexOrJson, "hex").toString("utf8") : hexOrJson;
+        const name = JSON.parse(text).name;
+        return typeof name === "string" ? name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function countCursorDb(file, kind) {
+    const db = openSqlite(file, true);
+    if (!db)
+        return null;
+    try {
+        const rows = (kind === "cursor-agent-db"
+            ? db.prepare("SELECT data AS v FROM blobs").all()
+            : db.prepare("SELECT key AS k, value AS v FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' OR key LIKE 'composerData:%'").all());
+        const chats = new Map();
+        const titles = new Map();
+        const agentChat = path.basename(path.dirname(file));
+        for (const row of rows) {
+            const text = typeof row.v === "string" ? row.v : row.v instanceof Uint8Array ? Buffer.from(row.v).toString("latin1") : "";
+            if (!text)
+                continue;
+            const chat = kind === "cursor-agent-db" ? agentChat : (row.k ?? "").split(":")[1] ?? "";
+            if (kind === "cursor-ide-db" && row.k?.startsWith("composerData:")) {
+                const name = decodeMetaName(text);
+                if (name)
+                    titles.set(chat, name);
+            }
+            const keys = (0, localScrubReport_1.keysIn)(text);
+            if (keys.length === 0)
+                continue;
+            chats.set(chat, (0, localScrubReport_1.mergeKeys)(chats.get(chat) ?? [], keys));
+        }
+        if (kind === "cursor-agent-db" && chats.size > 0) {
+            try {
+                const meta = db.prepare("SELECT value AS v FROM meta").all();
+                for (const m of meta) {
+                    const name = decodeMetaName(String(m.v));
+                    if (name)
+                        titles.set(agentChat, name);
+                }
+            }
+            catch { }
+        }
+        const details = [...chats].map(([chat, keys]) => ({
+            harness: "cursor",
+            sessionKey: chat,
+            ...(titles.get(chat) ? { title: (0, rules_1.scrubSecrets)(titles.get(chat)).text.slice(0, 80) } : {}),
+            keys,
+            status: "not_removed",
+            reason: "cursor_chat_store",
+        }));
+        return { keys: details.reduce((n, d) => n + d.keys.reduce((m, k) => m + k.count, 0), 0), chats: details.length, details };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch { }
+    }
+}
+const scrubDir = (stateDir) => path.join(stateDir, "local-scrub");
+function rulesFingerprint() {
+    try {
+        const src = fs.readFileSync(path.join(__dirname, "scrub", "rules.js"), "utf8");
+        let h = 0;
+        for (let i = 0; i < src.length; i++)
+            h = (h * 31 + src.charCodeAt(i)) | 0;
+        return String(h);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function readState(dir, rules) {
+    try {
+        const s = JSON.parse(fs.readFileSync(path.join(dir, "state.json"), "utf8"));
+        if (s.version === STATE_VERSION && s.rules === rules && s.files)
+            return s;
+    }
+    catch { }
+    return { version: STATE_VERSION, rules, files: {} };
+}
+function writeAtomic(file, text) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, text, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function runLocalScrub(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const deps = {
+        now,
+        minAgeMs: opts.minAgeMs ?? exports.MIN_AGE_MS,
+        dryRun: Boolean(opts.dryRun),
+        ...(opts.onlySessions ? { onlySessions: new Set(opts.onlySessions) } : {}),
+    };
+    const started = Date.now();
+    const budget = opts.budgetMs ?? DEFAULT_BUDGET_MS;
+    const stateDir = opts.stateDir ?? (0, configDir_1.codiedevStateDir)();
+    const dir = scrubDir(stateDir);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const rules = rulesFingerprint();
+    const state = readState(dir, rules);
+    const only = opts.only ? new Set(opts.only.map((p) => path.resolve(p))) : null;
+    const summary = {
+        dryRun: deps.dryRun, scanned: 0, cleaned: 0, redactions: 0, skippedRecent: 0, skippedLarge: 0,
+        changedWhileCleaning: 0, errors: 0, unfinished: false, byHarness: {}, leftInCursor: { keys: 0, chats: 0 }, sessions: [],
+    };
+    const found = new Map();
+    const detect = (harness, sessionKey, d) => {
+        const id = `${harness}\u0000${sessionKey}`;
+        const cur = found.get(id);
+        if (cur) {
+            cur.keys = (0, localScrubReport_1.mergeKeys)(cur.keys, d.keys);
+            cur.title ??= d.title;
+            cur.cwd ??= d.cwd;
+        }
+        else {
+            found.set(id, { harness, sessionKey, ...(d.title ? { title: d.title } : {}), ...(d.cwd ? { cwd: d.cwd } : {}), keys: d.keys, status: "removed" });
+        }
+    };
+    const counted = (state.counted ??= {});
+    const tally = (h, n) => {
+        const t = (summary.byHarness[h] ??= { files: 0, redactions: 0 });
+        t.files += 1;
+        t.redactions += n;
+    };
+    outer: for (const store of opts.stores ?? sessionStores(process.env, os.homedir(), stateDir)) {
+        if (store.kind === "cursor-agent-db" || store.kind === "cursor-ide-db") {
+            if (only || opts.onlySessions)
+                continue;
+            for (const file of filesOf(store)) {
+                let sig;
+                try {
+                    const st = fs.statSync(file);
+                    let wal = "";
+                    try {
+                        const w = fs.statSync(`${file}-wal`);
+                        wal = `:${w.size}:${w.mtimeMs}`;
+                    }
+                    catch { }
+                    sig = `${st.size}:${st.mtimeMs}${wal}`;
+                }
+                catch {
+                    continue;
+                }
+                if (counted[file]?.sig !== sig) {
+                    const c = countCursorDb(file, store.kind);
+                    if (!c)
+                        continue;
+                    counted[file] = { sig, ...c };
+                }
+            }
+            continue;
+        }
+        if (store.kind === "opencode-db") {
+            if (only && !only.has(path.resolve(store.root)))
+                continue;
+            const r = cleanOpenCodeDb(store.root, deps);
+            if (r.outcome === "no-sqlite")
+                continue;
+            summary.scanned += 1;
+            if (r.outcome === "error")
+                summary.errors += 1;
+            if (r.redactions > 0) {
+                summary.redactions += r.redactions;
+                if (r.outcome === "cleaned")
+                    summary.cleaned += 1;
+                tally(store.harness, r.redactions);
+                for (const [id, d] of r.sessions ?? [])
+                    detect(store.harness, id, d);
+            }
+            continue;
+        }
+        for (const file of filesOf(store)) {
+            if ((only || opts.onlySessions) && !only?.has(path.resolve(file)))
+                continue;
+            if (Date.now() - started > budget) {
+                summary.unfinished = true;
+                break outer;
+            }
+            let st;
+            try {
+                st = fs.statSync(file);
+            }
+            catch {
+                continue;
+            }
+            const sig = `${st.size}:${st.mtimeMs}`;
+            if (!only && state.files[file] === sig)
+                continue;
+            summary.scanned += 1;
+            const r = cleanFile(file, store.kind, deps);
+            switch (r.outcome) {
+                case "too-recent":
+                    summary.skippedRecent += 1;
+                    break;
+                case "too-large":
+                    summary.skippedLarge += 1;
+                    state.files[file] = sig;
+                    break;
+                case "changed-while-cleaning":
+                    summary.changedWhileCleaning += 1;
+                    break;
+                case "error":
+                    summary.errors += 1;
+                    break;
+                case "clean":
+                    state.files[file] = sig;
+                    break;
+                case "would-clean":
+                    summary.redactions += r.redactions;
+                    tally(store.harness, r.redactions);
+                    if (r.detail)
+                        detect(store.harness, (0, localScrubReport_1.sessionKeyOf)(store.harness, file), r.detail);
+                    break;
+                case "cleaned": {
+                    summary.cleaned += 1;
+                    summary.redactions += r.redactions;
+                    tally(store.harness, r.redactions);
+                    if (r.detail)
+                        detect(store.harness, (0, localScrubReport_1.sessionKeyOf)(store.harness, file), r.detail);
+                    try {
+                        const after = fs.statSync(file);
+                        state.files[file] = `${after.size}:${after.mtimeMs}`;
+                    }
+                    catch { }
+                    break;
+                }
+            }
+        }
+    }
+    for (const [f, c] of Object.entries(counted)) {
+        if (!fs.existsSync(f)) {
+            delete counted[f];
+            continue;
+        }
+        if (only || opts.onlySessions)
+            continue;
+        summary.leftInCursor.keys += c.keys;
+        summary.leftInCursor.chats += c.chats;
+        summary.sessions.push(...(c.details ?? []));
+    }
+    summary.sessions.unshift(...found.values());
+    if (!deps.dryRun) {
+        for (const f of Object.keys(state.files))
+            if (!fs.existsSync(f))
+                delete state.files[f];
+        try {
+            writeAtomic(path.join(dir, "state.json"), JSON.stringify(state));
+        }
+        catch { }
+        try {
+            fs.appendFileSync(path.join(dir, "log.jsonl"), JSON.stringify({ at: new Date(now).toISOString(), ...summary }) + "\n", { mode: 0o600 });
+        }
+        catch { }
+    }
+    return summary;
+}
+async function runAndReport(opts = {}) {
+    const at = opts.now ?? Date.now();
+    const summary = runLocalScrub(opts);
+    let reported = false;
+    if (!summary.dryRun && !opts.only && !opts.onlySessions) {
+        try {
+            const { readConfig } = require("./utils");
+            const { CLI_VERSION } = require("./version");
+            const { buildReport, machineId, sendReport } = await Promise.resolve().then(() => __importStar(require("./localScrubReport")));
+            const config = readConfig();
+            if (config?.token && config.backendUrl) {
+                const payload = buildReport({
+                    machineId: machineId(scrubDir(opts.stateDir ?? (0, configDir_1.codiedevStateDir)())),
+                    at,
+                    complete: !summary.unfinished,
+                    summary,
+                    sessions: summary.sessions,
+                    ignoredPaths: config.captureIgnoredPaths,
+                });
+                reported = await sendReport(config.backendUrl, config.token, payload, CLI_VERSION);
+            }
+        }
+        catch { }
+    }
+    return { ...summary, reported };
+}
+function maybeSpawnLocalScrub(opts = {}) {
+    try {
+        const env = opts.env ?? process.env;
+        if (opts.connected === false || env.CODIEDEV_LOCAL_SCRUB === "off" || env.CODIEDEV_LOCAL_SCRUB_CHILD)
+            return "disabled";
+        const now = opts.now ?? Date.now();
+        const dir = scrubDir(opts.stateDir ?? (0, configDir_1.codiedevStateDir)());
+        const stamp = path.join(dir, "last-run");
+        try {
+            const last = fs.statSync(stamp).mtimeMs;
+            if (now - last < exports.RUN_INTERVAL_MS && last <= now)
+                return "recent";
+        }
+        catch { }
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(stamp, String(now));
+        const t = new Date(now);
+        fs.utimesSync(stamp, t, t);
+        const child = (opts.spawn ?? child_process_1.spawn)(process.execPath, [opts.hookEntry ?? path.join(__dirname, "hook.js"), "local-scrub"], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...env, CODIEDEV_LOCAL_SCRUB_CHILD: "1" },
+        });
+        child.on?.("error", () => { });
+        child.unref?.();
+        return "spawned";
+    }
+    catch {
+        return "error";
+    }
+}