evolcore 0.0.10 → 0.0.12

package/dist/cli/handoff-command.js

@@ -203,6 +203,7 @@ Commands:
         }
         const result = await ipcQuery(resolvePaths().socket, {
             type: 'handoff-status', sessionId: process.env.EVOLCORE_SESSION_ID, handoffId,
+            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -234,6 +235,7 @@ Commands:
             state: parsed.state,
             filterSessionId: parsed.sessionId,
             limit: parsed.limit,
+            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');
@@ -276,6 +278,7 @@ Commands:
             agent: parsed.agent,
             handoffId: parsed.handoffId,
             limit: parsed.limit,
+            delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
         }, 5000);
         if (!result) {
             console.error('✗ daemon 暂时不可用');

package/dist/cli/index.js

@@ -3,7 +3,9 @@
 process.env.AUN_LOG_INI_DISABLE = '1';
 import fs from 'fs';
 import path from 'path';
-import { getPackageRoot } from '../paths.js';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
 import { cmdInit } from './init.js';
 import { cmdInitWechat, cmdInitFeishu, cmdInitDingtalk, cmdInitQQBot, cmdInitWecom, cmdInitAun } from './init-channel.js';
 import { isHelpFlag, wantsHelp, getArgValue } from './help.js';
@@ -15,6 +17,8 @@ import { cmdCtl } from './ctl-command.js';
 import { cmdQueue } from './queue-command.js';
 import { cmdStart, cmdStop, cmdRestart, cmdStatus, cmdLogs, cmdWatchCommand, cmdMv, cmdDiagnose } from './daemon-commands.js';
 import { logCliCommand } from './command-log.js';
+import { isInitCancelledError, printInitCancelHint } from './init-cancel.js';
+import { assertManagedTopLevelCommandAllowed, ManagedCommandNotAllowedError } from './managed-command-guard.js';
 const MAIN_HELP = `用法: ec <command> [选项]
 
 服务:
@@ -86,6 +90,16 @@ process.on('warning', (w) => { if (w.name === 'ExperimentalWarning')
     return; process.stderr.write((w.stack ?? String(w)) + '\n'); });
 export async function main(args) {
     const cmd = args[0] || 'start';
+    try {
+        assertManagedTopLevelCommandAllowed(cmd, args);
+    }
+    catch (error) {
+        if (!(error instanceof ManagedCommandNotAllowedError))
+            throw error;
+        console.error(`❌ [${error.code}] ${error.message}`);
+        process.exitCode = 1;
+        return;
+    }
     logCliCommand(cmd, args);
     if (cmd === '--version' || cmd === '-v' || cmd === '-V') {
         const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
@@ -97,9 +111,10 @@ export async function main(args) {
         return;
     }
     switch (cmd) {
-        case 'init':
-            if (wantsHelp(args.slice(1))) {
-                console.log(`用法: ec init [渠道] [选项]
+        case 'init': {
+            try {
+                if (wantsHelp(args.slice(1))) {
+                    console.log(`用法: ec init [渠道] [选项]
 
 仅初始化 defaults.json:
   ec init                          交互式（写完 defaults.json 后嵌套 agent new）
@@ -119,72 +134,85 @@ export async function main(args) {
     --force                              已有不同 owner 时强制覆盖
 
 配置渠道（先 ec agent new 创建 agent）:
-  ec init aun           AUN owner 绑定（daemon 或指定 agent）
+  ec init aun           AUN owner 追加绑定（daemon 或指定 agent）
   ec init feishu        飞书扫码登录
   ec init wechat        微信扫码登录
   ec init dingtalk      钉钉扫码登录
   ec init qqbot         QQ 机器人扫码绑定
   ec init wecom         企业微信 AI Bot 扫码创建/手工配置`);
-            }
-            else if (args[1] === 'aun') {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                await cmdInitAun();
-            }
-            else if (args[1] === 'wechat') {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                await cmdInitWechat();
-            }
-            else if (args[1] === 'feishu') {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                await cmdInitFeishu();
-            }
-            else if (args[1] === 'dingtalk') {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                await cmdInitDingtalk();
-            }
-            else if (args[1] === 'qqbot') {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                await cmdInitQQBot();
-            }
-            else if (args[1] === 'wecom') {
-                await cmdInitWecom();
-            }
-            else if (args[1] && !args[1].startsWith('-')) {
-                const supported = ['feishu', 'wechat', 'aun', 'dingtalk', 'qqbot', 'wecom'];
-                console.error(`❌ 不支持的渠道: ${args[1]}`);
-                console.error(`   支持的渠道: ${supported.join(', ')}`);
-                process.exit(1);
-            }
-            else {
-                const { suppressSdkLogs } = await import('../aun/aid/index.js');
-                suppressSdkLogs();
-                const nonInteractive = args.includes('--non-interactive');
-                const wantsAutoStart = args.includes('--auto-start');
-                const wantsNoAutoStart = args.includes('--no-auto-start');
-                if (wantsAutoStart && wantsNoAutoStart) {
-                    console.error('❌ --auto-start 与 --no-auto-start 不能同时使用');
-                    process.exitCode = 1;
-                    break;
                 }
-                const initialized = await cmdInit({
-                    nonInteractive,
-                    baseagent: getArgValue(args, '--baseagent'),
-                    force: args.includes('--force'),
-                    owner: getArgValue(args, '--owner'),
-                    projectpath: getArgValue(args, '--projectpath'),
-                    ecweb: args.includes('--ecweb') ? true : undefined,
-                    format: getArgValue(args, '--format'),
-                    autoStart: wantsAutoStart ? true : wantsNoAutoStart ? false : undefined,
-                });
-                if (!initialized)
-                    process.exitCode = 1;
+                else {
+                    const hasChannelTarget = Boolean(args[1] && !args[1].startsWith('-'));
+                    if (hasChannelTarget)
+                        printInitCancelHint();
+                    if (args[1] === 'aun') {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        await cmdInitAun();
+                    }
+                    else if (args[1] === 'wechat') {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        await cmdInitWechat();
+                    }
+                    else if (args[1] === 'feishu') {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        await cmdInitFeishu();
+                    }
+                    else if (args[1] === 'dingtalk') {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        await cmdInitDingtalk();
+                    }
+                    else if (args[1] === 'qqbot') {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        await cmdInitQQBot();
+                    }
+                    else if (args[1] === 'wecom') {
+                        await cmdInitWecom();
+                    }
+                    else if (args[1] && !args[1].startsWith('-')) {
+                        const supported = ['feishu', 'wechat', 'aun', 'dingtalk', 'qqbot', 'wecom'];
+                        console.error(`❌ 不支持的渠道: ${args[1]}`);
+                        console.error(`   支持的渠道: ${supported.join(', ')}`);
+                        process.exit(1);
+                    }
+                    else {
+                        const { suppressSdkLogs } = await import('../aun/aid/index.js');
+                        suppressSdkLogs();
+                        const nonInteractive = args.includes('--non-interactive');
+                        const wantsAutoStart = args.includes('--auto-start');
+                        const wantsNoAutoStart = args.includes('--no-auto-start');
+                        if (wantsAutoStart && wantsNoAutoStart) {
+                            console.error('❌ --auto-start 与 --no-auto-start 不能同时使用');
+                            process.exitCode = 1;
+                            break;
+                        }
+                        const initialized = await cmdInit({
+                            nonInteractive,
+                            baseagent: getArgValue(args, '--baseagent'),
+                            force: args.includes('--force'),
+                            owner: getArgValue(args, '--owner'),
+                            projectpath: getArgValue(args, '--projectpath'),
+                            ecweb: args.includes('--ecweb') ? true : undefined,
+                            format: getArgValue(args, '--format'),
+                            autoStart: wantsAutoStart ? true : wantsNoAutoStart ? false : undefined,
+                        });
+                        if (!initialized && process.exitCode == null)
+                            process.exitCode = 1;
+                    }
+                }
+            }
+            catch (error) {
+                if (!isInitCancelledError(error))
+                    throw error;
+                console.log('\n已退出初始化');
+                process.exitCode = 130;
             }
             break;
+        }
         case 'start':
             if (wantsHelp(args.slice(1))) {
                 printLifecycleHelp('start');
@@ -214,7 +242,22 @@ export async function main(args) {
                 printLifecycleHelp('status');
                 break;
             }
-            await cmdStatus();
+            if (process.env.EVOLCORE_SESSION_ID) {
+                const sessionId = process.env.EVOLCORE_SESSION_ID;
+                const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+                const result = await ipcQuery(resolvePaths().socket, {
+                    type: 'status.auth', sessionId, delegationToken,
+                });
+                if (!result?.ok) {
+                    console.error(`❌ ${result?.error || 'status is not allowed in this task'}`);
+                    process.exitCode = 1;
+                    break;
+                }
+                await cmdStatus();
+            }
+            else {
+                await cmdStatus();
+            }
             break;
         case 'logs':
             if (wantsHelp(args.slice(1))) {

package/dist/cli/init-cancel.js

@@ -0,0 +1,208 @@
+import { setupRawKeyListener } from './raw-key-input.js';
+const ESC = '\u001b';
+const ANSI_SEQUENCE_TIMEOUT_MS = 40;
+export const INIT_DOUBLE_ESCAPE_WINDOW_MS = 500;
+export class InitCancelledError extends Error {
+    constructor() {
+        super('EvolCore init cancelled');
+        this.name = 'InitCancelledError';
+    }
+}
+export function isInitCancelledError(error) {
+    return error instanceof InitCancelledError || (error instanceof Error && error.name === 'InitCancelledError');
+}
+export function printInitCancelHint() {
+    if (process.stdin.isTTY) {
+        console.log('提示：任意步骤连续按两次 Esc 退出（Ctrl+C 也可退出）\n');
+    }
+}
+function isAnsiFinalByte(char) {
+    const code = char.charCodeAt(0);
+    return code >= 0x40 && code <= 0x7e;
+}
+/**
+ * Detect two standalone Escape presses without treating arrow/function-key
+ * escape sequences as Escape presses.
+ */
+export function createDoubleEscapeDetector(onDoubleEscape, windowMs = INIT_DOUBLE_ESCAPE_WINDOW_MS) {
+    let pendingBareEscape = false;
+    let pendingTimer;
+    let lastBareEscapeAt = 0;
+    let ansiSequence = '';
+    let disposed = false;
+    let triggered = false;
+    const clearPending = () => {
+        if (pendingTimer)
+            clearTimeout(pendingTimer);
+        pendingTimer = undefined;
+        pendingBareEscape = false;
+    };
+    const registerBareEscape = () => {
+        if (disposed || triggered)
+            return;
+        const now = Date.now();
+        if (lastBareEscapeAt > 0 && now - lastBareEscapeAt <= windowMs) {
+            lastBareEscapeAt = 0;
+            triggered = true;
+            onDoubleEscape();
+            return;
+        }
+        lastBareEscapeAt = now;
+    };
+    const scheduleBareEscape = () => {
+        clearPending();
+        pendingBareEscape = true;
+        pendingTimer = setTimeout(() => {
+            pendingTimer = undefined;
+            pendingBareEscape = false;
+            registerBareEscape();
+        }, ANSI_SEQUENCE_TIMEOUT_MS);
+    };
+    const handle = (chunk) => {
+        if (disposed)
+            return;
+        const text = String(chunk);
+        for (let index = 0; index < text.length; index++) {
+            const char = text[index];
+            if (ansiSequence) {
+                lastBareEscapeAt = 0;
+                ansiSequence += char;
+                if (ansiSequence.length === 2 && ansiSequence[1] !== '[' && ansiSequence[1] !== 'O') {
+                    ansiSequence = '';
+                }
+                else if (ansiSequence.length >= 2 && isAnsiFinalByte(char)) {
+                    ansiSequence = '';
+                }
+                continue;
+            }
+            if (pendingBareEscape) {
+                clearPending();
+                if (char === ESC) {
+                    registerBareEscape();
+                    registerBareEscape();
+                }
+                else if (char === '[' || char === 'O') {
+                    lastBareEscapeAt = 0;
+                    ansiSequence = `${ESC}${char}`;
+                }
+                else {
+                    lastBareEscapeAt = 0;
+                }
+                continue;
+            }
+            if (char !== ESC) {
+                lastBareEscapeAt = 0;
+                continue;
+            }
+            const next = text[index + 1];
+            if (next === ESC) {
+                registerBareEscape();
+                registerBareEscape();
+                index++;
+            }
+            else if (next === '[' || next === 'O') {
+                lastBareEscapeAt = 0;
+                ansiSequence = `${ESC}${next}`;
+                index++;
+            }
+            else if (next !== undefined) {
+                lastBareEscapeAt = 0;
+                index++;
+            }
+            else {
+                scheduleBareEscape();
+            }
+        }
+    };
+    return {
+        handle,
+        dispose: () => {
+            disposed = true;
+            clearPending();
+            ansiSequence = '';
+        },
+    };
+}
+export function setupDoubleEscapeListener(onDoubleEscape, input = process.stdin) {
+    if (!input || typeof input.on !== 'function' || typeof input.removeListener !== 'function')
+        return () => { };
+    const detector = createDoubleEscapeDetector(onDoubleEscape);
+    const handler = (chunk) => detector.handle(chunk);
+    input.on('data', handler);
+    return () => {
+        input.removeListener('data', handler);
+        detector.dispose();
+    };
+}
+export function setupInitRawKeyListener(onKey, onDoubleEscape, input = process.stdin) {
+    const detector = createDoubleEscapeDetector(onDoubleEscape);
+    const cleanupRaw = setupRawKeyListener(key => {
+        detector.handle(key);
+        onKey(key);
+    }, input);
+    return () => {
+        cleanupRaw();
+        detector.dispose();
+    };
+}
+/** readline.question with the shared double-Escape cancellation behavior. */
+export function askInit(rl, question) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const input = rl.input;
+        let cleanupInput = () => { };
+        const cleanup = () => {
+            cleanupInput();
+            rl.removeListener('SIGINT', cancel);
+        };
+        const cancel = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            try {
+                rl.close();
+            }
+            catch { /* ignore */ }
+            try {
+                input?.pause?.();
+            }
+            catch { /* ignore */ }
+            reject(new InitCancelledError());
+        };
+        cleanupInput = setupDoubleEscapeListener(cancel, input);
+        rl.once('SIGINT', cancel);
+        try {
+            rl.question(question, answer => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(answer);
+            });
+        }
+        catch (error) {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                reject(error);
+            }
+        }
+    });
+}
+export function waitForInitDelay(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(new InitCancelledError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            reject(new InitCancelledError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}