@bolloon/bolloon-agent 0.1.35 → 0.1.37

package/src/documents/reader.ts

@@ -1,85 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import pdfParse from 'pdf-parse';
-import mammoth from 'mammoth';
-
-export interface DocumentContent {
-  text: string;
-  metadata: {
-    filename: string;
-    size: number;
-    type: string;
-  };
-}
-
-export class DocumentReader {
-  async read(filePath: string): Promise<DocumentContent> {
-    const stats = await fs.stat(filePath);
-    const ext = path.extname(filePath).toLowerCase();
-    const filename = path.basename(filePath);
-
-    let text: string;
-
-    switch (ext) {
-      case '.txt':
-      case '.md':
-      case '.html':
-      case '.htm':
-      case '.yaml':
-      case '.yml':
-      case '.json':
-        text = await fs.readFile(filePath, 'utf-8');
-        break;
-      case '.pdf':
-        text = await this.readPdf(filePath);
-        break;
-      case '.docx':
-        text = await this.readDocx(filePath);
-        break;
-      default:
-        throw new Error(`Unsupported file type: ${ext}`);
-    }
-
-    return {
-      text,
-      metadata: {
-        filename,
-        size: stats.size,
-        type: ext
-      }
-    };
-  }
-
-  private async readPdf(filePath: string): Promise<string> {
-    const dataBuffer = await fs.readFile(filePath);
-    // @ts-ignore - pdf-parse v2 API differs
-    const data = await pdfParse(dataBuffer);
-    return data.text;
-  }
-
-  private async readDocx(filePath: string): Promise<string> {
-    const result = await mammoth.extractRawText({ path: filePath });
-    return result.value;
-  }
-
-  chunk(text: string, maxChunkSize: number = 4000): string[] {
-    const chunks: string[] = [];
-    let current = '';
-
-    const sentences = text.split(/(?<=[.!?。！？])\s+/);
-
-    for (const sentence of sentences) {
-      if ((current + sentence).length <= maxChunkSize) {
-        current += (current ? ' ' : '') + sentence;
-      } else {
-        if (current) chunks.push(current);
-        current = sentence;
-      }
-    }
-
-    if (current) chunks.push(current);
-    return chunks;
-  }
-}
-
-export const documentReader = new DocumentReader();

package/src/documents/store.ts

@@ -1,252 +0,0 @@
-/**
- * Document Store - P2P Document Receiving and Storage
- * 接收并存储来自其他 iroh 节点的文档
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as crypto from 'crypto';
-
-export interface DocumentChunk {
-  docId: string;
-  fileName: string;
-  fileSize: number;
-  mimeType: string;
-  chunkIndex: number;
-  totalChunks: number;
-  content: string;  // Base64 encoded
-  fromNodeId: string;
-  message?: string;
-  timestamp: number;
-}
-
-export interface ReceivedDocument {
-  id: string;
-  fileName: string;
-  fileSize: number;
-  mimeType: string;
-  fromNodeId: string;
-  fromNodeIdShort: string;
-  receivedAt: number;
-  message?: string;
-  path: string;
-}
-
-export type DocumentReceivedCallback = (doc: ReceivedDocument) => void;
-
-interface PendingDocument {
-  docId: string;
-  fileName: string;
-  fileSize: number;
-  mimeType: string;
-  totalChunks: number;
-  receivedChunks: Map<number, string>;  // chunkIndex -> Base64 content
-  fromNodeId: string;
-  message?: string;
-  timestamp: number;
-}
-
-export class DocumentStore {
-  private baseDir: string;
-  private pendingDocs: Map<string, PendingDocument> = new Map();
-  private receivedCallback: DocumentReceivedCallback | null = null;
-
-  constructor(baseDir?: string) {
-    this.baseDir = baseDir || path.join(process.env.HOME || '/tmp', '.bolloon', 'documents', 'received');
-  }
-
-  async initialize(): Promise<void> {
-    await fs.mkdir(this.baseDir, { recursive: true });
-    await fs.mkdir(path.join(this.baseDir, 'chunks'), { recursive: true });
-    console.log('[DocumentStore] Initialized at', this.baseDir);
-  }
-
-  onDocumentReceived(callback: DocumentReceivedCallback): void {
-    this.receivedCallback = callback;
-  }
-
-  async receiveChunk(chunk: DocumentChunk): Promise<ReceivedDocument | null> {
-    const { docId, chunkIndex, totalChunks, fileName, fileSize, mimeType, content, fromNodeId, message, timestamp } = chunk;
-
-    // 获取或创建 pending document
-    let pending = this.pendingDocs.get(docId);
-    if (!pending) {
-      pending = {
-        docId,
-        fileName,
-        fileSize,
-        mimeType,
-        totalChunks,
-        receivedChunks: new Map(),
-        fromNodeId,
-        message,
-        timestamp,
-      };
-      this.pendingDocs.set(docId, pending);
-    }
-
-    // 存储分块
-    pending.receivedChunks.set(chunkIndex, content);
-
-    // 检查是否收齐
-    if (pending.receivedChunks.size >= totalChunks) {
-      return this.assembleDocument(docId);
-    }
-
-    return null;
-  }
-
-  private async assembleDocument(docId: string): Promise<ReceivedDocument | null> {
-    const pending = this.pendingDocs.get(docId);
-    if (!pending) return null;
-
-    try {
-      // 按顺序合并所有分块
-      const allContent: number[] = [];
-      for (let i = 0; i < pending.totalChunks; i++) {
-        const chunkContent = pending.receivedChunks.get(i);
-        if (!chunkContent) {
-          console.warn(`[DocumentStore] Missing chunk ${i} for doc ${docId}`);
-          return null;
-        }
-        const bytes = Uint8Array.from(atob(chunkContent), c => c.charCodeAt(0));
-        allContent.push(...Array.from(bytes));
-      }
-
-      // 创建文档目录
-      const docDir = path.join(this.baseDir, docId);
-      await fs.mkdir(docDir, { recursive: true });
-
-      // 保存文件
-      const filePath = path.join(docDir, pending.fileName);
-      await fs.writeFile(filePath, Buffer.from(allContent));
-
-      // 保存 manifest
-      const manifest = {
-        id: docId,
-        fileName: pending.fileName,
-        fileSize: pending.fileSize,
-        mimeType: pending.mimeType,
-        fromNodeId: pending.fromNodeId,
-        receivedAt: Date.now(),
-        message: pending.message,
-      };
-      await fs.writeFile(path.join(docDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
-
-      // 更新索引
-      await this.updateIndex(manifest);
-
-      // 清理 pending
-      this.pendingDocs.delete(docId);
-
-      const receivedDoc: ReceivedDocument = {
-        ...manifest,
-        fromNodeIdShort: pending.fromNodeId.substring(0, 16) + '...',
-        path: filePath,
-      };
-
-      // 触发回调
-      if (this.receivedCallback) {
-        this.receivedCallback(receivedDoc);
-      }
-
-      console.log(`[DocumentStore] Document assembled: ${pending.fileName} (${pending.fileSize} bytes)`);
-      return receivedDoc;
-    } catch (e) {
-      console.error('[DocumentStore] Failed to assemble document:', e);
-      this.pendingDocs.delete(docId);
-      return null;
-    }
-  }
-
-  private async updateIndex(manifest: any): Promise<void> {
-    const indexPath = path.join(this.baseDir, 'index.json');
-    let index: any[] = [];
-
-    try {
-      const existing = await fs.readFile(indexPath, 'utf-8');
-      index = JSON.parse(existing);
-    } catch {
-      // Index doesn't exist yet
-    }
-
-    // 添加新文档
-    index.unshift(manifest);  // newest first
-
-    // 只保留最近 100 条
-    if (index.length > 100) {
-      index = index.slice(0, 100);
-    }
-
-    await fs.writeFile(indexPath, JSON.stringify(index, null, 2));
-  }
-
-  async getReceivedDocuments(limit: number = 50, senderPeerId?: string): Promise<ReceivedDocument[]> {
-    const indexPath = path.join(this.baseDir, 'index.json');
-
-    try {
-      const data = await fs.readFile(indexPath, 'utf-8');
-      let docs: any[] = JSON.parse(data);
-
-      if (senderPeerId) {
-        docs = docs.filter(d => d.fromNodeId === senderPeerId);
-      }
-
-      return docs.slice(0, limit).map(doc => ({
-        ...doc,
-        fromNodeIdShort: doc.fromNodeId.substring(0, 16) + '...',
-        path: path.join(this.baseDir, doc.id, doc.fileName),
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  async readDocument(docId: string): Promise<{ content: string; metadata: ReceivedDocument } | null> {
-    const docDir = path.join(this.baseDir, docId);
-    const manifestPath = path.join(docDir, 'manifest.json');
-
-    try {
-      const manifestData = await fs.readFile(manifestPath, 'utf-8');
-      const manifest = JSON.parse(manifestData);
-      const filePath = path.join(docDir, manifest.fileName);
-      const fileContent = await fs.readFile(filePath, 'utf-8');
-
-      return {
-        content: fileContent,
-        metadata: {
-          ...manifest,
-          fromNodeIdShort: manifest.fromNodeId.substring(0, 16) + '...',
-          path: filePath,
-        },
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  async deleteDocument(docId: string): Promise<boolean> {
-    const docDir = path.join(this.baseDir, docId);
-
-    try {
-      await fs.rm(docDir, { recursive: true });
-
-      // 更新索引
-      const indexPath = path.join(this.baseDir, 'index.json');
-      try {
-        const data = await fs.readFile(indexPath, 'utf-8');
-        let index: any[] = JSON.parse(data);
-        index = index.filter(d => d.id !== docId);
-        await fs.writeFile(indexPath, JSON.stringify(index, null, 2));
-      } catch {
-        // Index doesn't exist
-      }
-
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-export const documentStore = new DocumentStore();

package/src/electron-preload.ts

@@ -1,25 +0,0 @@
-/**
- * Electron Preload 脚本
- * 在渲染进程和主进程之间建立安全的通信桥梁
- */
-import { contextBridge, ipcRenderer } from 'electron';
-
-// 暴露给渲染进程的 API
-contextBridge.exposeInMainWorld('electronAPI', {
-  getVersion: () => ipcRenderer.invoke('get-version'),
-  getUserDataPath: () => ipcRenderer.invoke('get-user-data-path'),
-  openExternal: (url: string) => ipcRenderer.invoke('open-external', url),
-  platform: process.platform,
-});
-
-// 类型声明
-declare global {
-  interface Window {
-    electronAPI: {
-      getVersion: () => Promise<string>;
-      getUserDataPath: () => Promise<string>;
-      openExternal: (url: string) => Promise<void>;
-      platform: string;
-    };
-  }
-}

package/src/electron.ts

@@ -1,200 +0,0 @@
-/**
- * Electron 主进程入口
- */
-import { app, BrowserWindow, ipcMain, shell } from 'electron';
-import * as path from 'path';
-import * as fs from 'fs';
-import { spawn, ChildProcess } from 'child_process';
-
-const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;
-
-// 日志文件路径
-const userDataPath = app.getPath('userData');
-const logPath = path.join(userDataPath, 'bolloon.log');
-
-function log(msg: string) {
-  const ts = new Date().toISOString();
-  const line = `[${ts}] ${msg}\n`;
-  fs.appendFileSync(logPath, line);
-  console.log(msg);
-}
-
-log('Bolloon Electron 启动');
-
-// 全局窗口引用
-let mainWindow: BrowserWindow | null = null;
-let webServerProcess: ChildProcess | null = null;
-
-// 防止多个实例
-const gotTheLock = app.requestSingleInstanceLock();
-if (!gotTheLock) {
-  log('已有实例在运行，退出');
-  app.quit();
-}
-
-app.on('second-instance', () => {
-  if (mainWindow) {
-    if (mainWindow.isMinimized()) mainWindow.restore();
-    mainWindow.focus();
-  }
-});
-
-function startWebServer(port: number): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const serverScript = path.join(__dirname, 'web', 'server.js');
-    log(`启动 Web 服务器进程: ${serverScript}`);
-
-    webServerProcess = spawn(process.execPath, [serverScript], {
-      env: {
-        ...process.env,
-        NODE_ENV: 'production',
-        PORT: String(port),
-        ELECTRON_PORT: String(port),
-      },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stdoutData = '';
-    let stderrData = '';
-
-    webServerProcess.stdout?.on('data', (data: Buffer) => {
-      stdoutData += data.toString();
-      process.stdout.write(`[WebServer] ${data}`);
-    });
-
-    webServerProcess.stderr?.on('data', (data: Buffer) => {
-      stderrData += data.toString();
-      process.stderr.write(`[WebServer ERR] ${data}`);
-    });
-
-    webServerProcess.on('error', (err) => {
-      log(`Web 服务器进程启动失败: ${err}`);
-      reject(err);
-    });
-
-    webServerProcess.on('exit', (code, signal) => {
-      log(`Web 服务器进程退出: code=${code} signal=${signal}`);
-      if (code !== 0 && code !== null) {
-        log(`Web 服务器 stderr: ${stderrData}`);
-      }
-    });
-
-    // 等待服务器就绪 - 检查 stdout 中的标记
-    const checkReady = setInterval(() => {
-      if (stdoutData.includes('服务器已监听') || stdoutData.includes('Web 服务器启动完成')) {
-        clearInterval(checkReady);
-        log('Web 服务器进程已就绪');
-        resolve();
-      }
-    }, 200);
-
-    // 超时
-    setTimeout(() => {
-      clearInterval(checkReady);
-      if (webServerProcess?.killed === false) {
-        log('Web 服务器启动超时');
-        reject(new Error('Web server startup timeout'));
-      }
-    }, 15000);
-  });
-}
-
-async function createWindow() {
-  log('创建主窗口...');
-
-  const width = 1200;
-  const height = 800;
-  const minWidth = 800;
-  const minHeight = 600;
-
-  mainWindow = new BrowserWindow({
-    width,
-    height,
-    minWidth,
-    minHeight,
-    title: 'Bolloon Agent',
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      sandbox: false,
-    },
-    show: false,
-  });
-
-  const port = parseInt(process.env.ELECTRON_PORT || '54188');
-
-  if (isDev) {
-    mainWindow.loadURL(`http://localhost:${port}`);
-    mainWindow.webContents.openDevTools();
-  } else {
-    try {
-      log(`启动内置 Web 服务器...`);
-      await startWebServer(port);
-      mainWindow.loadURL(`http://localhost:${port}`);
-    } catch (err) {
-      log(`启动服务器失败: ${err}`);
-      console.error('启动服务器失败:', err);
-    }
-  }
-
-  mainWindow.once('ready-to-show', () => {
-    mainWindow?.show();
-    log('窗口已显示');
-  });
-
-  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-    if (url.startsWith('http://') || url.startsWith('https://')) {
-      shell.openExternal(url);
-    }
-    return { action: 'deny' };
-  });
-
-  mainWindow.on('closed', () => {
-    mainWindow = null;
-  });
-
-  log('窗口创建完成');
-}
-
-app.whenReady().then(async () => {
-  log('Electron 准备好');
-  await createWindow();
-
-  app.on('activate', async () => {
-    if (BrowserWindow.getAllWindows().length === 0) {
-      await createWindow();
-    }
-  });
-});
-
-app.on('window-all-closed', () => {
-  log('所有窗口已关闭');
-  if (webServerProcess) {
-    webServerProcess.kill();
-    log('Web 服务器进程已终止');
-  }
-  if (process.platform !== 'darwin') {
-    app.quit();
-  }
-});
-
-app.on('before-quit', () => {
-  log('应用即将退出');
-  if (webServerProcess) {
-    webServerProcess.kill();
-  }
-});
-
-ipcMain.handle('get-version', () => {
-  return app.getVersion();
-});
-
-ipcMain.handle('get-user-data-path', () => {
-  return userDataPath;
-});
-
-ipcMain.handle('open-external', async (_, url: string) => {
-  await shell.openExternal(url);
-});
-
-log('主进程初始化完成');