evolclaw 2.8.0 → 2.8.1

package/dist/utils/init-channel.js

@@ -10,13 +10,13 @@ import readline from 'readline';
 import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
-import { fileURLToPath } from 'url';
-import { execFile, execFileSync } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { resolvePaths } from '../paths.js';
 import { normalizeChannelInstances } from '../config.js';
 import { selectInstance } from './init.js';
 import { isWindows } from './cross-platform.js';
+import { AUN_CORE_SDK_PKG, MIN_AUN_CORE_SDK, resolveAunCoreSdkPkg, isAunSdkVersionOk, isValidAid, aidCreate, agentmdPut, buildInitialAgentMd, } from '../channels/aun-ops.js';
 const execFileAsync = promisify(execFile);
 export async function npmInstallGlobal(pkg) {
     const npmCmd = isWindows ? 'npm.cmd' : 'npm';
@@ -580,91 +580,9 @@ export async function cmdInitWechat() {
     process.exit(1);
 }
 // ==================== AUN ====================
-// 最低 @agentunion/fastaun 版本要求
-const MIN_AUN_CORE_SDK = [0, 2, 14];
-const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
-function compareVersion(a, min) {
-    const parts = a.split('.').map(n => parseInt(n, 10));
-    if (parts.length < 3 || parts.some(isNaN))
-        return false;
-    if (parts[0] !== min[0])
-        return parts[0] > min[0];
-    if (parts[1] !== min[1])
-        return parts[1] > min[1];
-    return parts[2] >= min[2];
-}
-export function resolveAunCoreSdkPkg() {
-    const pkgName = AUN_CORE_SDK_PKG;
-    // Strategy 1: walk up node_modules from this file (no require.resolve — avoids ESM exports issues)
-    try {
-        let dir = path.dirname(fileURLToPath(import.meta.url));
-        while (true) {
-            const candidate = path.join(dir, 'node_modules', pkgName, 'package.json');
-            if (fs.existsSync(candidate)) {
-                const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-                if (data.name === pkgName)
-                    return { version: data.version, path: candidate };
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    catch { /* fall through */ }
-    // Strategy 2: npm root -g fallback (globally installed SDK)
-    try {
-        const npmCmd = isWindows ? 'npm.cmd' : 'npm';
-        const globalRoot = execFileSync(npmCmd, ['root', '-g'], {
-            encoding: 'utf-8', timeout: 10000, shell: isWindows,
-        }).trim();
-        const pkgPath = path.join(globalRoot, pkgName, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const data = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            return { version: data.version, path: pkgPath };
-        }
-    }
-    catch { /* not found */ }
-    return null;
-}
-/**
- * Download AUN CA root certificate to ~/.aun/CA/root/root.crt.
- * Idempotent: skips if file already exists. Returns true if a cert is on disk
- * after the call (either pre-existing or freshly downloaded).
- *
- * Must be called BEFORE constructing any AUNClient that needs to verify
- * gateway-issued certificates (e.g. for uploadAgentMd) — the SDK loads trusted
- * roots from disk at client construction time and won't pick up later writes.
- */
-export async function downloadCaRoot(aunPath, gatewayUrl, indent = '') {
-    const caDir = path.join(aunPath, 'CA', 'root');
-    const caCertPath = path.join(caDir, 'root.crt');
-    if (fs.existsSync(caCertPath))
-        return true;
-    if (!gatewayUrl)
-        return false;
-    try {
-        fs.mkdirSync(caDir, { recursive: true });
-        const gwHttp = gatewayUrl.replace(/^wss?:/, 'https:').replace(/\/aun$/, '');
-        const resp = await fetch(`${gwHttp}/pki/chain`, { redirect: 'follow' });
-        if (!resp.ok) {
-            console.warn(`${indent}⚠ CA 根证书下载失败: HTTP ${resp.status}`);
-            return false;
-        }
-        const body = await resp.text();
-        if (!body.includes('BEGIN CERTIFICATE')) {
-            console.warn(`${indent}⚠ CA 根证书响应内容无效，跳过写入`);
-            return false;
-        }
-        fs.writeFileSync(caCertPath, body);
-        console.log(`${indent}✓ CA 根证书已下载`);
-        return true;
-    }
-    catch (e) {
-        console.warn(`${indent}⚠ CA 根证书下载失败: ${e}，可稍后手动下载`);
-        return false;
-    }
-}
+//
+// AUN 原子操作（aidCreate, agentmdPut, downloadCaRoot, isValidAid, ...）
+// 已迁移至 src/channels/aun-ops.ts。本节仅保留交互式 UI 编排。
 export async function checkAunEnvironment(rl) {
     console.log('\n🔍 AUN 环境检查...\n');
     const minVer = MIN_AUN_CORE_SDK.join('.');
@@ -688,7 +606,7 @@ export async function checkAunEnvironment(rl) {
         console.log('');
         return true;
     }
-    if (compareVersion(installed.version, MIN_AUN_CORE_SDK)) {
+    if (isAunSdkVersionOk(installed.version)) {
         console.log(`  ✓ ${AUN_CORE_SDK_PKG} v${installed.version}`);
         console.log('');
         return true;
@@ -711,95 +629,8 @@ export async function checkAunEnvironment(rl) {
     console.log('');
     return true;
 }
-export function isValidAid(name) {
-    const labels = name.split('.');
-    return labels.length >= 3 && labels.every(l => /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(l));
-}
-/**
- * Non-interactive AID creation + agent.md publish.
- * Reuses the same logic as `evolclaw init --non-interactive --channel aun`.
- *
- * Returns the created AID string, or throws on failure.
- */
-export async function createAidSilent(opts) {
-    const aunPath = path.join(os.homedir(), '.aun');
-    const aidDir = path.join(aunPath, 'AIDs', opts.aid);
-    // Skip creation if AID already exists locally
-    if (fs.existsSync(aidDir) && fs.existsSync(path.join(aidDir, 'private'))) {
-        return { aid: opts.aid, alreadyExisted: true };
-    }
-    const { AUNClient, GatewayDiscovery } = await import('@agentunion/fastaun');
-    let client = new AUNClient({ aun_path: aunPath });
-    const result = await client.auth.createAid({ aid: opts.aid });
-    // Download CA root cert (if not already present)
-    const caDownloaded = await downloadCaRoot(aunPath, result.gateway || '');
-    // Rebuild client with CA cert + AID identity for uploadAgentMd
-    const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
-    if (caDownloaded && fs.existsSync(caCertPath)) {
-        try {
-            await client.close();
-        }
-        catch { /* ignore */ }
-        client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath, aid: opts.aid });
-    }
-    // Set gateway URL for uploadAgentMd
-    let gatewayUrl = result.gateway || '';
-    if (!gatewayUrl) {
-        try {
-            const discovery = new GatewayDiscovery({});
-            gatewayUrl = await discovery.discover(`https://${opts.aid}/.well-known/aun-gateway`);
-        }
-        catch { /* fall through */ }
-    }
-    if (gatewayUrl) {
-        client._gatewayUrl = gatewayUrl;
-    }
-    // Write initial agent.md (initialized: false, name = aid first label)
-    const agentName = opts.aid.split('.')[0];
-    const agentMdContent = `---\naid: "${opts.aid}"\nname: "${agentName}"\ntype: "ai"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolclaw\ninitialized: false\n---\n`;
-    const agentMdPath = path.join(aidDir, 'agent.md');
-    try {
-        await client.auth.uploadAgentMd(agentMdContent);
-    }
-    catch (e) {
-        // Non-fatal: first connection will auto-retry
-    }
-    fs.writeFileSync(agentMdPath, agentMdContent, 'utf-8');
-    try {
-        await client.close();
-    }
-    catch { /* ignore */ }
-    if (!fs.existsSync(agentMdPath)) {
-        throw new Error(`agent.md write verification failed: ${agentMdPath}`);
-    }
-    return { aid: opts.aid, alreadyExisted: false };
-}
-/**
- * Append a new AUN instance to the config's channels.aun array and save.
- * Handles upgrade from single-object to array format.
- */
-export function appendAunInstance(config, inst) {
-    if (!config.channels)
-        config.channels = {};
-    const newInst = {
-        name: inst.name,
-        enabled: inst.enabled ?? true,
-        aid: inst.aid,
-        ...(inst.owner && { owner: inst.owner }),
-    };
-    if (Array.isArray(config.channels.aun)) {
-        config.channels.aun.push(newInst);
-    }
-    else if (config.channels.aun) {
-        const oldInst = { ...config.channels.aun, name: config.channels.aun.name || 'aun' };
-        config.channels.aun = [oldInst, newInst];
-    }
-    else {
-        config.channels.aun = [newInst];
-    }
-    const p = resolvePaths();
-    fs.writeFileSync(p.config, JSON.stringify(config, null, 2) + '\n');
-}
+// isValidAid, createAidSilent → 已迁移至 src/channels/aun-ops.ts
+// appendAunInstance → 已迁移至 src/channels/aun-ops.ts
 export async function setupAunAid(rl, _config) {
     let aid = '';
     // Outer loop: allows retrying with a different AID
@@ -829,64 +660,35 @@ export async function setupAunAid(rl, _config) {
             console.log('  已跳过 AID 创建（启动时可能连接失败）');
             break;
         }
-        // Create AID using TS SDK directly
+        // Create AID + agent.md via atomic ops
         console.log('  正在创建 AID...');
         let failed = false;
         try {
-            const { AUNClient, GatewayDiscovery } = await import('@agentunion/fastaun');
-            let client = new AUNClient({ aun_path: aunPath });
-            const result = await client.auth.createAid({ aid });
+            const result = await aidCreate(aid);
             console.log(`  ✓ AID ${result.aid} 创建成功`);
-            // 下载 CA 根证书（如果本地不存在），从 SDK 返回的实际网关 URL 派生
-            const caDownloaded = await downloadCaRoot(aunPath, result.gateway || '', '  ');
-            // 重建 client：传 root_ca_path 以验证 server cert，传 aid 以加载身份
-            const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
-            if (caDownloaded && fs.existsSync(caCertPath)) {
-                try {
-                    await client.close();
-                }
-                catch { /* ignore */ }
-                client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath, aid });
-            }
-            // 设置 gateway URL（从 createAid 返回值或 well-known 自动发现）
-            let gatewayUrl = result.gateway || '';
-            if (!gatewayUrl) {
-                try {
-                    const discovery = new GatewayDiscovery({});
-                    gatewayUrl = await discovery.discover(`https://${aid}/.well-known/aun-gateway`);
-                }
-                catch { /* fall through */ }
-            }
-            if (gatewayUrl) {
-                client._gatewayUrl = gatewayUrl;
-            }
-            // Collect agent.md info and publish
+            // Collect agent.md type and upload
             const typeInput = (await ask(rl, '  Agent 类型 human/ai [ai]: ')).trim().toLowerCase();
             const agentType = typeInput === 'human' ? 'human' : 'ai';
-            const agentName = aid.split('.')[0];
-            const agentMdContent = `---\naid: "${aid}"\nname: "${agentName}"\ntype: "${agentType}"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolclaw\ninitialized: false\n---\n`;
-            const agentMdPath = path.join(aidDir, 'agent.md');
+            const content = buildInitialAgentMd({ aid, type: agentType });
             try {
-                await client.auth.uploadAgentMd(agentMdContent);
-                console.log('  ✓ agent.md 已发布');
+                await agentmdPut(content, { aid, client: result.client });
+                console.log('  ✓ agent.md 已发布并写入本地');
             }
             catch (e) {
                 console.log(`  ⚠ agent.md 发布失败（首次连接将自动重试）: ${String(e.message || e).slice(0, 100)}`);
-            }
-            fs.writeFileSync(agentMdPath, agentMdContent, 'utf-8');
-            if (!fs.existsSync(agentMdPath)) {
+                // Still write local copy as fallback
                 try {
-                    await client.close();
+                    fs.mkdirSync(aidDir, { recursive: true });
+                    fs.writeFileSync(path.join(aidDir, 'agent.md'), content, 'utf-8');
+                    console.log('  ✓ agent.md 已写入本地');
+                }
+                catch (we) {
+                    console.log(`  ✗ agent.md 本地写入失败: ${String(we.message || we).slice(0, 100)}`);
+                    failed = true;
                 }
-                catch { /* ignore */ }
-                console.log(`  ✗ agent.md 本地写入校验失败: ${agentMdPath}`);
-                failed = true;
-            }
-            else {
-                console.log('  ✓ agent.md 已写入本地');
             }
             try {
-                await client.close();
+                await result.client.close();
             }
             catch { /* ignore */ }
         }
@@ -1610,3 +1412,71 @@ export async function cmdInitWecom() {
     console.log(`  配置已写入: ${p.config}`);
     console.log(`\n现在可以启动服务: evolclaw restart`);
 }
+export function getChannelCredentialCollector(type) {
+    switch (type) {
+        case 'feishu':
+            return async () => {
+                const result = await runFeishuQrFlow();
+                if (!result)
+                    return null;
+                return { appId: result.appId, appSecret: result.appSecret, enabled: true };
+            };
+        case 'wechat':
+            return async () => {
+                const result = await runWechatQrFlow();
+                if (!result)
+                    return null;
+                return { baseUrl: result.baseUrl, token: result.token, enabled: true };
+            };
+        case 'aun':
+            return async () => {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                    if (!await checkAunEnvironment(rl))
+                        return null;
+                    const result = await setupAunAid(rl, {});
+                    if (!result)
+                        return null;
+                    return { aid: result.aid, owner: result.owner, enabled: true };
+                }
+                finally {
+                    rl.close();
+                }
+            };
+        case 'dingtalk':
+            return async () => {
+                const result = await runDingtalkQrFlowSimple();
+                if (!result)
+                    return null;
+                return { clientId: result.clientId, clientSecret: result.clientSecret, enabled: true };
+            };
+        case 'qqbot':
+            return async () => {
+                const result = await runQQBotBindFlowSimple();
+                if (!result)
+                    return null;
+                return { appId: result.appId, clientSecret: result.clientSecret, enabled: true };
+            };
+        case 'wecom':
+            return async () => {
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const ask = (q) => new Promise(r => rl.question(q, r));
+                try {
+                    console.log('企业微信 AI Bot 配置\n');
+                    console.log('请在企业微信管理后台 → AI Bot 页面获取 Bot ID 和 Secret\n');
+                    const botId = (await ask('  Bot ID: ')).trim();
+                    if (!botId)
+                        return null;
+                    const secret = (await ask('  Secret: ')).trim();
+                    if (!secret)
+                        return null;
+                    return { botId, secret, enabled: true };
+                }
+                finally {
+                    rl.close();
+                }
+            };
+        default:
+            return null;
+    }
+}

package/dist/utils/init.js

@@ -396,7 +396,7 @@ export async function cmdInit(options) {
     // 非交互式模式
     if (options?.nonInteractive) {
         const config = JSON.parse(fs.readFileSync(sampleSrc, 'utf-8'));
-        const defaultPath = options.defaultPath || path.join(os.homedir(), 'evolclaw-project');
+        const defaultPath = options.defaultPath || path.join(os.homedir(), 'projects', 'default');
         if (!fs.existsSync(defaultPath))
             fs.mkdirSync(defaultPath, { recursive: true });
         config.projects.defaultPath = defaultPath;
@@ -405,56 +405,32 @@ export async function cmdInit(options) {
             throw new Error('--aun-aid is required for AUN channel (e.g. --aun-aid mybot.agentid.pub)');
         }
         if (options.channel === 'aun' && options.aunAid) {
-            // 自动安装 AUN SDK
-            const { resolveAunCoreSdkPkg, npmInstallGlobal, downloadCaRoot } = await import('./init-channel.js');
-            if (!resolveAunCoreSdkPkg()) {
-                console.log('正在安装 @agentunion/fastaun...');
-                await npmInstallGlobal('@agentunion/fastaun@latest');
-            }
-            // 创建 AID（如果本地不存在）
+            const { ensureAunSdk, aidCreate, agentmdPut, buildInitialAgentMd } = await import('../channels/aun-ops.js');
+            await ensureAunSdk();
             const aunPath = path.join(os.homedir(), '.aun');
             const aidDir = path.join(aunPath, 'AIDs', options.aunAid);
             if (!fs.existsSync(path.join(aidDir, 'private'))) {
-                const { AUNClient } = await import('@agentunion/fastaun');
-                let client = new AUNClient({ aun_path: aunPath });
-                // 让 SDK 通过 well-known 自动发现网关
-                const result = await client.auth.createAid({ aid: options.aunAid });
-                // 下载 CA 根证书（如果本地不存在），从 SDK 返回的实际网关 URL 派生
-                const caDownloaded = await downloadCaRoot(aunPath, result.gateway || '');
-                // 关键：SDK 默认 rootCaPath=null，只读取包内 bundled certs。
-                // 必须显式传 root_ca_path 指向刚下载的 root.crt，uploadAgentMd 才能验证 server cert。
-                // 同时传 aid，否则新 client 不知道该加载哪个身份，uploadAgentMd 会报
-                // "no local identity found, call auth.createAid() first"。
-                const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
-                if (caDownloaded && fs.existsSync(caCertPath)) {
+                const result = await aidCreate(options.aunAid);
+                try {
+                    const content = buildInitialAgentMd({ aid: options.aunAid });
                     try {
-                        await client.close();
+                        await agentmdPut(content, { aid: options.aunAid, client: result.client });
+                    }
+                    catch (e) {
+                        console.warn(`⚠ agent.md 网络发布失败（首次连接将自动重试）: ${String(e?.message || e).slice(0, 100)}`);
+                        fs.mkdirSync(aidDir, { recursive: true });
+                        fs.writeFileSync(path.join(aidDir, 'agent.md'), content, 'utf-8');
+                    }
+                    if (!fs.existsSync(path.join(aidDir, 'agent.md'))) {
+                        throw new Error(`agent.md 写入校验失败: ${path.join(aidDir, 'agent.md')}`);
                     }
-                    catch { }
-                    client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath, aid: options.aunAid });
-                }
-                // 写入初始 agent.md（initialized: false）
-                const agentName = options.aunAid.split('.')[0];
-                const agentMd = `---\naid: "${options.aunAid}"\nname: "${agentName}"\ntype: "ai"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolclaw\ninitialized: false\n---\n`;
-                const agentMdPath = path.join(aidDir, 'agent.md');
-                try {
-                    await client.auth.uploadAgentMd(agentMd);
-                }
-                catch (e) {
-                    console.warn(`⚠ agent.md 网络发布失败（首次连接将自动重试）: ${String(e?.message || e).slice(0, 100)}`);
                 }
-                fs.writeFileSync(agentMdPath, agentMd, 'utf-8');
-                if (!fs.existsSync(agentMdPath)) {
+                finally {
                     try {
-                        await client.close();
+                        await result.client.close();
                     }
                     catch { }
-                    throw new Error(`agent.md 写入校验失败: ${agentMdPath}`);
-                }
-                try {
-                    await client.close();
                 }
-                catch { }
             }
             config.channels.aun = {
                 enabled: true,
@@ -483,7 +459,7 @@ export async function cmdInit(options) {
         }
         console.log('📝 交互式配置\n');
         // 通用配置
-        const defaultSuggestion = path.join(os.homedir(), 'evolclaw-project');
+        const defaultSuggestion = path.join(os.homedir(), 'projects', 'default');
         let defaultPath = (await ask(rl, `  默认项目路径 [${defaultSuggestion}]: `)).trim();
         if (!defaultPath)
             defaultPath = defaultSuggestion;

package/dist/utils/logger.js

@@ -4,6 +4,9 @@ import { resolvePaths } from '../paths.js';
 const LOG_DIR = resolvePaths().logs;
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+const HOUR_MS = 60 * 60 * 1000;
+const RETAIN_HOURS = 12;
+const LOG_FILE_RE = /^evolclaw-\d{8}-\d{2}\.log$/;
 const config = {
     messageLog: process.env.MESSAGE_LOG === 'true',
     eventLog: process.env.EVENT_LOG === 'true'
@@ -11,8 +14,60 @@ const config = {
 if (!fs.existsSync(LOG_DIR)) {
     fs.mkdirSync(LOG_DIR, { recursive: true });
 }
+/** 获取当前小时标识 YYYYMMDD-HH */
+function currentHourTag() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}`;
+}
+/** 清理超过 RETAIN_HOURS 的旧日志文件 */
+function cleanupOldLogs() {
+    const cutoff = Date.now() - RETAIN_HOURS * HOUR_MS;
+    try {
+        for (const name of fs.readdirSync(LOG_DIR)) {
+            if (!LOG_FILE_RE.test(name))
+                continue;
+            try {
+                const full = path.join(LOG_DIR, name);
+                if (fs.statSync(full).mtimeMs < cutoff)
+                    fs.unlinkSync(full);
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+let mainHourTag = currentHourTag();
+let mainStream = fs.createWriteStream(path.join(LOG_DIR, `evolclaw-${mainHourTag}.log`), { flags: 'a' });
+// 同时保留 evolclaw.log 软链接指向当前文件，方便 tail -f
+function updateSymlink() {
+    const link = path.join(LOG_DIR, 'evolclaw.log');
+    const target = `evolclaw-${mainHourTag}.log`;
+    try {
+        fs.unlinkSync(link);
+    }
+    catch { }
+    try {
+        fs.symlinkSync(target, link);
+    }
+    catch { }
+}
+updateSymlink();
+// 启动时清理一次，之后每小时清理
+cleanupOldLogs();
+const cleanupTimer = setInterval(cleanupOldLogs, HOUR_MS);
+cleanupTimer.unref?.();
+function rotateMainIfNeeded() {
+    const tag = currentHourTag();
+    if (tag === mainHourTag)
+        return;
+    mainStream.end();
+    mainHourTag = tag;
+    mainStream = fs.createWriteStream(path.join(LOG_DIR, `evolclaw-${mainHourTag}.log`), { flags: 'a' });
+    updateSymlink();
+    cleanupOldLogs();
+}
 const streams = {
-    main: fs.createWriteStream(path.join(LOG_DIR, 'evolclaw.log'), { flags: 'a' }),
     message: config.messageLog ? fs.createWriteStream(path.join(LOG_DIR, 'messages.log'), { flags: 'a' }) : null,
     event: config.eventLog ? fs.createWriteStream(path.join(LOG_DIR, 'events.log'), { flags: 'a' }) : null
 };
@@ -33,9 +88,10 @@ export function localTimestamp() {
 function log(level, ...args) {
     if (!shouldLog(level))
         return;
+    rotateMainIfNeeded();
     const timestamp = localTimestamp();
     const msg = `[${timestamp}] [${level}] ${args.join(' ')}`;
-    write(streams.main, msg);
+    mainStream.write(msg + '\n');
 }
 /**
  * 设置日志级别（config 加载后调用，覆盖环境变量默认值）

package/evolclaw-install-aun.md

@@ -46,23 +46,64 @@ export PATH=~/.npm-global/bin:$PATH
 npm install -g evolclaw
 ```
 
-### 步骤 3：准备配置信息
+### 步骤 3：检查是否已在运行
+
+npm 安装完成后，先检查是否有正在运行的 evolclaw 进程。升级或重装场景下，旧进程仍在使用旧版本代码，必须停止后才能让新版本生效。
+
+```bash
+evolclaw status
+```
+
+判断逻辑：
+
+- 输出包含 `running` / `PID` / `已启动` 等表明服务在运行 → **询问用户**是否停止：
+
+  > 检测到 evolclaw 正在运行（PID: xxx）。继续安装需要停止当前服务以应用新版本，是否停止？(y/N)
+
+  用户确认后执行：
+
+  ```bash
+  evolclaw stop
+  ```
+
+  用户拒绝则中止安装流程，提醒其手动 `evolclaw stop` 后重新发起。
+
+- 输出表明未运行（`not running` / `stopped` / 无 PID）→ 直接进入下一步。
+
+### 步骤 4：准备配置信息
 
 | 参数 | 说明 | 示例 |
 |------|------|------|
 | `--aun-aid` | **必填**，Agent 自身的 AID，作为 bot 在 AUN 网络上的独立身份 | `mybot.agentid.pub` |
 | `--aun-owner` | **必填**，Owner 的 AID，用于接收欢迎消息和管理权限 | `alice.agentid.pub` |
-| `--default-path` | 默认项目路径（可选，默认当前目录） | `/home/user/myproject` |
+| `--default-path` | 默认项目路径（bot 会话未显式 `/bind` 时使用的工作目录） | `/home/user/myproject` |
 
 **注意**：`--aun-aid` 和 `--aun-owner` 必须是不同的 AID。Agent 需要独立身份，不能与 Owner 相同。
 
 如果用户在触发安装时已提供 Owner AID（例如消息中包含"将 xxx 添加为 Owner ID"），直接使用该值，否则询问用户。Agent AID 必须单独询问用户，不能默认使用 Owner AID。
 
-### 步骤 4：非交互式初始化
+**默认项目路径必须询问用户，提供三个选项：**
+
+1. **推荐默认**：`~/projects/default`（EvolClaw 约定的默认工作区；若不存在会自动创建）
+2. **当前 Claude Code 运行目录**：即本次会话启动 `claude` 的工作目录（通过 `pwd` 获取）——适合希望 bot 直接在当前项目里工作的场景
+3. **自定义路径**：用户指定绝对路径（须是已存在的目录，或接受后自动创建）
+
+示例提问：
+
+> 请选择默认项目目录（bot 未显式 `/bind` 时使用的工作目录）：
+> 1) `~/projects/default`（推荐，EvolClaw 默认工作区）
+> 2) 当前目录：`<pwd 输出>`
+> 3) 自定义路径（请提供绝对路径）
+
+用户未选择时，默认取选项 1。选项 3 需校验路径是绝对路径；目录不存在则 `mkdir -p` 创建。
+
+### 步骤 5：非交互式初始化
+
+将用户选择的目录作为 `--default-path` 传入：
 
 ```bash
 evolclaw init --non-interactive \
-  --default-path "$PWD" \
+  --default-path <用户选择的绝对路径> \
   --channel aun \
   --aun-aid <AID> \
   --aun-owner <Owner AID>
@@ -76,7 +117,7 @@ evolclaw init --non-interactive \
 5. 写入初始 `agent.md`（`initialized: false`）
 6. 写入配置（含 owner 字段）
 
-### 步骤 5：启动前验证
+### 步骤 6：启动前验证
 
 读取配置文件确认关键字段：
 
@@ -92,13 +133,13 @@ cat ~/.evolclaw/data/evolclaw.json
 
 如发现缺失或异常，向用户说明并提供修复方案。
 
-### 步骤 6：启动服务
+### 步骤 7：启动服务
 
 ```bash
 evolclaw start
 ```
 
-### 步骤 7：验证运行状态
+### 步骤 8：验证运行状态
 
 ```bash
 evolclaw status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolclaw",
-  "version": "2.8.0",
+  "version": "2.8.1",
   "description": "Lightweight AI Agent gateway connecting Claude Agent SDK to messaging channels (Feishu, ACP) with multi-project session management",
   "type": "module",
   "main": "dist/index.js",