evolclaw 2.1.2 → 2.3.0

package/dist/utils/init.js

@@ -7,7 +7,7 @@ import { execFileSync } from 'child_process';
 import { promisify } from 'util';
 import { execFile } from 'child_process';
 import { resolveRoot, resolvePaths, ensureDataDirs, getPackageRoot } from '../paths.js';
-import { isWindows, commandExists } from './platform.js';
+import { isWindows, commandExists } from './cross-platform.js';
 const execFileAsync = promisify(execFile);
 // ==================== Helpers ====================
 function ask(rl, question) {
@@ -184,43 +184,73 @@ async function checkEnvironment(rl) {
         console.log('  → 请先安装: npm install -g @anthropic-ai/claude-code');
         return false;
     }
-    // @anthropic-ai/claude-agent-sdk >= 0.2.75
-    let sdkAction = 'ok';
+    // Agent SDK 检查：claude-agent-sdk / codex-sdk，至少需要一个
+    const MIN_CLAUDE_SDK = [0, 2, 75];
+    let hasClaudeSdk = false;
+    let hasCodexSdk = false;
+    // Check claude-agent-sdk
     try {
-        // 用 require.resolve 找到 SDK 入口，推导 package.json 路径
         const esmRequire = createRequire(import.meta.url);
         const sdkEntry = esmRequire.resolve('@anthropic-ai/claude-agent-sdk');
         const sdkPkgPath = path.join(path.dirname(sdkEntry), 'package.json');
         const sdkPkg = JSON.parse(fs.readFileSync(sdkPkgPath, 'utf-8'));
         const sdkVer = sdkPkg.version;
         const parts = sdkVer.split('.').map(Number);
-        const sdkOk = parts[0] > 0 || parts[1] > 2 || (parts[1] === 2 && parts[2] >= 75);
+        const sdkOk = parts[0] > MIN_CLAUDE_SDK[0]
+            || (parts[0] === MIN_CLAUDE_SDK[0] && parts[1] > MIN_CLAUDE_SDK[1])
+            || (parts[0] === MIN_CLAUDE_SDK[0] && parts[1] === MIN_CLAUDE_SDK[1] && parts[2] >= MIN_CLAUDE_SDK[2]);
         if (sdkOk) {
             console.log(`  ✓ claude-agent-sdk v${sdkVer}`);
+            hasClaudeSdk = true;
         }
         else {
-            console.log(`  ✗ claude-agent-sdk v${sdkVer} — 需要 >= 0.2.75`);
-            sdkAction = 'upgrade';
+            console.log(`  ✗ claude-agent-sdk v${sdkVer} — 需要 >= ${MIN_CLAUDE_SDK.join('.')}`);
+            const answer = (await ask(rl, '  → 是否升级 claude-agent-sdk？[Y/n] ')).trim().toLowerCase();
+            if (answer !== 'n' && answer !== 'no') {
+                console.log('  正在升级 claude-agent-sdk...');
+                try {
+                    await npmInstallGlobal('@anthropic-ai/claude-agent-sdk@latest');
+                    console.log('  ✓ claude-agent-sdk 升级完成');
+                    hasClaudeSdk = true;
+                }
+                catch (e) {
+                    console.log(`  ✗ 升级失败: ${e.message?.slice(0, 200) || e}`);
+                }
+            }
+        }
+    }
+    catch {
+        console.log('  - claude-agent-sdk 未安装');
+    }
+    // Check @openai/codex-sdk (ESM-only, cannot use require.resolve)
+    try {
+        const codexPkgPath = path.join(getPackageRoot(), 'node_modules', '@openai', 'codex-sdk', 'package.json');
+        if (fs.existsSync(codexPkgPath)) {
+            const codexPkg = JSON.parse(fs.readFileSync(codexPkgPath, 'utf-8'));
+            console.log(`  ✓ codex-sdk v${codexPkg.version}`);
+            hasCodexSdk = true;
+        }
+        else {
+            console.log('  - codex-sdk 未安装');
         }
     }
     catch {
-        console.log('  ✗ claude-agent-sdk 未安装');
-        sdkAction = 'install';
+        console.log('  - codex-sdk 未安装');
     }
-    if (sdkAction !== 'ok') {
-        const verb = sdkAction === 'install' ? '安装' : '升级';
-        const answer = (await ask(rl, `  → 是否${verb} claude-agent-sdk？[Y/n] `)).trim().toLowerCase();
+    if (!hasClaudeSdk && !hasCodexSdk) {
+        console.log('\n  ✗ 需要至少安装一个 Agent SDK：claude-agent-sdk 或 codex-sdk');
+        const answer = (await ask(rl, '  → 是否安装 claude-agent-sdk？[Y/n] ')).trim().toLowerCase();
         if (answer === 'n' || answer === 'no') {
             console.log('  已取消');
             return false;
         }
-        console.log(`  正在${verb} claude-agent-sdk...`);
+        console.log('  正在安装 claude-agent-sdk...');
         try {
             await npmInstallGlobal('@anthropic-ai/claude-agent-sdk@latest');
-            console.log(`  ✓ claude-agent-sdk ${verb}完成`);
+            console.log('  ✓ claude-agent-sdk 安装完成');
         }
         catch (e) {
-            console.log(`  ✗ ${verb}失败: ${e.message?.slice(0, 200) || e}`);
+            console.log(`  ✗ 安装失败: ${e.message?.slice(0, 200) || e}`);
             return false;
         }
     }
@@ -312,6 +342,39 @@ async function initFeishuManual(rl, config) {
     config.channels.feishu.enabled = true;
     return true;
 }
+// ==================== AUN Environment Check ====================
+// Moved to init-channel.ts
+// ==================== Rich Content Renderer ====================
+async function offerRichContentRenderer(rl, config) {
+    const answer = (await ask(rl, '\n是否启用 LaTeX + Mermaid 渲染模块（约 35MB）？[y/N] ')).trim().toLowerCase();
+    const enableRich = answer === 'y' || answer === 'yes';
+    // 记录用户选择到全局配置
+    config.enableRichContent = enableRich;
+    if (!enableRich) {
+        console.log('  ✓ 已跳过富内容渲染模块安装');
+        return;
+    }
+    console.log('  正在安装 katex 和 mermaid（可能需要 1-2 分钟）...');
+    try {
+        await npmInstallGlobal('katex');
+        await npmInstallGlobal('mermaid');
+        console.log('  ✓ LaTeX + Mermaid 渲染模块安装完成');
+    }
+    catch (e) {
+        const msg = e.message || '';
+        if (e.killed || msg.includes('ETIMEDOUT') || msg.includes('timed out')) {
+            console.log('  ✗ 安装超时，网络可能较慢');
+        }
+        else {
+            console.log(`  ✗ 安装失败: ${msg.slice(0, 200)}`);
+        }
+        console.log('  → 可稍后手动安装: npm install -g katex mermaid');
+        // 安装失败时，将配置设为 false
+        config.enableRichContent = false;
+    }
+}
+// ==================== AUN AID Helpers ====================
+// Moved to init-channel.ts
 // ==================== Main ====================
 export async function cmdInit() {
     const p = resolvePaths();
@@ -360,56 +423,83 @@ export async function cmdInit() {
         }
         const modelInput = (await ask(rl, '  模型 [sonnet(默认)/opus/haiku]: ')).trim().toLowerCase();
         const model = ['opus', 'haiku'].includes(modelInput) ? modelInput : 'sonnet';
-        // 渠道选择
-        console.log('\n选择消息渠道:');
-        console.log('  1. 飞书 (Feishu)');
-        console.log('  2. 微信 (WeChat)');
-        const channelChoice = (await ask(rl, '请选择 [1]: ')).trim() || '1';
+        // 渠道选择（支持退回重选）
         const config = JSON.parse(fs.readFileSync(sampleSrc, 'utf-8'));
         config.projects.defaultPath = defaultPath;
         config.projects.list = { [path.basename(defaultPath)]: defaultPath };
         config.agents.anthropic.model = model;
-        if (channelChoice === '1') {
-            console.log('\n飞书配置方式:');
-            console.log('  1. 扫码自动注册（推荐）');
-            console.log('  2. 手动输入 App ID/Secret');
-            const feishuMethod = (await ask(rl, '请选择 [1]: ')).trim() || '1';
-            if (feishuMethod === '1') {
-                const { runFeishuQrFlow } = await import('./init-feishu.js');
-                const result = await runFeishuQrFlow();
-                if (!result) {
-                    console.log('已取消');
-                    return;
+        let channelConfigured = false;
+        while (!channelConfigured) {
+            console.log('\n选择消息渠道:');
+            console.log('  1. 飞书 (Feishu)');
+            console.log('  2. 微信 (WeChat)');
+            console.log('  3. AUN (AgentUnin.Network)');
+            const channelChoice = (await ask(rl, '请选择 [1]: ')).trim() || '1';
+            if (channelChoice === '1') {
+                console.log('\n飞书配置方式:');
+                console.log('  1. 扫码自动注册（推荐）');
+                console.log('  2. 手动输入 App ID/Secret');
+                const feishuMethod = (await ask(rl, '请选择 [1]: ')).trim() || '1';
+                if (feishuMethod === '1') {
+                    const { runFeishuQrFlow } = await import('./init-channel.js');
+                    const result = await runFeishuQrFlow();
+                    if (!result) {
+                        console.log('已取消');
+                        return;
+                    }
+                    config.channels.feishu.appId = result.appId;
+                    config.channels.feishu.appSecret = result.appSecret;
+                    config.channels.feishu.enabled = true;
+                    if (result.openId)
+                        config.channels.feishu.owner = result.openId;
+                }
+                else {
+                    if (!await initFeishuManual(rl, config)) {
+                        console.log('已取消');
+                        return;
+                    }
                 }
-                config.channels.feishu.appId = result.appId;
-                config.channels.feishu.appSecret = result.appSecret;
-                config.channels.feishu.enabled = true;
-                if (result.openId)
-                    config.channels.feishu.owner = result.openId;
+                channelConfigured = true;
+                config.channels.defaultChannel = 'feishu';
             }
-            else {
-                if (!await initFeishuManual(rl, config)) {
+            else if (channelChoice === '2') {
+                const { runWechatQrFlow } = await import('./init-channel.js');
+                const result = await runWechatQrFlow();
+                if (!result) {
                     console.log('已取消');
                     return;
                 }
+                config.channels.wechat = {
+                    enabled: true,
+                    baseUrl: result.baseUrl,
+                    token: result.token,
+                };
+                channelConfigured = true;
+                config.channels.defaultChannel = 'wechat';
             }
-        }
-        else if (channelChoice === '2') {
-            const { runWechatQrFlow } = await import('./init-wechat.js');
-            const result = await runWechatQrFlow();
-            if (!result) {
-                console.log('已取消');
-                return;
+            else if (channelChoice === '3') {
+                const { checkAunEnvironment, setupAunAid } = await import('./init-channel.js');
+                const aunReady = await checkAunEnvironment(rl);
+                if (!aunReady)
+                    continue; // 退回重选渠道
+                const result = await setupAunAid(rl, config);
+                if (!result)
+                    continue;
+                config.channels.aun = {
+                    enabled: true,
+                    aid: result.aid,
+                    ...(result.gatewayPort && { gatewayPort: result.gatewayPort }),
+                };
+                channelConfigured = true;
+                config.channels.defaultChannel = 'aun';
+            }
+            else {
+                console.log('  无效选择，请重新输入');
             }
-            config.channels.wechat = {
-                enabled: true,
-                baseUrl: result.baseUrl,
-                token: result.token,
-            };
         }
-        else {
-            console.log('无效选择');
-            return;
+        // 可选：富内容渲染模块（仅 Feishu 通道需要）
+        if (config.channels?.feishu?.enabled) {
+            await offerRichContentRenderer(rl, config);
         }
         fs.writeFileSync(p.config, JSON.stringify(config, null, 2) + '\n');
         console.log(`\n✓ 已创建配置文件: ${p.config}`);
@@ -419,3 +509,50 @@ export async function cmdInit() {
         rl.close();
     }
 }
+/**
+ * Present instance selection menu when existing instances are found.
+ * Returns the user's choice, or null if cancelled.
+ */
+export async function selectInstance(rl, channelType, instances) {
+    const typeLabel = channelType === 'feishu' ? '飞书' : channelType === 'wechat' ? '微信' : 'AUN';
+    console.log(`\n发现已有 ${typeLabel} 机器人：`);
+    const letters = 'abcdefghijklmnopqrstuvwxyz';
+    for (let i = 0; i < instances.length; i++) {
+        console.log(`  ${letters[i]}. ${instances[i].name}`);
+    }
+    const addLetter = letters[instances.length];
+    console.log(`  ${addLetter}. 添加新机器人`);
+    console.log('');
+    const validOptions = letters.slice(0, instances.length + 1).split('');
+    let choice = '';
+    while (!validOptions.includes(choice)) {
+        choice = (await ask(rl, '请选择: ')).trim().toLowerCase();
+        if (!validOptions.includes(choice)) {
+            console.log(`无效选择，请输入 ${validOptions.join('/')}`);
+        }
+    }
+    const choiceIndex = letters.indexOf(choice);
+    if (choiceIndex === instances.length) {
+        // Add new — ask for name
+        let name = '';
+        while (!name) {
+            name = (await ask(rl, '请输入新机器人名称: ')).trim();
+            if (!name)
+                console.log('  名称不能为空');
+            if (instances.some(i => i.name === name)) {
+                console.log(`  名称 "${name}" 已存在，请换一个`);
+                name = '';
+            }
+        }
+        return { action: 'add', name };
+    }
+    // Overwrite — requires confirmation
+    const target = instances[choiceIndex];
+    console.log(`\n已选择：${target.name}`);
+    const confirm = (await ask(rl, `⚠️ 即将覆盖该机器人配置，确认？(y/N) `)).trim().toLowerCase();
+    if (confirm !== 'y' && confirm !== 'yes') {
+        console.log('已取消');
+        return null;
+    }
+    return { action: 'overwrite', index: choiceIndex, name: target.name };
+}

package/dist/utils/logger.js

@@ -25,10 +25,15 @@ function write(stream, data) {
     const line = typeof data === 'string' ? data : JSON.stringify(data);
     stream.write(`${line}\n`);
 }
+export function localTimestamp() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${String(d.getMilliseconds()).padStart(3, '0')}`;
+}
 function log(level, ...args) {
     if (!shouldLog(level))
         return;
-    const timestamp = new Date().toISOString();
+    const timestamp = localTimestamp();
     const msg = `[${timestamp}] [${level}] ${args.join(' ')}`;
     // 只写文件，不输出到 console（避免重定向时重复）
     write(streams.main, msg);
@@ -39,9 +44,9 @@ export const logger = {
     warn: (...args) => log('WARN', ...args),
     error: (...args) => log('ERROR', ...args),
     message: (data) => {
-        write(streams.message, { ts: new Date().toISOString(), ...data });
+        write(streams.message, { ts: localTimestamp(), ...data });
     },
     event: (data) => {
-        write(streams.event, { ts: new Date().toISOString(), ...data });
+        write(streams.event, { ts: localTimestamp(), ...data });
     }
 };

package/dist/utils/media-cache.js

@@ -0,0 +1,207 @@
+/**
+ * 统一媒体下载/缓存/SSRF防护框架
+ *
+ * 提供跨通道复用的文件处理能力：
+ * - 文件保存到 uploads 目录（自动去重、文件名清洗）
+ * - 图片类型白名单 + 大小限制
+ * - URL SSRF 防护（域名白名单 + 私有 IP 拦截）
+ * - 下载缓存（相同 key 不重复下载）
+ */
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { logger } from './logger.js';
+// ── 常量 ──────────────────────────────────────────────────────────────────────
+const DEFAULT_MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10 MB
+const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024; // 100 MB
+const ALLOWED_IMAGE_MIMES = new Set([
+    'image/png', 'image/jpeg', 'image/gif', 'image/webp',
+]);
+const UPLOADS_SUBDIR = '.evolclaw/uploads';
+// ── SSRF 防护 ─────────────────────────────────────────────────────────────────
+/** 已知安全的 CDN 域名白名单 */
+const ALLOWED_CDN_HOSTS = new Set([
+    'novac2c.cdn.weixin.qq.com',
+    'open.feishu.cn',
+    'internal-api-lark-file.feishu.cn',
+]);
+/** 私有 IP 段正则（IPv4） */
+const PRIVATE_IP_RE = /^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|127\.|0\.|169\.254\.|::1|fc|fd|fe80)/;
+/**
+ * 检查 URL 是否安全（非 SSRF）
+ * - 拒绝私有 IP
+ * - 仅允许 https（或白名单域名的 http）
+ * - 可选：域名白名单模式
+ */
+export function validateUrl(url, opts) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { ok: false, reason: `Invalid URL: ${url}` };
+    }
+    // 协议检查
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        return { ok: false, reason: `Blocked protocol: ${parsed.protocol}` };
+    }
+    // 私有 IP 检查
+    const host = parsed.hostname;
+    if (PRIVATE_IP_RE.test(host)) {
+        return { ok: false, reason: `Blocked private IP: ${host}` };
+    }
+    // 域名白名单（如果提供）
+    const allowed = opts?.allowedHosts ?? ALLOWED_CDN_HOSTS;
+    if (allowed.size > 0 && !allowed.has(host)) {
+        return { ok: false, reason: `Host not in allowlist: ${host}` };
+    }
+    return { ok: true };
+}
+// ── 文件名清洗 ────────────────────────────────────────────────────────────────
+/**
+ * 清洗文件名：
+ * - 移除路径穿越字符（只保留 basename）
+ * - 替换非法字符
+ * - 空结果兜底
+ */
+export function sanitizeFileName(name) {
+    return path.basename(name).replace(/[<>:"|?*\x00-\x1f]/g, '_') || `file_${Date.now()}`;
+}
+// ── 图片验证 ──────────────────────────────────────────────────────────────────
+/**
+ * 验证图片 Buffer：类型白名单 + 大小限制
+ * 返回检测到的 MIME 类型，验证失败返回 null + reason
+ */
+export async function validateImage(buffer, opts) {
+    const maxSize = opts?.maxSize ?? DEFAULT_MAX_IMAGE_SIZE;
+    const allowed = opts?.allowedMimes ?? ALLOWED_IMAGE_MIMES;
+    if (buffer.length === 0) {
+        return { mime: null, reason: 'Empty buffer' };
+    }
+    if (buffer.length > maxSize) {
+        return { mime: null, reason: `Image too large: ${buffer.length} bytes (max ${maxSize})` };
+    }
+    // 动态导入 image-type（ESM only）
+    const { default: imageType } = await import('image-type');
+    const type = await imageType(buffer);
+    if (!type) {
+        return { mime: null, reason: 'Unable to detect image type' };
+    }
+    if (!allowed.has(type.mime)) {
+        return { mime: null, reason: `Unsupported image type: ${type.mime}` };
+    }
+    return { mime: type.mime };
+}
+/**
+ * 保存 Buffer 到 uploads 目录
+ * - 自动创建目录
+ * - 文件名清洗
+ * - 同名文件自动添加时间戳后缀
+ */
+export function saveToUploads(buffer, rawFileName, projectPath, opts) {
+    const fileName = sanitizeFileName(rawFileName);
+    const uploadsDir = path.join(projectPath, UPLOADS_SUBDIR);
+    fs.mkdirSync(uploadsDir, { recursive: true });
+    let targetName = fileName;
+    const targetPath = path.join(uploadsDir, targetName);
+    // 去重：内容相同则复用
+    if (opts?.dedup !== false && fs.existsSync(targetPath)) {
+        const existingHash = hashFile(targetPath);
+        const newHash = crypto.createHash('md5').update(buffer).digest('hex');
+        if (existingHash === newHash) {
+            logger.debug(`[MediaCache] Dedup hit: ${targetName}`);
+            return { filePath: targetPath, fileName: targetName, size: buffer.length };
+        }
+        // 不同内容同名 → 加时间戳
+        const ext = path.extname(fileName);
+        const base = path.basename(fileName, ext);
+        targetName = `${base}_${Date.now()}${ext}`;
+    }
+    const finalPath = path.join(uploadsDir, targetName);
+    fs.writeFileSync(finalPath, buffer);
+    logger.info(`[MediaCache] Saved: ${finalPath} (${buffer.length} bytes)`);
+    return { filePath: finalPath, fileName: targetName, size: buffer.length };
+}
+function hashFile(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+/**
+ * 安全下载 URL 内容，带 SSRF 防护
+ */
+export async function safeFetch(url, opts) {
+    const maxSize = opts?.maxSize ?? DEFAULT_MAX_FILE_SIZE;
+    const timeout = opts?.timeout ?? 30_000;
+    // SSRF 检查
+    if (!opts?.skipSsrfCheck) {
+        const check = validateUrl(url, { allowedHosts: opts?.allowedHosts });
+        if (!check.ok) {
+            throw new Error(`SSRF blocked: ${check.reason}`);
+        }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+        // 检查 Content-Length（如果可用）
+        const contentLength = res.headers.get('content-length');
+        if (contentLength && parseInt(contentLength) > maxSize) {
+            throw new Error(`File too large: ${contentLength} bytes (max ${maxSize})`);
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        if (buffer.length > maxSize) {
+            throw new Error(`File too large: ${buffer.length} bytes (max ${maxSize})`);
+        }
+        return buffer;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * 内存级下载缓存
+ * - 相同 key 不重复下载
+ * - TTL 过期自动清理
+ * - 最大条目限制防止内存泄漏
+ */
+export class DownloadCache {
+    cache = new Map();
+    ttlMs;
+    maxEntries;
+    constructor(opts) {
+        this.ttlMs = opts?.ttlMs ?? 5 * 60 * 1000; // 5 min
+        this.maxEntries = opts?.maxEntries ?? 100;
+    }
+    /**
+     * 获取或下载：缓存命中直接返回，否则执行 fetcher 并缓存结果
+     */
+    async getOrFetch(key, fetcher) {
+        this.evict();
+        const cached = this.cache.get(key);
+        if (cached) {
+            logger.debug(`[DownloadCache] Hit: ${key}`);
+            return cached.buffer;
+        }
+        const buffer = await fetcher();
+        this.cache.set(key, { buffer, createdAt: Date.now() });
+        // 超过 maxEntries 时删最旧
+        if (this.cache.size > this.maxEntries) {
+            const oldest = this.cache.keys().next().value;
+            this.cache.delete(oldest);
+        }
+        return buffer;
+    }
+    evict() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (now - entry.createdAt > this.ttlMs) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    clear() {
+        this.cache.clear();
+    }
+}

package/dist/utils/migrate-project.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { resolvePaths } from '../paths.js';
+import { loadConfig, saveConfig } from '../config.js';
+/** 将绝对路径编码为 Claude Code 的目录名格式（/ \ . 替换为 -） */
+function encodePath(p) {
+    return p.replace(/[/\\\.]/g, '-');
+}
+/** 查找最新的 ~/.codex/state_*.sqlite */
+function findCodexDb() {
+    const codexHome = path.join(os.homedir(), '.codex');
+    if (!fs.existsSync(codexHome))
+        return null;
+    const files = fs.readdirSync(codexHome)
+        .filter(f => /^state_\d+\.sqlite$/.test(f))
+        .sort((a, b) => {
+        const va = parseInt(a.match(/state_(\d+)/)?.[1] || '0');
+        const vb = parseInt(b.match(/state_(\d+)/)?.[1] || '0');
+        return vb - va;
+    });
+    return files.length > 0 ? path.join(codexHome, files[0]) : null;
+}
+export async function migrateProject(oldPath, newPath) {
+    const result = {
+        claudeSessionsMoved: false,
+        claudeHistoryUpdated: false,
+        codexUpdated: 0,
+        evolclawDbUpdated: 0,
+        evolclawConfigUpdated: false,
+        directoryMoved: false,
+    };
+    const oldAbs = path.resolve(oldPath);
+    const newAbs = path.resolve(newPath);
+    if (!fs.existsSync(oldAbs))
+        throw new Error(`源目录不存在: ${oldAbs}`);
+    if (fs.existsSync(newAbs))
+        throw new Error(`目标目录已存在: ${newAbs}`);
+    const claudeProjects = path.join(os.homedir(), '.claude', 'projects');
+    const oldEncoded = encodePath(oldAbs);
+    const newEncoded = encodePath(newAbs);
+    // 1. 迁移 ~/.claude/projects/{encoded}/
+    const oldClaudeDir = path.join(claudeProjects, oldEncoded);
+    const newClaudeDir = path.join(claudeProjects, newEncoded);
+    if (fs.existsSync(oldClaudeDir)) {
+        fs.renameSync(oldClaudeDir, newClaudeDir);
+        result.claudeSessionsMoved = true;
+    }
+    // 2. .jsonl 内部路径不需要替换 — 它们是历史对话记录，
+    //    resume 时模型会根据当前 cwd 工作，旧路径只是历史上下文
+    // 3. 更新 ~/.claude/history.jsonl
+    const historyFile = path.join(os.homedir(), '.claude', 'history.jsonl');
+    if (fs.existsSync(historyFile)) {
+        const lines = fs.readFileSync(historyFile, 'utf-8').split('\n');
+        const updated = lines.map(line => {
+            if (!line.trim())
+                return line;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.project === oldAbs) {
+                    obj.project = newAbs;
+                    return JSON.stringify(obj);
+                }
+            }
+            catch { /* skip */ }
+            return line;
+        });
+        const newContent = updated.join('\n');
+        if (newContent !== fs.readFileSync(historyFile, 'utf-8')) {
+            fs.writeFileSync(historyFile, newContent, 'utf-8');
+            result.claudeHistoryUpdated = true;
+        }
+    }
+    // 4. 更新 Codex SQLite threads.cwd
+    const codexDbPath = findCodexDb();
+    if (codexDbPath) {
+        try {
+            const { DatabaseSync } = await import('node:sqlite');
+            const db = new DatabaseSync(codexDbPath);
+            const r = db.prepare('UPDATE threads SET cwd = ? WHERE cwd = ?').run(newAbs, oldAbs);
+            result.codexUpdated = r.changes ?? 0;
+            db.close();
+        }
+        catch { /* Codex not installed or DB locked */ }
+    }
+    // 5. 移动项目目录
+    fs.renameSync(oldAbs, newAbs);
+    result.directoryMoved = true;
+    // 6. 更新 EvolClaw sessions.db
+    const p = resolvePaths();
+    if (fs.existsSync(p.db)) {
+        try {
+            const { DatabaseSync } = await import('node:sqlite');
+            const db = new DatabaseSync(p.db);
+            const r = db.prepare('UPDATE sessions SET project_path = ? WHERE project_path = ?').run(newAbs, oldAbs);
+            result.evolclawDbUpdated = r.changes ?? 0;
+            db.close();
+        }
+        catch { /* DB not accessible */ }
+    }
+    // 7. 更新 evolclaw.json projects.list
+    if (fs.existsSync(p.config)) {
+        try {
+            const config = loadConfig(p.config);
+            if (config.projects?.list) {
+                let changed = false;
+                for (const [k, v] of Object.entries(config.projects.list)) {
+                    if (v === oldAbs) {
+                        config.projects.list[k] = newAbs;
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    saveConfig(config, p.config);
+                    result.evolclawConfigUpdated = true;
+                }
+            }
+        }
+        catch { /* config not accessible */ }
+    }
+    return result;
+}