evolclaw 2.8.2 → 3.0.0

package/dist/core/message/message-queue.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { logger } from '../../utils/logger.js';
-const DEFAULT_AGENT_NAME = '[default]';
+const DEFAULT_AGENT_NAME = '<unknown>';
 export class MessageQueue {
     queues = new Map();
     processing = new Set();
@@ -92,13 +92,13 @@ export class MessageQueue {
                     // 单聊：保留中断行为
                     logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt`);
                     this.eventBus?.publish({
-                        type: 'message:interrupted',
+                        type: 'task:interrupted',
                         sessionId: sessionKey,
                         reason: 'new_message',
                         agentName: this.processingAgent.get(queueKey),
                     });
                     if (this.interruptCallback) {
-                        this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
+                        this.interruptCallback(sessionKey, this.currentAgentId, this.processingAgent.get(queueKey)).catch(() => { });
                     }
                 }
                 else {
@@ -276,13 +276,13 @@ export class MessageQueue {
         const sessionKey = this.currentSessionKey.split('::')[0];
         logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
         this.eventBus?.publish({
-            type: 'message:interrupted',
+            type: 'task:interrupted',
             sessionId: sessionKey,
             reason: 'recalled',
             agentName: this.processingAgent.get(this.currentSessionKey),
         });
         if (this.interruptCallback) {
-            this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
+            this.interruptCallback(sessionKey, this.currentAgentId, this.processingAgent.get(this.currentSessionKey)).catch(() => { });
         }
         return true;
     }

package/dist/core/permission.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import { renderActionAsText } from './interaction-router.js';
+import { buildEnvelope, sendInteractionPayload } from './message/message-processor.js';
 // 危险命令黑名单（正则表达式）
 const DANGEROUS_PATTERNS = [
     // Unix
@@ -192,29 +194,40 @@ export class PermissionGateway {
             },
             channelId: context?.channelId || '',
             sessionId,
+            initiatorId: context?.userId,
+            fallback: { command: 'perm' },
         };
-        // 尝试富交互
+        // 尝试富交互（走统一 adapter.send 入口）
         let interactionSent = false;
-        if (context?.adapter?.sendInteraction && context.channelId) {
+        if (context?.adapter && context.channelId) {
             try {
-                const result = await context.adapter.sendInteraction(context.channelId, interaction, context.replyContext);
+                const envelope = buildEnvelope({
+                    taskId: context.taskId,
+                    channel: context.channel ?? context.adapter.channelName,
+                    channelId: context.channelId,
+                    agentName: context.agentName,
+                    chatmode: context.chatmode,
+                    replyContext: context.replyContext,
+                });
+                const fallbackText = `🔐 权限请求 - ${toolName}\n${displaySummary}${reasonLine}\n回复 /perm allow 同意 / /perm always 始终允许 / /perm deny 拒绝`;
+                const result = await sendInteractionPayload(context.adapter, envelope, interaction, fallbackText, context.replyContext);
                 interactionSent = !!result;
             }
             catch (err) {
-                // sendInteraction 失败，fallback 到文本
+                // sendInteractionPayload 已内部捕获，但保险起见再 try/catch
             }
         }
         // fallback 到文本
         if (!interactionSent) {
-            await sendPrompt(`🔐 权限请求\n工具：${toolName}\n操作：${displaySummary}${reasonLine}\n\n回复 /perm allow 本次允许 | always 始终允许 | deny 拒绝`);
+            await sendPrompt(renderActionAsText(interaction));
         }
         return new Promise((resolve) => {
             this.pending.set(requestId, { sessionId, toolName, resolve, timer: setTimeout(() => { }, 0) });
-            // 如果发了交互卡片，同时注册到 InteractionRouter
-            if (interactionSent && context?.interactionRouter) {
+            // 注册到 InteractionRouter（卡片和文本降级都注册，统一路由）
+            if (context?.interactionRouter) {
                 context.interactionRouter.register(requestId, sessionId, (action) => {
                     this.resolvePermission(sessionId, requestId, action);
-                });
+                }, { initiatorId: context?.userId, fallbackCommand: 'perm' });
             }
         });
     }

package/dist/core/session/adapters/codex-session-file-adapter.js

@@ -3,12 +3,31 @@
  *
  * Reads Codex thread data from ~/.codex/state_*.sqlite (read-only)
  * and Codex rollout JSONL files for detailed session info.
+ *
+ * `node:sqlite` 是 Node 22.5+ 的实验性内置模块。低版本 Node 上懒加载会失败，
+ * adapter 自动降级到只读 rollout JSONL —— `checkExists/getFileInfo/readFirstMessage/
+ * readLastUserMessage` 仍可工作；`scanCliSessions/listSdkSessions` 因依赖 DB 索引
+ * 会返回空数组。
  */
-import { DatabaseSync } from 'node:sqlite';
+import { createRequire } from 'module';
 import { logger } from '../../../utils/logger.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
+const requireFromHere = createRequire(import.meta.url);
+let sqliteModule; // undefined = not tried, null = unavailable
+function loadSqlite() {
+    if (sqliteModule !== undefined)
+        return sqliteModule;
+    try {
+        sqliteModule = requireFromHere('node:sqlite');
+    }
+    catch (e) {
+        logger.warn(`[CodexAdapter] node:sqlite unavailable (Node < 22.5?): ${e?.message || e}. Codex session listing falls back to rollout JSONL.`);
+        sqliteModule = null;
+    }
+    return sqliteModule;
+}
 export class CodexSessionFileAdapter {
     agentId = 'codex';
     db = null;
@@ -39,11 +58,14 @@ export class CodexSessionFileAdapter {
         if (this.dbInitialized)
             return this.db;
         this.dbInitialized = true;
+        const sqlite = loadSqlite();
+        if (!sqlite)
+            return null;
         const dbPath = this.resolveStateDbPath();
         if (!dbPath)
             return null;
         try {
-            this.db = new DatabaseSync(dbPath, { readOnly: true });
+            this.db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
             logger.debug(`[CodexAdapter] Opened state DB: ${dbPath}`);
         }
         catch (error) {

package/dist/core/session/session-fs-store.js

@@ -0,0 +1,230 @@
+import fs from 'fs';
+import path from 'path';
+// 文件系统非法字符（Windows 最严格）：< > : " / \ | ? *
+// 还有控制字符 0x00-0x1F。我们把这些字符编码为 %XX（hex 大写）。
+// `%` 本身也要转义为 %25，保证可逆。
+const UNSAFE_CHARS_RE = /[<>:"/\\|?*\x00-\x1F%]/g;
+function encodeSegment(s) {
+    return s.replace(UNSAFE_CHARS_RE, ch => '%' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0'));
+}
+function decodeSegment(s) {
+    return s.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+/**
+ * 计算 chat 目录的完整路径。
+ * - AUN：sessionsDir/aun/<urlEncode(selfId)>/<urlEncode(channelId)>/
+ * - 其它：sessionsDir/<channelType>/<urlEncode(channelId)>/
+ *
+ * 注：channelType 自身不编码（限定枚举值，不含非法字符）。
+ */
+export function chatDirPath(sessionsDir, channelType, channelId, selfId) {
+    if (channelType === 'aun') {
+        const self = selfId || '_unknown';
+        return path.join(sessionsDir, 'aun', encodeSegment(self), encodeSegment(channelId));
+    }
+    return path.join(sessionsDir, channelType, encodeSegment(channelId));
+}
+/** 解码目录段（用于扫描时把目录名还原为原始 channelId/selfId） */
+export function decodeDirSegment(seg) {
+    return decodeSegment(seg);
+}
+export function generateSessionId(now) {
+    const ts = now ?? Date.now();
+    const d = new Date(ts);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `meta_${yyyy}${mm}${dd}_${ts}`;
+}
+export function formatTimestamp(epochMs) {
+    const d = new Date(epochMs);
+    const yyyy = d.getFullYear();
+    const mo = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mi = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${yyyy}-${mo}-${dd} ${hh}:${mi}:${ss}`;
+}
+export function atomicWriteJson(filePath, data) {
+    const tmpPath = filePath + '.tmp';
+    const content = JSON.stringify(data, null, 2) + '\n';
+    const fd = fs.openSync(tmpPath, 'w');
+    fs.writeSync(fd, content);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    fs.renameSync(tmpPath, filePath);
+}
+export function appendJsonl(filePath, record) {
+    const line = JSON.stringify(record) + '\n';
+    const fd = fs.openSync(filePath, 'a');
+    fs.writeSync(fd, line);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+}
+export function readJsonFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        if (e instanceof SyntaxError)
+            return undefined;
+        throw e;
+    }
+}
+export function readLastJsonlLine(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trimEnd().split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        throw e;
+    }
+}
+export function readAllJsonlLines(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const results = [];
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                results.push(JSON.parse(trimmed));
+            }
+            catch { /* skip corrupt line */ }
+        }
+        return results;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+}
+/**
+ * 扫描所有 chat 目录。
+ * 顶层是 channelType 目录；aun 下面再有一层 selfId 目录。
+ * 返回每个 chat 的：channelType、selfId（仅 aun 有）、channelId、dirPath。
+ */
+export function scanChatDirs(sessionsDir) {
+    const results = [];
+    let typeEntries;
+    try {
+        typeEntries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+    for (const typeEntry of typeEntries) {
+        if (!typeEntry.isDirectory())
+            continue;
+        const channelType = typeEntry.name;
+        const typeDir = path.join(sessionsDir, channelType);
+        if (channelType === 'aun') {
+            // aun 下还有一层 selfId
+            let selfEntries;
+            try {
+                selfEntries = fs.readdirSync(typeDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const selfEntry of selfEntries) {
+                if (!selfEntry.isDirectory())
+                    continue;
+                const selfDir = path.join(typeDir, selfEntry.name);
+                let chatEntries;
+                try {
+                    chatEntries = fs.readdirSync(selfDir, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const chatEntry of chatEntries) {
+                    if (!chatEntry.isDirectory())
+                        continue;
+                    results.push({
+                        channelType,
+                        selfId: decodeSegment(selfEntry.name),
+                        channelId: decodeSegment(chatEntry.name),
+                        dirPath: path.join(selfDir, chatEntry.name),
+                    });
+                }
+            }
+        }
+        else {
+            // 通用 channel：sessionsDir/{channelType}/{encodedChannelId}/
+            let chatEntries;
+            try {
+                chatEntries = fs.readdirSync(typeDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const chatEntry of chatEntries) {
+                if (!chatEntry.isDirectory())
+                    continue;
+                results.push({
+                    channelType,
+                    selfId: null,
+                    channelId: decodeSegment(chatEntry.name),
+                    dirPath: path.join(typeDir, chatEntry.name),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function scanMetaFiles(chatDir) {
+    try {
+        const entries = fs.readdirSync(chatDir);
+        return entries
+            .filter(f => f.startsWith('meta_') && f.endsWith('.jsonl'))
+            .sort();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+}
+export function ensureChatDir(sessionsDir, channelType, channelId, selfId) {
+    const dir = chatDirPath(sessionsDir, channelType, channelId, selfId);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(path.join(dir, '_threads'), { recursive: true });
+    fs.mkdirSync(path.join(dir, '_trash'), { recursive: true });
+    return dir;
+}
+export function readThreadIndex(chatDir) {
+    return readJsonFile(path.join(chatDir, '_threads', 'thread-index.json')) || {};
+}
+export function writeThreadIndex(chatDir, index) {
+    atomicWriteJson(path.join(chatDir, '_threads', 'thread-index.json'), index);
+}