codiedev 0.9.80 → 0.9.81

package/dist/localScrubReport.d.ts

@@ -0,0 +1,83 @@
+export type SessionStatus = "removed" | "not_removed";
+export type NotRemovedReason = "cursor_chat_store";
+export interface KeyHit {
+    rule: string;
+    /** Last 4 alphanumerics, same as the server's secretFindings hint. */
+    hint: string;
+    count: number;
+}
+export interface SessionDetection {
+    harness: string;
+    /** Stable id of the session within its harness (uuid, file name, chat id). */
+    sessionKey: string;
+    title?: string;
+    cwd?: string;
+    keys: KeyHit[];
+    status: SessionStatus;
+    reason?: NotRemovedReason;
+}
+/** Keys in `text` as (rule, last 4, count). Never returns a value. */
+export declare function keysIn(text: string): KeyHit[];
+export declare function mergeKeys(a: KeyHit[], b: KeyHit[]): KeyHit[];
+/** Title and working folder of a session file, from its cleaned text. */
+export declare function describeText(kind: string, cleaned: string): {
+    title?: string;
+    cwd?: string;
+};
+/** Which session a file belongs to, per harness layout. */
+export declare function sessionKeyOf(harness: string, file: string): string;
+/** Drop titles and folders for sessions the person excluded from capture.
+ * With any exclusion set, a session whose folder we can't tell is treated
+ * as excluded too. */
+export declare function redactExcluded(s: SessionDetection, ignored: string[] | undefined): SessionDetection;
+/** A random id for this machine, kept in the scrub's state folder. */
+export declare function machineId(dir: string): string;
+export interface ReportPayload {
+    machine: {
+        id: string;
+        name: string;
+    };
+    at: number;
+    complete: boolean;
+    scanned: number;
+    cleaned: number;
+    redactions: number;
+    errors: number;
+    skippedRecent: number;
+    skippedLarge: number;
+    byHarness: Array<{
+        harness: string;
+        files: number;
+        redactions: number;
+    }>;
+    leftInCursor: {
+        keys: number;
+        chats: number;
+    };
+    sessions: Array<Omit<SessionDetection, "cwd">>;
+}
+export declare function buildReport(input: {
+    machineId: string;
+    at: number;
+    complete: boolean;
+    summary: {
+        scanned: number;
+        cleaned: number;
+        redactions: number;
+        errors: number;
+        skippedRecent: number;
+        skippedLarge: number;
+        byHarness: Partial<Record<string, {
+            files: number;
+            redactions: number;
+        }>>;
+        leftInCursor: {
+            keys: number;
+            chats: number;
+        };
+    };
+    sessions: SessionDetection[];
+    ignoredPaths?: string[];
+}): ReportPayload;
+/** Best-effort POST to Codiedev. Never throws. */
+export declare function sendReport(backendUrl: string, token: string, payload: ReportPayload, cliVersion: string, fetchImpl?: typeof fetch): Promise<boolean>;

package/dist/localScrubReport.js

@@ -0,0 +1,268 @@
+"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.keysIn = keysIn;
+exports.mergeKeys = mergeKeys;
+exports.describeText = describeText;
+exports.sessionKeyOf = sessionKeyOf;
+exports.redactExcluded = redactExcluded;
+exports.machineId = machineId;
+exports.buildReport = buildReport;
+exports.sendReport = sendReport;
+// What the local scrub tells Codiedev, for the Security tab's audit: per
+// session, when keys were found, which (type + last 4, never the key), and
+// whether they were removed or left (and why). Titles are the harness's own
+// title or the first prompt, taken from the CLEANED text so a title never
+// carries a key, and dropped for sessions in folders excluded from capture.
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const rules_1 = require("./scrub/rules");
+const extraRules_1 = require("./scrub/extraRules");
+const captureExclusions_1 = require("./captureExclusions");
+const MAX_KEYS_PER_SESSION = 20;
+const TITLE_LEN = 80;
+/** Keys in `text` as (rule, last 4, count). Never returns a value. */
+function keysIn(text) {
+    const { redactions } = (0, extraRules_1.scrub)(text);
+    if (redactions.length === 0)
+        return [];
+    const hints = new Map();
+    // secretFindings gives each redaction's hint the same way the server does.
+    for (const r of redactions) {
+        const [f] = (0, rules_1.secretFindings)(text, [r]);
+        if (!f)
+            continue;
+        const k = `${f.rule}\u0000${f.hint}`;
+        const hit = hints.get(k) ?? { rule: f.rule, hint: f.hint, count: 0 };
+        hit.count += 1;
+        hints.set(k, hit);
+    }
+    return [...hints.values()].slice(0, MAX_KEYS_PER_SESSION);
+}
+function mergeKeys(a, b) {
+    const out = new Map(a.map((k) => [`${k.rule}\u0000${k.hint}`, { ...k }]));
+    for (const k of b) {
+        const id = `${k.rule}\u0000${k.hint}`;
+        const cur = out.get(id);
+        if (cur)
+            cur.count += k.count;
+        else
+            out.set(id, { ...k });
+    }
+    return [...out.values()].slice(0, MAX_KEYS_PER_SESSION);
+}
+function tidy(s) {
+    const t = s.replace(/\s+/g, " ").trim();
+    if (!t)
+        return undefined;
+    return t.length > TITLE_LEN ? `${t.slice(0, TITLE_LEN - 1)}…` : t;
+}
+/** Injected context the harnesses put in user-role messages. */
+const NOT_A_PROMPT = /^(?:<|# AGENTS\.md|Caveat:|\[Request interrupted)/;
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        for (const part of content) {
+            const p = part;
+            if (p && typeof p.text === "string" && (p.type === undefined || /text/.test(String(p.type))))
+                return p.text;
+        }
+    }
+    return undefined;
+}
+/** The first thing the person typed, across every harness's JSONL shape. */
+function firstPrompt(obj) {
+    const msg = obj.message;
+    const payload = obj.payload;
+    const data = obj.data;
+    const candidates = [];
+    if (msg?.role === "user")
+        candidates.push(msg.content); // Claude Code, pi
+    if (obj.role === "user")
+        candidates.push(obj.message?.content ?? obj.content); // Cursor
+    if (payload?.type === "message" && payload.role === "user")
+        candidates.push(payload.content); // Codex
+    if (obj.type === "user.message")
+        candidates.push(data?.content); // Copilot
+    for (const c of candidates) {
+        const t = textOf(c);
+        if (t && !NOT_A_PROMPT.test(t.trimStart()))
+            return t;
+    }
+    return undefined;
+}
+/** Title and working folder of a session file, from its cleaned text. */
+function describeText(kind, cleaned) {
+    let title;
+    let named;
+    let cwd;
+    if (kind === "yaml") {
+        for (const line of cleaned.split(/\r?\n/)) {
+            const m = line.match(/^(summary|name|cwd):\s*(.*)$/);
+            if (!m)
+                continue;
+            const v = m[2].trim().replace(/^(["'])(.*)\1$/, "$2");
+            if (m[1] === "cwd")
+                cwd ??= v;
+            else
+                named ??= v;
+        }
+        return { title: named ? tidy(named) : undefined, cwd };
+    }
+    const docs = [];
+    if (kind === "jsonl") {
+        const lines = cleaned.split("\n");
+        for (let i = 0; i < lines.length && i < 2000; i++) {
+            if (!lines[i].trim())
+                continue;
+            try {
+                docs.push(JSON.parse(lines[i]));
+            }
+            catch { /* not JSON */ }
+        }
+    }
+    else if (kind === "json") {
+        try {
+            const d = JSON.parse(cleaned);
+            if (Array.isArray(d))
+                docs.push(...d);
+            else
+                docs.push(d);
+        }
+        catch { /* not JSON */ }
+    }
+    for (const d of docs) {
+        const o = d;
+        if (!o || typeof o !== "object")
+            continue;
+        // Harness-provided titles win over the first prompt.
+        if (!named && o.type === "summary" && typeof o.summary === "string")
+            named = o.summary; // Claude Code
+        if (!named && typeof o.thread_name === "string")
+            named = o.thread_name; // Codex
+        if (!cwd) {
+            const c = o.cwd ?? o.payload?.cwd;
+            if (typeof c === "string")
+                cwd = c;
+        }
+        if (!title) {
+            // OpenCode capture copy: [{ info: { role }, parts: [{ type: "text", text }] }]
+            const info = o.info;
+            const t = info?.role === "user" ? textOf(o.parts) : firstPrompt(o);
+            if (t)
+                title = t;
+        }
+    }
+    return { title: tidy(named ?? title ?? ""), cwd };
+}
+/** Which session a file belongs to, per harness layout. */
+function sessionKeyOf(harness, file) {
+    const base = path.basename(file);
+    if (base === "history.jsonl")
+        return "history";
+    if (harness === "copilot")
+        return path.basename(path.dirname(file)); // session-state/<id>/…
+    const uuid = base.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+    if (uuid)
+        return uuid[1];
+    return base.replace(/\.(jsonl|json|ya?ml|txt)$/, "");
+}
+/** Drop titles and folders for sessions the person excluded from capture.
+ * With any exclusion set, a session whose folder we can't tell is treated
+ * as excluded too. */
+function redactExcluded(s, ignored) {
+    if (!ignored?.length)
+        return s;
+    if (s.cwd && !(0, captureExclusions_1.isCaptureIgnored)(s.cwd, ignored))
+        return s;
+    const { title: _t, cwd: _c, ...rest } = s;
+    return rest;
+}
+/** A random id for this machine, kept in the scrub's state folder. */
+function machineId(dir) {
+    const file = path.join(dir, "machine-id");
+    try {
+        const id = fs.readFileSync(file, "utf8").trim();
+        if (/^[0-9a-f-]{36}$/.test(id))
+            return id;
+    }
+    catch { /* first run */ }
+    const id = crypto.randomUUID();
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(file, id, { mode: 0o600 });
+    }
+    catch { /* fall back to a per-run id */ }
+    return id;
+}
+const MAX_SESSIONS = 200;
+function buildReport(input) {
+    const s = input.summary;
+    return {
+        machine: { id: input.machineId, name: os.hostname().slice(0, 80) },
+        at: input.at,
+        complete: input.complete,
+        scanned: s.scanned,
+        cleaned: s.cleaned,
+        redactions: s.redactions,
+        errors: s.errors,
+        skippedRecent: s.skippedRecent,
+        skippedLarge: s.skippedLarge,
+        byHarness: Object.entries(s.byHarness).map(([harness, t]) => ({ harness, files: t.files, redactions: t.redactions })),
+        leftInCursor: s.leftInCursor,
+        sessions: input.sessions
+            .slice(0, MAX_SESSIONS)
+            .map((d) => redactExcluded(d, input.ignoredPaths))
+            .map(({ cwd: _cwd, ...rest }) => rest),
+    };
+}
+/** Best-effort POST to Codiedev. Never throws. */
+async function sendReport(backendUrl, token, payload, cliVersion, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${backendUrl}/api/cli/localScrub`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}`, "X-Codiedev-Cli-Version": cliVersion },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(15_000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/scrub/extraRules.d.ts

@@ -0,0 +1,4 @@
+import { type ExtraRule, type ScrubResult } from "./rules";
+export declare function setExtraRules(rules: ExtraRule[]): void;
+/** scrubSecrets with this run's extra rules. */
+export declare function scrub(text: string): ScrubResult;

package/dist/scrub/extraRules.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setExtraRules = setExtraRules;
+exports.scrub = scrub;
+// Rules added for this run of the laptop scrub on top of the built-in ones:
+// the company's own token formats (from the server) and the exact values of
+// this person's own secrets (knownSecrets.ts). Set once by the detached
+// scrub child before it runs; empty everywhere else.
+const rules_1 = require("./rules");
+let extra = [];
+function setExtraRules(rules) {
+    extra = rules;
+}
+/** scrubSecrets with this run's extra rules. */
+function scrub(text) {
+    return extra.length ? (0, rules_1.scrubSecrets)(text, { extraRules: extra }) : (0, rules_1.scrubSecrets)(text);
+}

package/dist/scrub/rules.d.ts

@@ -0,0 +1,86 @@
+export interface Redaction {
+    rule: string;
+    start: number;
+    end: number;
+}
+export interface ScrubResult {
+    text: string;
+    redactions: Redaction[];
+}
+/** Rules a caller adds for one scrub (a company's own token formats). */
+export interface ExtraRule {
+    name: string;
+    re: RegExp;
+    keywords?: readonly string[];
+}
+/** Shannon entropy in bits per character, as Gitleaks measures it. */
+export declare function shannonEntropy(s: string): number;
+export declare function scrubSecrets(input: string, opts?: {
+    extraRules?: readonly ExtraRule[];
+}): ScrubResult;
+/** Rewrite `input` with each span replaced by `[REDACTED:<rule>]`. Spans must
+ *  be sorted by start and not overlap. One forward pass: repeated
+ *  slice+concat would copy the whole string per redaction (quadratic). */
+export declare function redactSpans(input: string, spans: readonly Redaction[]): string;
+/** Where in a session a secret appeared. */
+export type SecretWhere = "prompt" | "tool_call" | "commit" | "tool_output" | "assistant" | "unknown";
+export interface SecretLocation {
+    where: SecretWhere;
+    /** Tool or MCP tool name for tool calls/outputs when the transcript has it. */
+    tool?: string;
+}
+export interface SecretFinding {
+    rule: string;
+    /** Last four alphanumeric characters of the redacted value — enough for a
+     *  person to recognise which key to rotate, never enough to use it. */
+    hint: string;
+    /** Distinct places in the session the key appeared. */
+    locations: SecretLocation[];
+    /** The variable or field it was assigned to (`X_BEARER_TOKEN`), when the
+     *  text shows one. A name, never the value. */
+    name?: string;
+    /** The file it was written to or read from (`altcap-bot/.env`), when the
+     *  text shows one: last two path parts only. */
+    file?: string;
+}
+/** What a caller may check before a key becomes a finding (exceptions).
+ *  `value` is the key itself: use it to compare, never store it. */
+export interface KeyContext {
+    rule: string;
+    value: string;
+    name?: string;
+    file?: string;
+}
+export declare const GENERIC_RULES: ReadonlySet<string>;
+/** Values that share a key's shape but are test or sample values: words
+ *  joined by _ or - with only digits or one repeated character between
+ *  (`cdv_local_pilot_token_2026`, `…_token_000000`), a long counting run
+ *  (`sk-1234567890…`), or a long repeated tail. Still removed from sessions;
+ *  just not listed as a key to rotate. */
+export declare function looksLikeTestValue(value: string): boolean;
+/** One finding per distinct (rule, last-4) in a scrub result, with every
+ *  distinct place it appeared. */
+export declare function secretFindings(input: string, redactions: Redaction[], opts?: {
+    skip?: (k: KeyContext) => boolean;
+}): SecretFinding[];
+export interface PossibleSecret {
+    label: string;
+    prefix?: string;
+    hint: string;
+    length: number;
+    shape: "hex" | "base64" | "alnum";
+    snippet: string;
+    locations: SecretLocation[];
+    /** Spans in the text this was read from, for redaction once confirmed. */
+    spans: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+export declare function possibleSecrets(text: string, limit?: number): PossibleSecret[];
+/** Redact every occurrence of an already-reviewed possible secret. */
+export declare function redactPossible(text: string, match: {
+    label: string;
+    hint: string;
+    length: number;
+}, rule?: string): ScrubResult;