fullcourtdefense-cli 1.3.0 → 1.3.2

package/dist/commands/discoverAgentFiles.js

@@ -0,0 +1,204 @@
+"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.scanAgentFiles = scanAgentFiles;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const MAX_FILES = 150;
+const MAX_FILE_BYTES = 512 * 1024;
+const EXCERPT_LEN = 180;
+const RISK_HEURISTICS = [
+    { re: /\b(?:shell|bash|exec|subprocess|terminal|run_command)\b/i, tag: 'allows_shell' },
+    { re: /\b(?:ignore (?:all )?(?:previous )?instructions|bypass|jailbreak|DAN mode)\b/i, tag: 'jailbreak_hint' },
+    { re: /\b(?:always allow|never block|disable security|skip validation)\b/i, tag: 'weak_guardrails' },
+    { re: /\b(?:read any file|full filesystem|\/etc\/passwd|sudo)\b/i, tag: 'broad_filesystem' },
+    { re: /\b(?:send email|post to slack|transfer funds|delete all)\b/i, tag: 'destructive_actions' },
+    { re: /\b(?:api[_-]?key|secret|password|token)\s*[:=]/i, tag: 'embedded_secret_ref' },
+];
+function stableId(parts) {
+    return crypto.createHash('sha256').update(parts.join('|')).digest('hex').slice(0, 16);
+}
+function readAgentFile(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES)
+            return null;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return { content, sizeBytes: stat.size, lineCount: content.split(/\r?\n/).length };
+    }
+    catch {
+        return null;
+    }
+}
+function analyzeContent(content) {
+    const tags = new Set();
+    for (const rule of RISK_HEURISTICS) {
+        if (rule.re.test(content))
+            tags.add(rule.tag);
+    }
+    return [...tags];
+}
+function pushFinding(out, seen, input) {
+    if (out.length >= MAX_FILES)
+        return;
+    const id = stableId([input.filePath, input.kind]);
+    if (seen.has(id))
+        return;
+    seen.add(id);
+    const riskTags = input.riskTags || (input.content ? analyzeContent(input.content) : []);
+    const excerpt = input.content
+        ? input.content.replace(/\s+/g, ' ').trim().slice(0, EXCERPT_LEN)
+        : undefined;
+    out.push({
+        id,
+        kind: input.kind,
+        client: input.client,
+        filePath: input.filePath,
+        title: input.title,
+        sizeBytes: input.sizeBytes,
+        lineCount: input.lineCount,
+        riskTags,
+        excerpt: excerpt || undefined,
+    });
+}
+function walkDir(dir, out, seen, matcher, mapper, maxDepth = 4, depth = 0) {
+    if (depth > maxDepth || out.length >= MAX_FILES)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (out.length >= MAX_FILES)
+            return;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (['node_modules', '.git', 'dist', 'build'].includes(entry.name))
+                continue;
+            walkDir(full, out, seen, matcher, mapper, maxDepth, depth + 1);
+            continue;
+        }
+        if (!entry.isFile() || !matcher(full, entry.name))
+            continue;
+        const parsed = readAgentFile(full);
+        if (!parsed)
+            continue;
+        pushFinding(out, seen, { ...mapper(full), ...parsed, content: parsed.content });
+    }
+}
+function scanNamedFiles(roots, names, kind, titleFor, out, seen) {
+    for (const { root, client } of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        for (const name of names) {
+            const filePath = path.join(root, name);
+            if (!fs.existsSync(filePath))
+                continue;
+            const parsed = readAgentFile(filePath);
+            if (!parsed)
+                continue;
+            pushFinding(out, seen, {
+                kind,
+                client,
+                filePath,
+                title: titleFor(name),
+                sizeBytes: parsed.sizeBytes,
+                lineCount: parsed.lineCount,
+                content: parsed.content,
+            });
+        }
+    }
+}
+function scanAgentFiles(options = {}) {
+    const home = os.homedir();
+    const cwd = options.cwd || process.cwd();
+    const out = [];
+    const seen = new Set();
+    const projectRoots = [{ root: cwd, client: 'project' }, { root: home, client: 'user' }];
+    scanNamedFiles(projectRoots, [
+        'AGENTS.md',
+        'CLAUDE.md',
+        'GEMINI.md',
+        '.cursorrules',
+        '.windsurfrules',
+    ], 'instructions', name => `Agent instructions (${name})`, out, seen);
+    scanNamedFiles([{ root: path.join(cwd, '.github'), client: 'github' }], [
+        'copilot-instructions.md',
+    ], 'instructions', () => 'GitHub Copilot instructions', out, seen);
+    for (const base of [
+        { dir: path.join(home, '.cursor', 'rules'), client: 'Cursor', kind: 'rules' },
+        { dir: path.join(cwd, '.cursor', 'rules'), client: 'Cursor (project)', kind: 'rules' },
+        { dir: path.join(home, '.agents', 'skills'), client: 'Agents', kind: 'skills' },
+        { dir: path.join(cwd, '.agents', 'skills'), client: 'Agents (project)', kind: 'skills' },
+    ]) {
+        if (!fs.existsSync(base.dir))
+            continue;
+        walkDir(base.dir, out, seen, (filePath, name) => name.endsWith('.md') || name.endsWith('.mdc') || name === 'SKILL.md', filePath => ({
+            kind: base.kind,
+            client: base.client,
+            filePath,
+            title: path.basename(filePath),
+            sizeBytes: 0,
+            lineCount: 0,
+        }));
+    }
+    for (const hooksPath of [
+        path.join(home, '.cursor', 'hooks.json'),
+        path.join(cwd, '.cursor', 'hooks.json'),
+    ]) {
+        if (!fs.existsSync(hooksPath))
+            continue;
+        const parsed = readAgentFile(hooksPath);
+        if (!parsed)
+            continue;
+        pushFinding(out, seen, {
+            kind: 'hooks',
+            client: 'Cursor',
+            filePath: hooksPath,
+            title: 'Cursor hooks config',
+            sizeBytes: parsed.sizeBytes,
+            lineCount: parsed.lineCount,
+            content: parsed.content,
+            riskTags: parsed.content.includes('fullcourtdefense') ? [] : ['no_runtime_hook'],
+        });
+    }
+    out.sort((a, b) => b.riskTags.length - a.riskTags.length || b.sizeBytes - a.sizeBytes);
+    return out;
+}

package/dist/commands/discoverBlastRadius.d.ts

@@ -0,0 +1,30 @@
+import type { ClientCoverageRow } from './discoverProxy';
+import type { AgentFileFinding } from './discoverAgentFiles';
+import type { SecretsScanResult } from './discoverSecrets';
+export type BlastSeverity = 'critical' | 'high' | 'medium';
+export interface BlastRadiusCombo {
+    id: string;
+    severity: BlastSeverity;
+    title: string;
+    detail: string;
+}
+export interface BlastRadiusReport {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    combos: BlastRadiusCombo[];
+    drivers: string[];
+}
+interface McpServerLike {
+    serverName: string;
+    riskLevel: 'critical' | 'high' | 'medium' | 'low';
+    riskTags: string[];
+    proxyStatus: string;
+    warnings: string[];
+}
+export declare function computeBlastRadius(input: {
+    mcpServers: McpServerLike[];
+    clientCoverage: ClientCoverageRow[];
+    secrets: SecretsScanResult;
+    agentFiles: AgentFileFinding[];
+}): BlastRadiusReport;
+export {};

package/dist/commands/discoverBlastRadius.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBlastRadius = computeBlastRadius;
+function gradeFromScore(score) {
+    if (score >= 90)
+        return 'A';
+    if (score >= 80)
+        return 'B';
+    if (score >= 70)
+        return 'C';
+    if (score >= 60)
+        return 'D';
+    return 'F';
+}
+function hasTag(servers, tag, directOnly = false) {
+    return servers.some(s => s.riskTags.includes(tag) && (!directOnly || s.proxyStatus === 'direct'));
+}
+function countDirect(servers, minLevel = 'medium') {
+    const order = { low: 0, medium: 1, high: 2, critical: 3 };
+    return servers.filter(s => s.proxyStatus === 'direct' && order[s.riskLevel] >= order[minLevel]).length;
+}
+function computeBlastRadius(input) {
+    const combos = [];
+    const drivers = [];
+    const { mcpServers, clientCoverage, secrets, agentFiles } = input;
+    const directServers = mcpServers.filter(s => s.proxyStatus === 'direct');
+    const criticalSecrets = secrets.findings.filter(f => f.severity === 'critical' || f.severity === 'high');
+    const riskyAgentFiles = agentFiles.filter(f => f.riskTags.length > 0);
+    if (hasTag(directServers, 'shell/exec', true)) {
+        combos.push({
+            id: 'unproxied_shell',
+            severity: 'critical',
+            title: 'Direct shell/exec MCP',
+            detail: 'At least one shell or command-runner MCP is not routed through Full Court Defense gateway.',
+        });
+    }
+    if (hasTag(directServers, 'database', true)) {
+        combos.push({
+            id: 'unproxied_database',
+            severity: 'critical',
+            title: 'Direct database MCP',
+            detail: 'Database MCP tools are reachable without gateway policy enforcement.',
+        });
+    }
+    if (hasTag(directServers, 'shell/exec', true) && hasTag(directServers, 'filesystem', true)) {
+        combos.push({
+            id: 'shell_plus_filesystem',
+            severity: 'critical',
+            title: 'Shell + filesystem combo (direct)',
+            detail: 'Agent can execute commands and read/write files without gateway — high blast radius.',
+        });
+    }
+    if (hasTag(mcpServers, 'shell/exec', true) && criticalSecrets.length > 0) {
+        combos.push({
+            id: 'shell_plus_secrets',
+            severity: 'critical',
+            title: 'Shell MCP + secrets on disk',
+            detail: `${criticalSecrets.length} high/critical secret(s) on this machine while shell/exec MCP is enabled.`,
+        });
+    }
+    if (hasTag(directServers, 'web/network', true) && criticalSecrets.length > 0) {
+        combos.push({
+            id: 'browser_plus_secrets',
+            severity: 'high',
+            title: 'Browser/network MCP + local secrets',
+            detail: 'Web or browser automation MCP combined with API keys in .env or credential stores.',
+        });
+    }
+    const clientsWithMcp = clientCoverage.filter(c => c.mcpServerCount > 0);
+    const missingGateway = clientsWithMcp.filter(c => !c.mcpGatewayInstalled && !c.cursorHooksInstalled);
+    if (clientsWithMcp.length > 0 && missingGateway.length === clientsWithMcp.length) {
+        combos.push({
+            id: 'no_gateway_coverage',
+            severity: 'high',
+            title: 'No gateway on any AI client',
+            detail: `${clientsWithMcp.length} AI client(s) have MCP configured but no FCD gateway or Cursor hooks.`,
+        });
+    }
+    if (countDirect(mcpServers, 'critical') >= 2) {
+        combos.push({
+            id: 'many_direct_critical',
+            severity: 'high',
+            title: 'Multiple unproxied critical MCPs',
+            detail: `${countDirect(mcpServers, 'critical')} critical MCP server(s) run direct.`,
+        });
+    }
+    const unencryptedSsh = secrets.findings.find(f => f.category === 'ssh_key' && f.severity === 'high');
+    if (unencryptedSsh) {
+        combos.push({
+            id: 'ssh_key_exposed',
+            severity: 'high',
+            title: 'Unencrypted SSH private key',
+            detail: unencryptedSsh.filePath,
+        });
+    }
+    if (riskyAgentFiles.some(f => f.riskTags.includes('allows_shell') || f.riskTags.includes('broad_filesystem'))) {
+        combos.push({
+            id: 'permissive_agent_rules',
+            severity: 'medium',
+            title: 'Permissive agent rules/skills',
+            detail: 'Cursor rules or skills mention shell, filesystem, or weak guardrails — review what the agent is allowed to do.',
+        });
+    }
+    if (agentFiles.length >= 5 && !clientCoverage.some(c => c.cursorHooksInstalled)) {
+        combos.push({
+            id: 'rich_instructions_no_hooks',
+            severity: 'medium',
+            title: 'Many instruction files, no runtime hooks',
+            detail: `${agentFiles.length} agent instruction/skill files found but Cursor hooks are not installed.`,
+        });
+    }
+    let score = 100;
+    for (const combo of combos) {
+        if (combo.severity === 'critical')
+            score -= 22;
+        else if (combo.severity === 'high')
+            score -= 12;
+        else
+            score -= 6;
+    }
+    score -= Math.min(30, criticalSecrets.length * 8);
+    score -= Math.min(15, countDirect(mcpServers, 'high') * 4);
+    score -= Math.min(10, riskyAgentFiles.length * 2);
+    score = Math.max(0, Math.min(100, score));
+    if (criticalSecrets.length)
+        drivers.push(`${criticalSecrets.length} exposed secret(s)`);
+    if (directServers.length)
+        drivers.push(`${directServers.length} direct MCP server(s)`);
+    if (missingGateway.length)
+        drivers.push(`${missingGateway.length} client(s) without gateway`);
+    if (riskyAgentFiles.length)
+        drivers.push(`${riskyAgentFiles.length} risky agent file(s)`);
+    return {
+        score,
+        grade: gradeFromScore(score),
+        combos,
+        drivers,
+    };
+}

package/dist/commands/discoverSecrets.d.ts

@@ -0,0 +1,24 @@
+export type SecretSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+export type SecretCategory = 'env_file' | 'credential_store' | 'config' | 'shell_history' | 'ssh_key' | 'other';
+export interface SecretFinding {
+    id: string;
+    category: SecretCategory;
+    severity: SecretSeverity;
+    provider?: string;
+    filePath: string;
+    lineNumber?: number;
+    title: string;
+    detail: string;
+    redactedPreview?: string;
+    remediation: string;
+}
+export interface SecretsScanResult {
+    findings: SecretFinding[];
+    scannedFiles: number;
+    scannedStores: number;
+    healthScore: number;
+}
+export declare function scanSecrets(options?: {
+    cwd?: string;
+    maxEnvDepth?: number;
+}): SecretsScanResult;

package/dist/commands/discoverSecrets.js

@@ -0,0 +1,286 @@
+"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.scanSecrets = scanSecrets;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** Patterns inspired by GhostHunt + secrets-audit-mcp (local-only, no network). */
+const SECRET_PATTERNS = [
+    { re: /\bsk-[a-zA-Z0-9_-]{20,}\b/, provider: 'openai', severity: 'critical', title: 'OpenAI API key' },
+    { re: /\bsk-proj-[a-zA-Z0-9_-]{20,}\b/, provider: 'openai', severity: 'critical', title: 'OpenAI project key' },
+    { re: /\bsk-ant-[a-zA-Z0-9_-]{20,}\b/, provider: 'anthropic', severity: 'critical', title: 'Anthropic API key' },
+    { re: /\bghp_[a-zA-Z0-9]{36,}\b/, provider: 'github', severity: 'critical', title: 'GitHub personal access token' },
+    { re: /\bgho_[a-zA-Z0-9]{36,}\b/, provider: 'github', severity: 'critical', title: 'GitHub OAuth token' },
+    { re: /\bgithub_pat_[a-zA-Z0-9_]{20,}\b/, provider: 'github', severity: 'critical', title: 'GitHub fine-grained PAT' },
+    { re: /\bAKIA[0-9A-Z]{16}\b/, provider: 'aws', severity: 'critical', title: 'AWS access key ID' },
+    { re: /\bAIza[0-9A-Za-z_-]{35}\b/, provider: 'google', severity: 'critical', title: 'Google API key' },
+    { re: /\bxox[baprs]-[a-zA-Z0-9-]{10,}\b/, provider: 'slack', severity: 'high', title: 'Slack token' },
+    { re: /\bsk_live_[0-9a-zA-Z]{24,}\b/, provider: 'stripe', severity: 'critical', title: 'Stripe live secret key' },
+    { re: /\brk_live_[0-9a-zA-Z]{24,}\b/, provider: 'stripe', severity: 'critical', title: 'Stripe restricted key' },
+    { re: /\bSG\.[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}\b/, provider: 'sendgrid', severity: 'high', title: 'SendGrid API key' },
+    { re: /\bsk-[0-9a-fA-F]{32}\b/, provider: 'twilio', severity: 'high', title: 'Twilio API key' },
+    { re: /\bhf_[a-zA-Z0-9]{30,}\b/, provider: 'huggingface', severity: 'high', title: 'HuggingFace token' },
+    { re: /\bag_org_[a-zA-Z0-9_-]{20,}\b/, provider: 'fullcourtdefense', severity: 'high', title: 'FullCourtDefense org API key' },
+    { re: /\bshsk_[a-zA-Z0-9]{20,}\b/, provider: 'fullcourtdefense', severity: 'high', title: 'Shield API key' },
+    { re: /\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b/, provider: 'jwt', severity: 'medium', title: 'JWT token' },
+    { re: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/, provider: 'private_key', severity: 'critical', title: 'Private key material' },
+    { re: /postgres(?:ql)?:\/\/[^\s'"]+:[^\s'"]+@/i, provider: 'database', severity: 'critical', title: 'Database connection string' },
+    { re: /mongodb(?:\+srv)?:\/\/[^\s'"]+:[^\s'"]+@/i, provider: 'database', severity: 'critical', title: 'MongoDB connection string' },
+];
+const SKIP_DIR_NAMES = new Set([
+    'node_modules', '.git', 'vendor', 'dist', 'build', '__pycache__', '.venv', 'venv',
+    'Library', 'Caches', 'Cache', 'Temp', 'tmp', 'Windows', 'Program Files', 'Program Files (x86)',
+    'AppData', 'Application Data', '.npm', '.cache', 'OneDrive', 'Google',
+]);
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_ENV_FILES = 400;
+const MAX_FINDINGS = 200;
+function redact(value) {
+    const trimmed = value.trim();
+    if (trimmed.length <= 8)
+        return '***';
+    return `${trimmed.slice(0, 4)}…${trimmed.slice(-4)}`;
+}
+function findingId(parts) {
+    return crypto.createHash('sha256').update(parts.join('|')).digest('hex').slice(0, 16);
+}
+function scoreFromFindings(findings) {
+    let score = 100;
+    for (const f of findings) {
+        if (f.severity === 'critical')
+            score -= 25;
+        else if (f.severity === 'high')
+            score -= 12;
+        else if (f.severity === 'medium')
+            score -= 5;
+        else if (f.severity === 'low')
+            score -= 2;
+    }
+    return Math.max(0, Math.min(100, score));
+}
+function scanTextLines(filePath, content, category, out, seen) {
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        for (const pattern of SECRET_PATTERNS) {
+            const match = line.match(pattern.re);
+            if (!match)
+                continue;
+            const raw = match[0];
+            const id = findingId([filePath, String(i + 1), pattern.provider, raw.slice(0, 12)]);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({
+                id,
+                category,
+                severity: pattern.severity,
+                provider: pattern.provider,
+                filePath,
+                lineNumber: i + 1,
+                title: pattern.title,
+                detail: `Matched ${pattern.provider} pattern in ${path.basename(filePath)}`,
+                redactedPreview: redact(raw),
+                remediation: pattern.provider === 'private_key'
+                    ? 'Move keys to a secure store; never commit private keys. Use ssh-agent or encrypted keys.'
+                    : 'Rotate this credential immediately and store it in a secret manager or OS keychain — not in plain files.',
+            });
+            if (out.length >= MAX_FINDINGS)
+                return;
+        }
+    }
+}
+function readTextFile(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile() || stat.size > MAX_FILE_BYTES)
+            return null;
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function credentialStores(home) {
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+    return [
+        { path: path.join(home, '.aws', 'credentials'), category: 'credential_store', title: 'AWS credentials file' },
+        { path: path.join(home, '.docker', 'config.json'), category: 'credential_store', title: 'Docker registry auth' },
+        { path: path.join(home, '.npmrc'), category: 'credential_store', title: 'npm auth token' },
+        { path: path.join(home, '.pypirc'), category: 'credential_store', title: 'PyPI auth token' },
+        { path: path.join(xdg, 'gh', 'hosts.yml'), category: 'credential_store', title: 'GitHub CLI OAuth token' },
+        { path: path.join(home, '.kube', 'config'), category: 'credential_store', title: 'Kubernetes kubeconfig' },
+        { path: path.join(home, '.netrc'), category: 'credential_store', title: 'Netrc passwords' },
+        { path: path.join(xdg, 'gcloud', 'application_default_credentials.json'), category: 'credential_store', title: 'GCP ADC JSON' },
+        { path: path.join(appData, 'gcloud', 'application_default_credentials.json'), category: 'credential_store', title: 'GCP ADC JSON (win)' },
+        { path: path.join(home, '.config', 'gcloud', 'application_default_credentials.json'), category: 'credential_store', title: 'GCP ADC JSON' },
+        { path: path.join(localAppData, 'Microsoft', 'PowerShell', 'PSReadLine', 'ConsoleHost_history.txt'), category: 'shell_history', title: 'PowerShell history' },
+        { path: path.join(home, '.bash_history'), category: 'shell_history', title: 'Bash history' },
+        { path: path.join(home, '.zsh_history'), category: 'shell_history', title: 'Zsh history' },
+        { path: path.join(home, '.local', 'share', 'fish', 'fish_history'), category: 'shell_history', title: 'Fish history' },
+    ];
+}
+function scanSshKeys(home, out, seen) {
+    const sshDir = path.join(home, '.ssh');
+    let scanned = 0;
+    if (!fs.existsSync(sshDir))
+        return 0;
+    for (const name of fs.readdirSync(sshDir)) {
+        if (!/^id_(?:rsa|ed25519|ecdsa|dsa)$/.test(name))
+            continue;
+        const filePath = path.join(sshDir, name);
+        const content = readTextFile(filePath);
+        if (!content)
+            continue;
+        scanned += 1;
+        const encrypted = /ENCRYPTED/.test(content);
+        const id = findingId([filePath, 'ssh']);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        out.push({
+            id,
+            category: 'ssh_key',
+            severity: encrypted ? 'info' : 'high',
+            provider: 'ssh',
+            filePath,
+            title: encrypted ? 'SSH private key (passphrase protected)' : 'Unencrypted SSH private key',
+            detail: encrypted
+                ? `${name} appears passphrase-protected — lower exposure if laptop is stolen while locked.`
+                : `${name} has no passphrase — any process/user on this machine can read it.`,
+            remediation: encrypted
+                ? 'Prefer hardware-backed or agent-stored keys for production access.'
+                : 'Run `ssh-keygen -p -f ~/.ssh/' + name + '` to add a passphrase, or use ssh-agent with limited lifetime.',
+        });
+    }
+    return scanned;
+}
+function collectEnvFiles(roots, maxDepth) {
+    const found = [];
+    const queue = roots.map(dir => ({ dir, depth: 0 }));
+    while (queue.length > 0 && found.length < MAX_ENV_FILES) {
+        const { dir, depth } = queue.shift();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (found.length >= MAX_ENV_FILES)
+                break;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth >= maxDepth)
+                    continue;
+                if (SKIP_DIR_NAMES.has(entry.name))
+                    continue;
+                if (entry.name.startsWith('.') && !['.cursor', '.claude', '.codex', '.vscode'].includes(entry.name))
+                    continue;
+                queue.push({ dir: full, depth: depth + 1 });
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (/^\.env(\..+)?$/.test(entry.name) || entry.name === '.env.local' || entry.name === '.env.production') {
+                found.push(full);
+            }
+        }
+    }
+    return found;
+}
+function scanSecrets(options = {}) {
+    const home = os.homedir();
+    const cwd = options.cwd || process.cwd();
+    const maxDepth = options.maxEnvDepth ?? 4;
+    const findings = [];
+    const seen = new Set();
+    let scannedFiles = 0;
+    let scannedStores = 0;
+    for (const store of credentialStores(home)) {
+        if (!fs.existsSync(store.path))
+            continue;
+        scannedStores += 1;
+        const content = readTextFile(store.path);
+        if (!content)
+            continue;
+        scannedFiles += 1;
+        if (store.category === 'shell_history') {
+            const tail = content.split(/\r?\n/).slice(-500).join('\n');
+            scanTextLines(store.path, tail, store.category, findings, seen);
+        }
+        else {
+            scanTextLines(store.path, content, store.category, findings, seen);
+        }
+        if (findings.length >= MAX_FINDINGS)
+            break;
+    }
+    scannedStores += scanSshKeys(home, findings, seen);
+    const envRoots = Array.from(new Set([
+        home,
+        cwd,
+        path.join(home, 'dev'),
+        path.join(home, 'repos'),
+        path.join(home, 'projects'),
+        path.join(home, 'Documents'),
+        path.join(home, 'code'),
+    ].filter(root => fs.existsSync(root))));
+    for (const envFile of collectEnvFiles(envRoots, maxDepth)) {
+        if (findings.length >= MAX_FINDINGS)
+            break;
+        const content = readTextFile(envFile);
+        if (!content)
+            continue;
+        scannedFiles += 1;
+        scanTextLines(envFile, content, 'env_file', findings, seen);
+    }
+    findings.sort((a, b) => {
+        const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+        return order[a.severity] - order[b.severity] || a.filePath.localeCompare(b.filePath);
+    });
+    return {
+        findings,
+        scannedFiles,
+        scannedStores,
+        healthScore: scoreFromFindings(findings),
+    };
+}