evolclaw 3.1.3 → 3.1.5

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

@@ -2,11 +2,11 @@
  * PeerIdentityCache - 对端身份缓存管理
  *
  * 职责：
- * 1. 从对端的 agent.md 确定身份（human / agent）
- * 2. 缓存到关系层文件（30天时效）
+ * 1. 通过 agentmdSync 标准流程获取对端 agent.md（check → fetch if changed）
+ * 2. 仅在 agent.md 内容变化时重写 peer-identity.json
  * 3. 支持入站和出站消息的身份查询
  *
- * 信源：对端的 agent.md（通过 AUN SDK 下载并验签）
+ * 信源：对端的 agent.md（通过 AIDStore.checkAgentMd + downloadAgentMd，由 agentmdSync 封装）
  * 判定规则：type !== 'human' → agent
  * 缓存位置：$AGENT_DIR/relations/<channel>#<urlEncode(peerId)>/peer-identity.json
  */
@@ -14,6 +14,8 @@ import * as fs from 'fs';
 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';
 /**
  * 对端身份缓存管理器
  */
@@ -23,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);
@@ -46,66 +48,76 @@ 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 agentMd 已验签的 agent.md 内容
      */
-    static updateFromAgentMd(channel, peerId, agentDir, agentMd, verifiedAt) {
-        // 解析 type 和 name
-        const typeMatch = agentMd.match(/^type:\s*["']?(\w+)["']?/m);
+    static updateFromAgentMd(channelType, peerId, agentDir, agentMd, verifiedAt) {
+        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';
         const name = nameMatch?.[1]?.trim();
-        // 计算 hash
         const agentMdHash = 'sha256:' + crypto.createHash('sha256').update(agentMd, 'utf-8').digest('hex');
-        // 构建身份信息
+        const now = Date.now();
         const identity = {
             aid: peerId,
             type,
             isAgent,
             name,
             agentMdHash,
+            agentMdUpdatedAt: now,
             verifiedAt,
-            lastCheckedAt: Date.now(),
+            lastCheckedAt: now,
             source: 'agentmd',
         };
-        // 写入文件
-        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}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write cache: ${filePath} err=${err}`);
         }
         return identity;
     }
+    /**
+     * 仅更新 lastCheckedAt（内容未变时的轻量操作）
+     */
+    static touchLastChecked(channelType, peerId, agentDir, cached) {
+        const updated = { ...cached, lastCheckedAt: Date.now() };
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(updated, null, 2), 'utf-8');
+        }
+        catch { /* ignore */ }
+        return updated;
+    }
     /**
      * 标记为 unknown（验签失败或无 agent.md）
      */
-    static markUnknown(channel, peerId, agentDir) {
+    static markUnknown(channelType, peerId, agentDir) {
         const identity = {
             aid: peerId,
             type: 'unknown',
-            isAgent: true, // 验签失败 → 当做 agent（安全策略）
+            isAgent: true,
             agentMdHash: '',
+            agentMdUpdatedAt: 0,
             verifiedAt: 0,
             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}`);
@@ -113,46 +125,68 @@ export class PeerIdentityCache {
         return identity;
     }
     /**
-     * 完整流程：检查缓存 → 需要刷新则下载 agent.md → 更新缓存
+     * 完整流程：缓存检查 → agentmdSync（check+fetch）→ 按 changed 决定是否重写
      *
-     * @param channel 渠道类型（如 'aun'）
+     * @param channelType 渠道类型（如 'aun'）
      * @param peerId 对端 ID（AUN 是 AID）
      * @param agentDir agent 数据根目录
-     * @param aunClient AUN SDK client（需要有 fetchAgentMd 方法）
+     * @param store AIDStore 实例（由调用方提供，负责 checkAgentMd + downloadAgentMd）
      * @param forceRefresh 强制刷新（忽略缓存时效）
-     * @returns PeerIdentity
      */
-    static async resolve(channel, peerId, agentDir, aunClient, forceRefresh = false) {
-        // 1. 检查缓存
-        if (!forceRefresh && !this.needsRefresh(channel, peerId, agentDir)) {
-            const cached = this.get(channel, peerId, agentDir);
+    static async resolve(channelType, peerId, agentDir, store, forceRefresh = false) {
+        // 1. 缓存检查
+        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. 下载并验签 agent.md（SDK 自动验签）
+        // 2. 通过 agentmdSync 拉取（内部走 store.checkAgentMd → store.downloadAgentMd）
         try {
-            logger.debug(`[PeerIdentityCache] Fetching agent.md: ${channel}#${peerId}`);
-            const result = await aunClient.fetchAgentMd(peerId);
-            const agentMd = result.content;
-            // 3. 更新缓存
-            return this.updateFromAgentMd(channel, peerId, agentDir, agentMd, Date.now());
+            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) {
+                throw new Error('agent.md content unavailable');
+            }
+            // 3. 比较 hash，仅在变化时重写 peer-identity.json
+            const newHash = 'sha256:' + crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
+            const cached = this.get(channelType, peerId, agentDir);
+            if (cached && cached.agentMdHash === newHash && cached.source === 'agentmd') {
+                return this.touchLastChecked(channelType, peerId, agentDir, cached);
+            }
+            return this.updateFromAgentMd(channelType, peerId, agentDir, content, Date.now());
         }
         catch (err) {
-            // 验签失败或下载失败 → 标记为 unknown，当做 agent
-            logger.warn(`[PeerIdentityCache] Failed to fetch agent.md: ${channel}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
-            return this.markUnknown(channel, peerId, agentDir);
+            // 4. 网络失败，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 localHash = 'sha256:' + crypto.createHash('sha256').update(localContent, 'utf-8').digest('hex');
+                    const cached = this.get(channelType, peerId, agentDir);
+                    if (cached && cached.agentMdHash === localHash && cached.source === 'agentmd') {
+                        return this.touchLastChecked(channelType, peerId, agentDir, cached);
+                    }
+                    return this.updateFromAgentMd(channelType, peerId, agentDir, localContent, cached?.verifiedAt ?? 0);
+                }
+            }
+            catch { /* ignore fs errors */ }
+            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)),
+    };
+}