lcch-cli 1.0.1

package/dist/scanner.js

@@ -0,0 +1,1789 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigPath = getConfigPath;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.getSettingsPath = getSettingsPath;
+exports.getProjectSettingsPath = getProjectSettingsPath;
+exports.readSettingsAt = readSettingsAt;
+exports.readSettings = readSettings;
+exports.getAllHooksWithScope = getAllHooksWithScope;
+exports.groupHooksByScope = groupHooksByScope;
+exports.groupHooksByEvent = groupHooksByEvent;
+exports.scanProjects = scanProjects;
+exports.getProjectInfo = getProjectInfo;
+exports.removeProjects = removeProjects;
+exports.buildProjectTree = buildProjectTree;
+exports.printProjectTree = printProjectTree;
+exports.formatDate = formatDate;
+exports.formatRelativeTime = formatRelativeTime;
+exports.readSessionHistory = readSessionHistory;
+exports.deleteSessions = deleteSessions;
+exports.groupSessionsByProject = groupSessionsByProject;
+exports.truncateText = truncateText;
+exports.getProjectResumeInfo = getProjectResumeInfo;
+exports.getOrphanedResumes = getOrphanedResumes;
+exports.deleteProjectResumes = deleteProjectResumes;
+exports.getAllMcpServers = getAllMcpServers;
+exports.groupMcpServersByScope = groupMcpServersByScope;
+exports.calculateGlobalStats = calculateGlobalStats;
+exports.getCacheInfo = getCacheInfo;
+exports.getPromptCacheStats = getPromptCacheStats;
+exports.scanCacheSecrets = scanCacheSecrets;
+exports.scanProjectCacheSecrets = scanProjectCacheSecrets;
+exports.getAllProjectCacheDirs = getAllProjectCacheDirs;
+exports.scanProjectSecrets = scanProjectSecrets;
+exports.maskProjectSecrets = maskProjectSecrets;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * 获取 Claude 配置文件路径
+ */
+function getConfigPath() {
+    return path.join(os.homedir(), '.claude.json');
+}
+/**
+ * 读取 Claude 配置文件
+ */
+async function readConfig() {
+    const configPath = getConfigPath();
+    if (!await fs.pathExists(configPath)) {
+        throw new Error(`配置文件不存在: ${configPath}`);
+    }
+    const content = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * 写入 Claude 配置文件
+ */
+async function writeConfig(config) {
+    const configPath = getConfigPath();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+/**
+ * 获取 Claude settings 文件路径（全局）
+ */
+function getSettingsPath() {
+    return path.join(os.homedir(), '.claude', 'settings.json');
+}
+/**
+ * 获取项目级 settings 文件路径
+ */
+function getProjectSettingsPath(projectPath) {
+    return path.join(projectPath, '.claude', 'settings.json');
+}
+/**
+ * 读取指定路径的 settings 文件
+ */
+async function readSettingsAt(settingsPath) {
+    if (!await fs.pathExists(settingsPath)) {
+        return null;
+    }
+    const content = await fs.readFile(settingsPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * 读取 Claude settings 文件（全局）
+ */
+async function readSettings() {
+    const settingsPath = getSettingsPath();
+    return readSettingsAt(settingsPath);
+}
+/**
+ * 获取所有 hooks（全局 + 项目级）
+ */
+async function getAllHooksWithScope(config) {
+    const hookInfos = [];
+    // 读取全局 hooks
+    const globalSettings = await readSettings();
+    if (globalSettings && globalSettings.hooks) {
+        const hooks = globalSettings.hooks;
+        for (const [event, hookList] of Object.entries(hooks)) {
+            if (!Array.isArray(hookList))
+                continue;
+            for (let i = 0; i < hookList.length; i++) {
+                const hookGroup = hookList[i];
+                if (!hookGroup.hooks || !Array.isArray(hookGroup.hooks))
+                    continue;
+                for (const hook of hookGroup.hooks) {
+                    hookInfos.push({
+                        event,
+                        matcher: hookGroup.matcher,
+                        type: hook.type,
+                        command: hook.command,
+                        index: i,
+                        scope: 'global',
+                    });
+                }
+            }
+        }
+    }
+    // 读取项目级 hooks
+    for (const projectPath of Object.keys(config.projects)) {
+        const expandedPath = projectPath.replace(/^~/, os.homedir());
+        const projectSettingsPath = getProjectSettingsPath(expandedPath);
+        const projectSettings = await readSettingsAt(projectSettingsPath);
+        if (projectSettings && projectSettings.hooks) {
+            const hooks = projectSettings.hooks;
+            for (const [event, hookList] of Object.entries(hooks)) {
+                if (!Array.isArray(hookList))
+                    continue;
+                for (let i = 0; i < hookList.length; i++) {
+                    const hookGroup = hookList[i];
+                    if (!hookGroup.hooks || !Array.isArray(hookGroup.hooks))
+                        continue;
+                    for (const hook of hookGroup.hooks) {
+                        hookInfos.push({
+                            event,
+                            matcher: hookGroup.matcher,
+                            type: hook.type,
+                            command: hook.command,
+                            index: i,
+                            scope: 'project',
+                            projectPath,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return hookInfos;
+}
+/**
+ * 按作用范围分组 hooks
+ */
+function groupHooksByScope(hooks) {
+    const global = [];
+    const project = new Map();
+    for (const hook of hooks) {
+        if (hook.scope === 'global') {
+            global.push(hook);
+        }
+        else if (hook.scope === 'project' && hook.projectPath) {
+            const list = project.get(hook.projectPath) || [];
+            list.push(hook);
+            project.set(hook.projectPath, list);
+        }
+    }
+    return { global, project };
+}
+/**
+ * 按事件分组 hooks
+ */
+function groupHooksByEvent(hooks) {
+    const groups = new Map();
+    for (const hook of hooks) {
+        const list = groups.get(hook.event) || [];
+        list.push(hook);
+        groups.set(hook.event, list);
+    }
+    return groups;
+}
+/**
+ * 扫描项目，检查路径是否存在
+ */
+async function scanProjects(config) {
+    const projects = Object.keys(config.projects);
+    const validProjects = [];
+    const invalidProjects = [];
+    for (const projectPath of projects) {
+        // 处理路径中的 ~ 符号
+        const expandedPath = projectPath.replace(/^~/, os.homedir());
+        if (await fs.pathExists(expandedPath)) {
+            validProjects.push(projectPath);
+        }
+        else {
+            invalidProjects.push(projectPath);
+        }
+    }
+    return {
+        validProjects,
+        invalidProjects,
+        totalCount: projects.length,
+        validCount: validProjects.length,
+        invalidCount: invalidProjects.length,
+    };
+}
+/**
+ * 获取项目的详细信息
+ */
+function getProjectInfo(config, projectPath) {
+    return config.projects[projectPath];
+}
+/**
+ * 从配置中删除项目
+ */
+function removeProjects(config, projectPaths) {
+    for (const projectPath of projectPaths) {
+        delete config.projects[projectPath];
+    }
+}
+/**
+ * 构建项目树结构
+ */
+function buildProjectTree(projectPaths) {
+    const tree = new Map();
+    for (const projectPath of projectPaths) {
+        // 统一使用 / 作为分隔符，并分割路径
+        const normalizedPath = projectPath.replace(/\\/g, '/');
+        const parts = normalizedPath.split('/').filter(p => p);
+        if (parts.length === 0)
+            continue;
+        let current = tree;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            if (isLast) {
+                // 最后一个部分是项目名
+                current.set(part, { _isLeaf: true, _fullPath: projectPath });
+            }
+            else {
+                // 中间部分是目录
+                if (!current.has(part)) {
+                    current.set(part, new Map());
+                }
+                const nextLevel = current.get(part);
+                if (nextLevel instanceof Map) {
+                    current = nextLevel;
+                }
+            }
+        }
+    }
+    return tree;
+}
+/**
+ * 打印项目树
+ */
+function printProjectTree(tree, prefix = '', isLast = true, validProjects = new Set(), invalidProjects = new Set()) {
+    const entries = Array.from(tree.entries());
+    for (let i = 0; i < entries.length; i++) {
+        const [name, value] = entries[i];
+        const isLastItem = i === entries.length - 1;
+        const connector = isLastItem ? '└── ' : '├── ';
+        const childPrefix = isLastItem ? '    ' : '│   ';
+        if (value && typeof value === 'object' && value._isLeaf) {
+            // 叶子节点（项目）
+            const isValid = validProjects.has(value._fullPath);
+            const isInvalid = invalidProjects.has(value._fullPath);
+            if (isValid) {
+                console.log(`${prefix}${connector}${name} ${chalk_1.default.green('✓')}`);
+            }
+            else if (isInvalid) {
+                console.log(`${prefix}${connector}${name} ${chalk_1.default.red('✗')}`);
+            }
+            else {
+                console.log(`${prefix}${connector}${name}`);
+            }
+        }
+        else if (value instanceof Map) {
+            // 目录节点
+            console.log(`${prefix}${connector}${chalk_1.default.white(name)}`);
+            printProjectTree(value, prefix + childPrefix, isLastItem, validProjects, invalidProjects);
+        }
+    }
+}
+/**
+ * 格式化日期
+ */
+function formatDate(date) {
+    return date.toLocaleString('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+}
+/**
+ * 格式化相对时间（如：2小时前）
+ */
+function formatRelativeTime(timestamp) {
+    const now = Date.now();
+    const diff = now - timestamp;
+    const minute = 60 * 1000;
+    const hour = 60 * minute;
+    const day = 24 * hour;
+    if (diff < minute) {
+        return '刚刚';
+    }
+    else if (diff < hour) {
+        return `${Math.floor(diff / minute)}分钟前`;
+    }
+    else if (diff < day) {
+        return `${Math.floor(diff / hour)}小时前`;
+    }
+    else if (diff < 7 * day) {
+        return `${Math.floor(diff / day)}天前`;
+    }
+    else {
+        return formatDate(new Date(timestamp));
+    }
+}
+/**
+ * 读取会话历史
+ */
+async function readSessionHistory() {
+    const historyPath = path.join(os.homedir(), '.claude', 'history.jsonl');
+    if (!await fs.pathExists(historyPath)) {
+        return [];
+    }
+    const content = await fs.readFile(historyPath, 'utf-8');
+    const lines = content.trim().split('\n').filter(line => line.trim());
+    const sessions = [];
+    for (const line of lines) {
+        try {
+            const record = JSON.parse(line);
+            if (record.project && record.sessionId) {
+                sessions.push({
+                    display: record.display || '',
+                    timestamp: record.timestamp || 0,
+                    project: record.project,
+                    sessionId: record.sessionId,
+                });
+            }
+        }
+        catch {
+            // 忽略解析失败的行
+        }
+    }
+    return sessions;
+}
+/**
+ * 删除指定会话
+ * @param sessionIds 要删除的会话ID列表
+ * @returns 实际删除的会话数量
+ */
+async function deleteSessions(sessionIds) {
+    const historyPath = path.join(os.homedir(), '.claude', 'history.jsonl');
+    if (!await fs.pathExists(historyPath)) {
+        return 0;
+    }
+    const content = await fs.readFile(historyPath, 'utf-8');
+    const lines = content.trim().split('\n').filter(line => line.trim());
+    const remainingLines = [];
+    let deletedCount = 0;
+    for (const line of lines) {
+        try {
+            const record = JSON.parse(line);
+            if (record.sessionId && sessionIds.has(record.sessionId)) {
+                deletedCount++;
+            }
+            else {
+                remainingLines.push(line);
+            }
+        }
+        catch {
+            // 保留解析失败的行
+            remainingLines.push(line);
+        }
+    }
+    // 写回文件
+    await fs.writeFile(historyPath, remainingLines.join('\n') + (remainingLines.length > 0 ? '\n' : ''));
+    return deletedCount;
+}
+/**
+ * 按项目分组会话
+ */
+function groupSessionsByProject(sessions) {
+    const groups = new Map();
+    for (const session of sessions) {
+        const list = groups.get(session.project) || [];
+        list.push(session);
+        groups.set(session.project, list);
+    }
+    // 对每个项目的会话按时间倒序排列
+    for (const [projectPath, list] of groups) {
+        list.sort((a, b) => b.timestamp - a.timestamp);
+        groups.set(projectPath, list);
+    }
+    return groups;
+}
+/**
+ * 截断文本到指定长度
+ */
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.substring(0, maxLength - 3) + '...';
+}
+/**
+ * 获取项目的 resume 信息
+ * 扫描 ~/.claude/projects/<project-path>/<session-id>.jsonl 文件
+ */
+async function getProjectResumeInfo(projectPath) {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    // 将项目路径转换为目录名（Claude Code 使用的格式）
+    // 例如: /Users/lrk/workspace/project -> -Users-lrk-workspace-project
+    const normalizedPath = projectPath.replace(/\//g, '-');
+    const projectDir = path.join(projectsDir, normalizedPath);
+    if (!await fs.pathExists(projectDir)) {
+        return [];
+    }
+    const entries = await fs.readdir(projectDir, { withFileTypes: true });
+    const resumeInfos = [];
+    for (const entry of entries) {
+        // 只处理 .jsonl 文件
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+            continue;
+        }
+        const sessionId = entry.name.replace('.jsonl', '');
+        const filePath = path.join(projectDir, entry.name);
+        const stats = await fs.stat(filePath);
+        // 读取文件内容统计信息
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        let messageCount = 0;
+        let compactCount = 0;
+        let lastActivity = stats.mtime;
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                messageCount++;
+                // 检测 compact_boundary 记录
+                if (record.subtype === 'compact_boundary' || record.type === 'compact_boundary') {
+                    compactCount++;
+                }
+                // 获取最后活动时间
+                if (record.timestamp) {
+                    const recordTime = new Date(record.timestamp);
+                    if (recordTime > lastActivity) {
+                        lastActivity = recordTime;
+                    }
+                }
+            }
+            catch {
+                // 忽略解析失败的行
+            }
+        }
+        resumeInfos.push({
+            sessionId,
+            createdAt: stats.birthtime || stats.ctime,
+            messageCount,
+            compactCount,
+            lastActivity,
+            fileSize: stats.size,
+        });
+    }
+    // 按最后活动时间倒序排列
+    return resumeInfos.sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
+}
+/**
+ * 扫描所有孤立的 resume 目录（不在 config 中的项目）
+ * @param configProjects config 中的项目路径集合
+ * @returns 孤立的 resume 信息列表
+ */
+async function getOrphanedResumes(configProjects) {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!await fs.pathExists(projectsDir)) {
+        return [];
+    }
+    // 将 config 中的项目路径转换为 normalized 形式
+    const normalizedConfigProjects = new Set();
+    for (const projectPath of configProjects) {
+        normalizedConfigProjects.add(projectPath.replace(/\//g, '-'));
+    }
+    const entries = await fs.readdir(projectsDir, { withFileTypes: true });
+    const orphanedResumes = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const normalizedPath = entry.name;
+        // 如果这个 normalized path 不在 config 中，则是孤立的
+        if (!normalizedConfigProjects.has(normalizedPath)) {
+            const projectDir = path.join(projectsDir, normalizedPath);
+            const resumeInfos = await scanResumesInDir(projectDir);
+            if (resumeInfos.length > 0) {
+                orphanedResumes.push({
+                    normalizedPath,
+                    resumes: resumeInfos,
+                });
+            }
+        }
+    }
+    return orphanedResumes;
+}
+/**
+ * 扫描指定目录中的 resume 文件
+ */
+async function scanResumesInDir(dirPath) {
+    if (!await fs.pathExists(dirPath)) {
+        return [];
+    }
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const resumeInfos = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl')) {
+            continue;
+        }
+        const sessionId = entry.name.replace('.jsonl', '');
+        const filePath = path.join(dirPath, entry.name);
+        const stats = await fs.stat(filePath);
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        let messageCount = 0;
+        let compactCount = 0;
+        let lastActivity = stats.mtime;
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                messageCount++;
+                // 检测 compact_boundary 记录
+                if (record.subtype === 'compact_boundary' || record.type === 'compact_boundary') {
+                    compactCount++;
+                }
+                // 获取最后活动时间
+                if (record.timestamp) {
+                    const recordTime = new Date(record.timestamp);
+                    if (recordTime > lastActivity) {
+                        lastActivity = recordTime;
+                    }
+                }
+            }
+            catch {
+                // 忽略解析失败的行
+            }
+        }
+        resumeInfos.push({
+            sessionId,
+            createdAt: stats.birthtime,
+            lastActivity,
+            messageCount,
+            compactCount,
+            fileSize: stats.size,
+        });
+    }
+    return resumeInfos.sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
+}
+/**
+ * 删除指定 resume 会话文件
+ * @param projectPath 项目路径
+ * @param sessionIds 要删除的会话ID列表
+ * @returns 实际删除的文件数量
+ */
+async function deleteProjectResumes(projectPath, sessionIds) {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const normalizedPath = projectPath.replace(/\//g, '-');
+    const projectDir = path.join(projectsDir, normalizedPath);
+    if (!await fs.pathExists(projectDir)) {
+        return 0;
+    }
+    let deletedCount = 0;
+    for (const sessionId of sessionIds) {
+        const filePath = path.join(projectDir, `${sessionId}.jsonl`);
+        if (await fs.pathExists(filePath)) {
+            await fs.remove(filePath);
+            deletedCount++;
+        }
+    }
+    // 如果目录为空，删除目录
+    const remainingFiles = await fs.readdir(projectDir);
+    if (remainingFiles.length === 0) {
+        await fs.remove(projectDir);
+    }
+    return deletedCount;
+}
+/**
+ * 获取所有 MCP 服务器信息
+ */
+function getAllMcpServers(config) {
+    const mcpServers = [];
+    // 全局 MCP 服务器
+    if (config.mcpServers) {
+        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+            mcpServers.push({
+                name,
+                config: serverConfig,
+                scope: 'global',
+            });
+        }
+    }
+    // 项目级 MCP 服务器
+    for (const [projectPath, projectConfig] of Object.entries(config.projects)) {
+        if (projectConfig.mcpServers) {
+            for (const [name, serverConfig] of Object.entries(projectConfig.mcpServers)) {
+                mcpServers.push({
+                    name,
+                    config: serverConfig,
+                    scope: 'project',
+                    projectPath,
+                });
+            }
+        }
+    }
+    return mcpServers;
+}
+/**
+ * 按范围分组 MCP 服务器
+ */
+function groupMcpServersByScope(mcpServers) {
+    const global = [];
+    const project = new Map();
+    for (const server of mcpServers) {
+        if (server.scope === 'global') {
+            global.push(server);
+        }
+        else if (server.scope === 'project' && server.projectPath) {
+            const list = project.get(server.projectPath) || [];
+            list.push(server);
+            project.set(server.projectPath, list);
+        }
+    }
+    return { global, project };
+}
+/**
+ * 计算全局统计信息
+ */
+async function calculateGlobalStats(config) {
+    // 获取配置中的所有项目路径
+    const configProjects = new Set(Object.keys(config.projects));
+    // 会话历史统计
+    const sessions = await readSessionHistory();
+    const totalSessionHistory = sessions.length;
+    // 按项目状态分类统计会话历史
+    const sessionHistoryByCategory = {
+        valid: 0,
+        invalid: 0,
+        orphaned: 0,
+    };
+    for (const session of sessions) {
+        const projectPath = session.project;
+        if (!projectPath) {
+            sessionHistoryByCategory.orphaned++;
+            continue;
+        }
+        if (configProjects.has(projectPath)) {
+            // 项目在配置中，需要检查路径是否有效
+            const expandedPath = projectPath.replace(/^~/, os.homedir());
+            if (await fs.pathExists(expandedPath)) {
+                sessionHistoryByCategory.valid++;
+            }
+            else {
+                sessionHistoryByCategory.invalid++;
+            }
+        }
+        else {
+            // 项目不在配置中（孤立会话）
+            sessionHistoryByCategory.orphaned++;
+        }
+    }
+    // Resume 会话统计
+    let totalResumeSessions = 0;
+    const resumeSessionsByCategory = {
+        valid: 0,
+        invalid: 0,
+        orphaned: 0,
+    };
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (await fs.pathExists(projectsDir)) {
+        const projectDirs = await fs.readdir(projectsDir, { withFileTypes: true });
+        for (const dir of projectDirs) {
+            if (dir.isDirectory()) {
+                // 将目录名还原为项目路径（Claude 使用 - 替换 /）
+                // 例如: -Users-lrk-workspace-project -> /Users/lrk/workspace/project
+                const normalizedPath = dir.name.replace(/-/g, '/');
+                // 检查是否是有效项目
+                let category;
+                if (configProjects.has(normalizedPath)) {
+                    if (await fs.pathExists(normalizedPath)) {
+                        category = 'valid';
+                    }
+                    else {
+                        category = 'invalid';
+                    }
+                }
+                else {
+                    category = 'orphaned';
+                }
+                const projectDir = path.join(projectsDir, dir.name);
+                const files = await fs.readdir(projectDir);
+                const resumeCount = files.filter(f => f.endsWith('.jsonl')).length;
+                totalResumeSessions += resumeCount;
+                resumeSessionsByCategory[category] += resumeCount;
+            }
+        }
+    }
+    // 费用统计（按项目状态分类）
+    let totalCost = 0;
+    let validCost = 0;
+    let invalidCost = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheCreationTokens = 0;
+    let totalCacheReadTokens = 0;
+    let lastActivity;
+    for (const [projectPath, projectConfig] of Object.entries(config.projects)) {
+        const cost = projectConfig.lastCost || 0;
+        totalCost += cost;
+        // 判断项目状态并累加到相应分类
+        const expandedPath = projectPath.replace(/^~/, os.homedir());
+        if (await fs.pathExists(expandedPath)) {
+            validCost += cost;
+        }
+        else {
+            invalidCost += cost;
+        }
+        totalInputTokens += projectConfig.lastTotalInputTokens || 0;
+        totalOutputTokens += projectConfig.lastTotalOutputTokens || 0;
+        totalCacheCreationTokens += projectConfig.lastTotalCacheCreationInputTokens || 0;
+        totalCacheReadTokens += projectConfig.lastTotalCacheReadInputTokens || 0;
+        // 获取最后活动时间
+        const metrics = projectConfig.lastSessionMetrics;
+        if (metrics?.timestamp) {
+            const activityTime = new Date(metrics.timestamp);
+            if (!lastActivity || activityTime > lastActivity) {
+                lastActivity = activityTime;
+            }
+        }
+    }
+    const projectCount = Object.keys(config.projects).length;
+    // 工具使用统计
+    const toolUsage = config.toolUsage || {};
+    const totalToolUsage = Object.values(toolUsage).reduce((sum, usage) => sum + (usage.usageCount || 0), 0);
+    const toolDetails = Object.entries(toolUsage)
+        .map(([name, usage]) => ({
+        name,
+        count: usage.usageCount || 0,
+        lastUsedAt: usage.lastUsedAt || 0,
+    }))
+        .sort((a, b) => b.count - a.count);
+    const skillUsage = config.skillUsage || {};
+    const totalSkillUsage = Object.values(skillUsage).reduce((sum, usage) => sum + (usage.usageCount || 0), 0);
+    const skillDetails = Object.entries(skillUsage)
+        .map(([name, usage]) => ({
+        name,
+        count: usage.usageCount || 0,
+        lastUsedAt: usage.lastUsedAt || 0,
+    }))
+        .sort((a, b) => b.count - a.count);
+    // 时间统计
+    let usageDays = 0;
+    if (config.firstStartTime) {
+        const firstStart = new Date(config.firstStartTime);
+        const now = new Date();
+        usageDays = Math.floor((now.getTime() - firstStart.getTime()) / (1000 * 60 * 60 * 24));
+    }
+    // GitHub 统计
+    const totalGithubRepos = Object.values(config.githubRepoPaths || {}).reduce((sum, repos) => sum + repos.length, 0);
+    // Companion 信息
+    let companionInfo;
+    if (config.companion) {
+        companionInfo = {
+            name: config.companion.name,
+            personality: config.companion.personality,
+            hatchedAt: new Date(config.companion.hatchedAt),
+        };
+    }
+    return {
+        totalSessionHistory,
+        sessionHistoryByCategory,
+        totalResumeSessions,
+        resumeSessionsByCategory,
+        totalCost,
+        avgCostPerProject: projectCount > 0 ? totalCost / projectCount : 0,
+        costByCategory: {
+            valid: validCost,
+            invalid: invalidCost,
+        },
+        totalInputTokens,
+        totalOutputTokens,
+        totalCacheCreationTokens,
+        totalCacheReadTokens,
+        totalToolUsage,
+        totalSkillUsage,
+        toolDetails,
+        skillDetails,
+        usageDays,
+        lastActivity,
+        totalGithubRepos,
+        companionInfo,
+    };
+}
+/**
+ * 获取各类缓存信息
+ */
+async function getCacheInfo() {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const caches = [];
+    // 1. 统计缓存 (stats-cache.json)
+    const statsCachePath = path.join(claudeDir, 'stats-cache.json');
+    if (await fs.pathExists(statsCachePath)) {
+        const stat = await fs.stat(statsCachePath);
+        const content = await fs.readFile(statsCachePath, 'utf-8');
+        const data = JSON.parse(content);
+        caches.push({
+            name: 'stats-cache',
+            description: '使用统计缓存（每日活动、Token 消耗、会话统计等）',
+            path: statsCachePath,
+            fileCount: 1,
+            totalSize: stat.size,
+            lastModified: stat.mtime,
+        });
+    }
+    // 2. 文件历史缓存 (file-history/)
+    const fileHistoryPath = path.join(claudeDir, 'file-history');
+    if (await fs.pathExists(fileHistoryPath)) {
+        const { fileCount, totalSize, lastModified } = await getDirectorySize(fileHistoryPath);
+        caches.push({
+            name: 'file-history',
+            description: '文件修改历史版本缓存',
+            path: fileHistoryPath,
+            fileCount,
+            totalSize,
+            lastModified,
+        });
+    }
+    // 3. 粘贴缓存 (paste-cache/)
+    const pasteCachePath = path.join(claudeDir, 'paste-cache');
+    if (await fs.pathExists(pasteCachePath)) {
+        const { fileCount, totalSize, lastModified } = await getDirectorySize(pasteCachePath);
+        caches.push({
+            name: 'paste-cache',
+            description: '粘贴内容临时缓存',
+            path: pasteCachePath,
+            fileCount,
+            totalSize,
+            lastModified,
+        });
+    }
+    // 4. Shell 快照缓存 (shell-snapshots/)
+    const shellSnapshotsPath = path.join(claudeDir, 'shell-snapshots');
+    if (await fs.pathExists(shellSnapshotsPath)) {
+        const { fileCount, totalSize, lastModified } = await getDirectorySize(shellSnapshotsPath);
+        caches.push({
+            name: 'shell-snapshots',
+            description: 'Shell 环境快照缓存',
+            path: shellSnapshotsPath,
+            fileCount,
+            totalSize,
+            lastModified,
+        });
+    }
+    // 5. 通用缓存目录 (cache/)
+    const cacheDirPath = path.join(claudeDir, 'cache');
+    if (await fs.pathExists(cacheDirPath)) {
+        const { fileCount, totalSize, lastModified } = await getDirectorySize(cacheDirPath);
+        caches.push({
+            name: 'cache',
+            description: '通用缓存目录（更新日志等）',
+            path: cacheDirPath,
+            fileCount,
+            totalSize,
+            lastModified,
+        });
+    }
+    // 6. 会话环境缓存 (session-env/)
+    const sessionEnvPath = path.join(claudeDir, 'session-env');
+    if (await fs.pathExists(sessionEnvPath)) {
+        const { fileCount, totalSize, lastModified } = await getDirectorySize(sessionEnvPath);
+        caches.push({
+            name: 'session-env',
+            description: '会话环境变量缓存',
+            path: sessionEnvPath,
+            fileCount,
+            totalSize,
+            lastModified,
+        });
+    }
+    return caches;
+}
+/**
+ * 获取目录的总大小和文件数
+ */
+async function getDirectorySize(dirPath) {
+    let fileCount = 0;
+    let totalSize = 0;
+    let lastModified;
+    async function walkDir(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walkDir(fullPath);
+            }
+            else if (entry.isFile()) {
+                fileCount++;
+                const stat = await fs.stat(fullPath);
+                totalSize += stat.size;
+                if (!lastModified || stat.mtime > lastModified) {
+                    lastModified = stat.mtime;
+                }
+            }
+        }
+    }
+    await walkDir(dirPath);
+    return { fileCount, totalSize, lastModified };
+}
+/**
+ * 获取 API Prompt 缓存统计
+ */
+async function getPromptCacheStats() {
+    const statsCachePath = path.join(os.homedir(), '.claude', 'stats-cache.json');
+    if (!await fs.pathExists(statsCachePath)) {
+        return null;
+    }
+    try {
+        const content = await fs.readFile(statsCachePath, 'utf-8');
+        const data = JSON.parse(content);
+        if (!data.modelUsage) {
+            return null;
+        }
+        // 处理模型名称中的特殊字符
+        const modelUsage = {};
+        for (const [modelKey, usage] of Object.entries(data.modelUsage)) {
+            const key = modelKey.replace(/@@/g, '.'); // Claude 可能用 @@ 替代 .
+            modelUsage[key] = {
+                inputTokens: usage.inputTokens || 0,
+                outputTokens: usage.outputTokens || 0,
+                cacheReadInputTokens: usage.cacheReadInputTokens || 0,
+                cacheCreationInputTokens: usage.cacheCreationInputTokens || 0,
+                costUSD: usage.costUSD || 0,
+            };
+        }
+        // 获取缓存读取和创建的总数
+        let cacheReadInputTokens = 0;
+        let cacheCreationInputTokens = 0;
+        for (const usage of Object.values(modelUsage)) {
+            cacheReadInputTokens += usage.cacheReadInputTokens;
+            cacheCreationInputTokens += usage.cacheCreationInputTokens;
+        }
+        return {
+            cacheReadInputTokens,
+            cacheCreationInputTokens,
+            modelUsage,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+const SECRET_PATTERNS = [
+    {
+        name: 'Anthropic API Key',
+        description: 'Anthropic/Claude API 密钥',
+        patterns: [
+            /sk-(?:sp-)?[a-zA-Z0-9]{20,}/,
+            /ANTHROPIC_AUTH_TOKEN["']?\s*[:=]\s*["']?(sk-[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'OpenAI API Key',
+        description: 'OpenAI API 密钥',
+        patterns: [
+            /sk-[a-zA-Z0-9]{20,}/,
+            /OPENAI_API_KEY["']?\s*[:=]\s*["']?(sk-[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'GitHub Token',
+        description: 'GitHub 访问令牌',
+        patterns: [
+            /ghp_[a-zA-Z0-9]{36}/,
+            /gho_[a-zA-Z0-9]{36}/,
+            /ghu_[a-zA-Z0-9]{36}/,
+            /ghs_[a-zA-Z0-9]{36}/,
+            /ghr_[a-zA-Z0-9]{36}/,
+            /github_pat_[a-zA-Z0-9_]{22,}/,
+            /GITHUB_TOKEN["']?\s*[:=]\s*["']?(ghp_[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt', '.sh'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'AWS Access Key',
+        description: 'AWS 访问密钥',
+        patterns: [
+            /AKIA[0-9A-Z]{16}/,
+            /aws_access_key_id["']?\s*[:=]\s*["']?(AKIA[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'AWS Secret Key',
+        description: 'AWS 秘密密钥',
+        patterns: [
+            /aws_secret_access_key["']?\s*[:=]\s*["']?([A-Za-z0-9/+=]{40})/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'Bearer Token',
+        description: 'Bearer 认证令牌（包含 JWT Token）',
+        patterns: [
+            // Bearer Token 格式
+            /Bearer\s+[a-zA-Z0-9_\-\.]+/i,
+            /Authorization["']?\s*[:=]\s*["']?Bearer\s+([a-zA-Z0-9_\-\.]+)/i,
+            // JWT Token 格式 (eyJ...eyJ...xxx)
+            /eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*/,
+            /JWT["']?\s*[:=]\s*["']?(eyJ[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.txt', '.jsonl'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'Database URL',
+        description: '数据库连接字符串',
+        patterns: [
+            // 移除了 mysql，避免误报 MCP 资源描述中的 mysql:// 前缀
+            /(?:mongodb(?:\+srv)?|postgres(?:ql)?|redis):\/\/[^\s"']+/i,
+            /(?:DATABASE_URL|DB_CONNECTION|MONGO_URI|POSTGRES_URL|REDIS_URL)["']?\s*[:=]\s*["']?([^\s"']+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'Slack Token',
+        description: 'Slack 访问令牌',
+        patterns: [
+            /xox[baprs]-[0-9a-zA-Z-]+/,
+            /SLACK_TOKEN["']?\s*[:=]\s*["']?(xox[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'Stripe API Key',
+        description: 'Stripe 支付密钥',
+        patterns: [
+            /sk_live_[a-zA-Z0-9]{24,}/,
+            /pk_live_[a-zA-Z0-9]{24,}/,
+            /STRIPE_SECRET_KEY["']?\s*[:=]\s*["']?(sk_live[^"'$\s]+)/i,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.txt'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'API Key',
+        description: '通用 API 密钥（包含 API_KEY、APIKEY 等格式）',
+        patterns: [
+            // 匹配 API_KEY 或 APIKEY 结尾的键名，后面跟着等号和值
+            // 支持: MY_API_KEY="value", "MY_APIKEY": "value", API_KEY=value
+            /[A-Za-z0-9_]*(?:API_KEY|APIKEY)["']?\s*[:=]\s*["']?([A-Za-z0-9_\-]+)/gi,
+        ],
+        allowedExtensions: ['.json', '.jsonc', '.env', '.yaml', '.yml', '.toml', '.txt', '.jsonl'],
+        excludePatterns: ['node_modules', '.git', 'dist', 'build'],
+    },
+    {
+        name: 'Private Key',
+        description: '私钥文件',
+        patterns: [
+            /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+        ],
+        allowedExtensions: ['.pem', '.key', '.pub', '.txt'],
+        excludePatterns: ['.git'],
+    },
+];
+/**
+ * 模糊化密钥
+ */
+function maskSecret(secret, type) {
+    if (secret.length <= 8) {
+        return '*'.repeat(secret.length);
+    }
+    if (type === 'Private Key') {
+        return '-----BEGIN PRIVATE KEY-----\n  [密钥内容已隐藏]\n-----END PRIVATE KEY-----';
+    }
+    // 保留前4位和后4位，中间模糊
+    const prefix = secret.substring(0, 4);
+    const suffix = secret.substring(secret.length - 4);
+    const masked = '*'.repeat(Math.min(secret.length - 8, 20));
+    return `${prefix}${masked}${suffix}`;
+}
+/**
+ * 扫描缓存目录中的密钥
+ */
+async function scanCacheSecrets() {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const findings = [];
+    // 需要扫描的目录/文件
+    const scanTargets = [
+        // 全局设置
+        { path: path.join(claudeDir, 'settings.json'), isDir: false },
+        { path: path.join(claudeDir, 'settings.json.bak'), isDir: false },
+        // 项目会话
+        { path: path.join(claudeDir, 'projects'), isDir: true },
+        // 历史记录
+        { path: path.join(claudeDir, 'history.jsonl'), isDir: false },
+        // 会话环境
+        { path: path.join(claudeDir, 'session-env'), isDir: true },
+    ];
+    for (const target of scanTargets) {
+        if (target.isDir) {
+            await scanDirectoryForSecrets(target.path, findings);
+        }
+        else {
+            if (await fs.pathExists(target.path)) {
+                await scanFileForSecrets(target.path, findings);
+            }
+        }
+    }
+    // 去除重复项（基于路径、类型、行号和匹配内容）
+    const uniqueFindings = new Map();
+    for (const finding of findings) {
+        const key = `${finding.path}:${finding.type}:${finding.line}:${finding.context}`;
+        if (!uniqueFindings.has(key)) {
+            uniqueFindings.set(key, finding);
+        }
+    }
+    return Array.from(uniqueFindings.values());
+}
+/**
+ * 扫描目录中的密钥
+ */
+async function scanDirectoryForSecrets(dirPath, findings) {
+    if (!await fs.pathExists(dirPath)) {
+        return;
+    }
+    async function walkDir(dir, depth = 0) {
+        if (depth > 5)
+            return; // 限制递归深度
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            // 跳过特定目录
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '.git') {
+                    continue;
+                }
+                await walkDir(fullPath, depth + 1);
+            }
+            else if (entry.isFile()) {
+                // 检查文件扩展名
+                const ext = path.extname(entry.name).toLowerCase();
+                // 跳过二进制文件和日志
+                if (['.log', '.bin', '.dat', '.sqlite', '.db'].includes(ext)) {
+                    continue;
+                }
+                // 跳过过大的文件（> 10MB）
+                const stat = await fs.stat(fullPath);
+                if (stat.size > 10 * 1024 * 1024) {
+                    continue;
+                }
+                await scanFileForSecrets(fullPath, findings);
+            }
+        }
+    }
+    await walkDir(dirPath);
+}
+/**
+ * 扫描单个文件中的密钥
+ */
+async function scanFileForSecrets(filePath, findings) {
+    // 检查是否应该扫描此文件
+    const fileName = path.basename(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    // 检查每个模式
+    for (const patternDef of SECRET_PATTERNS) {
+        // 检查扩展名
+        if (patternDef.allowedExtensions.length > 0 &&
+            !patternDef.allowedExtensions.includes(ext) &&
+            !patternDef.allowedExtensions.includes('*')) {
+            continue;
+        }
+        // 检查排除模式
+        const shouldExclude = patternDef.excludePatterns.some(exc => filePath.includes(`/node_modules/`) ||
+            filePath.includes(`/${exc}/`) ||
+            fileName === exc);
+        if (shouldExclude) {
+            continue;
+        }
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // 对于 JSON 文件，尝试解析并只扫描值
+            if (ext === '.json' || ext === '.jsonc') {
+                await scanJsonContent(filePath, content, patternDef, findings);
+            }
+            else {
+                await scanTextContent(filePath, content, patternDef, findings);
+            }
+        }
+        catch {
+            // 跳过无法读取的文件（二进制文件等）
+        }
+    }
+}
+/**
+ * 扫描 JSON 内容
+ */
+async function scanJsonContent(filePath, content, patternDef, findings) {
+    try {
+        // 简化处理：将 JSON 转换为行以便逐行扫描
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const pattern of patternDef.patterns) {
+                const matches = line.matchAll(new RegExp(pattern, 'gi'));
+                for (const match of matches) {
+                    // 提取密钥（从匹配组或完整匹配）
+                    let secret = match[1] || match[0];
+                    // 验证是否真的是密钥（排除误报）
+                    // Bearer Token、Authorization 等模式需要特殊处理，因为捕获组可能只包含 token 部分
+                    const isAuthPattern = patternDef.name === 'Bearer Token' ||
+                        patternDef.name === 'JWT Token';
+                    const minLength = isAuthPattern ? 4 : 10;
+                    if (secret.length < minLength)
+                        continue;
+                    if (secret.includes('$') || secret.includes('${'))
+                        continue;
+                    // 提取上下文（周围 100 个字符）
+                    const start = Math.max(0, match.index - 50);
+                    const end = Math.min(line.length, match.index + secret.length + 50);
+                    const context = line.substring(start, end);
+                    // 计算完整匹配内容
+                    const fullMatch = match[0];
+                    findings.push({
+                        type: patternDef.name,
+                        description: patternDef.description,
+                        path: filePath,
+                        line: i + 1,
+                        context: context.replace(/\s+/g, ' ').trim(),
+                        masked: maskSecret(secret, patternDef.name),
+                        originalSecret: secret, // 保存原始密钥
+                        fullMatch,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // JSON 解析失败，尝试作为纯文本处理
+        await scanTextContent(filePath, content, patternDef, findings);
+    }
+}
+/**
+ * 扫描纯文本内容
+ */
+async function scanTextContent(filePath, content, patternDef, findings) {
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of patternDef.patterns) {
+            const matches = line.matchAll(new RegExp(pattern, 'gi'));
+            for (const match of matches) {
+                let secret = match[1] || match[0];
+                // 验证
+                // Bearer Token、Authorization 等模式需要特殊处理，因为捕获组可能只包含 token 部分
+                const isAuthPattern = patternDef.name === 'Bearer Token' ||
+                    patternDef.name === 'JWT Token';
+                const minLength = isAuthPattern ? 4 : 10;
+                if (secret.length < minLength)
+                    continue;
+                if (secret.includes('$') || secret.includes('${'))
+                    continue;
+                // 排除常见的示例/占位符值
+                const lowerSecret = secret.toLowerCase();
+                if (lowerSecret === 'your_key_here' ||
+                    lowerSecret === 'your-api-key' ||
+                    lowerSecret === 'your_api_key' ||
+                    lowerSecret === 'xxx' ||
+                    lowerSecret === 'xxxx' ||
+                    lowerSecret === 'xxxxx' ||
+                    lowerSecret === 'placeholder' ||
+                    lowerSecret === 'example' ||
+                    lowerSecret === 'sample' ||
+                    lowerSecret === 'test' ||
+                    lowerSecret === 'demo' ||
+                    lowerSecret === 'mock' ||
+                    lowerSecret === 'fake' ||
+                    lowerSecret === 'dummy' ||
+                    lowerSecret === 'invalid' ||
+                    lowerSecret === 'none' ||
+                    lowerSecret === 'null' ||
+                    lowerSecret === 'undefined' ||
+                    lowerSecret === 'default' ||
+                    lowerSecret === 'changeme' ||
+                    lowerSecret === 'password' ||
+                    lowerSecret === 'secret' ||
+                    lowerSecret === 'secret_123' ||
+                    lowerSecret === 'secret123' ||
+                    lowerSecret === 'token' ||
+                    lowerSecret === 'key' ||
+                    // Bearer Token 相关占位符
+                    lowerSecret === 'bearer' || // 单独的 "Bearer"
+                    lowerSecret.startsWith('bearer ') || // "Bearer xxx" 整个被匹配
+                    lowerSecret === 'abc' || // Bearer abc
+                    lowerSecret === 'token' || // Bearer token
+                    lowerSecret.startsWith('token') || // token456, token123 等
+                    lowerSecret === 'tok' || // 部分 "token"
+                    lowerSecret === 'oken' || // 部分 "token"
+                    // 模糊化后的密钥（扫描结果又被扫描）
+                    secret.includes('****') || // 已模糊化的内容
+                    // 标准 JWT 示例（完整的示例，不是以该header开头的所有JWT）
+                    // 注意：只排除完整的示例JWT，不排除使用相同header的真实JWT
+                    secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c' ||
+                    secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ' ||
+                    // 仅header部分的示例
+                    secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9' ||
+                    // 文档中的截断示例
+                    secret === 'eyJhbG...' ||
+                    secret === 'eyJxxxx' ||
+                    // Anthropic 测试密钥示例
+                    lowerSecret.startsWith('sk-test-') ||
+                    lowerSecret.startsWith('sk-tes') || // 部分匹配
+                    lowerSecret.startsWith('sk-te') ||
+                    lowerSecret === '1234567890' ||
+                    lowerSecret === '12345678901234567890' ||
+                    lowerSecret === 'abcdefghijklmnopqrstuvwxyz' ||
+                    lowerSecret === 'cdefghijklmnopqrstuvwxyzab' ||
+                    lowerSecret === 'defghijklmnopqrstuvwxyzabc' ||
+                    lowerSecret === 'eyj' || // JWT 开头片段
+                    // JWT 模糊化示例
+                    lowerSecret.includes('xxxx') ||
+                    lowerSecret.includes('****') ||
+                    // 纯星号（已被模糊化的内容）
+                    /^\*+$/.test(secret) ||
+                    // API Key 示例
+                    lowerSecret.startsWith('my_api_') ||
+                    lowerSecret.startsWith('test_') ||
+                    lowerSecret.endsWith('_123') || // secret_123
+                    lowerSecret === 'secret123') {
+                    continue;
+                }
+                const start = Math.max(0, match.index - 50);
+                const end = Math.min(line.length, match.index + secret.length + 50);
+                const context = line.substring(start, end);
+                // 计算完整匹配内容
+                const fullMatch = match[0];
+                findings.push({
+                    type: patternDef.name,
+                    description: patternDef.description,
+                    path: filePath,
+                    line: i + 1,
+                    context: context.replace(/\s+/g, ' ').trim(),
+                    masked: maskSecret(secret, patternDef.name),
+                    originalSecret: secret,
+                    fullMatch,
+                });
+            }
+        }
+    }
+}
+/**
+ * 扫描项目缓存目录中的敏感信息（~/.claude/projects/<normalized-path>/）
+ * 使用与 scanCacheSecrets 相同的扫描规则
+ * @param normalizedPath 项目规范化路径（如 "-Users-lrk-project"）
+ * @returns 敏感信息发现列表
+ */
+async function scanProjectCacheSecrets(normalizedPath) {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const projectDir = path.join(claudeDir, 'projects', normalizedPath);
+    const findings = [];
+    if (!await fs.pathExists(projectDir)) {
+        return findings;
+    }
+    // 使用与 scanDirectoryForSecrets 相同的扫描逻辑
+    await scanDirectoryForSecrets(projectDir, findings);
+    return findings;
+}
+/**
+ * 获取所有项目缓存目录（包括孤立的）
+ * @returns 所有规范化路径列表
+ */
+async function getAllProjectCacheDirs() {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const dirs = [];
+    if (!await fs.pathExists(projectsDir)) {
+        return dirs;
+    }
+    const entries = await fs.readdir(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            dirs.push(entry.name);
+        }
+    }
+    return dirs.sort();
+}
+/**
+ * 扫描项目目录中的敏感信息（真实项目目录）
+ * 使用与 scanCacheSecrets 相同的扫描规则
+ */
+async function scanProjectSecrets(projectPath) {
+    const findings = [];
+    // 递归扫描目录
+    async function walkDir(dir, depth = 0) {
+        if (depth > 10)
+            return; // 限制递归深度
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            // 跳过特定目录
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' ||
+                    entry.name === '.git' ||
+                    entry.name === 'dist' ||
+                    entry.name === 'build' ||
+                    entry.name === '.next' ||
+                    entry.name === 'coverage') {
+                    continue;
+                }
+                await walkDir(fullPath, depth + 1);
+            }
+            else if (entry.isFile()) {
+                // 使用与 scanFileForSecrets 相同的扫描逻辑
+                await scanFileForProjectSecrets(fullPath, findings);
+            }
+        }
+    }
+    if (await fs.pathExists(projectPath)) {
+        await walkDir(projectPath);
+    }
+    return findings;
+}
+/**
+ * 扫描单个文件中的敏感信息（用于项目扫描）
+ * 使用与 scanFileForSecrets 相同的扫描规则和过滤逻辑
+ */
+async function scanFileForProjectSecrets(filePath, findings) {
+    // 检查是否应该扫描此文件
+    const fileName = path.basename(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    // 跳过二进制文件和日志
+    if (['.log', '.bin', '.dat', '.sqlite', '.db'].includes(ext)) {
+        return;
+    }
+    // 跳过过大的文件（> 10MB）
+    try {
+        const stat = await fs.stat(filePath);
+        if (stat.size > 10 * 1024 * 1024) {
+            return;
+        }
+    }
+    catch {
+        return;
+    }
+    // 检查每个模式
+    for (const patternDef of SECRET_PATTERNS) {
+        // 检查扩展名
+        if (patternDef.allowedExtensions.length > 0 &&
+            !patternDef.allowedExtensions.includes(ext) &&
+            !patternDef.allowedExtensions.includes('*')) {
+            continue;
+        }
+        // 检查排除模式
+        const shouldExclude = patternDef.excludePatterns.some(exc => filePath.includes(`/node_modules/`) ||
+            filePath.includes(`/${exc}/`) ||
+            fileName === exc);
+        if (shouldExclude) {
+            continue;
+        }
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // 对于 JSON 文件，尝试解析并只扫描值
+            if (ext === '.json' || ext === '.jsonc') {
+                await scanJsonContentForProject(filePath, content, patternDef, findings);
+            }
+            else {
+                await scanTextContentForProject(filePath, content, patternDef, findings);
+            }
+        }
+        catch {
+            // 跳过无法读取的文件（二进制文件等）
+        }
+    }
+}
+/**
+ * 扫描 JSON 内容（用于项目扫描）
+ */
+async function scanJsonContentForProject(filePath, content, patternDef, findings) {
+    try {
+        // 简化处理：将 JSON 转换为行以便逐行扫描
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const pattern of patternDef.patterns) {
+                const matches = line.matchAll(new RegExp(pattern, 'gi'));
+                for (const match of matches) {
+                    // 提取密钥（从匹配组或完整匹配）
+                    let secret = match[1] || match[0];
+                    // 验证是否真的是密钥（排除误报）
+                    // Bearer Token、Authorization 等模式需要特殊处理，因为捕获组可能只包含 token 部分
+                    const isAuthPattern = patternDef.name === 'Bearer Token' ||
+                        patternDef.name === 'JWT Token';
+                    const minLength = isAuthPattern ? 4 : 10;
+                    if (secret.length < minLength)
+                        continue;
+                    if (secret.includes('$') || secret.includes('${'))
+                        continue;
+                    // 排除常见的示例/占位符值（使用与 cache 扫描相同的逻辑）
+                    const lowerSecret = secret.toLowerCase();
+                    if (shouldExcludeSecret(lowerSecret, secret)) {
+                        continue;
+                    }
+                    // 生成替换值
+                    const replacement = generateReplacement(secret);
+                    // 提取上下文（周围 100 个字符）
+                    const start = Math.max(0, match.index - 50);
+                    const end = Math.min(line.length, match.index + secret.length + 50);
+                    const context = line.substring(start, end);
+                    // 计算完整匹配内容
+                    const fullMatch = match[0];
+                    findings.push({
+                        type: patternDef.name,
+                        description: patternDef.description,
+                        path: filePath,
+                        line: i + 1,
+                        context: context.replace(/\s+/g, ' ').trim(),
+                        masked: maskSecret(secret, patternDef.name),
+                        originalSecret: secret,
+                        fullMatch,
+                        replacement,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // JSON 解析失败，尝试作为纯文本处理
+        await scanTextContentForProject(filePath, content, patternDef, findings);
+    }
+}
+/**
+ * 扫描纯文本内容（用于项目扫描）
+ */
+async function scanTextContentForProject(filePath, content, patternDef, findings) {
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of patternDef.patterns) {
+            const matches = line.matchAll(new RegExp(pattern, 'gi'));
+            for (const match of matches) {
+                let secret = match[1] || match[0];
+                // 验证
+                // Bearer Token、Authorization 等模式需要特殊处理，因为捕获组可能只包含 token 部分
+                const isAuthPattern = patternDef.name === 'Bearer Token' ||
+                    patternDef.name === 'JWT Token';
+                const minLength = isAuthPattern ? 4 : 10;
+                if (secret.length < minLength)
+                    continue;
+                if (secret.includes('$') || secret.includes('${'))
+                    continue;
+                // 排除常见的示例/占位符值（使用与 cache 扫描相同的逻辑）
+                const lowerSecret = secret.toLowerCase();
+                if (shouldExcludeSecret(lowerSecret, secret)) {
+                    continue;
+                }
+                // 生成替换值
+                const replacement = generateReplacement(secret);
+                const start = Math.max(0, match.index - 50);
+                const end = Math.min(line.length, match.index + secret.length + 50);
+                const context = line.substring(start, end);
+                // 计算完整匹配内容
+                const fullMatch = match[0];
+                findings.push({
+                    type: patternDef.name,
+                    description: patternDef.description,
+                    path: filePath,
+                    line: i + 1,
+                    context: context.replace(/\s+/g, ' ').trim(),
+                    masked: maskSecret(secret, patternDef.name),
+                    originalSecret: secret,
+                    fullMatch,
+                    replacement,
+                });
+            }
+        }
+    }
+}
+/**
+ * 判断是否应排除某个密钥（避免误报）
+ */
+function shouldExcludeSecret(lowerSecret, secret) {
+    return lowerSecret === 'your_key_here' ||
+        lowerSecret === 'your-api-key' ||
+        lowerSecret === 'your_api_key' ||
+        lowerSecret === 'xxx' ||
+        lowerSecret === 'xxxx' ||
+        lowerSecret === 'xxxxx' ||
+        lowerSecret === 'placeholder' ||
+        lowerSecret === 'example' ||
+        lowerSecret === 'sample' ||
+        lowerSecret === 'test' ||
+        lowerSecret === 'demo' ||
+        lowerSecret === 'mock' ||
+        lowerSecret === 'fake' ||
+        lowerSecret === 'dummy' ||
+        lowerSecret === 'invalid' ||
+        lowerSecret === 'none' ||
+        lowerSecret === 'null' ||
+        lowerSecret === 'undefined' ||
+        lowerSecret === 'default' ||
+        lowerSecret === 'changeme' ||
+        lowerSecret === 'password' ||
+        lowerSecret === 'secret' ||
+        lowerSecret === 'secret_123' ||
+        lowerSecret === 'secret123' ||
+        lowerSecret === 'token' ||
+        lowerSecret === 'key' ||
+        lowerSecret === 'bearer' ||
+        lowerSecret.startsWith('bearer ') ||
+        lowerSecret === 'abc' ||
+        lowerSecret === 'token' ||
+        lowerSecret.startsWith('token') ||
+        lowerSecret === 'tok' ||
+        lowerSecret === 'oken' ||
+        secret.includes('****') ||
+        secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c' ||
+        secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ' ||
+        secret === 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9' ||
+        secret === 'eyJhbG...' ||
+        secret === 'eyJxxxx' ||
+        lowerSecret.startsWith('sk-test-') ||
+        lowerSecret.startsWith('sk-tes') ||
+        lowerSecret.startsWith('sk-te') ||
+        lowerSecret === '1234567890' ||
+        lowerSecret === '12345678901234567890' ||
+        lowerSecret === 'abcdefghijklmnopqrstuvwxyz' ||
+        lowerSecret === 'cdefghijklmnopqrstuvwxyzab' ||
+        lowerSecret === 'defghijklmnopqrstuvwxyzabc' ||
+        lowerSecret === 'eyj' ||
+        lowerSecret.includes('xxxx') ||
+        lowerSecret.includes('****') ||
+        /^\*+$/.test(secret) ||
+        lowerSecret.startsWith('my_api_') ||
+        lowerSecret.startsWith('test_') ||
+        lowerSecret.endsWith('_123') ||
+        lowerSecret === 'secret123';
+}
+/**
+ * 生成替换值（保留前4位，其余用 **** 替代）
+ */
+function generateReplacement(secret) {
+    if (secret.length <= 8) {
+        return secret.substring(0, Math.min(4, secret.length)) + '****';
+    }
+    return secret.substring(0, 4) + '****';
+}
+/**
+ * 执行敏感信息掩码替换
+ * 只在包含敏感信息的文件旁边创建备份（aaa.jsonl.backup.时间戳）
+ */
+async function maskProjectSecrets(projectPath, findings) {
+    const result = {
+        projectPath,
+        backups: [],
+        findings,
+        filesModified: [],
+        totalReplacements: 0,
+    };
+    // 按文件分组
+    const byFile = new Map();
+    for (const finding of findings) {
+        const list = byFile.get(finding.path) || [];
+        list.push(finding);
+        byFile.set(finding.path, list);
+    }
+    // 处理每个文件
+    for (const [filePath, fileFindings] of byFile) {
+        try {
+            // 1. 先创建文件备份（在相同目录下）
+            const timestamp = Date.now();
+            const backupPath = `${filePath}.backup.${timestamp}`;
+            await fs.copy(filePath, backupPath);
+            result.backups.push({
+                originalPath: filePath,
+                backupPath,
+            });
+            // 2. 读取文件内容并执行掩码替换
+            let content = await fs.readFile(filePath, 'utf-8');
+            let modified = false;
+            // 按行号排序（从后往前替换，避免位置变化）
+            const sortedFindings = [...fileFindings].sort((a, b) => (b.line || 0) - (a.line || 0));
+            // 按行处理
+            const lines = content.split('\n');
+            for (const finding of sortedFindings) {
+                if (finding.line && finding.line <= lines.length) {
+                    const lineIndex = finding.line - 1;
+                    const originalLine = lines[lineIndex];
+                    let newLine = originalLine;
+                    // 查找并替换所有敏感信息
+                    for (const patternDef of SECRET_PATTERNS) {
+                        if (patternDef.name === finding.type) {
+                            for (const pattern of patternDef.patterns) {
+                                const matches = originalLine.matchAll(new RegExp(pattern, 'gi'));
+                                for (const match of matches) {
+                                    const matchedSecret = match[1] || match[0];
+                                    if (matchedSecret.length >= 4) {
+                                        // 检查这个匹配是否应该被排除
+                                        const lowerSecret = matchedSecret.toLowerCase();
+                                        if (!shouldExcludeSecret(lowerSecret, matchedSecret)) {
+                                            // 执行替换
+                                            const replacement = generateReplacement(matchedSecret);
+                                            newLine = newLine.replace(matchedSecret, replacement);
+                                            modified = true;
+                                            result.totalReplacements++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    lines[lineIndex] = newLine;
+                }
+            }
+            if (modified) {
+                await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+                result.filesModified.push(filePath);
+            }
+        }
+        catch (error) {
+            // 跳过无法处理的文件
+            console.error(`处理文件失败: ${filePath}`, error);
+        }
+    }
+    return result;
+}
+/**
+ * 转义正则表达式特殊字符
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}