@bolloon/bolloon-agent 0.1.36 → 0.1.38

package/src/network/storage/adapters/json-adapter.ts

@@ -1,454 +0,0 @@
-/**
- * JSON File Adapter for MessageStore
- * 基于 JSON 文件的消息存储实现
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as fsSync from 'fs';
-import * as crypto from 'crypto';
-
-import type {
-  MessageStore,
-  StoredMessage,
-  OfflineMessage,
-  PendingResponse,
-  MessageQueryOptions,
-  StorageConfig,
-  MessageStatus,
-} from '../types';
-
-const DEFAULT_CONFIG: Required<StorageConfig> = {
-  baseDir: '',
-  maxFileSize: 10 * 1024 * 1024,  // 10MB
-  maxMessagesPerFile: 1000,
-  fileNamingStrategy: 'daily',
-  maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
-};
-
-interface FileLock {
-  release: () => void;
-}
-
-export class JsonMessageStore implements MessageStore {
-  private config: Required<StorageConfig>;
-  private initialized: boolean = false;
-  private offlineMessages: Map<string, OfflineMessage[]> = new Map();
-  private pendingResponses: Map<string, PendingResponse> = new Map();
-  private locks: Map<string, Promise<FileLock>> = new Map();
-
-  constructor(config: StorageConfig) {
-    // 设置默认基础路径
-    const baseDir = config.baseDir || path.join(process.env.HOME || '/tmp', '.bolloon', 'messages');
-    this.config = { ...DEFAULT_CONFIG, ...config, baseDir };
-  }
-
-  async initialize(): Promise<void> {
-    // 创建必要的目录
-    await fs.mkdir(this.config.baseDir, { recursive: true });
-    await fs.mkdir(path.join(this.config.baseDir, 'offline'), { recursive: true });
-    await fs.mkdir(path.join(this.config.baseDir, 'pending'), { recursive: true });
-
-    // 加载离线消息
-    await this.loadOfflineMessages();
-
-    // 加载待响应请求
-    await this.loadPendingResponses();
-
-    this.initialized = true;
-    console.log(`[JsonMessageStore] Initialized at ${this.config.baseDir}`);
-  }
-
-  // ============================================================================
-  // 消息持久化
-  // ============================================================================
-
-  async saveMessage(msg: Omit<StoredMessage, 'id'>): Promise<StoredMessage> {
-    const id = crypto.randomUUID();
-    const stored: StoredMessage = { ...msg, id };
-    const filePath = this.getMessageFilePath(new Date(msg.timestamp));
-
-    await this.withLock(filePath, async () => {
-      let messages = await this.readJsonFile<StoredMessage[]>(filePath) || [];
-      messages.push(stored);
-
-      // 如果文件过大，拆分
-      if (messages.length > this.config.maxMessagesPerFile) {
-        const newFile = this.getMessageFilePath(new Date(), true);
-        await this.writeJsonFile(newFile, messages.slice(this.config.maxMessagesPerFile / 2));
-        messages = messages.slice(0, this.config.maxMessagesPerFile / 2);
-      }
-
-      await this.writeJsonFile(filePath, messages);
-    });
-
-    return stored;
-  }
-
-  async getMessage(id: string): Promise<StoredMessage | null> {
-    const allMessages = await this.getAllMessageFiles();
-    for (const file of allMessages) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file) || [];
-      const found = messages.find(m => m.id === id);
-      if (found) return found;
-    }
-    return null;
-  }
-
-  async updateMessageStatus(id: string, status: MessageStatus): Promise<void> {
-    const allFiles = await this.getAllMessageFiles();
-    for (const file of allFiles) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file);
-      if (!messages) continue;
-
-      const idx = messages.findIndex(m => m.id === id);
-      if (idx >= 0) {
-        messages[idx].status = status;
-        await this.writeJsonFile(file, messages);
-        return;
-      }
-    }
-  }
-
-  async getMessages(options?: MessageQueryOptions): Promise<StoredMessage[]> {
-    const allMessages: StoredMessage[] = [];
-    const files = await this.getAllMessageFiles();
-
-    for (const file of files) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file) || [];
-      allMessages.push(...messages);
-    }
-
-    // 过滤
-    let filtered = allMessages;
-
-    if (options?.direction) {
-      filtered = filtered.filter(m => m.direction === options.direction);
-    }
-    if (options?.type) {
-      filtered = filtered.filter(m => m.type === options.type);
-    }
-    if (options?.from) {
-      filtered = filtered.filter(m => m.from === options.from);
-    }
-    if (options?.to) {
-      filtered = filtered.filter(m => m.to === options.to);
-    }
-    if (options?.startTime) {
-      filtered = filtered.filter(m => m.timestamp >= options.startTime!);
-    }
-    if (options?.endTime) {
-      filtered = filtered.filter(m => m.timestamp <= options.endTime!);
-    }
-    if (options?.status) {
-      filtered = filtered.filter(m => m.status === options.status);
-    }
-
-    // 排序和分页
-    filtered.sort((a, b) => b.timestamp - a.timestamp);
-
-    if (options?.offset) {
-      filtered = filtered.slice(options.offset);
-    }
-    if (options?.limit) {
-      filtered = filtered.slice(0, options.limit);
-    }
-
-    return filtered;
-  }
-
-  async deleteMessage(id: string): Promise<void> {
-    const allFiles = await this.getAllMessageFiles();
-    for (const file of allFiles) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file);
-      if (!messages) continue;
-
-      const idx = messages.findIndex(m => m.id === id);
-      if (idx >= 0) {
-        messages.splice(idx, 1);
-        await this.writeJsonFile(file, messages);
-        return;
-      }
-    }
-  }
-
-  // ============================================================================
-  // 离线消息队列
-  // ============================================================================
-
-  async enqueueOfflineMessage(msg: Omit<OfflineMessage, 'id'>): Promise<OfflineMessage> {
-    const id = crypto.randomUUID();
-    const offline: OfflineMessage = { ...msg, id };
-
-    // 更新内存缓存
-    const queue = this.offlineMessages.get(msg.targetNodeId) || [];
-    queue.push(offline);
-    this.offlineMessages.set(msg.targetNodeId, queue);
-
-    // 持久化到文件
-    const filePath = this.getOfflineFilePath(msg.targetNodeId);
-    await this.writeJsonFile(filePath, queue);
-
-    console.log(`[JsonMessageStore] Enqueued offline message for ${msg.targetNodeId}`);
-    return offline;
-  }
-
-  async getOfflineMessages(targetNodeId: string): Promise<OfflineMessage[]> {
-    // 优先从内存返回
-    if (this.offlineMessages.has(targetNodeId)) {
-      return this.offlineMessages.get(targetNodeId)!;
-    }
-
-    // 从文件加载
-    const filePath = this.getOfflineFilePath(targetNodeId);
-    const messages = await this.readJsonFile<OfflineMessage[]>(filePath) || [];
-    this.offlineMessages.set(targetNodeId, messages);
-    return messages;
-  }
-
-  async dequeueOfflineMessage(id: string): Promise<void> {
-    for (const [targetId, queue] of this.offlineMessages.entries()) {
-      const idx = queue.findIndex(m => m.id === id);
-      if (idx >= 0) {
-        queue.splice(idx, 1);
-        this.offlineMessages.set(targetId, queue);
-        await this.writeJsonFile(this.getOfflineFilePath(targetId), queue);
-        return;
-      }
-    }
-  }
-
-  async incrementOfflineRetry(id: string): Promise<void> {
-    for (const [targetId, queue] of this.offlineMessages.entries()) {
-      const idx = queue.findIndex(m => m.id === id);
-      if (idx >= 0) {
-        queue[idx].retryCount++;
-        this.offlineMessages.set(targetId, queue);
-        await this.writeJsonFile(this.getOfflineFilePath(targetId), queue);
-        return;
-      }
-    }
-  }
-
-  async getPendingOfflineCount(): Promise<number> {
-    let count = 0;
-    for (const queue of this.offlineMessages.values()) {
-      count += queue.length;
-    }
-    return count;
-  }
-
-  async getAllOfflineTargets(): Promise<string[]> {
-    // 重新从磁盘加载最新状态（避免内存 vs 磁盘不一致）
-    const baseDir = path.join(this.config.baseDir, 'offline');
-    let files: string[] = [];
-    try {
-      files = await fs.readdir(baseDir);
-    } catch {
-      return Array.from(this.offlineMessages.keys());
-    }
-    return files
-      .filter((f) => f.endsWith('.json'))
-      .map((f) => f.replace(/\.json$/, ''))
-      .filter((id) => id.length > 0);
-  }
-
-  // ============================================================================
-  // 待响应请求
-  // ============================================================================
-
-  async savePendingResponse(req: Omit<PendingResponse, 'id'>): Promise<PendingResponse> {
-    const id = crypto.randomUUID();
-    const pending: PendingResponse = { ...req, id };
-
-    this.pendingResponses.set(req.requestId, pending);
-    await this.savePendingResponsesToFile();
-
-    console.log(`[JsonMessageStore] Saved pending response ${req.requestId}`);
-    return pending;
-  }
-
-  async getPendingResponse(requestId: string): Promise<PendingResponse | null> {
-    // 优先从内存返回
-    if (this.pendingResponses.has(requestId)) {
-      return this.pendingResponses.get(requestId)!;
-    }
-
-    // 尝试从文件恢复
-    await this.loadPendingResponses();
-    return this.pendingResponses.get(requestId) || null;
-  }
-
-  async removePendingResponse(requestId: string): Promise<void> {
-    this.pendingResponses.delete(requestId);
-    await this.savePendingResponsesToFile();
-  }
-
-  // ============================================================================
-  // 统计与清理
-  // ============================================================================
-
-  async getMessageCount(): Promise<number> {
-    const files = await this.getAllMessageFiles();
-    let count = 0;
-    for (const file of files) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file);
-      if (messages) count += messages.length;
-    }
-    return count;
-  }
-
-  async getOfflineMessageCount(): Promise<number> {
-    return this.getPendingOfflineCount();
-  }
-
-  async pruneOldMessages(maxAgeMs: number): Promise<number> {
-    const cutoff = Date.now() - maxAgeMs;
-    let pruned = 0;
-    const files = await this.getAllMessageFiles();
-
-    for (const file of files) {
-      const messages = await this.readJsonFile<StoredMessage[]>(file);
-      if (!messages) continue;
-
-      const originalLen = messages.length;
-      const filtered = messages.filter(m => m.timestamp >= cutoff || m.status === 'pending');
-
-      if (filtered.length < originalLen) {
-        pruned += originalLen - filtered.length;
-        await this.writeJsonFile(file, filtered);
-      }
-    }
-
-    console.log(`[JsonMessageStore] Pruned ${pruned} old messages`);
-    return pruned;
-  }
-
-  // ============================================================================
-  // 生命周期
-  // ============================================================================
-
-  async shutdown(): Promise<void> {
-    // 保存所有待处理数据
-    await this.savePendingResponsesToFile();
-
-    for (const [targetId, queue] of this.offlineMessages.entries()) {
-      if (queue.length > 0) {
-        await this.writeJsonFile(this.getOfflineFilePath(targetId), queue);
-      }
-    }
-
-    this.initialized = false;
-    console.log('[JsonMessageStore] Shutdown complete');
-  }
-
-  // ============================================================================
-  // 私有辅助方法
-  // ============================================================================
-
-  private getMessageFilePath(date: Date, useNewFile = false): string {
-    const dateStr = this.config.fileNamingStrategy === 'daily'
-      ? date.toISOString().split('T')[0]
-      : `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
-
-    const filename = useNewFile
-      ? `messages-${dateStr}-${Date.now()}.json`
-      : `messages-${dateStr}.json`;
-
-    return path.join(this.config.baseDir, filename);
-  }
-
-  private getOfflineFilePath(nodeId: string): string {
-    // 清理 nodeId 中的非法字符
-    const safeId = nodeId.replace(/[^a-zA-Z0-9_-]/g, '_');
-    return path.join(this.config.baseDir, 'offline', `${safeId}.json`);
-  }
-
-  private getPendingFilePath(): string {
-    return path.join(this.config.baseDir, 'pending', 'responses.json');
-  }
-
-  private async getAllMessageFiles(): Promise<string[]> {
-    try {
-      const files = await fs.readdir(this.config.baseDir);
-      return files
-        .filter(f => f.startsWith('messages-') && f.endsWith('.json'))
-        .map(f => path.join(this.config.baseDir, f));
-    } catch {
-      return [];
-    }
-  }
-
-  private async readJsonFile<T>(filePath: string): Promise<T | null> {
-    try {
-      const content = await fs.readFile(filePath, 'utf-8');
-      return JSON.parse(content) as T;
-    } catch {
-      return null;
-    }
-  }
-
-  private async writeJsonFile(filePath: string, data: unknown): Promise<void> {
-    const dir = path.dirname(filePath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
-  }
-
-  private async loadOfflineMessages(): Promise<void> {
-    const offlineDir = path.join(this.config.baseDir, 'offline');
-    try {
-      const files = await fs.readdir(offlineDir);
-      for (const file of files) {
-        if (!file.endsWith('.json')) continue;
-        const nodeId = file.replace('.json', '');
-        const messages = await this.readJsonFile<OfflineMessage[]>(path.join(offlineDir, file));
-        if (messages) {
-          this.offlineMessages.set(nodeId, messages);
-        }
-      }
-    } catch {
-      // 目录不存在或为空
-    }
-  }
-
-  private async loadPendingResponses(): Promise<void> {
-    const filePath = this.getPendingFilePath();
-    const data = await this.readJsonFile<PendingResponse[]>(filePath);
-    if (data) {
-      for (const req of data) {
-        this.pendingResponses.set(req.requestId, req);
-      }
-    }
-  }
-
-  private async savePendingResponsesToFile(): Promise<void> {
-    const data = Array.from(this.pendingResponses.values());
-    await this.writeJsonFile(this.getPendingFilePath(), data);
-  }
-
-  private async withLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
-    // 简化的文件锁实现
-    const lockKey = filePath;
-
-    // 等待现有锁
-    while (this.locks.has(lockKey)) {
-      await this.locks.get(lockKey);
-    }
-
-    // 获取新锁
-    let releaseLock: () => void;
-    const lockPromise = new Promise<FileLock>((resolve) => {
-      releaseLock = () => {
-        this.locks.delete(lockKey);
-        resolve({ release: () => {} });
-      };
-    });
-    this.locks.set(lockKey, lockPromise);
-
-    try {
-      return await fn();
-    } finally {
-      releaseLock!();
-    }
-  }
-}

package/src/network/storage/index.ts

@@ -1,203 +0,0 @@
-/**
- * Storage Layer Entry Point
- * 导出消息存储工厂函数和类型
- */
-
-import type {
-  MessageStore,
-  StoredMessage,
-  OfflineMessage,
-  PendingResponse,
-  LocalPendingRequest,
-  MessageQueryOptions,
-  StorageConfig,
-  MessageDirection,
-  MessageStatus,
-  TransportType,
-  IrohPeer,
-  IrohMessage,
-  IrohMessageHandler,
-} from './types.js';
-import { DEFAULT_STORAGE_CONFIG } from './types.js';
-
-export type {
-  MessageStore,
-  StoredMessage,
-  OfflineMessage,
-  PendingResponse,
-  LocalPendingRequest,
-  MessageQueryOptions,
-  StorageConfig,
-  MessageDirection,
-  MessageStatus,
-  TransportType,
-  IrohPeer,
-  IrohMessage,
-  IrohMessageHandler,
-};
-
-export { DEFAULT_STORAGE_CONFIG };
-
-import { JsonMessageStore } from './adapters/json-adapter.js';
-import * as path from 'path';
-
-// 默认存储配置
-const DEFAULT_BASE_DIR = path.join(
-  process.env.HOME || '/tmp',
-  '.bolloon',
-  'messages'
-);
-
-/**
- * 创建消息存储实例
- * @param transport 传输类型 ('iroh' | 'libp2p')
- * @param config 存储配置
- * @returns MessageStore 实例
- */
-export async function createMessageStore(
-  transport: 'iroh' | 'libp2p' = 'libp2p',
-  config?: Partial<StorageConfig>
-): Promise<MessageStore> {
-  const fullConfig: StorageConfig = {
-    baseDir: config?.baseDir || DEFAULT_BASE_DIR,
-    maxFileSize: config?.maxFileSize || 10 * 1024 * 1024,
-    maxMessagesPerFile: config?.maxMessagesPerFile || 1000,
-    fileNamingStrategy: config?.fileNamingStrategy || 'daily',
-    maxAge: config?.maxAge || 30 * 24 * 60 * 60 * 1000,
-  };
-
-  const store = new JsonMessageStore(fullConfig);
-  await store.initialize();
-
-  console.log(`[Storage] Created ${transport} message store at ${fullConfig.baseDir}`);
-  return store;
-}
-
-/**
- * 创建离线消息存储（无持久化，仅内存）
- * 用于不需要消息历史的轻量级场景
- */
-export function createInMemoryStore(): MessageStore {
-  const messages: Map<string, StoredMessage> = new Map();
-  const offlineQueues: Map<string, OfflineMessage[]> = new Map();
-  const pendingResponses: Map<string, PendingResponse> = new Map();
-
-  return {
-    async saveMessage(msg) {
-      const id = crypto.randomUUID();
-      const stored = { ...msg, id };
-      messages.set(id, stored);
-      return stored;
-    },
-
-    async getMessage(id) {
-      return messages.get(id) || null;
-    },
-
-    async updateMessageStatus(id, status) {
-      const msg = messages.get(id);
-      if (msg) {
-        msg.status = status;
-        messages.set(id, msg);
-      }
-    },
-
-    async getMessages(options) {
-      let result = Array.from(messages.values());
-      if (options?.direction) result = result.filter(m => m.direction === options.direction);
-      if (options?.type) result = result.filter(m => m.type === options.type);
-      if (options?.from) result = result.filter(m => m.from === options.from);
-      if (options?.to) result = result.filter(m => m.to === options.to);
-      if (options?.startTime) result = result.filter(m => m.timestamp >= options.startTime!);
-      if (options?.endTime) result = result.filter(m => m.timestamp <= options.endTime!);
-      if (options?.status) result = result.filter(m => m.status === options.status);
-      result.sort((a, b) => b.timestamp - a.timestamp);
-      if (options?.offset) result = result.slice(options.offset);
-      if (options?.limit) result = result.slice(0, options.limit);
-      return result;
-    },
-
-    async deleteMessage(id) {
-      messages.delete(id);
-    },
-
-    async enqueueOfflineMessage(msg) {
-      const id = crypto.randomUUID();
-      const offline = { ...msg, id };
-      const queue = offlineQueues.get(msg.targetNodeId) || [];
-      queue.push(offline);
-      offlineQueues.set(msg.targetNodeId, queue);
-      return offline;
-    },
-
-    async getOfflineMessages(targetNodeId) {
-      return offlineQueues.get(targetNodeId) || [];
-    },
-
-    async dequeueOfflineMessage(id) {
-      for (const [nodeId, queue] of offlineQueues.entries()) {
-        const idx = queue.findIndex(m => m.id === id);
-        if (idx >= 0) {
-          queue.splice(idx, 1);
-          offlineQueues.set(nodeId, queue);
-          return;
-        }
-      }
-    },
-
-    async incrementOfflineRetry(id) {
-      for (const queue of offlineQueues.values()) {
-        const msg = queue.find(m => m.id === id);
-        if (msg) {
-          msg.retryCount++;
-          return;
-        }
-      }
-    },
-
-    async getPendingOfflineCount() {
-      let count = 0;
-      for (const queue of offlineQueues.values()) {
-        count += queue.length;
-      }
-      return count;
-    },
-
-    async savePendingResponse(req) {
-      const id = crypto.randomUUID();
-      const pending = { ...req, id };
-      pendingResponses.set(req.requestId, pending);
-      return pending;
-    },
-
-    async getPendingResponse(requestId) {
-      return pendingResponses.get(requestId) || null;
-    },
-
-    async removePendingResponse(requestId) {
-      pendingResponses.delete(requestId);
-    },
-
-    async getMessageCount() {
-      return messages.size;
-    },
-
-    async getOfflineMessageCount() {
-      return this.getPendingOfflineCount();
-    },
-
-    async pruneOldMessages() {
-      return 0;
-    },
-
-    async initialize() {},
-    async shutdown() {
-      messages.clear();
-      offlineQueues.clear();
-      pendingResponses.clear();
-    },
-  };
-}
-
-// 导入 crypto 用于内存存储的 ID 生成
-import * as crypto from 'crypto';