opclawtm 1.4.0

package/dist/cli/tui/menus/reset.menu.js

@@ -0,0 +1,767 @@
+"use strict";
+/**
+ * System Reset Menu
+ */
+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.showResetSystemDialog = showResetSystemDialog;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("../index");
+const utils_1 = require("../../../core/utils");
+const db_1 = require("../../../db");
+const configChangeRepo = __importStar(require("../../../db/repositories/config-change.repo"));
+const credentials_cleanup_1 = require("../../../core/utils/credentials-cleanup");
+/**
+ * 获取备份目录（位于当前 OpenClaw 根目录下）
+ */
+function getBackupDir() {
+    return path.join((0, utils_1.getOpenClawRoot)(), 'backup');
+}
+/**
+ * 显示系统重置菜单
+ *
+ * @returns 'reset' 表示已重置，需要重新初始化；'back' 表示返回
+ */
+async function showResetSystemDialog() {
+    while (true) {
+        const choices = [
+            new inquirer_1.default.Separator(chalk_1.default.cyan.bold('🔄 系统重置与恢复')),
+            new inquirer_1.default.Separator(),
+            { name: '🔄 重置系统（恢复到初始状态）', value: 'reset' },
+            { name: '📂 从备份恢复', value: 'restore' },
+            { name: '📋 查看备份列表', value: 'list' },
+            new inquirer_1.default.Separator(),
+            { name: '🔙 返回主菜单', value: 'back' }
+        ];
+        const { action } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: '请选择：',
+                choices,
+                loop: true,
+                pageSize: 15
+            }
+        ]);
+        switch (action) {
+            case 'reset':
+                const resetted = await confirmAndReset();
+                if (resetted) {
+                    return 'reset';
+                }
+                break;
+            case 'restore':
+                await selectBackupAndRestore();
+                break;
+            case 'list':
+                await listBackups();
+                break;
+            case 'back':
+                return 'back';
+        }
+    }
+}
+/**
+ * 确认并重置系统
+ *
+ * @returns true 表示重置成功，false 表示取消或失败
+ */
+async function confirmAndReset() {
+    console.log(chalk_1.default.yellow('\n⚠️ 警告：此操作将删除以下内容：'));
+    console.log(chalk_1.default.dim('  • 所有 Agent 数据（包括总助理）'));
+    console.log(chalk_1.default.dim('  • 所有事业部数据'));
+    console.log(chalk_1.default.dim('  • 所有任务和节点数据'));
+    console.log(chalk_1.default.dim('  • Agent 工作空间目录'));
+    console.log(chalk_1.default.dim('  • 配置变更记录'));
+    console.log(chalk_1.default.dim('  • 飞书配对文件（credentials 目录）'));
+    console.log(chalk_1.default.dim('\n  ✅ 保留以下内容：'));
+    console.log(chalk_1.default.dim('  • OpenClaw 基础配置（模型 API Key 等）'));
+    console.log(chalk_1.default.dim('  • 渠道配置（飞书账号配置）\n'));
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: '确认要重置系统吗？',
+            default: false
+        }
+    ]);
+    if (!confirm) {
+        console.log(chalk_1.default.dim('\n已取消\n'));
+        return false;
+    }
+    // 二次确认
+    const { confirmText } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'confirmText',
+            message: chalk_1.default.red('请输入 "RESET" 确认重置：')
+        }
+    ]);
+    if (confirmText !== 'RESET') {
+        console.log(chalk_1.default.dim('\n已取消重置\n'));
+        return false;
+    }
+    // 检查数据库是否存在
+    const openClawRoot = (0, utils_1.getOpenClawRoot)();
+    const teamDir = path.join(openClawRoot, 'team');
+    const dbPath = path.join(teamDir, 'team.db');
+    if (!fs.existsSync(dbPath)) {
+        console.log(chalk_1.default.dim('\n系统未初始化，无需重置\n'));
+        return false;
+    }
+    // 执行重置
+    console.log(chalk_1.default.dim('\n正在重置系统...'));
+    // 1. 最先创建备份（在任何修改操作之前）
+    console.log(chalk_1.default.dim('  创建备份...'));
+    let backupPath;
+    try {
+        backupPath = await createBackup();
+        console.log(chalk_1.default.dim(`  ✓ 备份已创建: ${backupPath}`));
+    }
+    catch (e) {
+        console.log(chalk_1.default.red(`  ✗ 备份失败: ${e instanceof Error ? e.message : String(e)}`));
+        return false;
+    }
+    // 2. 执行重置操作
+    const result = await resetSystem();
+    if (result.success) {
+        console.log(chalk_1.default.green('\n✓ 系统已重置！'));
+        console.log(chalk_1.default.dim(`备份位置: ${backupPath}\n`));
+        return true;
+    }
+    else {
+        console.log(chalk_1.default.red(`\n✗ 重置失败: ${result.message}\n`));
+        console.log(chalk_1.default.dim(`备份位置: ${backupPath}\n`));
+        return false;
+    }
+}
+/**
+ * 重置系统
+ *
+ * 根据变更记录精确撤销：
+ * 1. 获取变更记录
+ * 2. 根据变更记录撤销配置
+ * 3. 清理飞书配置
+ * 4. 删除工作空间目录和 Agent 目录
+ * 5. 最后清空数据库表
+ *
+ * 注意：备份已在 confirmAndReset() 中执行
+ */
+async function resetSystem() {
+    try {
+        const db = (0, db_1.getDatabase)();
+        const openClawRoot = (0, utils_1.getOpenClawRoot)();
+        // 检查数据库是否存在
+        const teamDir = path.join(openClawRoot, 'team');
+        const dbPath = path.join(teamDir, 'team.db');
+        const hasDatabase = fs.existsSync(dbPath);
+        if (!hasDatabase) {
+            return { success: false, message: '系统未初始化，无需重置' };
+        }
+        // 1. 获取所有变更记录（备份已在 confirmAndReset 中执行）
+        const allChanges = configChangeRepo.getAllChanges();
+        console.log(chalk_1.default.dim(`  变更记录总数: ${allChanges.length}`));
+        // 3. 根据变更记录撤销配置（精确撤销）
+        if (allChanges.length > 0) {
+            const stats = {
+                agent_create: allChanges.filter(c => c.change_type === 'agent_create').length,
+                agent_delete: allChanges.filter(c => c.change_type === 'agent_delete').length,
+                department_create: allChanges.filter(c => c.change_type === 'department_create').length,
+                binding_create: allChanges.filter(c => c.change_type === 'binding_create').length,
+                directory_create: allChanges.filter(c => c.change_type === 'directory_create').length
+            };
+            console.log(chalk_1.default.dim(`  Agent创建: ${stats.agent_create}, 删除: ${stats.agent_delete}`));
+            console.log(chalk_1.default.dim(`  事业部创建: ${stats.department_create}`));
+            console.log(chalk_1.default.dim(`  绑定创建: ${stats.binding_create}`));
+            console.log(chalk_1.default.dim(`  目录创建: ${stats.directory_create}`));
+            // 3.1 删除变更记录中的目录
+            console.log(chalk_1.default.dim('  根据变更记录清理目录...'));
+            const dirCreates = allChanges.filter(c => c.change_type === 'directory_create' && c.action === 'add');
+            const deletedDirs = [];
+            for (const change of dirCreates) {
+                if (change.target_path && fs.existsSync(change.target_path)) {
+                    try {
+                        fs.rmSync(change.target_path, { recursive: true, force: true });
+                        deletedDirs.push(change.target_path);
+                        console.log(chalk_1.default.dim(`    ✓ 已删除: ${change.target_path}`));
+                    }
+                    catch (e) {
+                        console.log(chalk_1.default.yellow(`    ⚠ 删除失败: ${change.target_path}`));
+                    }
+                }
+            }
+            // 3.2 删除 Agent 创建记录中的 workspace 目录
+            console.log(chalk_1.default.dim('  清理 Agent 工作空间...'));
+            const agentCreates = allChanges.filter(c => c.change_type === 'agent_create' && c.related_id);
+            for (const change of agentCreates) {
+                const agentId = change.related_id;
+                if (agentId && agentId !== 'main') {
+                    // 删除 workspace-{agentId}
+                    const workspaceDir = path.join(openClawRoot, `workspace-${agentId}`);
+                    if (fs.existsSync(workspaceDir)) {
+                        try {
+                            fs.rmSync(workspaceDir, { recursive: true, force: true });
+                            deletedDirs.push(workspaceDir);
+                            console.log(chalk_1.default.dim(`    ✓ 已删除: workspace-${agentId}`));
+                        }
+                        catch (e) {
+                            console.log(chalk_1.default.yellow(`    ⚠ 删除失败: workspace-${agentId}`));
+                        }
+                    }
+                    // 删除 agents/{agentId}
+                    const agentDir = path.join(openClawRoot, 'agents', agentId);
+                    if (fs.existsSync(agentDir)) {
+                        try {
+                            fs.rmSync(agentDir, { recursive: true, force: true });
+                            deletedDirs.push(agentDir);
+                            console.log(chalk_1.default.dim(`    ✓ 已删除: agents/${agentId}`));
+                        }
+                        catch (e) {
+                            console.log(chalk_1.default.yellow(`    ⚠ 删除失败: agents/${agentId}`));
+                        }
+                    }
+                }
+            }
+            // 3.3 清理空目录
+            if (deletedDirs.length > 0) {
+                console.log(chalk_1.default.dim('  清理空目录...'));
+                const cleanedCount = cleanEmptyDirectories(openClawRoot, deletedDirs);
+                if (cleanedCount > 0) {
+                    console.log(chalk_1.default.dim(`    ✓ 已清理 ${cleanedCount} 个空目录`));
+                }
+            }
+            // 3.4 撤销 openclaw.json 配置变更
+            console.log(chalk_1.default.dim('  撤销配置变更...'));
+            // 获取所有未清理的变更并撤销
+            const uncleanedChanges = allChanges.filter(c => !c.cleaned);
+            for (const change of uncleanedChanges.reverse()) { // 逆序撤销
+                try {
+                    revertConfigChange(change);
+                }
+                catch (e) {
+                    console.log(chalk_1.default.yellow(`    ⚠ 撤销失败: ${change.change_type} - ${change.target_path}`));
+                }
+            }
+            console.log(chalk_1.default.dim(`    ✓ 已撤销 ${uncleanedChanges.length} 条配置变更`));
+        }
+        // 4. 清理飞书配置
+        console.log(chalk_1.default.dim('  清理飞书配置...'));
+        const feishuConfigCleaned = cleanupFeishuGroupConfig();
+        if (feishuConfigCleaned) {
+            console.log(chalk_1.default.dim('    ✓ 已清理飞书群配置'));
+        }
+        // 清理飞书配对文件
+        const cleanupResult = (0, credentials_cleanup_1.cleanupAllFeishuCredentials)();
+        if (cleanupResult.deleted.length > 0) {
+            console.log(chalk_1.default.dim(`    ✓ 已清理 ${cleanupResult.deleted.length} 个飞书配对文件`));
+        }
+        // 5. 关闭数据库连接（在清空前关闭）
+        (0, db_1.closeDatabase)();
+        console.log(chalk_1.default.dim('  ✓ 数据库连接已关闭'));
+        // 6. 最后清空数据库（删除数据库文件并重新创建空数据库）
+        console.log(chalk_1.default.dim('  清空数据库...'));
+        try {
+            // 删除整个数据库文件
+            if (fs.existsSync(dbPath)) {
+                fs.unlinkSync(dbPath);
+                console.log(chalk_1.default.dim('    ✓ 数据库文件已删除'));
+            }
+            // 删除 team 目录（如果为空）
+            const teamDir = path.dirname(dbPath);
+            if (fs.existsSync(teamDir)) {
+                const remaining = fs.readdirSync(teamDir);
+                if (remaining.length === 0) {
+                    fs.rmdirSync(teamDir);
+                    console.log(chalk_1.default.dim('    ✓ team 目录已清理'));
+                }
+            }
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`    ⚠ 清空数据库失败: ${e instanceof Error ? e.message : String(e)}`));
+        }
+        console.log(chalk_1.default.green('\n✓ 系统重置完成！'));
+        console.log(chalk_1.default.yellow('⚠️  请手动重启 Gateway 以断开飞书长连接：'));
+        console.log(chalk_1.default.cyan('    openclaw gateway restart\n'));
+        // 重置完成后退出进程
+        process.exit(0);
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * 撤销单条配置变更
+ */
+function revertConfigChange(change) {
+    const configPath = (0, utils_1.getOpenClawJsonPath)();
+    if (!fs.existsSync(configPath))
+        return;
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    switch (change.change_type) {
+        case 'agent_create':
+            // 从 agents.list 中移除
+            if (config.agents?.list && change.related_id) {
+                config.agents.list = config.agents.list.filter((a) => a.id !== change.related_id);
+            }
+            break;
+        case 'agent_delete':
+            // 恢复到 agents.list
+            if (change.old_value && config.agents?.list) {
+                const oldAgent = JSON.parse(change.old_value);
+                config.agents.list.push(oldAgent);
+            }
+            break;
+        case 'agent_allow_list_update':
+            // 恢复 allowAgents（旧格式，已弃用）
+            if (change.old_value && change.related_id && config.agents?.list) {
+                const agentConfig = config.agents.list.find((a) => a.id === change.related_id);
+                if (agentConfig) {
+                    if (!agentConfig.subagents) {
+                        agentConfig.subagents = {};
+                    }
+                    agentConfig.subagents.allowAgents = JSON.parse(change.old_value);
+                }
+            }
+            break;
+        case 'agent_to_agent_update':
+            // 恢复 tools.agentToAgent.allow
+            if (change.old_value) {
+                if (!config.tools) {
+                    config.tools = {};
+                }
+                if (!config.tools.agentToAgent) {
+                    config.tools.agentToAgent = { enabled: true, allow: [] };
+                }
+                config.tools.agentToAgent.enabled = true;
+                config.tools.agentToAgent.allow = JSON.parse(change.old_value);
+                console.log(chalk_1.default.dim(`    ✓ 已恢复 agentToAgent.allow`));
+            }
+            break;
+        case 'binding_create':
+            // 从 bindings 中移除
+            if (config.bindings) {
+                config.bindings = config.bindings.filter((b, i) => change.target_path !== `bindings[${i}]`);
+            }
+            break;
+        case 'binding_delete':
+            // 恢复到 bindings
+            if (change.old_value) {
+                if (!config.bindings)
+                    config.bindings = [];
+                config.bindings.push(JSON.parse(change.old_value));
+            }
+            break;
+        case 'department_create':
+        case 'department_delete':
+            // 部门在数据库中处理，配置文件无影响
+            break;
+        case 'feishu_group_bind':
+            // 清理飞书群绑定
+            if (config.channels?.feishu?.groups && change.related_id) {
+                delete config.channels.feishu.groups[change.related_id];
+            }
+            break;
+        default:
+            // 其他变更：尝试恢复 old_value
+            if (change.old_value && change.target_path) {
+                applyValueToPath(config, change.target_path, JSON.parse(change.old_value));
+            }
+    }
+    // 写回配置文件
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    // 标记为已清理
+    configChangeRepo.markAsCleaned(change.id);
+}
+/**
+ * 根据路径设置配置值
+ */
+function applyValueToPath(obj, path, value) {
+    const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!current[part]) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+/**
+ * 创建备份
+ */
+async function createBackup() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupBase = getBackupDir();
+    const backupDir = path.join(backupBase, `team-manager-reset-${timestamp}`);
+    // 确保备份目录存在
+    if (!fs.existsSync(backupBase)) {
+        fs.mkdirSync(backupBase, { recursive: true });
+    }
+    fs.mkdirSync(backupDir, { recursive: true });
+    // 备份数据库（清理加密内容）
+    const dbPath = (0, utils_1.getDatabasePath)();
+    if (fs.existsSync(dbPath)) {
+        const cleanedDbPath = path.join(backupDir, 'team.db');
+        await createCleanedDatabaseBackup(dbPath, cleanedDbPath);
+    }
+    // 备份配置
+    const configPath = (0, utils_1.getOpenClawJsonPath)();
+    if (fs.existsSync(configPath)) {
+        fs.copyFileSync(configPath, path.join(backupDir, 'openclaw.json'));
+    }
+    // 写入备份信息
+    const backupInfo = {
+        timestamp: new Date().toISOString(),
+        type: 'reset',
+        description: '系统重置前自动备份（已清理加密预设数据）'
+    };
+    fs.writeFileSync(path.join(backupDir, 'backup-info.json'), JSON.stringify(backupInfo, null, 2));
+    return backupDir;
+}
+/**
+ * 创建清理后的数据库备份
+ *
+ * 清理内容：
+ * 1. 删除所有预设数据（is_preset=1）
+ * 2. 预设数据包含加密内容，备份无意义
+ */
+async function createCleanedDatabaseBackup(sourcePath, targetPath) {
+    const Database = require('better-sqlite3');
+    // 打开源数据库
+    const sourceDb = new Database(sourcePath, { readonly: true });
+    // 创建目标数据库
+    const targetDb = new Database(targetPath);
+    try {
+        // 禁用外键约束（避免复制顺序问题）
+        targetDb.exec('PRAGMA foreign_keys = OFF');
+        // 获取源数据库的所有表结构
+        const tables = sourceDb.prepare("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+        // 在目标数据库创建表结构
+        for (const table of tables) {
+            targetDb.exec(table.sql);
+        }
+        // 复制数据（排除预设数据）
+        for (const table of tables) {
+            const tableName = table.name;
+            // 检查表是否有 is_preset 字段
+            const columns = sourceDb.pragma(`table_info(${tableName})`);
+            const hasIsPreset = columns.some((col) => col.name === 'is_preset');
+            if (hasIsPreset) {
+                // 只复制非预设数据
+                const rows = sourceDb.prepare(`SELECT * FROM ${tableName} WHERE is_preset = 0`).all();
+                if (rows.length > 0) {
+                    const columnNames = columns.map((c) => c.name);
+                    const placeholders = columnNames.map(() => '?').join(', ');
+                    const insertStmt = targetDb.prepare(`INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${placeholders})`);
+                    for (const row of rows) {
+                        insertStmt.run(...columnNames.map((c) => row[c]));
+                    }
+                }
+            }
+            else {
+                // 没有 is_preset 字段，复制所有数据
+                const rows = sourceDb.prepare(`SELECT * FROM ${tableName}`).all();
+                if (rows.length > 0) {
+                    const columnNames = columns.map((c) => c.name);
+                    const placeholders = columnNames.map(() => '?').join(', ');
+                    const insertStmt = targetDb.prepare(`INSERT INTO ${tableName} (${columnNames.join(', ')}) VALUES (${placeholders})`);
+                    for (const row of rows) {
+                        insertStmt.run(...columnNames.map((c) => row[c]));
+                    }
+                }
+            }
+        }
+        // 重新启用外键约束
+        targetDb.exec('PRAGMA foreign_keys = ON');
+        console.log(chalk_1.default.dim('    ✓ 已清理备份中的加密预设数据'));
+    }
+    finally {
+        sourceDb.close();
+        targetDb.close();
+    }
+}
+/**
+ * 从备份恢复
+ */
+async function selectBackupAndRestore() {
+    const backups = listBackupDirs();
+    if (backups.length === 0) {
+        console.log(chalk_1.default.yellow('\n暂无可用备份\n'));
+        return;
+    }
+    const choices = [
+        ...backups.map(b => ({
+            name: `${b.name} (${b.time})`,
+            value: b.path
+        })),
+        new inquirer_1.default.Separator(),
+        { name: '🔙 取消', value: 'cancel' }
+    ];
+    const { backupPath } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'backupPath',
+            message: '选择要恢复的备份：',
+            choices,
+            loop: true
+        }
+    ]);
+    if (backupPath === 'cancel') {
+        return;
+    }
+    // 确认恢复
+    const { confirm } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk_1.default.yellow('确认要从此备份恢复吗？当前数据将被覆盖。'),
+            default: false
+        }
+    ]);
+    if (!confirm) {
+        console.log(chalk_1.default.dim('\n已取消\n'));
+        return;
+    }
+    // 执行恢复
+    console.log(chalk_1.default.dim('\n正在恢复...'));
+    const result = await restoreFromBackup(backupPath);
+    if (result.success) {
+        console.log(chalk_1.default.green('\n✓ 恢复成功！\n'));
+    }
+    else {
+        console.log(chalk_1.default.red(`\n✗ 恢复失败: ${result.message}\n`));
+    }
+}
+/**
+ * 从备份恢复
+ */
+async function restoreFromBackup(backupPath) {
+    try {
+        // 恢复数据库
+        const backupDb = path.join(backupPath, 'team.db');
+        if (fs.existsSync(backupDb)) {
+            const dbPath = (0, utils_1.getDatabasePath)();
+            // 确保目录存在
+            const dbDir = path.dirname(dbPath);
+            if (!fs.existsSync(dbDir)) {
+                fs.mkdirSync(dbDir, { recursive: true });
+            }
+            fs.copyFileSync(backupDb, dbPath);
+            console.log(chalk_1.default.dim('  ✓ 数据库已恢复'));
+        }
+        // 恢复配置
+        const backupConfig = path.join(backupPath, 'openclaw.json');
+        if (fs.existsSync(backupConfig)) {
+            const configPath = (0, utils_1.getOpenClawJsonPath)();
+            fs.copyFileSync(backupConfig, configPath);
+            console.log(chalk_1.default.dim('  ✓ 配置已恢复'));
+        }
+        return { success: true, message: '恢复成功' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * 列出备份目录
+ */
+function listBackupDirs() {
+    const backupBase = getBackupDir();
+    if (!fs.existsSync(backupBase)) {
+        return [];
+    }
+    const entries = fs.readdirSync(backupBase, { withFileTypes: true });
+    const backups = [];
+    for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith('team-manager-')) {
+            const backupPath = path.join(backupBase, entry.name);
+            const infoPath = path.join(backupPath, 'backup-info.json');
+            let time = '';
+            if (fs.existsSync(infoPath)) {
+                try {
+                    const info = JSON.parse(fs.readFileSync(infoPath, 'utf-8'));
+                    time = new Date(info.timestamp).toLocaleString('zh-CN');
+                }
+                catch {
+                    time = entry.name.replace('team-manager-reset-', '');
+                }
+            }
+            else {
+                time = entry.name.replace('team-manager-reset-', '');
+            }
+            backups.push({
+                name: entry.name,
+                path: backupPath,
+                time
+            });
+        }
+    }
+    // 按时间倒序排列
+    return backups.sort((a, b) => b.name.localeCompare(a.name));
+}
+/**
+ * 列出所有备份
+ */
+async function listBackups() {
+    const backups = listBackupDirs();
+    if (backups.length === 0) {
+        console.log(chalk_1.default.yellow('\n暂无备份\n'));
+        return;
+    }
+    console.log(chalk_1.default.bold('\n📋 备份列表\n'));
+    console.log(chalk_1.default.dim('名称'.padEnd(45)) + chalk_1.default.dim('时间'));
+    index_1.tuiUtils.printDivider();
+    for (const backup of backups) {
+        console.log(backup.name.padEnd(45) + backup.time);
+    }
+    console.log('');
+}
+/**
+ * 清理 openclaw.json 中的飞书群相关配置
+ *
+ * 清理内容：
+ * - channels.feishu.accounts - 清空所有 agent 的飞书账户
+ * - channels.feishu.groupAllowFrom - 清空群组白名单
+ * - channels.feishu.groups - 清空群组配置
+ * - bindings - 移除所有飞书相关的绑定
+ *
+ * @returns 是否有配置被清理
+ */
+function cleanupFeishuGroupConfig() {
+    const configPath = (0, utils_1.getOpenClawJsonPath)();
+    if (!fs.existsSync(configPath))
+        return false;
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        let configChanged = false;
+        // 清理 channels.feishu.accounts
+        const channels = config.channels;
+        if (channels?.feishu) {
+            const feishuConfig = channels.feishu;
+            // 清空 accounts
+            if (feishuConfig.accounts && Object.keys(feishuConfig.accounts).length > 0) {
+                feishuConfig.accounts = {};
+                configChanged = true;
+                console.log(chalk_1.default.dim('    - 已清空飞书账户配置'));
+            }
+            // 清空 groupAllowFrom
+            if (feishuConfig.groupAllowFrom && Array.isArray(feishuConfig.groupAllowFrom) && feishuConfig.groupAllowFrom.length > 0) {
+                feishuConfig.groupAllowFrom = [];
+                configChanged = true;
+                console.log(chalk_1.default.dim('    - 已清空群组白名单'));
+            }
+            // 清空 groups
+            if (feishuConfig.groups && Object.keys(feishuConfig.groups).length > 0) {
+                feishuConfig.groups = {};
+                configChanged = true;
+                console.log(chalk_1.default.dim('    - 已清空群组配置'));
+            }
+        }
+        // 清理飞书相关的 bindings
+        if (config.bindings && Array.isArray(config.bindings) && config.bindings.length > 0) {
+            const originalLength = config.bindings.length;
+            config.bindings = config.bindings.filter((b) => b.match?.channel !== 'feishu');
+            if (config.bindings.length < originalLength) {
+                configChanged = true;
+                console.log(chalk_1.default.dim(`    - 已移除 ${originalLength - config.bindings.length} 个飞书绑定`));
+            }
+        }
+        if (configChanged) {
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        return configChanged;
+    }
+    catch (e) {
+        console.warn('清理飞书群配置失败:', e);
+        return false;
+    }
+}
+/**
+ * 清理空目录
+ *
+ * @param rootDir 根目录
+ * @param deletedDirs 已删除的目录列表（用于检查父目录）
+ * @returns 清理的空目录数量
+ */
+function cleanEmptyDirectories(rootDir, deletedDirs) {
+    let count = 0;
+    const checkedDirs = new Set();
+    // 收集所有需要检查的父目录
+    const dirsToCheck = new Set();
+    for (const dir of deletedDirs) {
+        let current = path.dirname(dir);
+        while (current !== rootDir && current.length > rootDir.length) {
+            dirsToCheck.add(current);
+            current = path.dirname(current);
+        }
+    }
+    // 按深度从深到浅排序（先删除深层目录）
+    const sortedDirs = Array.from(dirsToCheck).sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+        if (checkedDirs.has(dir))
+            continue;
+        checkedDirs.add(dir);
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const entries = fs.readdirSync(dir);
+            if (entries.length === 0) {
+                fs.rmdirSync(dir);
+                count++;
+                console.log(chalk_1.default.dim(`    ✓ 已清理空目录: ${path.relative(rootDir, dir)}`));
+            }
+        }
+        catch (e) {
+            // 忽略错误（可能被其他进程占用）
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=reset.menu.js.map