acp-ts 1.0.6 → 1.0.9

package/dist/agentcp.d.ts

@@ -1,11 +1,17 @@
 import { IAgentCP, IAgentIdentity } from "./interfaces";
+import { MessageStore } from "./messagestore";
 declare class AgentCP implements IAgentCP {
     private seedPassword;
     private apUrl;
     private msgUrl;
     private activeAid;
+    private _messageStore;
     private agentMdPath;
-    constructor(apiUrl: string, seedPassword?: string);
+    private agentMdUploaded;
+    get messageStore(): MessageStore;
+    constructor(apiUrl: string, seedPassword?: string, basePath?: string, options?: {
+        persistMessages?: boolean;
+    });
     /**
      * 初始化并预热加密模块
      */
@@ -21,28 +27,14 @@ declare class AgentCP implements IAgentCP {
         messageServer: string;
         heartbeatServer: string;
     }>;
-    /**
-     * 设置 agent.md 文件路径，登录成功后会自动上传（仅首次）
-     * @param filePath agent.md 文件的本地路径
-     */
-    setAgentMdPath(filePath: string): void;
-    /**
-     * 重置 agent.md 上传状态，下次登录时会重新上传
-     * 当 agent.md 内容更新后调用此方法
-     */
-    resetAgentMdUploadStatus(): Promise<void>;
-    /**
-     * 上传 agent.md 文件
-     * @param signature 签名（从 signIn 获取）
-     * @returns 上传结果
-     */
-    private uploadAgentMd;
     getCertInfo(aid: string): Promise<{
         privateKey: string;
         publicKey: string;
         csr: string;
         cert: string;
     } | null>;
+    setAgentMdPath(filePath: string): void;
+    resetAgentMdUploadStatus(): Promise<void>;
     private handleError;
 }
 export { AgentCP };

package/dist/agentcp.js

@@ -1,32 +1,38 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentCP = void 0;
 const cert_1 = require("./cert");
 const datamanager_1 = require("./datamanager");
 const api_1 = require("./api");
 const utils_1 = require("./utils");
-const axios_1 = __importDefault(require("axios"));
-// 环境检测
-const isNodeEnvironment = typeof process !== 'undefined' &&
-    process.versions != null &&
-    process.versions.node != null;
+const messagestore_1 = require("./messagestore");
+const filesync_1 = require("./filesync");
 class AgentCP {
-    constructor(apiUrl, seedPassword = "") {
+    get messageStore() {
+        return this._messageStore;
+    }
+    constructor(apiUrl, seedPassword = "", basePath, options) {
+        var _a;
         this.activeAid = '';
-        this.agentMdPath = '';
+        this.agentMdPath = null;
+        this.agentMdUploaded = false;
         if (!apiUrl) {
             this.handleError("参数缺失：apiUrl不应为空");
         }
         if (apiUrl.startsWith('http://')) {
             this.handleError("apiUrl不需要http://开头");
         }
+        if (basePath) {
+            datamanager_1.CertAndKeyStore.setBasePath(basePath);
+        }
         const baseUrl = `https://acp3.${apiUrl}`;
         this.seedPassword = seedPassword;
         this.apUrl = `${baseUrl}/api/accesspoint`;
         this.msgUrl = `${baseUrl}/api/message`;
+        this._messageStore = new messagestore_1.MessageStore({
+            persistMessages: (_a = options === null || options === void 0 ? void 0 : options.persistMessages) !== null && _a !== void 0 ? _a : false,
+            basePath: basePath || process.cwd(),
+        });
         // 预热加密模块
         this.initializeCrypto();
     }
@@ -155,20 +161,25 @@ class AgentCP {
         else {
             messageSignature = (_a = msgData.signature) !== null && _a !== void 0 ? _a : '';
         }
-        // 登录成功后自动上传 agent.md（如果已配置路径且未上传过）
-        if (this.agentMdPath && messageSignature) {
-            const uploaded = await datamanager_1.CertAndKeyStore.getData(`agent_md_uploaded_${aid}`);
-            if (!uploaded) {
-                const uploadResult = await this.uploadAgentMd(messageSignature);
-                if (uploadResult.success) {
-                    console.log(`agent.md 上传成功: ${uploadResult.url}`);
-                    // 记录已上传状态
-                    await datamanager_1.CertAndKeyStore.storeData(`agent_md_uploaded_${aid}`, true);
+        // 登录成功后自动上传 agent.md（仅首次）
+        if (this.agentMdPath && !this.agentMdUploaded) {
+            try {
+                const fileSync = new filesync_1.FileSync({
+                    apiUrl: this.msgUrl,
+                    aid: this.activeAid,
+                    signature: messageSignature,
+                });
+                const result = await fileSync.uploadAgentMdFromFile(this.agentMdPath);
+                if (result.success) {
+                    this.agentMdUploaded = true;
                 }
                 else {
-                    console.warn(`agent.md 上传失败: ${uploadResult.error}`);
+                    console.warn('agent.md 上传失败:', result.error);
                 }
             }
+            catch (err) {
+                console.warn('agent.md 上传异常:', err);
+            }
         }
         return {
             messageSignature,
@@ -176,63 +187,6 @@ class AgentCP {
             heartbeatServer
         };
     }
-    /**
-     * 设置 agent.md 文件路径，登录成功后会自动上传（仅首次）
-     * @param filePath agent.md 文件的本地路径
-     */
-    setAgentMdPath(filePath) {
-        this.agentMdPath = filePath;
-    }
-    /**
-     * 重置 agent.md 上传状态，下次登录时会重新上传
-     * 当 agent.md 内容更新后调用此方法
-     */
-    async resetAgentMdUploadStatus() {
-        if (this.activeAid) {
-            await datamanager_1.CertAndKeyStore.storeData(`agent_md_uploaded_${this.activeAid}`, false);
-        }
-    }
-    /**
-     * 上传 agent.md 文件
-     * @param signature 签名（从 signIn 获取）
-     * @returns 上传结果
-     */
-    async uploadAgentMd(signature) {
-        var _a, _b, _c;
-        if (!this.agentMdPath) {
-            return { success: false, error: '未设置 agent.md 路径' };
-        }
-        if (!isNodeEnvironment) {
-            return { success: false, error: '自动上传 agent.md 仅支持 Node.js 环境' };
-        }
-        const fs = require('fs');
-        try {
-            if (!fs.existsSync(this.agentMdPath)) {
-                return { success: false, error: `文件不存在: ${this.agentMdPath}` };
-            }
-            const content = fs.readFileSync(this.agentMdPath, 'utf8');
-            // 检查文件大小限制（4KB）
-            const contentSize = Buffer.byteLength(content, 'utf8');
-            if (contentSize > 4 * 1024) {
-                return { success: false, error: `文件大小超过限制: ${contentSize} bytes > 4KB` };
-            }
-            const url = `https://${this.activeAid}/agent.md`;
-            const response = await axios_1.default.post(url, content, {
-                headers: {
-                    'Content-Type': 'text/markdown',
-                    'Authorization': `Bearer ${signature}`
-                }
-            });
-            if (response.status === 200) {
-                return { success: true, url: response.data.url || url };
-            }
-            return { success: false, error: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.message) || `上传失败: ${response.status}` };
-        }
-        catch (error) {
-            const errorMsg = ((_c = (_b = error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || error.message || '上传 agent.md 失败';
-            return { success: false, error: errorMsg };
-        }
-    }
     async getCertInfo(aid) {
         const csr = await datamanager_1.CertAndKeyStore.getCsr(aid);
         const privateKey = await datamanager_1.CertAndKeyStore.getPrivateKey(aid);
@@ -247,6 +201,12 @@ class AgentCP {
             cert: certPem
         };
     }
+    setAgentMdPath(filePath) {
+        this.agentMdPath = filePath;
+    }
+    async resetAgentMdUploadStatus() {
+        this.agentMdUploaded = false;
+    }
     handleError(error, customMessage) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`${customMessage || '操作失败'}: ${errorMessage}`);

package/dist/agentmanager.d.ts

@@ -1,37 +1,15 @@
 import { IAgentCP, IAgentWS, IConnectionConfig } from './interfaces';
-import { FileSync, SyncResult } from './filesync';
 declare class AgentManager {
     private static instance;
     private agentCP;
     private agentWS;
-    private fileSync;
-    private apiUrl;
     private constructor();
     static getInstance(): AgentManager;
-    initACP(apiUrl: string, seedPassword?: string): IAgentCP;
+    initACP(apiUrl: string, seedPassword?: string, basePath?: string, options?: {
+        persistMessages?: boolean;
+    }): IAgentCP;
     initAWS(aid: string, config: IConnectionConfig): IAgentWS;
     acp(): IAgentCP;
     aws(): IAgentWS;
-    /**
-     * 初始化文件同步模块
-     * @param aid 智能体ID
-     * @param signature 签名
-     * @param localDir 本地公共文件目录
-     * @returns FileSync实例
-     */
-    initFileSync(aid: string, signature: string, localDir: string): FileSync;
-    /**
-     * 获取文件同步实例
-     * @returns FileSync实例
-     */
-    fs(): FileSync;
-    /**
-     * 快捷方法：同步公共文件
-     * @param aid 智能体ID
-     * @param signature 签名
-     * @param localDir 本地公共文件目录
-     * @returns 同步结果
-     */
-    syncPublicFiles(aid: string, signature: string, localDir: string): Promise<SyncResult>;
 }
 export { AgentManager };

package/dist/agentmanager.js

@@ -3,13 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentManager = void 0;
 const agentcp_1 = require("./agentcp");
 const agentws_1 = require("./agentws");
-const filesync_1 = require("./filesync");
 class AgentManager {
     constructor() {
         this.agentCP = null;
         this.agentWS = null;
-        this.fileSync = null;
-        this.apiUrl = '';
     }
     static getInstance() {
         if (!AgentManager.instance) {
@@ -17,10 +14,10 @@ class AgentManager {
         }
         return AgentManager.instance;
     }
-    initACP(apiUrl, seedPassword = "") {
-        this.apiUrl = apiUrl;
-        this.agentCP = new agentcp_1.AgentCP(apiUrl, seedPassword);
-        return this.agentCP;
+    initACP(apiUrl, seedPassword = "", basePath, options) {
+        const acp = new agentcp_1.AgentCP(apiUrl, seedPassword, basePath, options);
+        this.agentCP = acp;
+        return acp;
     }
     initAWS(aid, config) {
         const { messageServer, messageSignature } = config;
@@ -39,48 +36,5 @@ class AgentManager {
         }
         return this.agentWS;
     }
-    /**
-     * 初始化文件同步模块
-     * @param aid 智能体ID
-     * @param signature 签名
-     * @param localDir 本地公共文件目录
-     * @returns FileSync实例
-     */
-    initFileSync(aid, signature, localDir) {
-        if (!this.apiUrl) {
-            throw new Error("请先调用initACP初始化API地址");
-        }
-        // 构建完整的 API URL（与 AgentCP 保持一致）
-        const baseUrl = `https://acp3.${this.apiUrl}`;
-        const config = {
-            apiUrl: `${baseUrl}/api/accesspoint`,
-            aid: aid,
-            signature: signature,
-            localDir: localDir
-        };
-        this.fileSync = new filesync_1.FileSync(config);
-        return this.fileSync;
-    }
-    /**
-     * 获取文件同步实例
-     * @returns FileSync实例
-     */
-    fs() {
-        if (!this.fileSync) {
-            throw new Error("FileSync未初始化，请先调用initFileSync");
-        }
-        return this.fileSync;
-    }
-    /**
-     * 快捷方法：同步公共文件
-     * @param aid 智能体ID
-     * @param signature 签名
-     * @param localDir 本地公共文件目录
-     * @returns 同步结果
-     */
-    async syncPublicFiles(aid, signature, localDir) {
-        const fileSync = this.initFileSync(aid, signature, localDir);
-        return fileSync.syncPublicFiles();
-    }
 }
 exports.AgentManager = AgentManager;

package/dist/cli.js

@@ -107,6 +107,7 @@ function update() {
 const args = process.argv.slice(2);
 let port = 9527; // 使用非常用端口
 let apiUrl = 'aid.pub'; // 默认服务地址
+let dataDir = ''; // 数据目录
 // 解析命令行参数
 for (let i = 0; i < args.length; i++) {
     if (args[i] === 'update') {
@@ -140,6 +141,15 @@ for (let i = 0; i < args.length; i++) {
         apiUrl = urlArg;
         i++;
     }
+    else if (args[i] === '-d' || args[i] === '--data-dir') {
+        const dirArg = args[i + 1];
+        if (!dirArg || dirArg.startsWith('-')) {
+            console.error('错误: -d 参数需要指定数据目录路径');
+            process.exit(1);
+        }
+        dataDir = dirArg;
+        i++;
+    }
     else if (args[i] === '-h' || args[i] === '--help') {
         console.log(`
 acp-ts - 智能体通信调试工具 v${getVersion()}
@@ -152,6 +162,7 @@ acp-ts - 智能体通信调试工具 v${getVersion()}
   -v, --version        显示版本号
   -p, --port <端口>    指定服务端口 (默认: 9527)
   -u, --url <地址>     指定 API 服务器地址 (默认: aid.pub)
+  -d, --data-dir <路径> 指定数据目录 (默认: 当前目录)
   -h, --help           显示帮助信息
 
 安装:
@@ -165,4 +176,4 @@ acp-ts - 智能体通信调试工具 v${getVersion()}
         process.exit(0);
     }
 }
-(0, server_1.startServer)(port, apiUrl);
+(0, server_1.startServer)(port, apiUrl, dataDir);

package/dist/datamanager.d.ts

@@ -1,5 +1,8 @@
 export declare class CertAndKeyStore {
     static aidKey: string;
+    private static basePath;
+    static setBasePath(p: string): void;
+    static getAIDsDir(): string;
     static storeData(key: string, value: any): Promise<void>;
     static getData(key: string): Promise<any>;
     static getGuestAid(): Promise<string | null>;

package/dist/datamanager.js

@@ -105,7 +105,13 @@ else {
     }
 }
 class CertAndKeyStore {
-    // 存储数据
+    static setBasePath(p) {
+        this.basePath = p;
+    }
+    static getAIDsDir() {
+        return path.join(this.basePath, 'AIDs');
+    }
+    // 存储数据（仍用 storage.json，用于会话/消息）
     static async storeData(key, value) {
         try {
             await AsyncStorage.setItem(key, JSON.stringify(value));
@@ -114,7 +120,7 @@ class CertAndKeyStore {
             console.error(e);
         }
     }
-    // 获取数据
+    // 获取数据（仍用 storage.json，用于会话/消息）
     static async getData(key) {
         try {
             const value = await AsyncStorage.getItem(key);
@@ -151,48 +157,82 @@ class CertAndKeyStore {
         }
     }
     static async getAids() {
-        const aids = await this.getData(this.aidKey);
-        if (aids) {
-            return aids;
+        try {
+            const aidsDir = this.getAIDsDir();
+            if (!fs.existsSync(aidsDir)) {
+                return [];
+            }
+            const entries = fs.readdirSync(aidsDir, { withFileTypes: true });
+            return entries.filter(e => e.isDirectory()).map(e => e.name);
+        }
+        catch (e) {
+            console.error('扫描 AIDs 目录失败:', e);
+            return [];
         }
-        return [];
     }
     static async saveAid(aid) {
         try {
-            const aids = await this.getAids();
-            if (aids) {
-                if (!aids.includes(aid)) {
-                    const mergedAids = [...aids, aid];
-                    await this.storeData(this.aidKey, mergedAids);
-                }
+            const privateDir = path.join(this.getAIDsDir(), aid, 'private');
+            const publicDir = path.join(this.getAIDsDir(), aid, 'public');
+            if (!fs.existsSync(privateDir)) {
+                fs.mkdirSync(privateDir, { recursive: true });
             }
-            else {
-                await this.storeData(this.aidKey, [aid]);
+            if (!fs.existsSync(publicDir)) {
+                fs.mkdirSync(publicDir, { recursive: true });
             }
         }
         catch (e) {
-            console.error('保存数组失败:', e);
+            console.error('创建 AID 目录失败:', e);
         }
     }
     static async getCertificate(aid) {
-        return this.getData(`cert_${aid}`);
+        try {
+            const certPath = path.join(this.getAIDsDir(), aid, 'public', `${aid}.crt`);
+            if (fs.existsSync(certPath)) {
+                return fs.readFileSync(certPath, 'utf-8');
+            }
+            return null;
+        }
+        catch (e) {
+            console.error('读取证书失败:', e);
+            return null;
+        }
     }
     static async saveCertificate(aid, cert) {
-        await this.storeData(`cert_${aid}`, cert);
+        await this.saveAid(aid);
+        const certPath = path.join(this.getAIDsDir(), aid, 'public', `${aid}.crt`);
+        fs.writeFileSync(certPath, cert, 'utf-8');
     }
     static async getCsr(aid) {
-        return this.getData(`csr_${aid}`);
+        try {
+            const csrPath = path.join(this.getAIDsDir(), aid, 'private', `${aid}.csr`);
+            if (fs.existsSync(csrPath)) {
+                return fs.readFileSync(csrPath, 'utf-8');
+            }
+            return null;
+        }
+        catch (e) {
+            console.error('读取 CSR 失败:', e);
+            return null;
+        }
     }
     static async saveCsr(aid, csr) {
-        await this.storeData(`csr_${aid}`, csr);
+        await this.saveAid(aid);
+        const csrPath = path.join(this.getAIDsDir(), aid, 'private', `${aid}.csr`);
+        fs.writeFileSync(csrPath, csr, 'utf-8');
     }
     static async savePrivateKey(aid, key) {
-        await this.storeData(`private_key_${aid}`, key);
+        await this.saveAid(aid);
+        const keyPath = path.join(this.getAIDsDir(), aid, 'private', `${aid}.key`);
+        fs.writeFileSync(keyPath, key, 'utf-8');
     }
     static async getPrivateKey(aid) {
         try {
-            const encryptedKey = await this.getData(`private_key_${aid}`);
-            return encryptedKey;
+            const keyPath = path.join(this.getAIDsDir(), aid, 'private', `${aid}.key`);
+            if (fs.existsSync(keyPath)) {
+                return fs.readFileSync(keyPath, 'utf-8');
+            }
+            return null;
         }
         catch (error) {
             console.error('获取私钥失败:', error);
@@ -202,3 +242,4 @@ class CertAndKeyStore {
 }
 exports.CertAndKeyStore = CertAndKeyStore;
 CertAndKeyStore.aidKey = 'currentAidKey';
+CertAndKeyStore.basePath = process.cwd();

package/dist/index.d.ts

@@ -2,6 +2,6 @@ import { ConnectionStatus } from "./websocket";
 import { AgentManager } from './agentmanager';
 import { IAgentIdentity } from './interfaces';
 import { HeartbeatClient, HeartbeatStatus, InviteInfo } from './heartbeat';
-import { FileSync, FileSyncStatus, LocalFileInfo, SyncResult, FileSyncConfig } from './filesync';
-export { AgentManager, IAgentIdentity, HeartbeatClient, FileSync };
-export type { ConnectionStatus, HeartbeatStatus, InviteInfo, FileSyncStatus, LocalFileInfo, SyncResult, FileSyncConfig, };
+import { MessageStore, MessageItem, SessionRecord, Session, SessionSummary } from './messagestore';
+export { AgentManager, IAgentIdentity, HeartbeatClient, MessageStore };
+export type { ConnectionStatus, HeartbeatStatus, InviteInfo, MessageItem, SessionRecord, Session, SessionSummary, };

package/dist/index.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSync = exports.HeartbeatClient = exports.AgentManager = void 0;
+exports.MessageStore = exports.HeartbeatClient = exports.AgentManager = void 0;
 const agentmanager_1 = require("./agentmanager");
 Object.defineProperty(exports, "AgentManager", { enumerable: true, get: function () { return agentmanager_1.AgentManager; } });
 const heartbeat_1 = require("./heartbeat");
 Object.defineProperty(exports, "HeartbeatClient", { enumerable: true, get: function () { return heartbeat_1.HeartbeatClient; } });
-const filesync_1 = require("./filesync");
-Object.defineProperty(exports, "FileSync", { enumerable: true, get: function () { return filesync_1.FileSync; } });
+const messagestore_1 = require("./messagestore");
+Object.defineProperty(exports, "MessageStore", { enumerable: true, get: function () { return messagestore_1.MessageStore; } });

package/dist/interfaces.d.ts

@@ -1,4 +1,5 @@
 import { ACPMessageSessionResponse, ConnectionStatus, InviteStatus } from "./websocket";
+import { MessageStore } from "./messagestore";
 /**
  * 代理身份信息接口
  * @interface IAgentIdentity
@@ -28,6 +29,10 @@ interface IConnectionConfig {
  * @interface IAgentCP
  */
 interface IAgentCP {
+    /**
+     * 消息存储模块
+     */
+    readonly messageStore: MessageStore;
     /**
      * 导入代理身份
      * @param {IAgentIdentity} identity - 代理身份信息

package/dist/messagestore.d.ts

@@ -0,0 +1,65 @@
+export type MessageItem = {
+    type: 'sent' | 'received';
+    content: string;
+    from?: string;
+    to?: string;
+    timestamp: number;
+};
+export interface SessionRecord {
+    sessionId: string;
+    identifyingCode: string;
+    peerAid: string;
+    ownerAid: string;
+    type: 'outgoing' | 'incoming';
+    createdAt: number;
+    lastMessageAt: number;
+    messageCount: number;
+    closed: boolean;
+}
+export interface Session extends SessionRecord {
+    messages: MessageItem[];
+}
+export interface SessionSummary {
+    sessionId: string;
+    peerAid: string;
+    ownerAid: string;
+    type: 'outgoing' | 'incoming';
+    lastMessageAt: number;
+    messageCount: number;
+    createdAt: number;
+    lastMessage: string;
+    closed: boolean;
+}
+export declare class MessageStore {
+    private persistMessages;
+    private basePath;
+    private maxMessagesPerSession;
+    private sessions;
+    constructor(options: {
+        persistMessages: boolean;
+        basePath: string;
+        maxMessagesPerSession?: number;
+    });
+    private getSessionsDir;
+    private getIndexPath;
+    private getSessionFilePath;
+    private ensureDir;
+    loadSessionsForAid(ownerAid: string): Promise<void>;
+    /** 从 JSONL 文件读取消息列表 */
+    private readMessagesFromFile;
+    private migrateFromLegacy;
+    getOrCreateSession(sessionId: string, identifyingCode: string, peerAid: string, type: 'outgoing' | 'incoming', ownerAid: string): Session;
+    addMessageToSession(sessionId: string, msg: MessageItem): void;
+    getSessionList(ownerAid: string): SessionSummary[];
+    hasSession(sessionId: string): boolean;
+    getSession(sessionId: string): Session | null;
+    /** 只写索引文件 */
+    flushIndex(ownerAid: string): Promise<void>;
+    /** 全量重写单个会话的消息文件（JSONL 格式） */
+    flushSession(ownerAid: string, sessionId: string): Promise<void>;
+    /** 追加单条消息到 JSONL 文件 */
+    private appendMessage;
+    /** 全量写入指定 AID 的索引 + 所有会话消息文件 */
+    flush(ownerAid: string): Promise<void>;
+    flushAll(): Promise<void>;
+}