openclaw-rollback 1.0.0

package/dist/core.js

@@ -0,0 +1,842 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { recordChange } from './config-graph.js';
+const IS_WINDOWS = process.platform === 'win32';
+const IS_LINUX = process.platform === 'linux';
+const IS_MAC = process.platform === 'darwin';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PLUGIN_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.openclaw', 'extensions', 'openclaw-rollback');
+const CONFIG_FILE = path.join(PLUGIN_DIR, 'config.json');
+const BACKUPS_DIR = path.join(PLUGIN_DIR, 'backups');
+const REGULAR_BACKUPS_DIR = path.join(BACKUPS_DIR, 'regular');
+const TRAVEL_BACKUPS_DIR = path.join(BACKUPS_DIR, 'travel-mode');
+const OPENCLAW_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.openclaw');
+// 默认配置 - 自动扫描并备份所有 .md 和 .json 文件
+const DEFAULT_BACKUP_ITEMS = []; // 空数组表示使用自动扫描
+const BACKUP_EXCLUDE_PATTERNS = [
+    'node_modules',
+    'extensions/*/node_modules',
+    'backups',
+    'logs',
+    'cache',
+    '*.log',
+    '*.tmp',
+    '*.temp',
+    'agents/main/sessions/*.trajectory-path.json',
+    'skills/*/output',
+    'npm/package-lock.json'
+];
+// 动态读取版本号
+let _packageVersion = '';
+function getPackageVersion() {
+    if (_packageVersion)
+        return _packageVersion;
+    try {
+        // Windows 兼容：使用 path.join 直接构造路径
+        const pkgPath = path.join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        _packageVersion = pkg.version || 'unknown';
+    }
+    catch {
+        _packageVersion = 'unknown';
+    }
+    return _packageVersion;
+}
+// 需要备份的文件扩展名
+const BACKUP_EXTENSIONS = ['.md', '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.config'];
+// 关键配置文件 - 需要验证有效性的文件
+const CRITICAL_CONFIG_FILES = ['openclaw.json', 'gateway.json'];
+// 验证 JSON 配置文件是否有效且包含必要字段
+function validateConfigFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const config = JSON.parse(content);
+        // 对于 openclaw.json，检查是否包含必要的顶级字段
+        if (filePath.endsWith('openclaw.json')) {
+            // 如果只有 version 和 gateway.port，说明是测试用的简化配置
+            const keys = Object.keys(config);
+            if (keys.length <= 2 && config.version && config.gateway && Object.keys(config.gateway).length <= 1) {
+                console.log(`  ⚠️ 跳过无效配置: ${path.relative(OPENCLAW_DIR, filePath)} (简化测试配置)`);
+                return false;
+            }
+            // 检查是否包含必要的 agents 或 gateway.mode 字段
+            if (!config.agents && !config.gateway?.mode) {
+                console.log(`  ⚠️ 跳过无效配置: ${path.relative(OPENCLAW_DIR, filePath)} (缺少必要字段)`);
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        console.log(`  ⚠️ 跳过损坏的 JSON: ${path.relative(OPENCLAW_DIR, filePath)}`);
+        return false;
+    }
+}
+// 扫描需要备份的文件
+function scanBackupItems(dir, baseDir) {
+    const items = [];
+    function scan(currentDir) {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(baseDir, fullPath);
+            // 检查是否排除
+            if (shouldExclude(entry.name, relativePath, BACKUP_EXCLUDE_PATTERNS)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                scan(fullPath);
+            }
+            else if (entry.isFile()) {
+                // 备份配置文件类型
+                const ext = path.extname(entry.name).toLowerCase();
+                if (BACKUP_EXTENSIONS.includes(ext)) {
+                    // 验证关键配置文件的有效性
+                    if (CRITICAL_CONFIG_FILES.includes(entry.name)) {
+                        if (!validateConfigFile(fullPath)) {
+                            continue; // 跳过无效的关键配置文件
+                        }
+                    }
+                    items.push(relativePath);
+                }
+            }
+        }
+    }
+    scan(dir);
+    return items;
+}
+// 复制目录，支持排除模式
+function copyDirWithExclude(src, dest, excludePatterns) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        const relativePath = path.relative(OPENCLAW_DIR, srcPath);
+        // 检查是否匹配排除模式
+        if (shouldExclude(entry.name, relativePath, excludePatterns)) {
+            console.log(`  ⏭ 跳过: ${relativePath}`);
+            continue;
+        }
+        if (entry.isDirectory()) {
+            copyDirWithExclude(srcPath, destPath, excludePatterns);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+// 检查是否应该排除
+function shouldExclude(fileName, relativePath, patterns) {
+    // Windows 兼容：将路径分隔符统一为 /
+    const normalizedPath = relativePath.replace(/\\/g, '/');
+    for (const pattern of patterns) {
+        // 简单匹配：检查文件名或路径是否包含模式
+        if (pattern.includes('*')) {
+            // 通配符匹配
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+            if (regex.test(fileName) || regex.test(normalizedPath)) {
+                return true;
+            }
+        }
+        else {
+            // 精确匹配或包含
+            if (fileName === pattern || normalizedPath.includes(pattern)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function getConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        const defaultConfig = {
+            autoBackup: true,
+            maxBackups: 10,
+            webUIPort: 3739,
+            backupItems: DEFAULT_BACKUP_ITEMS,
+            backupInterval: 30, // 默认30分钟
+            travelMode: false,
+            travelModeInterval: 120, // 默认2小时
+            travelModeMaxBackups: 20,
+            consecutiveFailures: 0
+        };
+        saveConfig(defaultConfig);
+        return defaultConfig;
+    }
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    // 如果使用的是旧配置（包含旧的特定文件列表），切换到自动扫描
+    const oldItems = ['config.json', 'gateway.json', 'agents.json', 'skills.json', 'memory', 'workspace'];
+    const hasOldItems = config.backupItems?.some((item) => oldItems.includes(item) || item.includes('config.json') || item.includes('gateway.json'));
+    if (hasOldItems) {
+        console.log('📝 检测到旧配置，切换到自动扫描模式');
+        config.backupItems = DEFAULT_BACKUP_ITEMS;
+        saveConfig(config);
+    }
+    // 确保 backupInterval 有默认值
+    if (config.backupInterval === undefined) {
+        config.backupInterval = 30;
+        saveConfig(config);
+    }
+    // 确保出行模式配置有默认值
+    if (config.travelMode === undefined) {
+        config.travelMode = false;
+    }
+    if (config.travelModeInterval === undefined) {
+        config.travelModeInterval = 120;
+    }
+    if (config.travelModeMaxBackups === undefined) {
+        config.travelModeMaxBackups = 20;
+    }
+    if (config.consecutiveFailures === undefined) {
+        config.consecutiveFailures = 0;
+    }
+    return config;
+}
+export function saveConfig(config) {
+    fs.mkdirSync(PLUGIN_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// 获取 Gateway 端口（从配置文件读取）
+function getGatewayPort() {
+    const openclawJsonPath = path.join(OPENCLAW_DIR, 'openclaw.json');
+    try {
+        if (fs.existsSync(openclawJsonPath)) {
+            const ocConfig = JSON.parse(fs.readFileSync(openclawJsonPath, 'utf8'));
+            return ocConfig.gateway?.port || ocConfig.port || 3000;
+        }
+    }
+    catch {
+        // 使用默认端口
+    }
+    return 3000;
+}
+// 跨平台检测 TCP 端口是否可连接（同步）
+// 核心修复：使用 Node.js 内置 net 模块，不再依赖 PowerShell/bash 等外部命令
+// 避免 Windows 下 PowerShell 命令超时/失败导致误判 Gateway 不健康
+function checkPortReachable(port) {
+    // 重试3次，避免偶发网络波动导致误判（Windows下尤其重要）
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            // 方法1：使用 Node.js 内置 net 模块（最可靠，跨平台）
+            const checkScript = `const net=require('net'),s=new net.Socket();s.setTimeout(3000);s.once('connect',()=>{s.end();process.exit(0)});s.once('error',()=>process.exit(1));s.once('timeout',()=>{s.destroy();process.exit(1)});s.connect(${port},'127.0.0.1');`;
+            const tmpFile = path.join(PLUGIN_DIR, `.check-port-${Date.now()}.tmp.js`);
+            fs.writeFileSync(tmpFile, checkScript);
+            try {
+                execSync(`node "${tmpFile}"`, { timeout: 5000 });
+                return true;
+            }
+            finally {
+                try {
+                    fs.unlinkSync(tmpFile);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch {
+            if (attempt < 3) {
+                // 短暂等待后重试
+                const start = Date.now();
+                while (Date.now() - start < 500) { /* busy wait 500ms */ }
+            }
+        }
+    }
+    // 方法2：备选方案（系统命令）
+    try {
+        if (IS_WINDOWS) {
+            // Windows 备选: netstat 查看端口监听状态
+            const output = execSync(`netstat -an | findstr "127.0.0.1:${port}"`, { timeout: 5000, encoding: 'utf8', windowsHide: true });
+            return output.includes('LISTENING') || output.includes('ESTABLISHED');
+        }
+        else {
+            // Linux/Mac 备选: /dev/tcp
+            execSync(`bash -c 'timeout 3 bash -c "cat < /dev/null > /dev/tcp/127.0.0.1/${port}"'`, { timeout: 5000 });
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+// 检查 OpenClaw Gateway 进程是否存在（跨平台）
+// 注意：进程检测只是辅助，端口检测才是主要判断依据
+function checkGatewayProcess() {
+    try {
+        if (IS_WINDOWS) {
+            // Windows: 使用 tasklist 查找 openclaw 相关进程
+            try {
+                // 方法1：查找 openclaw-gateway.exe
+                const output = execSync('tasklist /FI "IMAGENAME eq openclaw-gateway.exe" /NH', {
+                    timeout: 5000,
+                    encoding: 'utf8',
+                    windowsHide: true
+                });
+                if (output.toLowerCase().includes('openclaw')) {
+                    return true;
+                }
+                // 方法2：查找 node.exe（openclaw 可能是通过 node 运行的）
+                const nodeOutput = execSync('tasklist /FI "IMAGENAME eq node.exe" /NH', {
+                    timeout: 5000,
+                    encoding: 'utf8',
+                    windowsHide: true
+                });
+                if (nodeOutput.toLowerCase().includes('node')) {
+                    // node.exe 存在，再检查端口来确认是否是 Gateway
+                    const port = getGatewayPort();
+                    if (checkPortReachable(port)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            // Linux/Mac: 使用 pgrep
+            try {
+                execSync('pgrep -f "openclaw-gateway"', { timeout: 5000 });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+}
+// 检查 OpenClaw Gateway 健康状态（兼容版）
+export function checkOpenClawHealth() {
+    // 优先检测端口，端口通了就是健康的
+    const port = getGatewayPort();
+    if (checkPortReachable(port)) {
+        return true;
+    }
+    // 端口不通再检测进程
+    return checkGatewayProcess();
+}
+const DAEMON_PID_FILE = path.join(PLUGIN_DIR, 'rollback-daemon.pid');
+// 检查守护进程是否在运行
+export function isDaemonRunning() {
+    if (!fs.existsSync(DAEMON_PID_FILE)) {
+        return false;
+    }
+    try {
+        const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim(), 10);
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        try {
+            fs.unlinkSync(DAEMON_PID_FILE);
+        }
+        catch { }
+        return false;
+    }
+}
+// 更全面的健康检查：进程 + API 响应（跨平台支持 Windows/Linux/Mac）
+// 核心逻辑：端口检测优先，端口通了就是健康的
+export function checkGatewayHealthDeep() {
+    // 1. 读取端口配置
+    const port = getGatewayPort();
+    // 2. 优先检测端口（最可靠的方式）
+    const portReachable = checkPortReachable(port);
+    if (portReachable) {
+        // 端口通了，Gateway 肯定在运行
+        return { healthy: true, gatewayRunning: true };
+    }
+    // 3. 端口不通，再检测进程是否存在
+    const processRunning = checkGatewayProcess();
+    if (!processRunning) {
+        return { healthy: false, gatewayRunning: false, details: 'Gateway process not found' };
+    }
+    // 4. 进程存在但端口不通，可能是启动中或配置问题
+    // 尝试 CLI 状态检查
+    try {
+        if (IS_WINDOWS) {
+            try {
+                execSync('openclaw gateway status', { timeout: 10000, windowsHide: true });
+                return { healthy: true, gatewayRunning: true, details: 'Gateway process running, CLI status OK' };
+            }
+            catch {
+                // Windows 下 CLI 命令可能路径不同
+            }
+        }
+        else {
+            execSync('openclaw gateway status', { timeout: 10000 });
+            return { healthy: true, gatewayRunning: true, details: 'Gateway process running, CLI status OK' };
+        }
+    }
+    catch {
+        // CLI 状态检查失败
+    }
+    // 进程存在但端口不通且 CLI 也失败
+    return { healthy: false, gatewayRunning: true, details: `Gateway port ${port} not responding` };
+}
+export function createBackup(options) {
+    const config = getConfig();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupId = `backup-${timestamp}`;
+    const backupDir = options?.isTravelMode
+        ? path.join(TRAVEL_BACKUPS_DIR, backupId)
+        : path.join(REGULAR_BACKUPS_DIR, backupId);
+    console.log(`[${new Date().toLocaleString()}] 开始备份...`);
+    // 出行模式下，如果 Gateway 不健康，跳过备份（因为马上要回滚了）
+    if (options?.isTravelMode && options?.gatewayHealthy === false) {
+        console.log('⚠️  Gateway 不健康，出行模式跳过本次备份');
+        return { success: false, error: 'Gateway is unhealthy, skipping backup in travel mode' };
+    }
+    // 确定要备份的项目（提前确定，供后续使用）
+    let itemsToBackup;
+    if (config.backupItems.length === 0) {
+        // 自动扫描所有 .md 和 .json 文件
+        console.log('🔍 自动扫描配置文件...');
+        itemsToBackup = scanBackupItems(OPENCLAW_DIR, OPENCLAW_DIR);
+        console.log(`📋 发现 ${itemsToBackup.length} 个配置文件`);
+    }
+    else {
+        itemsToBackup = config.backupItems;
+    }
+    try {
+        fs.mkdirSync(backupDir, { recursive: true });
+        // 记录配置变更快照（用于后续根因分析）
+        recordConfigSnapshot(itemsToBackup, backupId);
+        // 备份元数据
+        const meta = {
+            timestamp: new Date().toISOString(),
+            version: getPackageVersion(),
+            items: [],
+            isTravelMode: options?.isTravelMode || false,
+            gatewayHealthy: options?.gatewayHealthy !== undefined ? options.gatewayHealthy : checkOpenClawHealth()
+        };
+        // 备份各项
+        for (const item of itemsToBackup) {
+            const sourcePath = path.join(OPENCLAW_DIR, item);
+            const destPath = path.join(backupDir, item);
+            if (fs.existsSync(sourcePath)) {
+                const stat = fs.statSync(sourcePath);
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                if (stat.isDirectory()) {
+                    copyDirWithExclude(sourcePath, destPath, BACKUP_EXCLUDE_PATTERNS);
+                }
+                else {
+                    fs.copyFileSync(sourcePath, destPath);
+                }
+                meta.items.push(item);
+                console.log(`  ✓ ${item}`);
+            }
+        }
+        // 保存元数据
+        fs.writeFileSync(path.join(backupDir, 'meta.json'), JSON.stringify(meta, null, 2));
+        // 更新配置 - 保存 ISO 格式的时间戳
+        config.lastBackup = meta.timestamp;
+        // 如果是出行模式且 Gateway 健康，更新 lastKnownGoodBackup
+        if (options?.isTravelMode && meta.gatewayHealthy) {
+            config.lastKnownGoodBackup = backupId;
+            config.consecutiveFailures = 0;
+            console.log(`✅ 更新 lastKnownGoodBackup: ${backupId}`);
+        }
+        saveConfig(config);
+        // 清理旧备份（按各自目录分别清理）
+        if (options?.isTravelMode) {
+            cleanupOldBackups(TRAVEL_BACKUPS_DIR, config.travelModeMaxBackups);
+        }
+        else {
+            cleanupOldBackups(REGULAR_BACKUPS_DIR, config.maxBackups);
+        }
+        console.log(`✅ 备份完成: ${backupId}`);
+        // 记录本次备份变更到变更日志
+        logBackupChanges(itemsToBackup, backupId);
+        return { success: true, backupId };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error('❌ 备份失败:', error);
+        // 清理失败的备份
+        if (fs.existsSync(backupDir)) {
+            fs.rmSync(backupDir, { recursive: true });
+        }
+        return { success: false, error };
+    }
+}
+export function cleanupOldBackups(backupDir, maxBackups = 10) {
+    if (!fs.existsSync(backupDir))
+        return;
+    const backups = fs.readdirSync(backupDir)
+        .filter(d => d.startsWith('backup-'))
+        .map(d => ({
+        name: d,
+        path: path.join(backupDir, d),
+        time: fs.statSync(path.join(backupDir, d)).mtime.getTime()
+    }))
+        .sort((a, b) => b.time - a.time);
+    // 保留最近 N 个
+    const toDelete = backups.slice(maxBackups);
+    for (const backup of toDelete) {
+        fs.rmSync(backup.path, { recursive: true });
+        console.log(`🗑️  清理旧备份: ${backup.name}`);
+    }
+}
+export function listBackups() {
+    const results = [];
+    // 读取普通备份
+    if (fs.existsSync(REGULAR_BACKUPS_DIR)) {
+        for (const d of fs.readdirSync(REGULAR_BACKUPS_DIR).filter(d => d.startsWith('backup-'))) {
+            const metaPath = path.join(REGULAR_BACKUPS_DIR, d, 'meta.json');
+            let meta = {};
+            if (fs.existsSync(metaPath)) {
+                meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            }
+            results.push({
+                id: d,
+                timestamp: meta.timestamp || d.replace('backup-', ''),
+                items: meta.items || [],
+                isTravelMode: meta.isTravelMode,
+                gatewayHealthy: meta.gatewayHealthy
+            });
+        }
+    }
+    // 读取出行模式备份
+    if (fs.existsSync(TRAVEL_BACKUPS_DIR)) {
+        for (const d of fs.readdirSync(TRAVEL_BACKUPS_DIR).filter(d => d.startsWith('backup-'))) {
+            const metaPath = path.join(TRAVEL_BACKUPS_DIR, d, 'meta.json');
+            let meta = {};
+            if (fs.existsSync(metaPath)) {
+                meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            }
+            results.push({
+                id: d,
+                timestamp: meta.timestamp || d.replace('backup-', ''),
+                items: meta.items || [],
+                isTravelMode: meta.isTravelMode,
+                gatewayHealthy: meta.gatewayHealthy
+            });
+        }
+    }
+    return results.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}
+// 获取最后一个已知良好的备份（用于出行模式回滚，只在 travel-mode 目录中查找）
+export function getLastKnownGoodBackup() {
+    const config = getConfig();
+    // 只在出行模式备份目录中查找
+    if (!fs.existsSync(TRAVEL_BACKUPS_DIR)) {
+        return null;
+    }
+    const travelBackups = fs.readdirSync(TRAVEL_BACKUPS_DIR)
+        .filter(d => d.startsWith('backup-'))
+        .map(d => {
+        const metaPath = path.join(TRAVEL_BACKUPS_DIR, d, 'meta.json');
+        let meta = {};
+        if (fs.existsSync(metaPath)) {
+            meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+        }
+        return {
+            id: d,
+            timestamp: meta.timestamp || d.replace('backup-', ''),
+            items: meta.items || [],
+            isTravelMode: meta.isTravelMode,
+            gatewayHealthy: meta.gatewayHealthy
+        };
+    })
+        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    // 优先使用配置中记录的 lastKnownGoodBackup
+    if (config.lastKnownGoodBackup) {
+        const found = travelBackups.find(b => b.id === config.lastKnownGoodBackup);
+        if (found)
+            return found;
+    }
+    // 回退：找最后一个 gatewayHealthy=true 的备份
+    const goodBackup = travelBackups.find(b => b.gatewayHealthy === true);
+    if (goodBackup)
+        return goodBackup;
+    // 最后回退：返回最新的备份
+    return travelBackups.length > 0 ? travelBackups[0] : null;
+}
+export function restoreBackup(backupId) {
+    // 在两个目录中查找备份
+    let backupDir = path.join(REGULAR_BACKUPS_DIR, backupId);
+    if (!fs.existsSync(backupDir)) {
+        backupDir = path.join(TRAVEL_BACKUPS_DIR, backupId);
+    }
+    if (!fs.existsSync(backupDir)) {
+        console.error(`❌ 备份不存在: ${backupId}`);
+        return { success: false, error: `Backup not found: ${backupId}` };
+    }
+    console.log(`🔄 准备回滚到: ${backupId}`);
+    console.log('⚠️  这将覆盖当前配置，请确认...');
+    try {
+        // 先创建当前配置的紧急备份（使用实际扫描到的文件，而非配置列表）
+        const emergencyBackup = path.join(BACKUPS_DIR, `emergency-${Date.now()}`);
+        fs.mkdirSync(emergencyBackup, { recursive: true });
+        // 获取当前实际存在的所有配置文件
+        console.log('📦 创建紧急备份（当前配置快照）...');
+        const currentItems = scanBackupItems(OPENCLAW_DIR, OPENCLAW_DIR);
+        let emergencyItemCount = 0;
+        for (const item of currentItems) {
+            const sourcePath = path.join(OPENCLAW_DIR, item);
+            const destPath = path.join(emergencyBackup, item);
+            if (fs.existsSync(sourcePath)) {
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                const stat = fs.statSync(sourcePath);
+                if (stat.isDirectory()) {
+                    fs.cpSync(sourcePath, destPath, { recursive: true });
+                }
+                else {
+                    fs.copyFileSync(sourcePath, destPath);
+                }
+                emergencyItemCount++;
+            }
+        }
+        // 保存紧急备份元数据
+        const emergencyMeta = {
+            timestamp: new Date().toISOString(),
+            version: getPackageVersion(),
+            items: currentItems
+        };
+        fs.writeFileSync(path.join(emergencyBackup, 'meta.json'), JSON.stringify(emergencyMeta, null, 2));
+        console.log(`📦 已创建紧急备份: ${path.basename(emergencyBackup)} (${emergencyItemCount} 个文件)`);
+        // 停止 gateway
+        console.log('🛑 停止 OpenClaw Gateway...');
+        try {
+            execSync('openclaw gateway stop', { timeout: 30000 });
+        }
+        catch {
+            console.log('  ⚠️  gateway 可能未运行');
+        }
+        // 恢复备份
+        console.log('📂 恢复配置文件中...');
+        const metaPath = path.join(backupDir, 'meta.json');
+        const meta = fs.existsSync(metaPath)
+            ? JSON.parse(fs.readFileSync(metaPath, 'utf8'))
+            : { items: [], timestamp: '', version: '' };
+        // 安全恢复：只覆盖备份中存在的文件，不删除任何现有文件
+        for (const item of meta.items || []) {
+            const sourcePath = path.join(backupDir, item);
+            const destPath = path.join(OPENCLAW_DIR, item);
+            if (fs.existsSync(sourcePath)) {
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                const stat = fs.statSync(sourcePath);
+                if (stat.isDirectory()) {
+                    fs.cpSync(sourcePath, destPath, { recursive: true, force: true });
+                }
+                else {
+                    fs.copyFileSync(sourcePath, destPath);
+                }
+                console.log(`  ✓ ${item}`);
+            }
+        }
+        console.log('✅ 配置文件恢复完成（未删除任何现有文件）');
+        // 记录回滚变更
+        recordChange({
+            timestamp: new Date().toISOString(),
+            file: 'system',
+            nodeId: 'system.restore',
+            oldValue: `备份前状态`,
+            newValue: backupId,
+            changeType: 'auto'
+        });
+        // 验证关键配置文件是否有效
+        console.log('🔍 验证关键配置文件...');
+        const openclawJsonPath = path.join(OPENCLAW_DIR, 'openclaw.json');
+        if (fs.existsSync(openclawJsonPath)) {
+            if (!validateConfigFile(openclawJsonPath)) {
+                console.error('❌ openclaw.json 配置无效，无法启动 Gateway');
+                console.log('📦 正在从紧急备份恢复...');
+                const emergencyOpenclaw = path.join(emergencyBackup, 'openclaw.json');
+                if (fs.existsSync(emergencyOpenclaw) && validateConfigFile(emergencyOpenclaw)) {
+                    fs.copyFileSync(emergencyOpenclaw, openclawJsonPath);
+                    console.log('✅ 已从紧急备份恢复 openclaw.json');
+                }
+                else {
+                    return {
+                        success: false,
+                        error: '回滚后的 openclaw.json 配置无效，且紧急备份也无法恢复。请手动检查 ~/.openclaw/openclaw.json'
+                    };
+                }
+            }
+        }
+        // 启动 gateway
+        console.log('🚀 启动 OpenClaw Gateway...');
+        let gatewayStarted = false;
+        let gatewayError = '';
+        try {
+            execSync('openclaw gateway start', { timeout: 30000 });
+            console.log('✅ Gateway 已启动');
+            gatewayStarted = true;
+        }
+        catch (err) {
+            gatewayError = err instanceof Error ? err.message : String(err);
+            console.error('❌ Gateway 启动失败:', gatewayError);
+        }
+        console.log('✅ 回滚完成！');
+        return {
+            success: true,
+            message: gatewayStarted
+                ? '配置已恢复，Gateway 启动成功'
+                : '配置已恢复，但 Gateway 启动失败，请手动检查配置',
+            gatewayStarted,
+            gatewayError: gatewayError || undefined
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error('❌ 回滚失败:', error);
+        return { success: false, error };
+    }
+}
+// 出行模式自动回滚：回滚到最后一个已知良好的备份
+// 核心保护：回滚前进行双重确认，避免偶发检测误判导致频繁重启 Gateway
+export async function autoRollbackTravelMode() {
+    const config = getConfig();
+    // 双重确认：等待3秒后再次检测，连续两次异常才执行回滚
+    console.log('⏳ 出行模式: 首次检测到异常，等待3秒后二次确认...');
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    const secondCheck = checkGatewayHealthDeep();
+    if (secondCheck.healthy) {
+        console.log('✅ 二次确认: Gateway 已恢复正常，跳过本次回滚');
+        return { success: true, message: 'Gateway recovered during confirmation, rollback skipped' };
+    }
+    const goodBackup = getLastKnownGoodBackup();
+    if (!goodBackup) {
+        console.error('❌ 没有找到可用的已知良好备份，无法自动回滚');
+        config.consecutiveFailures = (config.consecutiveFailures || 0) + 1;
+        saveConfig(config);
+        return { success: false, error: 'No known-good backup found for auto-rollback' };
+    }
+    console.log(`🚨 出行模式检测到 Gateway 异常（二次确认），准备自动回滚到最后已知良好备份: ${goodBackup.id}`);
+    const result = restoreBackup(goodBackup.id);
+    if (result.success) {
+        config.consecutiveFailures = 0;
+        console.log('✅ 出行模式自动回滚成功');
+    }
+    else {
+        config.consecutiveFailures = (config.consecutiveFailures || 0) + 1;
+        console.error('❌ 出行模式自动回滚失败:', result.error);
+    }
+    saveConfig(config);
+    return result;
+}
+export function deleteBackup(backupId) {
+    // 在两个目录中查找备份
+    let backupDir = path.join(REGULAR_BACKUPS_DIR, backupId);
+    if (!fs.existsSync(backupDir)) {
+        backupDir = path.join(TRAVEL_BACKUPS_DIR, backupId);
+    }
+    if (!fs.existsSync(backupDir)) {
+        return { success: false, error: `Backup not found: ${backupId}` };
+    }
+    try {
+        fs.rmSync(backupDir, { recursive: true });
+        console.log(`🗑️  已删除备份: ${backupId}`);
+        return { success: true };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        return { success: false, error };
+    }
+}
+// ==================== 配置变更追踪辅助函数 ====================
+const SNAPSHOT_FILE = path.join(PLUGIN_DIR, 'last-config-snapshot.json');
+/**
+ * 记录配置快照（用于后续对比变更）
+ */
+function recordConfigSnapshot(items, backupId) {
+    try {
+        const snapshot = {};
+        for (const item of items) {
+            const filePath = path.join(OPENCLAW_DIR, item);
+            if (fs.existsSync(filePath) && fs.statSync(filePath).isFile() && item.endsWith('.json')) {
+                try {
+                    snapshot[item] = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                }
+                catch {
+                    // 非JSON文件跳过
+                }
+            }
+        }
+        snapshot['_backupId'] = backupId;
+        snapshot['_timestamp'] = new Date().toISOString();
+        fs.writeFileSync(SNAPSHOT_FILE, JSON.stringify(snapshot, null, 2));
+    }
+    catch {
+        // 忽略快照错误
+    }
+}
+/**
+ * 对比上次快照，记录变更到变更日志
+ */
+function logBackupChanges(items, backupId) {
+    try {
+        if (!fs.existsSync(SNAPSHOT_FILE))
+            return;
+        const lastSnapshot = JSON.parse(fs.readFileSync(SNAPSHOT_FILE, 'utf8'));
+        const lastBackupId = lastSnapshot['_backupId'];
+        if (lastBackupId === backupId)
+            return; // 同一个备份不重复记录
+        for (const item of items) {
+            const filePath = path.join(OPENCLAW_DIR, item);
+            if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile() || !item.endsWith('.json'))
+                continue;
+            const lastContent = lastSnapshot[item];
+            if (!lastContent)
+                continue;
+            try {
+                const currentContent = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                const diffs = findJsonDiffs(lastContent, currentContent, item);
+                for (const diff of diffs) {
+                    recordChange({
+                        timestamp: new Date().toISOString(),
+                        file: item,
+                        nodeId: diff.path,
+                        oldValue: diff.oldValue,
+                        newValue: diff.newValue,
+                        changeType: 'manual'
+                    });
+                }
+            }
+            catch {
+                // 解析失败跳过
+            }
+        }
+    }
+    catch {
+        // 忽略变更记录错误
+    }
+}
+/**
+ * 递归查找JSON差异
+ */
+function findJsonDiffs(oldObj, newObj, file, path = '') {
+    const diffs = [];
+    if (typeof oldObj !== typeof newObj) {
+        diffs.push({ path: path || file, oldValue: oldObj, newValue: newObj });
+        return diffs;
+    }
+    if (typeof oldObj !== 'object' || oldObj === null || newObj === null) {
+        if (oldObj !== newObj) {
+            diffs.push({ path: path || file, oldValue: oldObj, newValue: newObj });
+        }
+        return diffs;
+    }
+    const allKeys = new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+    for (const key of allKeys) {
+        const newPath = path ? `${path}.${key}` : key;
+        if (!(key in oldObj)) {
+            diffs.push({ path: newPath, oldValue: undefined, newValue: newObj[key] });
+        }
+        else if (!(key in newObj)) {
+            diffs.push({ path: newPath, oldValue: oldObj[key], newValue: undefined });
+        }
+        else {
+            diffs.push(...findJsonDiffs(oldObj[key], newObj[key], file, newPath));
+        }
+    }
+    return diffs;
+}
+//# sourceMappingURL=core.js.map