evolcore 0.0.16 → 0.0.18

package/dist/ipc.js

@@ -1,9 +1,11 @@
 import net from 'net';
+import { performance } from 'node:perf_hooks';
 import fs from 'fs';
 import crypto from 'crypto';
 import os from 'os';
 import path from 'path';
 import { logger } from './utils/logger.js';
+import { withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived } from './core/command/menu-protocol.js';
 import { fileCache } from './core/daemon-file-cache.js';
 import { HANDOFF_QUERY_MAX_LIMIT, HANDOFF_STATES } from './core/handoff/types.js';
 import { AgentReloadBusyError } from './core/agent-reload-coordinator.js';
@@ -27,11 +29,14 @@ const LOCAL_CONTROL_COMMANDS = new Set([
     'wechat.contact-bind.register',
     'queue-snapshot',
     'aun-aid-stats-record-outbound',
+    'evolagent.list',
+    'evolagent.show',
     'evolagent.reload',
     'evolagent.load',
     'evolagent.resync',
     'menu.exec',
     'monitor-snapshot',
+    'shutdown',
 ]);
 function requiresLocalControlToken(cmd) {
     // Managed bootstrap completion is authenticated by the session delegation
@@ -61,6 +66,7 @@ export class IpcServer {
     aunAidStatsProvider;
     aunAidStatsRecorder;
     menuExecutor;
+    agentOperationExecutor;
     statsProvider;
     agentStatsProvider;
     queueSnapshotProvider;
@@ -71,6 +77,7 @@ export class IpcServer {
     triggerExecutor;
     bootstrapCompleteExecutor;
     agentReloadExecutor;
+    shutdownExecutor;
     taskRuntimeContextProvider;
     codexPreToolUseExecutor;
     aunMsgSender;
@@ -121,6 +128,9 @@ export class IpcServer {
     setMenuExecutor(executor) {
         this.menuExecutor = executor;
     }
+    setAgentOperationExecutor(executor) {
+        this.agentOperationExecutor = executor;
+    }
     setConfigOperationExecutor(executor) {
         this.configOperationExecutor = executor;
     }
@@ -142,6 +152,10 @@ export class IpcServer {
     setAgentReloadExecutor(executor) {
         this.agentReloadExecutor = executor;
     }
+    /** Inject the daemon's graceful shutdown lifecycle for local stop/restart. */
+    setShutdownExecutor(executor) {
+        this.shutdownExecutor = executor;
+    }
     /** Inject AUN AID state aggregator for aun-aids IPC handler */
     setAunAidProvider(provider) {
         this.aunAidProvider = provider;
@@ -332,23 +346,31 @@ export class IpcServer {
         return new Promise((resolve, reject) => {
             this.server = net.createServer((conn) => {
                 let buf = '';
+                let handled = false;
+                let requestReceivedAtMono;
+                const requestAbort = new AbortController();
                 conn.on('data', async (data) => {
+                    if (handled)
+                        return;
+                    requestReceivedAtMono ??= performance.now();
                     buf += data.toString();
                     // Simple newline-delimited JSON protocol
                     const idx = buf.indexOf('\n');
                     if (idx === -1)
                         return;
+                    handled = true;
                     const line = buf.slice(0, idx);
                     buf = buf.slice(idx + 1);
                     try {
                         const cmd = JSON.parse(line);
-                        const response = await this.handleCommand(cmd);
+                        const response = await this.handleCommand(cmd, requestAbort.signal, requestReceivedAtMono);
                         conn.end(JSON.stringify(response) + '\n');
                     }
                     catch {
                         conn.end(JSON.stringify({ error: 'invalid request' }) + '\n');
                     }
                 });
+                conn.on('close', () => requestAbort.abort('Codex hook client disconnected'));
                 conn.on('error', () => { }); // ignore client errors
             });
             const onListenError = (err) => {
@@ -385,7 +407,7 @@ export class IpcServer {
             catch { }
         }
     }
-    async handleCommand(cmd) {
+    async handleCommand(cmd, requestSignal, receivedAtMono = performance.now()) {
         if (requiresLocalControlToken(cmd) && !this.hasValidControlToken(cmd.controlToken)) {
             return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
         }
@@ -405,6 +427,7 @@ export class IpcServer {
                         threadId: cmd.threadId,
                         toolName: cmd.toolName,
                         toolInput: cmd.toolInput,
+                        signal: requestSignal,
                     });
                 }
                 catch (error) {
@@ -413,6 +436,23 @@ export class IpcServer {
             }
             case 'ping':
                 return { pong: true, pid: process.pid, protocolVersion: 1 };
+            case 'shutdown': {
+                if (!this.shutdownExecutor)
+                    return { ok: false, error: 'shutdown executor not configured' };
+                if (Number.isInteger(cmd.expectedPid) && cmd.expectedPid !== process.pid) {
+                    return { ok: false, code: 'PID_MISMATCH', error: 'daemon pid changed before shutdown request' };
+                }
+                const reason = typeof cmd.reason === 'string' && cmd.reason.trim()
+                    ? cmd.reason.trim().slice(0, 80)
+                    : 'ipc';
+                // Let the response flush before shutdown closes the IPC server/process.
+                setImmediate(() => {
+                    Promise.resolve(this.shutdownExecutor?.(reason)).catch(error => {
+                        logger.error(`[IPC] graceful shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                });
+                return { ok: true, accepted: true, pid: process.pid };
+            }
             case 'bind.begin': {
                 if (!this.bindExecutor)
                     return { ok: false, error: 'bind executor not configured' };
@@ -833,6 +873,18 @@ export class IpcServer {
                 }
                 return await this.fsOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'agent.op': {
+                if (!this.agentOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'agent.op not configured' };
+                const { argv, sessionId, delegationToken } = cmd;
+                if (!Array.isArray(argv) || argv.some(value => typeof value !== 'string') || !sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                return await this.agentOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
             case 'trigger.list':
             case 'trigger.show':
             case 'trigger.history':
@@ -944,17 +996,36 @@ export class IpcServer {
                 }
             }
             case 'menu.exec': {
-                if (!this.menuExecutor)
+                const request = cmd.payload && typeof cmd.payload === 'object' && !Array.isArray(cmd.payload)
+                    ? cmd.payload
+                    : { type: 'menu.invalid' };
+                const flowContext = {
+                    source: 'ecweb-ipc',
+                };
+                logMenuRequestReceived(request, flowContext);
+                if (!this.menuExecutor) {
+                    logMenuRequestCompleted(request, undefined, flowContext, {
+                        delivery: 'dropped',
+                        reason: 'menu-executor-not-configured',
+                    });
                     return { ok: false, error: 'menu.exec not configured' };
+                }
                 try {
                     const response = await this.menuExecutor(cmd.payload, {
                         source: 'ecweb',
                         actorAid: null,
                         localDirect: true,
                     });
-                    return { ok: true, response };
+                    const timedResponse = withMenuProcessingTime(response, { receivedAtMono });
+                    logMenuRequestCompleted(request, timedResponse, flowContext, { delivery: 'returned' });
+                    return { ok: true, response: timedResponse };
                 }
                 catch (e) {
+                    logMenuRequestCompleted(request, undefined, flowContext, {
+                        delivery: 'failed',
+                        reason: 'handler-error',
+                        transportError: e,
+                    });
                     return { ok: false, error: e?.message ?? String(e) };
                 }
             }

package/dist/utils/atomic-write.js

@@ -1,9 +1,9 @@
 /**
- * Atomic write via dual rename.
+ * Atomic write with a hot backup.
  *
  * 写入流程（写 foo.json）：
- *   1. 把当前 foo.json 改名为 foo.json_   （保留旧版作为热备）
- *   2. 把新内容写到 foo.json__            （写入完成才有完整内容）
+ *   1. 把新内容写到 foo.json__            （写入完成才有完整内容）
+ *   2. 保留当前 foo.json 为 foo.json_      （不移走正式文件）
  *   3. 把 foo.json__ rename 为 foo.json   （原子切换）
  *   foo.json_ 留到下次写入时被覆盖。
  *
@@ -17,8 +17,32 @@ import fs from 'fs';
 import path from 'path';
 const HOT = '_'; // foo.json_   旧版热备
 const TMP = '__'; // foo.json__  写入中
+const HOT_BACKUP_FALLBACK_CODES = new Set(['EACCES', 'ENOSYS', 'ENOTSUP', 'EPERM', 'EXDEV']);
+/** Preserve the previous version without making the live path disappear. */
+function refreshHotBackup(filePath, hotPath) {
+    const backupTmp = `${hotPath}.${process.pid}.tmp`;
+    try {
+        fs.rmSync(backupTmp, { force: true });
+        try {
+            // A hard link is exact and avoids copying large protected state files.
+            fs.linkSync(filePath, backupTmp);
+        }
+        catch (error) {
+            const code = error.code;
+            if (!HOT_BACKUP_FALLBACK_CODES.has(code ?? ''))
+                throw error;
+            fs.copyFileSync(filePath, backupTmp);
+        }
+        // The live target remains untouched until the new file is ready.
+        fs.rmSync(hotPath, { force: true });
+        fs.renameSync(backupTmp, hotPath);
+    }
+    finally {
+        fs.rmSync(backupTmp, { force: true });
+    }
+}
 /**
- * 原子写入 JSON 文件（双 rename）。dirname 不存在时会自动创建。
+ * 原子写入 JSON 文件（临时文件 + 热备）。dirname 不存在时会自动创建。
  *
  * @param filePath 目标文件
  * @param content 完整内容（不含末尾换行也可，由调用方控制）
@@ -27,15 +51,25 @@ export function atomicWrite(filePath, content) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const hot = filePath + HOT;
     const tmp = filePath + TMP;
-    // 步骤 1：当前文件 → hot（保留旧版作热备）
+    // Write the complete new version before changing either the live target or
+    // its backup. This keeps the live path present throughout the update, which
+    // matters to readers that project protected files into a sandbox.
+    fs.writeFileSync(tmp, content, 'utf-8');
+    // Preserve the old version while leaving the live target in place. A writer
+    // in another process may remove the target between existsSync and linkSync;
+    // in that case the new version still replaces it below and the old backup is
+    // simply unavailable for this write.
     if (fs.existsSync(filePath)) {
-        if (fs.existsSync(hot))
-            fs.unlinkSync(hot);
-        fs.renameSync(filePath, hot);
+        try {
+            refreshHotBackup(filePath, hot);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
     }
-    // 步骤 2：写到 tmp
-    fs.writeFileSync(tmp, content, 'utf-8');
-    // 步骤 3：tmp → 目标（原子）
+    // The final rename atomically replaces the old target without an absent-path
+    // window.
     fs.renameSync(tmp, filePath);
 }
 export function atomicWriteJson(filePath, value) {

package/dist/utils/error-utils.js

@@ -3,6 +3,32 @@ import path from 'path';
 import { getPackageRoot, resolvePaths } from '../paths.js';
 import { logger } from './logger.js';
 import { isSandboxInitializationFailure } from '../core/permission/sandbox-runtime.js';
+export const CLAUDE_STARTUP_ARGUMENTS_TOO_LONG = 'claude_startup_arguments_too_long';
+/** Identify a Claude process-start failure without treating ordinary tool errors as startup failures. */
+export function isClaudeStartupArgumentsTooLong(error) {
+    const code = error && typeof error === 'object' && 'code' in error
+        ? String(error.code ?? '')
+        : '';
+    const message = error && typeof error === 'object' && 'message' in error
+        ? String(error.message ?? '')
+        : String(error ?? '');
+    const text = `${code}\n${message}`.toLowerCase();
+    return text.includes(CLAUDE_STARTUP_ARGUMENTS_TOO_LONG)
+        || text.includes('enametoolong')
+        || text.includes('e2big')
+        || text.includes('argument list too long')
+        || text.includes('command line too long');
+}
+export function createClaudeStartupArgumentsTooLongError(error) {
+    const wrapped = new Error(`${CLAUDE_STARTUP_ARGUMENTS_TOO_LONG}: Claude 启动参数过长，任务未执行`);
+    wrapped.name = 'ClaudeStartupArgumentsTooLongError';
+    wrapped.code = CLAUDE_STARTUP_ARGUMENTS_TOO_LONG;
+    // Keep the original error available to diagnostics without echoing argv,
+    // settings contents, or absolute paths to users.
+    if (error !== undefined)
+        wrapped.cause = error;
+    return wrapped;
+}
 export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
@@ -13,6 +39,7 @@ export var ErrorType;
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
     ErrorType["MODEL_UNAVAILABLE"] = "model_unavailable";
     ErrorType["SANDBOX_INITIALIZATION_FAILED"] = "sandbox_initialization_failed";
+    ErrorType["CLAUDE_STARTUP_ARGUMENTS_TOO_LONG"] = "claude_startup_arguments_too_long";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
 /**
@@ -251,6 +278,11 @@ function hasRetryableHttpStatus(text) {
 }
 export function classifyError(error) {
     const msg = (error?.message || '').toLowerCase();
+    // Startup-size failures are deterministic local failures and must win over
+    // dictionary rules that would otherwise turn them into generic retries.
+    if (isClaudeStartupArgumentsTooLong(error)) {
+        return ErrorType.CLAUDE_STARTUP_ARGUMENTS_TOO_LONG;
+    }
     // 字典优先 — 命中则直接返回
     const rule = matchErrorRule(msg);
     if (rule) {
@@ -314,6 +346,10 @@ export function isRetryableError(error) {
     return false;
 }
 export function getErrorMessage(error, terminalReason, includeEmoji = true) {
+    if (isClaudeStartupArgumentsTooLong(error)) {
+        const prefix = includeEmoji ? '⚠️ ' : '';
+        return `${prefix}当前 Claude 启动参数过长，任务未执行`;
+    }
     // terminalReason 提供更精确的错误提示（SDK 0.2.100+）
     if (terminalReason) {
         const prefix = includeEmoji ? '❌ ' : '';
@@ -335,6 +371,8 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
                 return `${prefix}权限被拒绝，操作已取消`;
             case 'sandbox_initialization_failed':
                 return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+            case 'claude_startup_arguments_too_long':
+                return `${warnPrefix}当前 Claude 启动参数过长，任务未执行`;
             case 'aborted_streaming':
             case 'aborted_tools':
                 return `${prefix}任务已中断`;

package/dist/utils/logger.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import { resolvePaths } from '../paths.js';
 import { LogWriter } from './log-writer.js';
 import { classifyToolErrorCode } from '../core/permission/tool-error-code.js';
+import { buildToolLifecycleEventKey } from '../core/audit/event-key.js';
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
 const config = {
@@ -14,6 +15,7 @@ function closeWriters(current) {
     current.main.close();
     current.message?.close();
     current.event?.close();
+    current.menu.close();
     current.channelIn.close();
     current.channelOut.close();
 }
@@ -32,6 +34,7 @@ function getWriters() {
         event: config.eventLog
             ? new LogWriter({ baseName: 'events', logDir, rotation: 'hourly', retention: { hours: 48 } })
             : null,
+        menu: new LogWriter({ baseName: 'menu-protocol', logDir, rotation: 'hourly', retention: { hours: 48 } }),
         channelIn: new LogWriter({ baseName: 'channel-in', logDir, rotation: 'hourly', retention: { hours: 48 } }),
         channelOut: new LogWriter({ baseName: 'channel-out', logDir, rotation: 'hourly', retention: { hours: 48 } }),
     };
@@ -48,6 +51,8 @@ export function normalizeStructuredLog(data) {
         return data;
     const nested = data.event && typeof data.event === 'object' ? data.event : undefined;
     const eventType = data.type ?? nested?.type;
+    const eventKey = data.eventKey ?? data.event_key ?? nested?.eventKey ?? nested?.event_key;
+    const eventPhase = data.eventPhase ?? data.event_phase ?? nested?.eventPhase ?? nested?.event_phase;
     const correlationId = data.correlationId
         ?? data.correlation_id
         ?? data.callId
@@ -80,6 +85,11 @@ export function normalizeStructuredLog(data) {
         ?? (isToolResult && isError === false ? 'allow' : undefined)
         ?? (isToolUse ? 'started' : undefined)
         ?? nested?.decision;
+    const executed = data.executed ?? nested?.executed
+        ?? (isToolResult ? true : isToolUse ? false : undefined);
+    const executionState = data.executionState ?? data.execution_state
+        ?? nested?.executionState ?? nested?.execution_state
+        ?? (isToolResult ? (isError === true ? 'failed' : 'completed') : isToolUse ? 'requested' : undefined);
     const explicitErrorCode = data.errorCode
         ?? data.error_code
         ?? nested?.errorCode
@@ -88,17 +98,29 @@ export function normalizeStructuredLog(data) {
         ? classifyToolErrorCode({ errorCode: explicitErrorCode, error, result })
         : explicitErrorCode;
     const lifecycleRecord = isToolUse || isToolResult;
+    const lifecycleEventKey = lifecycleRecord
+        ? (eventKey ?? buildToolLifecycleEventKey({
+            sessionId,
+            callId: data.callId ?? data.call_id ?? data.toolUseId ?? data.tool_use_id ?? nested?.callId ?? nested?.call_id,
+            correlationId: data.correlationId ?? data.correlation_id ?? nested?.correlationId ?? nested?.correlation_id,
+            requestId: data.requestId ?? data.request_id ?? nested?.requestId ?? nested?.request_id,
+        }))
+        : undefined;
     const missingContextFields = lifecycleRecord
         ? ['sessionId', 'agentAid', 'permissionMode'].filter(field => ({ sessionId, agentAid, permissionMode }[field] == null))
         : [];
     return {
         ...data,
+        ...(lifecycleEventKey ? { eventKey: lifecycleEventKey } : {}),
+        ...(eventPhase ? { eventPhase } : {}),
         ...(correlationId ? { correlationId } : {}),
         ...(sessionId ? { sessionId } : lifecycleRecord ? { sessionId: 'unknown' } : {}),
         ...(agentAid ? { agentAid } : lifecycleRecord ? { agentAid: 'unknown' } : {}),
         ...(permissionMode ? { permissionMode } : lifecycleRecord ? { permissionMode: 'unknown' } : {}),
         ...(toolName ? { toolName } : {}),
         ...(decision ? { decision } : {}),
+        ...(executed !== undefined ? { executed } : {}),
+        ...(executionState ? { executionState } : {}),
         ...(errorCode ? { errorCode } : {}),
         ...(missingContextFields.length > 0 ? { contextMissing: missingContextFields } : {}),
     };
@@ -144,6 +166,11 @@ export const logger = {
             return;
         writer.write(JSON.stringify({ ts: localTimestamp(), ...normalizeStructuredLog(data) }));
     },
+    menu: (data) => {
+        // Menu has a deliberately compact domain schema. Do not expand it with
+        // channel/tool lifecycle aliases used by the generic structured streams.
+        getWriters().menu.write(JSON.stringify({ ts: localTimestamp(), ...data }));
+    },
     channelIn: (data) => {
         getWriters().channelIn.write(JSON.stringify({ ts: localTimestamp(), ...normalizeStructuredLog(data) }));
     },