evolcore 0.0.32 → 0.0.33

package/dist/cli/daemon-commands.js

@@ -25,7 +25,7 @@ import { isNonAgentSessionChannel } from '../core/system-channels.js';
 import { printCodeStats } from './code-stats.js';
 import { getProcessStartTime, startTimeMatches } from '../utils/process-introspect.js';
 import { AGENT_DELEGATION_TOKEN_ENV, readDelegationCredential } from '../core/auth/agent-delegation.js';
-import { RUNTIME_HOME_ENV, WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.js';
+import { MAIN_CLI_BIN, RUNTIME_HOME_ENV, WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.js';
 import { rotateStdoutLog } from '../utils/log-writer.js';
 import { inspectDataMigrationRequirement } from '../core/data-migration.js';
 import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
@@ -34,8 +34,34 @@ import { listCodexAppServerProcesses, unregisterCodexAppServerProcess } from '..
 import { DEFAULT_ECWEB_PORT, ecwebService, setEcwebEnabled } from '../config/daemon-services.js';
 import { checkCodexProjectPath, inspectCodexManagedHook, ensureCodexManagedHook, runCodexHookLaunchDiagnostic, } from '../agents/codex/diagnostics.js';
 const execFileAsync = promisify(execFile);
+export async function confirmCodexHookRebind(state, packageRoot) {
+    console.log('⚠️ Codex 受管 Hook 绑定的另一套 EvolCore/Node 路径仍存在，需确认是否切换：');
+    console.log(`  现有包: ${state.managedPackageRoot}`);
+    console.log(`  现有 Node: ${state.managedNodePath}`);
+    console.log(`  当前包: ${packageRoot}`);
+    console.log(`  当前 Node: ${process.execPath}`);
+    console.log('  切换会更新机器级 Hook，影响共享此策略的 Codex 会话；不会执行数据迁移。');
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.warn(`  非交互模式不自动选择。请在交互式终端运行 ${MAIN_CLI_BIN} start 确认；也可使用现有安装的 CLI。`);
+        return false;
+    }
+    const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (confirmed) => {
+            if (settled)
+                return;
+            settled = true;
+            terminal.close();
+            resolve(confirmed);
+        };
+        terminal.once('close', () => finish(false));
+        terminal.once('SIGINT', () => finish(false));
+        terminal.question('  [1] 切换到当前包/Node 并修复  [2] 保留原绑定并取消本次启动 [1/2，默认 2]: ', answer => finish(answer.trim() === '1'));
+    });
+}
 /** Run before launch, and before restart stops any existing daemon. */
-export function ensureCodexHookBeforeLifecycle(onRepaired) {
+export async function ensureCodexHookBeforeLifecycle(onRepaired) {
     if (!platform.isWindows)
         return true;
     try {
@@ -53,19 +79,31 @@ export function ensureCodexHookBeforeLifecycle(onRepaired) {
             });
         if (!usesCodex)
             return true;
-        const result = ensureCodexManagedHook({
-            packageRoot: getPackageRoot(),
-            onInstallRequired: () => console.log('🔧 Codex 运行组件缺失，正在自动安装；Windows 提示管理员授权时请选择“是”。'),
+        const packageRoot = getPackageRoot();
+        const result = await ensureCodexManagedHook({
+            packageRoot,
+            repairDecision: state => confirmCodexHookRebind(state, packageRoot),
+            onInstallRequired: state => console.log(state.status === 'stale'
+                ? '🔧 Codex 受管 Hook 路径已过期，正在修复；Windows 提示管理员授权时请选择“是”。'
+                : '🔧 Codex 运行组件缺失，正在自动安装；Windows 提示管理员授权时请选择“是”。'),
         });
         if (result.status === 'installed') {
             if (result.repaired) {
-                console.log('✅ Codex Windows managed hook 已自动安装并验证');
+                console.log('✅ Codex Windows managed hook 已修复并验证');
                 onRepaired?.();
             }
             return true;
         }
-        console.error(`❌ Codex Windows managed hook 未就绪：${result.error || result.reason || result.status}`);
-        if (result.status === 'missing') {
+        if (result.cancelled) {
+            console.warn('ℹ 未确认切换 Codex 受管 Hook，保留原绑定；本次启动/重启已取消，现有服务未停止。');
+            process.exitCode = 1;
+            return false;
+        }
+        console.error(`❌ Codex Windows managed hook 启动检查未通过：${result.error || result.reason || result.status}`);
+        if (result.status === 'stale') {
+            console.error(`  本次操作已停止，现有服务未停止。请在交互式终端运行 ${MAIN_CLI_BIN} start 确认修复，或使用原安装的 CLI。`);
+        }
+        else if (result.status === 'missing') {
             console.error('  本次操作已停止。下次启动或重启会再次自动尝试安装，需要允许 Windows 管理员授权。');
         }
         else {
@@ -192,6 +230,7 @@ function buildDaemonEnv(p, opts) {
         EVENT_LOG: process.env.EVENT_LOG || 'true',
         ...(opts.diagnose ? { EVOLCORE_DIAGNOSE: '1' } : {}),
         ...(opts.bindBootstrap ? { EVOLCORE_BIND_BOOTSTRAP: '1' } : {}),
+        ...(opts.debug ? { EVOLCORE_DEBUG_MODE: '1' } : {}),
     };
 }
 function latestSourceMtime(dir) {
@@ -474,10 +513,10 @@ export async function cmdStart(opts = {}) {
     const existingDaemon = await probeDaemon(p.socket);
     if (existingDaemon) {
         let hookRepaired = false;
-        if (!ensureCodexHookBeforeLifecycle(() => { hookRepaired = true; }))
+        if (!await ensureCodexHookBeforeLifecycle(() => { hookRepaired = true; }))
             return;
         if (hookRepaired) {
-            console.log('🔄 Codex 运行组件已补齐，正在自动重启服务以加载策略...');
+            console.log('🔄 Codex 运行组件已修复，正在自动重启服务以加载策略...');
             await cmdRestart({ diagnose: opts.diagnose });
             return;
         }
@@ -524,7 +563,7 @@ export async function cmdStart(opts = {}) {
     // The initialization path can create the first Codex agent, so perform the
     // machine-hook check after config migration/auto-init and before any daemon
     // process is launched.
-    if (!ensureCodexHookBeforeLifecycle())
+    if (!await ensureCodexHookBeforeLifecycle())
         return;
     // 控制 AID 门禁：缺 aid 且交互式 → 只补全控制 AID + owners（不重走 baseagent 向导）。
     // 非 TTY（restart-monitor/systemd/管道）不补全（无法交互），只提示后继续启动，daemon 侧 warn 兜底。
@@ -666,6 +705,21 @@ export async function cmdStart(opts = {}) {
             console.log(`  EVOLCORE_HOME: ${resolveRoot()}`);
             console.log(`  Logs: ${p.logs}/`);
             console.log(`⏱ ready in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
+            if (opts.debug) {
+                console.log('');
+                console.log('🔧 调试模式已启用（EVOLCORE_DEBUG_MODE=1）');
+                console.log('  在宿主终端以任意 session 身份执行命令：');
+                console.log('');
+                console.log('    ec msg send "消息内容" --as-session <sessionId>');
+                console.log('    ec trigger list --as-session <sessionId>');
+                console.log('    ec memory list --as-session <sessionId>');
+                console.log('');
+                console.log('  查看可用会话（运行后将在此处列出）：');
+                console.log('    ec msg send "test" --as-session   # 不带 sessionId 自动列出');
+                console.log('');
+                console.log('  注意：重启 daemon（ec restart）会清除调试模式，');
+                console.log('        需重新执行 ec start --debug 才能恢复。');
+            }
             void waitForExistingEcweb(p).then((ecweb) => {
                 if (shouldPrintNoSelfAgentHints) {
                     printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: ecweb !== null, skipped });
@@ -769,6 +823,21 @@ export async function cmdStart(opts = {}) {
                 printCodeStats(getPackageRoot(), p.logs);
             }
             console.log(`⏱ done in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
+            if (opts.debug) {
+                console.log('');
+                console.log('🔧 调试模式已启用（EVOLCORE_DEBUG_MODE=1）');
+                console.log('  在宿主终端以任意 session 身份执行命令：');
+                console.log('');
+                console.log('    ec msg send "消息内容" --as-session <sessionId>');
+                console.log('    ec trigger list --as-session <sessionId>');
+                console.log('    ec memory list --as-session <sessionId>');
+                console.log('');
+                console.log('  查看可用会话（运行后将在此处列出）：');
+                console.log('    ec msg send "test" --as-session   # 不带 sessionId 自动列出');
+                console.log('');
+                console.log('  注意：重启 daemon（ec restart）会清除调试模式，');
+                console.log('        需重新执行 ec start --debug 才能恢复。');
+            }
             // ECWeb lifecycle belongs to the daemon; the CLI only reports whether
             // the supervised instance became healthy.
             const ecwebStarted = await waitForExistingEcweb(p) !== null;
@@ -904,7 +973,7 @@ export async function cmdStop() {
 export async function cmdRestart(opts = {}) {
     const cmdStartedAt = Date.now();
     console.log('🔄 Restarting EvolCore...');
-    if (!ensureCodexHookBeforeLifecycle())
+    if (!await ensureCodexHookBeforeLifecycle())
         return;
     const initialStatus = scanInstances();
     const socketPath = resolvePaths().socket;

package/dist/cli/debug-mode.js

@@ -0,0 +1,154 @@
+/**
+ * debug-mode.ts — `--as-session <sessionId>` 调试路径
+ *
+ * 在外部终端（宿主 CC 终端）以任意 agent 身份执行托管命令。
+ * 调用方在检查 EVOLCORE_SESSION_ID 之前先调用 resolveDebugContext(args)；
+ * 注入完成后 process.env.EVOLCORE_SESSION_ID 已设好，后续走统一托管路径。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, debugSessionsDir } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { buildTaskRuntimeEnv } from './task-context.js';
+const AS_SESSION_FLAG = '--as-session';
+function formatTimeAgo(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}秒前`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}分钟前`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}小时前`;
+    return `${Math.floor(h / 24)}天前`;
+}
+function listAvailableSessions() {
+    const dir = debugSessionsDir();
+    if (!fs.existsSync(dir))
+        return { sessions: [], dirExists: false };
+    try {
+        const sessions = fs.readdirSync(dir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null && !!s.sessionId)
+            .sort((a, b) => b.writtenAt - a.writtenAt)
+            .slice(0, 20);
+        return { sessions, dirExists: true };
+    }
+    catch {
+        return { sessions: [], dirExists: true };
+    }
+}
+function printSessionList(result) {
+    const { sessions, dirExists } = result;
+    if (!dirExists) {
+        console.error('❌ 调试模式未启用。请先执行：ec start --debug');
+        return;
+    }
+    if (sessions.length === 0) {
+        console.error('ℹ️  调试模式已启用，但暂无可用会话。');
+        console.error('   请等待 agent 收到至少一条消息后再试。');
+        return;
+    }
+    console.error('\n可用会话（最近 20 个）：');
+    for (const s of sessions) {
+        const age = formatTimeAgo(Date.now() - s.writtenAt);
+        console.error(`  ${s.sessionId}  ${s.selfAid} → ${s.channelId}  ${age}`);
+    }
+}
+/**
+ * 检测命令行参数中是否包含 --as-session，若有则执行调试路径：
+ * 1. 互斥检查（托管会话中拒绝）
+ * 2. 读临时文件
+ * 3. 调 debug-issue-token IPC 现取 token
+ * 4. 注入 process.env，后续命令走统一托管路径
+ *
+ * 不带 --as-session 时直接返回，不做任何事。
+ */
+export async function resolveDebugContext(args) {
+    const flagIdx = args.indexOf(AS_SESSION_FLAG);
+    if (flagIdx === -1)
+        return;
+    // 互斥检查：托管会话里不允许 --as-session
+    if (process.env.EVOLCORE_SESSION_ID) {
+        console.error('❌ --as-session 仅限外部终端使用，托管会话中不可用');
+        process.exit(1);
+    }
+    const sessionId = args[flagIdx + 1];
+    // 不带 sessionId 或 sessionId 以 - 开头（下一个 flag）
+    if (!sessionId || sessionId.startsWith('-')) {
+        console.error('❌ --as-session 需要指定 sessionId\n');
+        console.error(`使用：ec <命令> --as-session <sessionId>`);
+        printSessionList(listAvailableSessions());
+        process.exit(1);
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(sessionId)) {
+        console.error('❌ 无效 sessionId');
+        process.exit(1);
+    }
+    // 读临时文件（session bind 时已写入）
+    const snapshotPath = path.join(debugSessionsDir(), `${sessionId}.json`);
+    if (!fs.existsSync(snapshotPath)) {
+        const result = listAvailableSessions();
+        if (!result.dirExists) {
+            console.error('❌ 调试模式未启用。请先执行：ec start --debug');
+        }
+        else {
+            console.error(`❌ 调试会话不存在：${sessionId}\n`);
+            printSessionList(result);
+        }
+        process.exit(1);
+    }
+    // 调 debug-issue-token IPC 现取 token
+    let response;
+    try {
+        response = await ipcQuery(resolvePaths().socket, { type: 'debug-issue-token', sessionId }, 5000);
+    }
+    catch (err) {
+        console.error(`❌ 无法连接 daemon：${err instanceof Error ? err.message : String(err)}`);
+        console.error('请确认 daemon 正在以 debug 模式运行：ec start --debug');
+        process.exit(1);
+    }
+    if (!response) {
+        console.error('❌ daemon 无响应，请确认 daemon 正在以 debug 模式运行：ec start --debug');
+        process.exit(1);
+    }
+    if (!response.ok) {
+        console.error(`❌ 无法获取调试 token：${response.error}`);
+        process.exit(1);
+    }
+    const { token, runtimeContext } = response;
+    // 注入 process.env，后续代码走统一托管路径
+    // 注意：去掉 daemonRuntimeEpoch——debug session 不是真实任务，
+    // 不应该受 ipc.ts 里的 daemon epoch 检查约束，否则 msg send --thread 后续命令会报
+    // "The task delegation token belongs to a previous daemon runtime"
+    const ctxWithoutEpoch = { ...runtimeContext, daemonRuntimeEpoch: undefined };
+    Object.assign(process.env, buildTaskRuntimeEnv(ctxWithoutEpoch));
+    process.env[AGENT_DELEGATION_TOKEN_ENV] = token;
+    // thread 命令从 EVOLCORE_SELF_AID 读 selfAid（不走 taskRuntimeContext），单独注入
+    if (runtimeContext.selfAid)
+        process.env.EVOLCORE_SELF_AID = runtimeContext.selfAid;
+}
+/** 从 args 中去掉 --as-session <sessionId> 两个元素，返回净化后的参数列表 */
+export function stripAsSessionArgs(args) {
+    const result = [];
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === AS_SESSION_FLAG) {
+            i += 2; // 跳过 flag 和 sessionId
+        }
+        else {
+            result.push(args[i++]);
+        }
+    }
+    return result;
+}

package/dist/cli/handoff-command.js

@@ -162,6 +162,9 @@ export async function cmdHandoff(args) {
     if (!sub || isHelpFlag(sub) || wantsHelp(args)) {
         console.log(`用法: ec handoff <command> [args]
 
+⚠  ec handoff 已废弃，请改用话题链（ec thread + ec msg send --thread）。
+   本命令保留以兼容现有脚本，将在 P2 后续版本中移除。
+
 Commands:
   return [handoff-id] [content]       提交一个回流结果；required 可用同一 ID 追加多个结果
   return [handoff-id] --text-from-file <path>