evolclaw 3.1.4 → 3.1.6

package/dist/core/relation/peer-identity.js

@@ -6,7 +6,7 @@
  * 2. 仅在 agent.md 内容变化时重写 peer-identity.json
  * 3. 支持入站和出站消息的身份查询
  *
- * 信源：对端的 agent.md（通过 AUN SDK checkAgentMd + fetchAgentMd）
+ * 信源：对端的 agent.md（通过 AIDStore.checkAgentMd + downloadAgentMd，由 agentmdSync 封装）
  * 判定规则：type !== 'human' → agent
  * 缓存位置：$AGENT_DIR/relations/<channel>#<urlEncode(peerId)>/peer-identity.json
  */
@@ -15,6 +15,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { agentMdPath } from '../../paths.js';
+import { formatPeerKey } from './peer-key.js';
 /**
  * 对端身份缓存管理器
  */
@@ -24,16 +25,16 @@ export class PeerIdentityCache {
     /**
      * 获取 peer-identity.json 文件路径
      */
-    static getFilePath(channel, peerId, agentDir) {
-        const peerKey = `${channel}#${encodeURIComponent(peerId)}`;
+    static getFilePath(channelType, peerId, agentDir) {
+        const peerKey = formatPeerKey(channelType, peerId);
         return path.join(agentDir, 'relations', peerKey, 'peer-identity.json');
     }
     /**
      * 从文件读取缓存
      * @returns PeerIdentity | null（缓存不存在）
      */
-    static get(channel, peerId, agentDir) {
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+    static get(channelType, peerId, agentDir) {
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             const content = fs.readFileSync(filePath, 'utf-8');
             return JSON.parse(content);
@@ -47,17 +48,19 @@ export class PeerIdentityCache {
      * @param maxAgeMs 最大缓存时间（默认 30 天）
      * @returns true=需要刷新
      */
-    static needsRefresh(channel, peerId, agentDir, maxAgeMs = this.CACHE_MAX_AGE_MS) {
-        const cached = this.get(channel, peerId, agentDir);
+    static needsRefresh(channelType, peerId, agentDir, maxAgeMs = this.CACHE_MAX_AGE_MS) {
+        const cached = this.get(channelType, peerId, agentDir);
         if (!cached)
             return true;
         return Date.now() - cached.lastCheckedAt > maxAgeMs;
     }
     /**
      * 从 agent.md 更新身份信息
+     * @param source 'agentmd'（验签通过）或 'agentmd-unverified'（内容可解析但验签未过）
+     * @param verifiedAt 验签通过时间戳；未验签传 0
      */
-    static updateFromAgentMd(channel, peerId, agentDir, agentMd, verifiedAt) {
-        const typeMatch = agentMd.match(/^type:\s*["']?(\w+)["']?/m);
+    static updateFromAgentMd(channelType, peerId, agentDir, agentMd, verifiedAt, source = 'agentmd') {
+        const typeMatch = agentMd.match(/^type:\s*["']?([^"'\n]+?)["']?\s*$/m);
         const nameMatch = agentMd.match(/^name:\s*["']?(.+?)["']?\s*$/m);
         const type = typeMatch?.[1] || 'unknown';
         const isAgent = type !== 'human';
@@ -73,13 +76,13 @@ export class PeerIdentityCache {
             agentMdUpdatedAt: now,
             verifiedAt,
             lastCheckedAt: now,
-            source: 'agentmd',
+            source,
         };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
-            logger.debug(`[PeerIdentityCache] Updated: ${channel}#${peerId} type=${type} isAgent=${isAgent}`);
+            logger.debug(`[PeerIdentityCache] Updated: ${channelType}#${peerId} type=${type} isAgent=${isAgent} source=${source}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write cache: ${filePath} err=${err}`);
@@ -89,9 +92,9 @@ export class PeerIdentityCache {
     /**
      * 仅更新 lastCheckedAt（内容未变时的轻量操作）
      */
-    static touchLastChecked(channel, peerId, agentDir, cached) {
+    static touchLastChecked(channelType, peerId, agentDir, cached) {
         const updated = { ...cached, lastCheckedAt: Date.now() };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.writeFileSync(filePath, JSON.stringify(updated, null, 2), 'utf-8');
         }
@@ -101,7 +104,7 @@ export class PeerIdentityCache {
     /**
      * 标记为 unknown（验签失败或无 agent.md）
      */
-    static markUnknown(channel, peerId, agentDir) {
+    static markUnknown(channelType, peerId, agentDir) {
         const identity = {
             aid: peerId,
             type: 'unknown',
@@ -112,11 +115,11 @@ export class PeerIdentityCache {
             lastCheckedAt: Date.now(),
             source: 'unknown',
         };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
-            logger.debug(`[PeerIdentityCache] Marked unknown: ${channel}#${peerId}`);
+            logger.debug(`[PeerIdentityCache] Marked unknown: ${channelType}#${peerId}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write unknown cache: ${filePath} err=${err}`);
@@ -126,76 +129,76 @@ export class PeerIdentityCache {
     /**
      * 完整流程：缓存检查 → agentmdSync（check+fetch）→ 按 changed 决定是否重写
      *
-     * @param channel 渠道类型（如 'aun'）
+     * @param channelType 渠道类型（如 'aun'）
      * @param peerId 对端 ID（AUN 是 AID）
      * @param agentDir agent 数据根目录
-     * @param aunClient AUN SDK client（需要有 checkAgentMd / fetchAgentMd 方法）
+     * @param store AIDStore 实例（由调用方提供，负责 checkAgentMd + downloadAgentMd）
      * @param forceRefresh 强制刷新（忽略缓存时效）
-     * @returns PeerIdentity
      */
-    static async resolve(channel, peerId, agentDir, aunClient, forceRefresh = false) {
+    static async resolve(channelType, peerId, agentDir, store, forceRefresh = false) {
         // 1. 缓存检查
-        if (!forceRefresh && !this.needsRefresh(channel, peerId, agentDir)) {
-            const cached = this.get(channel, peerId, agentDir);
+        if (!forceRefresh && !this.needsRefresh(channelType, peerId, agentDir)) {
+            const cached = this.get(channelType, peerId, agentDir);
             if (cached) {
-                logger.debug(`[PeerIdentityCache] Cache hit: ${channel}#${peerId} type=${cached.type} age=${Math.floor((Date.now() - cached.lastCheckedAt) / 1000 / 60 / 60 / 24)}d`);
+                logger.debug(`[PeerIdentityCache] Cache hit: ${channelType}#${peerId} type=${cached.type} age=${Math.floor((Date.now() - cached.lastCheckedAt) / 1000 / 60 / 60 / 24)}d`);
                 return cached;
             }
         }
-        // 2. 标准流程：checkAgentMd → fetchAgentMd（如果有变化）
+        // 2. 通过 agentmdSync 拉取（内部走 store.checkAgentMd → store.downloadAgentMd）
         try {
-            logger.debug(`[PeerIdentityCache] Syncing agent.md: ${channel}#${peerId}`);
-            const state = await aunClient.checkAgentMd(peerId, 30);
-            let content;
-            if (state.in_sync && state.local_found) {
-                // 本地已是最新，读本地文件
-                const localPath = agentMdPath(peerId);
-                try {
-                    content = fs.readFileSync(localPath, 'utf-8');
-                }
-                catch { /* ignore */ }
-            }
+            logger.debug(`[PeerIdentityCache] Syncing agent.md: ${channelType}#${peerId}`);
+            const { agentmdSync } = await import('../../aun/aid/agentmd.js');
+            const result = await agentmdSync(peerId, { store });
+            const content = result.content;
             if (!content) {
-                // 需要下载（不同步或本地不存在）
-                const info = await aunClient.fetchAgentMd(peerId);
-                content = info.content;
+                throw new Error('agent.md content unavailable');
+            }
+            // 验签通过 → 可信（source=agentmd）；否则 type 仍解析但标记未验证
+            const verified = result.verification?.status === 'verified';
+            const source = verified ? 'agentmd' : 'agentmd-unverified';
+            if (!verified) {
+                logger.info(`[PeerIdentityCache] agent.md unverified for ${peerId}: status=${result.verification?.status ?? 'unknown'} reason=${result.verification?.reason ?? '-'} (type 仍按声明解析)`);
             }
-            // 3. 比较 hash，仅在变化时重写 peer-identity.json
+            // 3. 比较 hash，内容与可信级别都未变时仅 touch
             const newHash = 'sha256:' + crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
-            const cached = this.get(channel, peerId, agentDir);
-            if (cached && cached.agentMdHash === newHash && cached.source === 'agentmd') {
-                return this.touchLastChecked(channel, peerId, agentDir, cached);
+            const cached = this.get(channelType, peerId, agentDir);
+            if (cached && cached.agentMdHash === newHash && cached.source === source) {
+                return this.touchLastChecked(channelType, peerId, agentDir, cached);
             }
-            return this.updateFromAgentMd(channel, peerId, agentDir, content, Date.now());
+            return this.updateFromAgentMd(channelType, peerId, agentDir, content, verified ? Date.now() : 0, source);
         }
         catch (err) {
-            // 4. 网络失败，fallback 本地文件
+            // 4. agentmdSync 抛错（非网络失败——网络失败时它内部已 fallback 返回本地内容；
+            //    这里通常是无内容或解析异常）。兜底读本地文件，但无法重新验签，
+            //    故沿用缓存里已有的可信级别，绝不凭空升级为已验签。
             const localPath = agentMdPath(peerId);
             try {
                 if (fs.existsSync(localPath)) {
                     const localContent = fs.readFileSync(localPath, 'utf-8');
-                    logger.info(`[PeerIdentityCache] Network failed, using local agent.md for ${peerId}`);
+                    const cached = this.get(channelType, peerId, agentDir);
+                    logger.info(`[PeerIdentityCache] Using local agent.md for ${peerId} (cached source=${cached?.source ?? 'none'})`);
                     const localHash = 'sha256:' + crypto.createHash('sha256').update(localContent, 'utf-8').digest('hex');
-                    const cached = this.get(channel, peerId, agentDir);
-                    if (cached && cached.agentMdHash === localHash && cached.source === 'agentmd') {
-                        return this.touchLastChecked(channel, peerId, agentDir, cached);
+                    if (cached && cached.agentMdHash === localHash && (cached.source === 'agentmd' || cached.source === 'agentmd-unverified')) {
+                        return this.touchLastChecked(channelType, peerId, agentDir, cached);
                     }
-                    return this.updateFromAgentMd(channel, peerId, agentDir, localContent, cached?.verifiedAt ?? 0);
+                    // 无匹配缓存可信级别 → 本地内容未经本次验签，标记为未验证
+                    const fallbackSource = cached?.source === 'agentmd' ? 'agentmd' : 'agentmd-unverified';
+                    return this.updateFromAgentMd(channelType, peerId, agentDir, localContent, cached?.verifiedAt ?? 0, fallbackSource);
                 }
             }
             catch { /* ignore fs errors */ }
-            logger.warn(`[PeerIdentityCache] Failed to resolve: ${channel}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
-            return this.markUnknown(channel, peerId, agentDir);
+            logger.warn(`[PeerIdentityCache] Failed to resolve: ${channelType}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
+            return this.markUnknown(channelType, peerId, agentDir);
         }
     }
     /**
      * 清除指定对端的缓存
      */
-    static clear(channel, peerId, agentDir) {
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+    static clear(channelType, peerId, agentDir) {
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.unlinkSync(filePath);
-            logger.debug(`[PeerIdentityCache] Cleared: ${channel}#${peerId}`);
+            logger.debug(`[PeerIdentityCache] Cleared: ${channelType}#${peerId}`);
         }
         catch {
             // 文件不存在，忽略

package/dist/core/relation/peer-key.js

@@ -0,0 +1,16 @@
+/**
+ * peerKey: 关系层路由键,格式 `<channelType>#<urlEncode(channelId)>`。
+ * 群聊场景下 channelId = groupId,所有发言者共用同一个 peerKey。
+ */
+export function formatPeerKey(channelType, channelId) {
+    return `${channelType}#${encodeURIComponent(channelId)}`;
+}
+export function parsePeerKey(key) {
+    const idx = key.indexOf('#');
+    if (idx <= 0)
+        throw new Error(`Invalid peer key: ${key}`);
+    return {
+        channelType: key.slice(0, idx),
+        channelId: decodeURIComponent(key.slice(idx + 1)),
+    };
+}

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

@@ -12,19 +12,16 @@ function decodeSegment(s) {
 }
 /**
  * 计算 chat 目录的完整路径。
- * - AUN：sessionsDir/aun/<urlEncode(selfId)>/<urlEncode(channelId)>/
- * - 其它：sessionsDir/<channelType>/<urlEncode(channelId)>/
- *
- * 注：channelType 自身不编码（限定枚举值，不含非法字符）。
+ * - aun: sessionsDir/aun/<urlEncode(selfAID|'_unknown')>/<urlEncode(channelId)>/
+ * - 其它: sessionsDir/<channelType>/<urlEncode(channelId)>/
  */
-export function chatDirPath(sessionsDir, channelType, channelId, selfId) {
+export function chatDirPath(sessionsDir, channelType, channelId, selfAID) {
     if (channelType === 'aun') {
-        const self = selfId || '_unknown';
-        return path.join(sessionsDir, 'aun', encodeSegment(self), encodeSegment(channelId));
+        return path.join(sessionsDir, channelType, encodeSegment(selfAID || '_unknown'), encodeSegment(channelId));
     }
     return path.join(sessionsDir, channelType, encodeSegment(channelId));
 }
-/** 解码目录段（用于扫描时把目录名还原为原始 channelId/selfId） */
+/** 解码目录段（用于扫描时把目录名还原为原始 channelId/selfAID） */
 export function decodeDirSegment(seg) {
     return decodeSegment(seg);
 }
@@ -128,8 +125,8 @@ export function readAllJsonlLines(filePath) {
 }
 /**
  * 扫描所有 chat 目录。
- * 顶层是 channelType 目录；aun 下面再有一层 selfId 目录。
- * 返回每个 chat 的：channelType、selfId（仅 aun 有）、channelId、dirPath。
+ * - aun: channelType / selfAID / channelId  (3层)
+ * - 其它: channelType / channelId           (2层)
  */
 export function scanChatDirs(sessionsDir) {
     const results = [];
@@ -146,40 +143,17 @@ export function scanChatDirs(sessionsDir) {
         if (!typeEntry.isDirectory())
             continue;
         const channelType = typeEntry.name;
-        // 包含 '#' 的目录是旧 channelKey 格式（如 'aun#dddd.agentid.pub#main'），
-        // 按通用 channel 布局扫描（sessionsDir/{channelKey}/{encodedChannelId}/），保持兼容
-        if (channelType.includes('#')) {
-            const typeDir = path.join(sessionsDir, channelType);
-            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),
-                });
-            }
+        const typeDir = path.join(sessionsDir, channelType);
+        let level2Entries;
+        try {
+            level2Entries = fs.readdirSync(typeDir, { withFileTypes: true });
+        }
+        catch {
             continue;
         }
-        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) {
+            // 3-layer: aun/selfAID/channelId
+            for (const selfEntry of level2Entries) {
                 if (!selfEntry.isDirectory())
                     continue;
                 const selfDir = path.join(typeDir, selfEntry.name);
@@ -195,7 +169,7 @@ export function scanChatDirs(sessionsDir) {
                         continue;
                     results.push({
                         channelType,
-                        selfId: decodeSegment(selfEntry.name),
+                        selfAID: decodeSegment(selfEntry.name),
                         channelId: decodeSegment(chatEntry.name),
                         dirPath: path.join(selfDir, chatEntry.name),
                     });
@@ -203,20 +177,13 @@ export function scanChatDirs(sessionsDir) {
             }
         }
         else {
-            // 通用 channel：sessionsDir/{channelType}/{encodedChannelId}/
-            let chatEntries;
-            try {
-                chatEntries = fs.readdirSync(typeDir, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const chatEntry of chatEntries) {
+            // 2-layer: channelType/channelId
+            for (const chatEntry of level2Entries) {
                 if (!chatEntry.isDirectory())
                     continue;
                 results.push({
                     channelType,
-                    selfId: null,
+                    selfAID: '',
                     channelId: decodeSegment(chatEntry.name),
                     dirPath: path.join(typeDir, chatEntry.name),
                 });
@@ -238,15 +205,27 @@ export function scanMetaFiles(chatDir) {
         throw e;
     }
 }
-export function ensureChatDir(sessionsDir, channelType, channelId, selfId) {
-    const dir = chatDirPath(sessionsDir, channelType, channelId, selfId);
+export function ensureChatDir(sessionsDir, channelType, channelId, selfAID) {
+    const dir = chatDirPath(sessionsDir, channelType, channelId, selfAID);
     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')) || {};
+    const raw = readJsonFile(path.join(chatDir, '_threads', 'thread-index.json')) || {};
+    // Migrate legacy format: { threadId: sessionId } → { threadId: { sessionId, sessionKey, metaFile } }
+    const result = {};
+    for (const [tid, val] of Object.entries(raw)) {
+        if (typeof val === 'string') {
+            // Legacy: val is sessionId
+            result[tid] = { sessionId: val, sessionKey: '', metaFile: `${val}.jsonl` };
+        }
+        else {
+            result[tid] = val;
+        }
+    }
+    return result;
 }
 export function writeThreadIndex(chatDir, index) {
     atomicWriteJson(path.join(chatDir, '_threads', 'thread-index.json'), index);

package/dist/core/session/session-key.js

@@ -0,0 +1,24 @@
+/**
+ * sessionKey: agent 内部会话路由键。
+ * 格式: channelType#urlEncode(channelId)#urlEncode(threadId)
+ * 无话题时 threadId 固定为 'main'。
+ */
+export const DEFAULT_THREAD_ID = 'main';
+export function formatSessionKey(channelType, channelId, threadId) {
+    const tid = threadId || DEFAULT_THREAD_ID;
+    return `${channelType}#${encodeURIComponent(channelId)}#${encodeURIComponent(tid)}`;
+}
+export function parseSessionKey(key) {
+    const first = key.indexOf('#');
+    if (first <= 0)
+        throw new Error(`Invalid session key: ${key}`);
+    const rest = key.slice(first + 1);
+    const second = rest.indexOf('#');
+    if (second <= 0)
+        throw new Error(`Invalid session key (missing threadId): ${key}`);
+    return {
+        channelType: key.slice(0, first),
+        channelId: decodeURIComponent(rest.slice(0, second)),
+        threadId: decodeURIComponent(rest.slice(second + 1)),
+    };
+}