codiedev 0.9.79 → 0.9.81

package/dist/knownSecrets.d.ts

@@ -0,0 +1,43 @@
+import { type ExtraRule } from "./scrub/rules";
+export interface KnownSecret {
+    value: string;
+    name?: string;
+    /** Where it came from: last two path parts, e.g. `api/.env`. */
+    file: string;
+}
+/** A value worth matching: long and random enough that it can't be an
+ *  ordinary word, path or setting, and safe to fingerprint (a short or
+ *  low-entropy value could be guessed back from its hash). */
+export declare function worthMatching(v: string): boolean;
+/** KEY=value lines (.env, .ini-style credentials, .npmrc, .pypirc). */
+export declare function parseAssignments(text: string): Array<{
+    name: string;
+    value: string;
+}>;
+/** Per-user credential files, and .env files in the repos sessions ran in. */
+/** Per-user credential files read, relative to home. Listed in the product
+ *  (Team Security → Settings) and in `codiedev scrub --help`. */
+export declare const CREDENTIAL_FILES: readonly [".aws/credentials", ".npmrc", ".pypirc", ".netrc", ".git-credentials", ".config/gh/hosts.yml", ".docker/config.json", ".config/hub", ".gem/credentials", ".config/openai/credentials"];
+export declare function credentialFiles(home: string, cwds: readonly string[]): string[];
+export declare function collectKnownSecrets(home?: string, cwds?: readonly string[]): KnownSecret[];
+/** One scrub rule matching any of these exact values (and their JSON-escaped
+ *  forms), on non-alphanumeric boundaries. */
+export declare function knownSecretRule(secrets: readonly KnownSecret[]): ExtraRule | null;
+/** Same as the server's knownHash: HMAC-SHA256 with the company's key (hex,
+ *  from the scrub policy), first 32 hex. */
+export declare function knownHash(keyHex: string, value: string): string;
+export declare const hintOf: (value: string) => string;
+export declare function fingerprints(keyHex: string, secrets: readonly KnownSecret[]): {
+    file: string;
+    name?: string | undefined;
+    hash: string;
+    hint: string;
+}[];
+/** Send keyed fingerprints (never values). Replaces this person's set.
+ *  Only in "server" mode, with the key the server sent. Best-effort. */
+export declare function uploadKnownSecrets(config: {
+    backendUrl?: string;
+    token?: string;
+} | null, keyHex: string, secrets: readonly KnownSecret[], fetchImpl?: typeof fetch): Promise<boolean>;
+export declare function rememberCwd(stateDir: string, cwd: string | undefined): void;
+export declare function recentCwds(stateDir: string): string[];

package/dist/knownSecrets.js

@@ -0,0 +1,241 @@
+"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.hintOf = exports.CREDENTIAL_FILES = void 0;
+exports.worthMatching = worthMatching;
+exports.parseAssignments = parseAssignments;
+exports.credentialFiles = credentialFiles;
+exports.collectKnownSecrets = collectKnownSecrets;
+exports.knownSecretRule = knownSecretRule;
+exports.knownHash = knownHash;
+exports.fingerprints = fingerprints;
+exports.uploadKnownSecrets = uploadKnownSecrets;
+exports.rememberCwd = rememberCwd;
+exports.recentCwds = recentCwds;
+// This person's own secrets: values in their .env and credentials files.
+// The laptop scrub removes those exact values from past sessions on this
+// machine, in any format. Only where the laptop scrub is on, and only as the
+// company's admin set it (Team Security → Settings):
+//   off     these files are never read;
+//   laptop  read and matched here; nothing about them leaves (default);
+//   server  also sends a keyed fingerprint of each (HMAC with a per-company
+//           key from the server, never the value) so uploaded sessions are
+//           checked too.
+// Files read: CREDENTIAL_FILES below, and .env / .env.* (not .example,
+// .sample, .template) in the repos sessions started in.
+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 MAX_SECRETS = 500;
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_CWDS = 30;
+/** A value worth matching: long and random enough that it can't be an
+ *  ordinary word, path or setting, and safe to fingerprint (a short or
+ *  low-entropy value could be guessed back from its hash). */
+function worthMatching(v) {
+    if (v.length < 16 || v.length > 512)
+        return false;
+    // URLs aren't the secret; a password inside one is caught by url-password.
+    if (/\s/.test(v) || /^[a-z][a-z0-9+.-]*:\/\//i.test(v))
+        return false;
+    if (/^(?:true|false|null|undefined|localhost)$/i.test(v) || /^[\d.]+$/.test(v))
+        return false;
+    if (/^[~./]/.test(v) || /\$\{|\$\(/.test(v))
+        return false;
+    if ((0, rules_1.looksLikeTestValue)(v))
+        return false;
+    return (0, rules_1.shannonEntropy)(v) >= 3.5;
+}
+const unquote = (v) => v.trim().replace(/^(['"])(.*)\1$/, "$2");
+const short = (p) => p.split(path.sep).filter(Boolean).slice(-2).join("/");
+/** KEY=value lines (.env, .ini-style credentials, .npmrc, .pypirc). */
+function parseAssignments(text) {
+    const out = [];
+    for (const line of text.split(/\r?\n/)) {
+        const m = line.match(/^\s*(?:export\s+)?([A-Za-z_./:@-][\w./:@-]*)\s*[=:]\s*(.+?)\s*$/);
+        if (!m || line.trim().startsWith("#") || line.trim().startsWith(";"))
+            continue;
+        out.push({ name: m[1].replace(/^\/\/[^:]*:/, ""), value: unquote(m[2].replace(/\s+#.*$/, "")) });
+    }
+    return out;
+}
+function read(file) {
+    try {
+        const st = fs.statSync(file);
+        if (!st.isFile() || st.size > MAX_FILE_BYTES)
+            return null;
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Per-user credential files, and .env files in the repos sessions ran in. */
+/** Per-user credential files read, relative to home. Listed in the product
+ *  (Team Security → Settings) and in `codiedev scrub --help`. */
+exports.CREDENTIAL_FILES = [
+    ".aws/credentials", ".npmrc", ".pypirc", ".netrc", ".git-credentials", ".config/gh/hosts.yml",
+    ".docker/config.json", ".config/hub", ".gem/credentials", ".config/openai/credentials",
+];
+function credentialFiles(home, cwds) {
+    const global = exports.CREDENTIAL_FILES.map((p) => path.join(home, p));
+    const envs = [];
+    for (const cwd of cwds) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(cwd);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (/^\.env(?:\.[\w-]+)?$/.test(e) && !/\.(?:example|sample|template|dist|defaults?)$/i.test(e))
+                envs.push(path.join(cwd, e));
+        }
+    }
+    return [...global, ...envs];
+}
+function collectKnownSecrets(home = os.homedir(), cwds = []) {
+    const seen = new Map();
+    const add = (value, file, name) => {
+        if (seen.size >= MAX_SECRETS || !worthMatching(value) || seen.has(value))
+            return;
+        seen.set(value, { value, file: short(file), ...(name ? { name: name.slice(0, 64) } : {}) });
+    };
+    for (const file of credentialFiles(home, cwds)) {
+        const text = read(file);
+        if (!text)
+            continue;
+        const base = path.basename(file);
+        if (base === "config.json") {
+            try {
+                const auths = JSON.parse(text).auths ?? {};
+                for (const [host, a] of Object.entries(auths)) {
+                    if (a.auth)
+                        add(a.auth, file, `docker ${host}`);
+                    if (a.identitytoken)
+                        add(a.identitytoken, file, `docker ${host}`);
+                }
+            }
+            catch { /* not JSON */ }
+            continue;
+        }
+        if (base === ".git-credentials") {
+            for (const m of text.matchAll(/^https?:\/\/[^:\s]+:([^@\s]+)@(\S+)$/gm))
+                add(decodeURIComponent(m[1]), file, `git ${m[2]}`);
+            continue;
+        }
+        if (base === ".netrc") {
+            for (const m of text.matchAll(/\bpassword\s+(\S+)/g))
+                add(m[1], file, "netrc password");
+            continue;
+        }
+        for (const { name, value } of parseAssignments(text))
+            add(value, file, name);
+    }
+    return [...seen.values()];
+}
+/** One scrub rule matching any of these exact values (and their JSON-escaped
+ *  forms), on non-alphanumeric boundaries. */
+function knownSecretRule(secrets) {
+    if (secrets.length === 0)
+        return null;
+    const forms = new Set();
+    for (const s of secrets) {
+        forms.add(s.value);
+        const escaped = JSON.stringify(s.value).slice(1, -1);
+        if (escaped !== s.value)
+            forms.add(escaped);
+    }
+    const alt = [...forms].sort((a, b) => b.length - a.length).map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    return { name: "known-secret", re: new RegExp(`(?<![A-Za-z0-9])(?:${alt})(?![A-Za-z0-9])`, "g") };
+}
+/** Same as the server's knownHash: HMAC-SHA256 with the company's key (hex,
+ *  from the scrub policy), first 32 hex. */
+function knownHash(keyHex, value) {
+    return crypto.createHmac("sha256", Buffer.from(keyHex, "hex")).update(value).digest("hex").slice(0, 32);
+}
+const hintOf = (value) => value.replace(/[^A-Za-z0-9]/g, "").slice(-4);
+exports.hintOf = hintOf;
+function fingerprints(keyHex, secrets) {
+    return secrets.map((s) => ({ hash: knownHash(keyHex, s.value), hint: (0, exports.hintOf)(s.value), ...(s.name ? { name: s.name } : {}), file: s.file }));
+}
+/** Send keyed fingerprints (never values). Replaces this person's set.
+ *  Only in "server" mode, with the key the server sent. Best-effort. */
+async function uploadKnownSecrets(config, keyHex, secrets, fetchImpl = fetch) {
+    if (!config?.backendUrl || !config.token || !/^[0-9a-f]{64}$/.test(keyHex))
+        return false;
+    try {
+        const res = await fetchImpl(`${config.backendUrl}/api/cli/knownSecrets`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.token}` },
+            body: JSON.stringify({ secrets: fingerprints(keyHex, secrets) }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+// Repos sessions start in, so the scrub knows which .env files are this
+// person's. Kept next to the scrub state; the last 30, newest first.
+function rememberCwd(stateDir, cwd) {
+    if (!cwd || !path.isAbsolute(cwd))
+        return;
+    try {
+        const file = path.join(stateDir, "cwds.json");
+        let list = [];
+        try {
+            list = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch { /* first */ }
+        list = [cwd, ...list.filter((c) => c !== cwd)].slice(0, MAX_CWDS);
+        fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(file, JSON.stringify(list), { mode: 0o600 });
+    }
+    catch { /* best-effort */ }
+}
+function recentCwds(stateDir) {
+    try {
+        const list = JSON.parse(fs.readFileSync(path.join(stateDir, "cwds.json"), "utf8"));
+        return Array.isArray(list) ? list.filter((c) => typeof c === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/launcher.d.ts

@@ -8,13 +8,18 @@ export declare function launcherPath(): string;
 /** True iff `cmd` invokes the stable launcher (from any state dir). */
 export declare function usesLauncher(cmd: string | undefined): boolean;
 export declare function readInstallRecord(): InstallRecord | null;
+/**
+ * The hook script worth recording: absolute and present, and a global install over an npx cache
+ * copy (npm prunes ~/.npm/_npx, and hooks pointed there go quietly dead). Null = don't record.
+ */
+export declare function stableHookScript(hookScript: string, globalCandidates?: string[]): string | null;
 /** Point the launcher at `hookScript`. Atomic, so a hook mid-launch never reads half a file. */
-export declare function recordCurrentInstall(hookScript: string): boolean;
+export declare function recordCurrentInstall(requested: string): boolean;
 /**
  * Make sure the launcher exists and forwards to `hookScript`, returning the
  * launcher path to bake into hook configs — or null if the state dir is not
  * writable, in which case callers keep baking the direct path. Memoized:
  * one connect writes ~20 hook entries.
  */
-export declare function ensureLauncher(hookScript: string): string | null;
+export declare function ensureLauncher(requested: string): string | null;
 export declare function resetLauncherCacheForTests(): void;

package/dist/launcher.js

@@ -48,6 +48,7 @@ exports.LAUNCHER_FILE = void 0;
 exports.launcherPath = launcherPath;
 exports.usesLauncher = usesLauncher;
 exports.readInstallRecord = readInstallRecord;
+exports.stableHookScript = stableHookScript;
 exports.recordCurrentInstall = recordCurrentInstall;
 exports.ensureLauncher = ensureLauncher;
 exports.resetLauncherCacheForTests = resetLauncherCacheForTests;
@@ -114,8 +115,35 @@ function packageVersionFor(hookScript) {
         return undefined;
     }
 }
+/**
+ * The hook script worth recording: absolute and present, and a global install over an npx cache
+ * copy (npm prunes ~/.npm/_npx, and hooks pointed there go quietly dead). Null = don't record.
+ */
+function stableHookScript(hookScript, globalCandidates = globalHookScripts()) {
+    if (!hookScript || !path.isAbsolute(hookScript) || hookScript.includes(`${path.sep}~${path.sep}`))
+        return null;
+    if (!fs.existsSync(hookScript))
+        return null;
+    if (hookScript.includes(`${path.sep}_npx${path.sep}`)) {
+        const global = globalCandidates.find((p) => path.isAbsolute(p) && fs.existsSync(p));
+        if (global)
+            return global;
+    }
+    return hookScript;
+}
+/** Where a global `npm i -g codiedev` puts hook.js, next to the node running this. */
+function globalHookScripts() {
+    const prefix = path.dirname(path.dirname(process.execPath));
+    return [
+        path.join(prefix, "lib", "node_modules", "codiedev", "dist", "hook.js"),
+        path.join(prefix, "node_modules", "codiedev", "dist", "hook.js"),
+    ];
+}
 /** Point the launcher at `hookScript`. Atomic, so a hook mid-launch never reads half a file. */
-function recordCurrentInstall(hookScript) {
+function recordCurrentInstall(requested) {
+    const hookScript = stableHookScript(requested);
+    if (!hookScript)
+        return false;
     try {
         const record = {
             hookScript,
@@ -136,11 +164,17 @@ let ensuredFor;
  * writable, in which case callers keep baking the direct path. Memoized:
  * one connect writes ~20 hook entries.
  */
-function ensureLauncher(hookScript) {
+function ensureLauncher(requested) {
+    const hookScript = stableHookScript(requested);
+    if (!hookScript)
+        return null;
     if (ensuredFor !== undefined && ensuredFor === hookScript)
         return launcherPath();
     try {
         const target = launcherPath();
+        // A relative launcher path in a hook config only works from one folder; never bake one.
+        if (!path.isAbsolute(target))
+            return null;
         const source = launcherSource(hookScript);
         let current = null;
         try {

package/dist/localScrub.d.ts

@@ -0,0 +1,172 @@
+import { spawn as nodeSpawn } from "child_process";
+import type { ExtraRule } from "./scrub/rules";
+import { type KeyHit, type SessionDetection } from "./localScrubReport";
+export type Harness = "claude-code" | "codex" | "cursor" | "copilot" | "opencode" | "pi";
+export type FileKind = "jsonl" | "json" | "text" | "yaml";
+/** cursor-*-db stores are only counted, never written: see countCursorDb. */
+export type StoreKind = FileKind | "opencode-db" | "cursor-agent-db" | "cursor-ide-db";
+export interface Store {
+    harness: Harness;
+    kind: StoreKind;
+    /** A file, or a directory searched recursively. */
+    root: string;
+    /** For directory roots: which files belong to this store. */
+    match?: (file: string) => boolean;
+}
+export declare const MIN_AGE_MS: number;
+export declare const RUN_INTERVAL_MS: number;
+/** Every place a harness keeps conversation text on this machine. Snapshots
+ * of the user's own files (Copilot rewind, Claude file-history) are left
+ * alone: cleaning them would change code the user restores later. */
+export declare function sessionStores(env?: NodeJS.ProcessEnv, home?: string, stateDir?: string): Store[];
+/** The Cursor IDE's chat database (VS Code layout, per platform). */
+export declare function cursorIdeDb(env?: NodeJS.ProcessEnv, home?: string, platform?: NodeJS.Platform): string;
+export interface CleanResult {
+    text: string;
+    redactions: number;
+}
+/** One JSON document. Cleans the raw text (keeps formatting byte-for-byte
+ * outside the keys); if that would break the JSON, cleans value by value. */
+export declare function cleanJson(text: string): CleanResult;
+/** JSONL: each line is its own JSON document. Line endings are kept. */
+export declare function cleanJsonl(text: string): CleanResult;
+export declare function cleanText(text: string): CleanResult;
+/** Flat `key: value` YAML. A redaction at the start of an unquoted value
+ * would read as a YAML list (`[REDACTED:…]`), so such values get quoted. */
+export declare function cleanYaml(text: string): CleanResult;
+export declare function cleanFor(kind: FileKind, text: string): CleanResult;
+export type FileOutcome = "cleaned" | "would-clean" | "clean" | "too-recent" | "too-large" | "changed-while-cleaning" | "error";
+export interface FileDeps {
+    now: number;
+    minAgeMs: number;
+    dryRun: boolean;
+    /** OpenCode database: only these session ids (tests, `--session`). */
+    onlySessions?: Set<string>;
+    /** Test seam: runs after the cleaned copy is written, before the swap. */
+    beforeSwap?: (file: string) => void;
+}
+export interface FileDetail {
+    keys: KeyHit[];
+    title?: string;
+    cwd?: string;
+}
+/** Clean one file in place, safely. Returns the outcome, how many keys, and
+ * (when keys were found) which ones plus the session's title and folder. */
+export declare function cleanFile(file: string, kind: FileKind, deps: FileDeps): {
+    outcome: FileOutcome;
+    redactions: number;
+    detail?: FileDetail;
+};
+export declare function filesOf(store: Store): string[];
+/** OpenCode keeps messages and parts as JSON text rows. Clean rows whose
+ * session hasn't changed in the last hour, inside one transaction; SQLite's
+ * own locking keeps a running OpenCode safe (we wait or skip, never corrupt). */
+export interface DbResult {
+    outcome: FileOutcome | "no-sqlite";
+    redactions: number;
+    rows: number;
+    /** Per session: keys found, title and folder. */
+    sessions?: Map<string, FileDetail>;
+}
+export declare function cleanOpenCodeDb(file: string, deps: FileDeps): DbResult;
+/** Keys in a Cursor chat database, read-only. cursor-agent's store.db is
+ * content-addressed (each blob's id is the sha256 of its bytes and blobs link
+ * to each other by id), so editing one key would break the chat. The IDE's
+ * state.vscdb holds chats as JSON under bubbleId:/composerData: keys; it is
+ * counted too until it can be tested against a live Cursor. */
+export interface CursorCount {
+    keys: number;
+    chats: number;
+    details: SessionDetection[];
+}
+export declare function countCursorDb(file: string, kind: "cursor-agent-db" | "cursor-ide-db"): CursorCount | null;
+export interface RunOptions {
+    now?: number;
+    minAgeMs?: number;
+    dryRun?: boolean;
+    budgetMs?: number;
+    /** Restrict the run to these files (tests, `codiedev scrub --path`). */
+    only?: string[];
+    /** Restrict the OpenCode database to these sessions (`--session`). */
+    onlySessions?: string[];
+    stores?: Store[];
+    stateDir?: string;
+}
+export interface RunSummary {
+    dryRun: boolean;
+    scanned: number;
+    cleaned: number;
+    redactions: number;
+    skippedRecent: number;
+    skippedLarge: number;
+    changedWhileCleaning: number;
+    errors: number;
+    unfinished: boolean;
+    byHarness: Partial<Record<Harness, {
+        files: number;
+        redactions: number;
+    }>>;
+    /** Keys still in Cursor's own chat stores, which are never changed. */
+    leftInCursor: {
+        keys: number;
+        chats: number;
+    };
+    /** Every session keys were found in this run: what, and removed or not. */
+    sessions: SessionDetection[];
+}
+export declare function runLocalScrub(opts?: RunOptions): RunSummary;
+/** Run the scrub and send the audit to Codiedev when connected. Dry runs and
+ * runs limited by --path/--session are never sent. */
+export declare function runAndReport(opts?: RunOptions): Promise<RunSummary & {
+    reported: boolean;
+}>;
+/** Should this person's machine run the background scrub? Off by default:
+ * only when they turned it on in Security → Settings, or their company
+ * requires it. Any failure (offline, older server, not signed in) means no. */
+type ScrubConfig = {
+    token?: string;
+    backendUrl?: string;
+    companyId?: string;
+} | null;
+/** A company token format as the server sends it: a validated, bounded
+ *  pattern source (prefix + class + length), never free-form. */
+export interface TokenFormatRule {
+    name: string;
+    source: string;
+    keyword?: string;
+}
+export type OwnSecretsMode = "off" | "laptop" | "server";
+export interface ScrubPolicy {
+    enabled: boolean;
+    formats: TokenFormatRule[];
+    ownSecrets: OwnSecretsMode;
+    fingerprintKey?: string;
+}
+export declare function scrubPolicy(fetchImpl?: typeof fetch, getConfig?: () => ScrubConfig): Promise<ScrubPolicy>;
+/** Should this person's machine run the background scrub? */
+export declare function scrubAllowed(fetchImpl?: typeof fetch, getConfig?: () => ScrubConfig): Promise<boolean>;
+/** Turn the company's token formats into scrub rules; a bad one is skipped. */
+export declare function formatRules(formats: readonly TokenFormatRule[]): ExtraRule[];
+/** The scheduled run: policy check, then this person's own secrets (as the
+ *  admin set it: not read / matched here / also keyed fingerprints to the
+ *  server) and the company's formats, then the scrub and its report. */
+export declare function runScheduledScrub(opts?: {
+    fetchImpl?: typeof fetch;
+    getConfig?: () => ScrubConfig;
+    home?: string;
+    stateDir?: string;
+}): Promise<boolean>;
+export interface SpawnOptions {
+    connected?: boolean;
+    /** The session's working directory (its repo). */
+    cwd?: string;
+    now?: number;
+    stateDir?: string;
+    env?: NodeJS.ProcessEnv;
+    hookEntry?: string;
+    spawn?: typeof nodeSpawn;
+}
+/** Start a background scrub if the last one was over an hour ago. Stamps
+ * first so sessions opening at the same time don't each start one. */
+export declare function maybeSpawnLocalScrub(opts?: SpawnOptions): "spawned" | "recent" | "disabled" | "error";
+export {};