@bolloon/bolloon-agent 0.1.7 → 0.1.9

package/bin/bolloon-cli.cjs

@@ -114,10 +114,17 @@ async function startCLI(additionalArgs) {
 }
 
 async function main() {
+  // Get version from package.json
+  const binPath = require.main.filename;
+  const binDir = path.dirname(binPath);
+  const packageDir = path.dirname(binDir);
+  const packageJson = JSON.parse(fs.readFileSync(path.join(packageDir, "package.json"), "utf-8"));
+  const version = packageJson.version;
+
   const { mode, args } = parseArgs();
   switch (mode) {
     case "version":
-      console.log("Bolloon Agent v0.1.2");
+      console.log("Bolloon Agent v" + version);
       break;
     case "help":
       printBanner();

package/bin/bolloon.cjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+const path = require("path");
+const { spawn } = require("child_process");
+const fs = require("fs");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const MAGENTA = "\x1b[35m";
+
+function log(msg, color) {
+  console.log((color || RESET) + msg + RESET);
+}
+
+function printBanner() {
+  console.log("\n" + CYAN + BOLD + [
+    "   ╔═══════════════════════════════════════════╗",
+    "   ║      🤖 Bolloon Agent                     ║",
+    "   ║      P2P AI Document Processor            ║",
+    "   ╚═══════════════════════════════════════════╝"
+  ].join("\n") + RESET + "\n");
+}
+
+function getMainEntry() {
+  const distDir = path.dirname(require.main.filename);
+  const distIndex = path.join(distDir, "index.js");
+  if (fs.existsSync(distIndex)) {
+    return distIndex;
+  }
+  return path.join(process.cwd(), "src", "index.ts");
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    return { mode: "gui", args: [] };
+  }
+  const first = args[0];
+  switch (first) {
+    case "-v":
+    case "--version":
+      return { mode: "version", args: [] };
+    case "-h":
+    case "--help":
+      return { mode: "help", args: [] };
+    case "-g":
+    case "--gui":
+      return { mode: "gui", args: args.slice(1) };
+    case "-w":
+    case "--web":
+      return { mode: "web", args: args.slice(1) };
+    case "-c":
+    case "--cli":
+      return { mode: "cli", args: args.slice(1) };
+    default:
+      return { mode: "passthrough", args };
+  }
+}
+
+async function startElectron(additionalArgs) {
+  try {
+    const electron = require("electron");
+    const distDir = path.dirname(require.main.filename);
+    let mainPath = path.join(distDir, "electron.js");
+    if (!fs.existsSync(mainPath)) {
+      mainPath = path.join(process.cwd(), "src", "electron.ts");
+    }
+    log("启动 Electron...", CYAN);
+    const child = spawn(electron, [mainPath, ...additionalArgs], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    child.on("error", (err) => {
+      log("Electron 启动失败: " + err.message, MAGENTA);
+      process.exit(1);
+    });
+    child.on("exit", (code) => process.exit(code || 0));
+  } catch (err) {
+    log("Electron 不可用，切换到 Web 模式...", CYAN);
+    await startWebServer(additionalArgs);
+  }
+}
+
+async function startWebServer(additionalArgs) {
+  const mainPath = getMainEntry();
+  const webArgs = ["--web", ...additionalArgs];
+  log("启动 Web 服务...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...webArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("Web 服务启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function startCLI(additionalArgs) {
+  const mainPath = getMainEntry();
+  log("启动命令行界面...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...additionalArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("CLI 启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function main() {
+  const { mode, args } = parseArgs();
+  switch (mode) {
+    case "version":
+      console.log("Bolloon Agent v0.1.1");
+      break;
+    case "help":
+      printBanner();
+      console.log(BOLD + "用法:" + RESET + "  bolloon [选项] [命令] [参数]");
+      console.log(BOLD + "选项:" + RESET + "  --gui, -g           启动图形界面");
+      console.log("         --web, -w           启动 Web UI");
+      console.log("         --cli, -c           启动命令行界面");
+      console.log("         --version, -v       显示版本");
+      console.log("         --help, -h          显示帮助");
+      console.log(BOLD + "示例:" + RESET + "  bolloon              # 启动图形界面");
+      console.log("         bolloon --web        # 启动 Web UI");
+      console.log("         bolloon --read file  # 读取文档");
+      break;
+    case "gui":
+      printBanner();
+      await startElectron(args);
+      break;
+    case "web":
+      printBanner();
+      await startWebServer(args);
+      break;
+    case "cli":
+      await startCLI(args);
+      break;
+    case "passthrough":
+      const mainPath = getMainEntry();
+      const child = spawn(process.execPath, [mainPath, ...args], { stdio: "inherit" });
+      child.on("error", (err) => {
+        log("执行失败: " + err.message, MAGENTA);
+        process.exit(1);
+      });
+      child.on("exit", (code) => process.exit(code || 0));
+      break;
+    default:
+      log("未知模式: " + mode, MAGENTA);
+      printBanner();
+      console.log("输入 --help 查看帮助");
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/agents/p2p-document-tools.js

@@ -0,0 +1,169 @@
+/**
+ * P2P Document Tools - Tools for sending/receiving documents over iroh P2P
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import { irohTransport } from '../network/iroh-transport.js';
+import { documentReader } from '../documents/reader.js';
+import { documentStore } from '../documents/store.js';
+const CHUNK_SIZE = 60 * 1024; // 60KB per chunk
+function generateDocId() {
+    return crypto.randomUUID();
+}
+function getMimeType(filename) {
+    const ext = filename.toLowerCase().split('.').pop();
+    const mimeTypes = {
+        'txt': 'text/plain',
+        'md': 'text/markdown',
+        'pdf': 'application/pdf',
+        'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    };
+    return mimeTypes[ext || ''] || 'application/octet-stream';
+}
+export async function initDocumentReceiver() {
+    await documentStore.initialize();
+    documentStore.onDocumentReceived((doc) => {
+        console.log(`[DocumentReceiver] Document received: ${doc.fileName} from ${doc.fromNodeIdShort}`);
+    });
+    irohTransport.onMessage('document_chunk', async (msg) => {
+        try {
+            const chunk = JSON.parse(new TextDecoder().decode(msg.payload));
+            const result = await documentStore.receiveChunk(chunk);
+            if (result) {
+                console.log(`[DocumentReceiver] Document complete: ${result.fileName}`);
+            }
+        }
+        catch (e) {
+            console.error('[DocumentReceiver] Failed to process chunk:', e);
+        }
+    });
+    console.log('[DocumentReceiver] Initialized and listening for document chunks');
+}
+export const p2pDocumentTools = [
+    {
+        name: 'list_online_peers',
+        description: '列出当前通过 iroh P2P 网络在线的对等节点',
+        parameters: {},
+        execute: async () => {
+            try {
+                const peers = irohTransport.getConnectedPeers();
+                if (peers.length === 0) {
+                    return { success: true, output: '当前无在线的对等节点' };
+                }
+                return {
+                    success: true,
+                    output: `在线节点 (${peers.length}):\n${peers.map(p => `  - ${p.substring(0, 16)}...`).join('\n')}`
+                };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        }
+    },
+    {
+        name: 'send_document',
+        description: '读取本地文档并发送给指定的对等节点，支持 .txt, .md, .pdf, .docx 格式',
+        parameters: {
+            target_peer_id: '目标对等节点的完整 nodeId',
+            file_path: '要发送的本地文件路径',
+            message: '可选的附言消息'
+        },
+        execute: async (args) => {
+            try {
+                const { target_peer_id, file_path, message } = args;
+                // 读取文档
+                let content;
+                try {
+                    content = await documentReader.read(file_path);
+                }
+                catch (e) {
+                    return { success: false, error: `无法读取文件: ${e}` };
+                }
+                // 分块
+                const mimeType = getMimeType(file_path);
+                const fileData = await fs.readFile(file_path);
+                const contentBase64 = fileData.toString('base64');
+                const totalChunks = Math.ceil(contentBase64.length / CHUNK_SIZE);
+                const docId = generateDocId();
+                // 逐块发送
+                for (let i = 0; i < totalChunks; i++) {
+                    const chunk = {
+                        docId,
+                        fileName: content.metadata.filename,
+                        fileSize: content.metadata.size,
+                        mimeType,
+                        chunkIndex: i,
+                        totalChunks,
+                        content: contentBase64.substring(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE),
+                        fromNodeId: irohTransport.getNodeId() || '',
+                        message: i === 0 ? message : undefined,
+                        timestamp: Date.now(),
+                    };
+                    const sent = await irohTransport.sendMessage(target_peer_id, 'document_chunk', new TextEncoder().encode(JSON.stringify(chunk)));
+                    if (!sent) {
+                        return { success: false, error: `发送第 ${i + 1}/${totalChunks} 块失败` };
+                    }
+                }
+                return {
+                    success: true,
+                    output: `📤 文档已发送: ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n分块: ${totalChunks}\n目标: ${target_peer_id.substring(0, 16)}...`
+                };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        }
+    },
+    {
+        name: 'receive_documents',
+        description: '列出已接收到的文档，可按发送者筛选',
+        parameters: {
+            limit: '返回数量上限，默认 50',
+            sender_peer_id: '可选，按发送者 nodeId 筛选'
+        },
+        execute: async (args) => {
+            try {
+                const limit = parseInt(args.limit) || 50;
+                const docs = await documentStore.getReceivedDocuments(limit, args.sender_peer_id);
+                if (docs.length === 0) {
+                    return { success: true, output: '暂无已接收的文档' };
+                }
+                const list = docs.map(d => `📄 ${d.fileName}\n   ID: ${d.id}\n   大小: ${d.fileSize} 字节\n   来自: ${d.fromNodeIdShort}\n   时间: ${new Date(d.receivedAt).toLocaleString()}`).join('\n\n');
+                return {
+                    success: true,
+                    output: `已接收文档 (${docs.length}):\n\n${list}`
+                };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        }
+    },
+    {
+        name: 'read_received_document',
+        description: '读取已接收文档的内容，返回文档ID可查询文档详情',
+        parameters: {
+            document_id: '文档ID (从 receive_documents 获取)'
+        },
+        execute: async (args) => {
+            try {
+                const { document_id } = args;
+                if (!document_id) {
+                    return { success: false, error: '缺少 document_id 参数' };
+                }
+                const result = await documentStore.readDocument(document_id);
+                if (!result) {
+                    return { success: false, error: `未找到文档: ${document_id}` };
+                }
+                const { content, metadata } = result;
+                return {
+                    success: true,
+                    output: `📄 ${metadata.fileName}\nID: ${metadata.id}\n大小: ${metadata.fileSize} 字节\n来自: ${metadata.fromNodeIdShort}\n\n${content.substring(0, 2000)}${content.length > 2000 ? '...\n(内容已截断)' : ''}`
+                };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        }
+    }
+];

package/dist/agents/pi-sdk.js

@@ -12,6 +12,7 @@ import { ConstraintLayer } from './constraint-layer.js';
 import { WorkflowEngine } from './workflow-engine.js';
 import { DeepThinkingEngine, AgentCoordinator } from '@bolloon/constraint-runtime';
 import { WorkflowPivotLoop, createDefaultPivotConfig } from './workflow-pivot-loop.js';
+import { p2pDocumentTools, initDocumentReceiver } from './p2p-document-tools.js';
 import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
 import { getGlobalSharedContext } from '../social/global-shared-context.js';
 import { Session, SkillRegistry, saveSession, loadSession } from '@bolloon/constraint-runtime';
@@ -350,6 +351,7 @@ class PiAgentSession {
         this.usePivotLoop = config.usePivotLoop ?? false;
         this.pivotLoopConfig = config.pivotLoopConfig;
         this.initSession();
+        initDocumentReceiver();
         this.registerTools();
         this.initHarness();
     }
@@ -577,6 +579,13 @@ class PiAgentSession {
                 }
             }
         });
+        // P2P Document Tools
+        for (const tool of p2pDocumentTools) {
+            this.tools.set(tool.name, tool);
+        }
+    }
+    async registerP2PDocumentReceiver() {
+        await initDocumentReceiver();
     }
     getToolDefinitions() {
         const defs = ['可用工具:'];

package/dist/documents/store.js

@@ -0,0 +1,182 @@
+/**
+ * Document Store - P2P Document Receiving and Storage
+ * 接收并存储来自其他 iroh 节点的文档
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class DocumentStore {
+    baseDir;
+    pendingDocs = new Map();
+    receivedCallback = null;
+    constructor(baseDir) {
+        this.baseDir = baseDir || path.join(process.env.HOME || '/tmp', '.bolloon', 'documents', 'received');
+    }
+    async initialize() {
+        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) {
+        this.receivedCallback = callback;
+    }
+    async receiveChunk(chunk) {
+        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;
+    }
+    async assembleDocument(docId) {
+        const pending = this.pendingDocs.get(docId);
+        if (!pending)
+            return null;
+        try {
+            // 按顺序合并所有分块
+            const allContent = [];
+            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 = {
+                ...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;
+        }
+    }
+    async updateIndex(manifest) {
+        const indexPath = path.join(this.baseDir, 'index.json');
+        let index = [];
+        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 = 50, senderPeerId) {
+        const indexPath = path.join(this.baseDir, 'index.json');
+        try {
+            const data = await fs.readFile(indexPath, 'utf-8');
+            let docs = 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) {
+        const docDir = path.join(this.baseDir, docId);
+        const manifestPath = path.join(docDir, 'manifest.json');
+        const filePath = path.join(docDir);
+        try {
+            const manifestData = await fs.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestData);
+            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) {
+        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 = 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli.js",
@@ -32,7 +32,7 @@
     "src/constraint-runtime"
   ],
   "dependencies": {
-    "@bolloon/bolloon-agent": "^0.1.5",
+    "@bolloon/bolloon-agent": "^0.1.8",
     "@bolloon/constraint-runtime": "0.1.0",
     "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/libp2p-yamux": "^8.0.1",

package/src/agents/p2p-document-tools.ts

@@ -0,0 +1,197 @@
+/**
+ * P2P Document Tools - Tools for sending/receiving documents over iroh P2P
+ */
+
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import { irohTransport } from '../network/iroh-transport.js';
+import { documentReader, type DocumentContent } from '../documents/reader.js';
+import { documentStore, type DocumentChunk, type ReceivedDocument } from '../documents/store.js';
+import type { Tool } from './pi-sdk.js';
+
+const CHUNK_SIZE = 60 * 1024;  // 60KB per chunk
+
+function generateDocId(): string {
+  return crypto.randomUUID();
+}
+
+function getMimeType(filename: string): string {
+  const ext = filename.toLowerCase().split('.').pop();
+  const mimeTypes: Record<string, string> = {
+    'txt': 'text/plain',
+    'md': 'text/markdown',
+    'pdf': 'application/pdf',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  };
+  return mimeTypes[ext || ''] || 'application/octet-stream';
+}
+
+export async function initDocumentReceiver(): Promise<void> {
+  await documentStore.initialize();
+
+  documentStore.onDocumentReceived((doc) => {
+    console.log(`[DocumentReceiver] Document received: ${doc.fileName} from ${doc.fromNodeIdShort}`);
+  });
+
+  irohTransport.onMessage('document_chunk', async (msg) => {
+    try {
+      const chunk: DocumentChunk = JSON.parse(new TextDecoder().decode(msg.payload));
+      const result = await documentStore.receiveChunk(chunk);
+      if (result) {
+        console.log(`[DocumentReceiver] Document complete: ${result.fileName}`);
+      }
+    } catch (e) {
+      console.error('[DocumentReceiver] Failed to process chunk:', e);
+    }
+  });
+
+  console.log('[DocumentReceiver] Initialized and listening for document chunks');
+}
+
+export const p2pDocumentTools: Tool[] = [
+  {
+    name: 'list_online_peers',
+    description: '列出当前通过 iroh P2P 网络在线的对等节点',
+    parameters: {},
+    execute: async () => {
+      try {
+        const peers = irohTransport.getConnectedPeers();
+        if (peers.length === 0) {
+          return { success: true, output: '当前无在线的对等节点' };
+        }
+        return {
+          success: true,
+          output: `在线节点 (${peers.length}):\n${peers.map(p => `  - ${p.substring(0, 16)}...`).join('\n')}`
+        };
+      } catch (e) {
+        return { success: false, error: String(e) };
+      }
+    }
+  },
+
+  {
+    name: 'send_document',
+    description: '读取本地文档并发送给指定的对等节点，支持 .txt, .md, .pdf, .docx 格式',
+    parameters: {
+      target_peer_id: '目标对等节点的完整 nodeId',
+      file_path: '要发送的本地文件路径',
+      message: '可选的附言消息'
+    },
+    execute: async (args) => {
+      try {
+        const { target_peer_id, file_path, message } = args;
+
+        // 读取文档
+        let content: DocumentContent;
+        try {
+          content = await documentReader.read(file_path);
+        } catch (e) {
+          return { success: false, error: `无法读取文件: ${e}` };
+        }
+
+        // 分块
+        const mimeType = getMimeType(file_path);
+        const fileData = await fs.readFile(file_path);
+        const contentBase64 = fileData.toString('base64');
+        const totalChunks = Math.ceil(contentBase64.length / CHUNK_SIZE);
+
+        const docId = generateDocId();
+
+        // 逐块发送
+        for (let i = 0; i < totalChunks; i++) {
+          const chunk: DocumentChunk = {
+            docId,
+            fileName: content.metadata.filename,
+            fileSize: content.metadata.size,
+            mimeType,
+            chunkIndex: i,
+            totalChunks,
+            content: contentBase64.substring(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE),
+            fromNodeId: irohTransport.getNodeId() || '',
+            message: i === 0 ? message : undefined,
+            timestamp: Date.now(),
+          };
+
+          const sent = await irohTransport.sendMessage(
+            target_peer_id,
+            'document_chunk',
+            new TextEncoder().encode(JSON.stringify(chunk))
+          );
+
+          if (!sent) {
+            return { success: false, error: `发送第 ${i + 1}/${totalChunks} 块失败` };
+          }
+        }
+
+        return {
+          success: true,
+          output: `📤 文档已发送: ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n分块: ${totalChunks}\n目标: ${target_peer_id.substring(0, 16)}...`
+        };
+      } catch (e) {
+        return { success: false, error: String(e) };
+      }
+    }
+  },
+
+  {
+    name: 'receive_documents',
+    description: '列出已接收到的文档，可按发送者筛选',
+    parameters: {
+      limit: '返回数量上限，默认 50',
+      sender_peer_id: '可选，按发送者 nodeId 筛选'
+    },
+    execute: async (args) => {
+      try {
+        const limit = parseInt(args.limit) || 50;
+        const docs = await documentStore.getReceivedDocuments(limit, args.sender_peer_id);
+
+        if (docs.length === 0) {
+          return { success: true, output: '暂无已接收的文档' };
+        }
+
+        const list = docs.map(d =>
+          `📄 ${d.fileName}\n   ID: ${d.id}\n   大小: ${d.fileSize} 字节\n   来自: ${d.fromNodeIdShort}\n   时间: ${new Date(d.receivedAt).toLocaleString()}`
+        ).join('\n\n');
+
+        return {
+          success: true,
+          output: `已接收文档 (${docs.length}):\n\n${list}`
+        };
+      } catch (e) {
+        return { success: false, error: String(e) };
+      }
+    }
+  },
+
+  {
+    name: 'read_received_document',
+    description: '读取已接收文档的内容，返回文档ID可查询文档详情',
+    parameters: {
+      document_id: '文档ID (从 receive_documents 获取)'
+    },
+    execute: async (args) => {
+      try {
+        const { document_id } = args;
+
+        if (!document_id) {
+          return { success: false, error: '缺少 document_id 参数' };
+        }
+
+        const result = await documentStore.readDocument(document_id);
+
+        if (!result) {
+          return { success: false, error: `未找到文档: ${document_id}` };
+        }
+
+        const { content, metadata } = result;
+
+        return {
+          success: true,
+          output: `📄 ${metadata.fileName}\nID: ${metadata.id}\n大小: ${metadata.fileSize} 字节\n来自: ${metadata.fromNodeIdShort}\n\n${content.substring(0, 2000)}${content.length > 2000 ? '...\n(内容已截断)' : ''}`
+        };
+      } catch (e) {
+        return { success: false, error: String(e) };
+      }
+    }
+  }
+];

package/src/agents/pi-sdk.ts

@@ -13,6 +13,7 @@ import { ConstraintLayer, WorkflowContext } from './constraint-layer.js';
 import { WorkflowEngine, WorkflowStep, StepResult, Workflow } from './workflow-engine.js';
 import { DeepThinkingEngine, AgentCoordinator, type ThinkResult, type AgentResult } from '@bolloon/constraint-runtime';
 import { WorkflowPivotLoop, createDefaultPivotConfig, type PivotLoopConfig, type LoopResult } from './workflow-pivot-loop.js';
+import { p2pDocumentTools, initDocumentReceiver } from './p2p-document-tools.js';
 import {
   DiscoveredAgentsManager,
   SocialHeartbeat,
@@ -572,6 +573,7 @@ class PiAgentSession implements AgentSession {
     this.usePivotLoop = config.usePivotLoop ?? false;
     this.pivotLoopConfig = config.pivotLoopConfig;
     this.initSession();
+    initDocumentReceiver();
     this.registerTools();
     this.initHarness();
   }
@@ -801,6 +803,15 @@ class PiAgentSession implements AgentSession {
         }
       }
     });
+
+    // P2P Document Tools
+    for (const tool of p2pDocumentTools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+
+  private async registerP2PDocumentReceiver(): Promise<void> {
+    await initDocumentReceiver();
   }
 
   private getToolDefinitions(): string {

package/src/documents/store.ts

@@ -0,0 +1,252 @@
+/**
+ * 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');
+    const filePath = path.join(docDir);
+
+    try {
+      const manifestData = await fs.readFile(manifestPath, 'utf-8');
+      const manifest = JSON.parse(manifestData);
+      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/web/index.html

@@ -4,6 +4,18 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Bolloon Agent</title>
+
+  <!-- Favicon -->
+  <link rel="icon" type="image/x-icon" href="/icons/favicon.ico">
+  <link rel="icon" type="image/png" sizes="32x32" href="/icons/favicon-32x32.png">
+  <link rel="icon" type="image/png" sizes="16x16" href="/icons/favicon-16x16.png">
+
+  <!-- Apple Touch Icon -->
+  <link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">
+
+  <!-- PWA Manifest -->
+  <link rel="manifest" href="/manifest.json">
+
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Noto+Sans+SC:wght@400;500;600&display=swap" rel="stylesheet">

package/src/web/manifest.json

@@ -0,0 +1,21 @@
+{
+  "name": "Bolloon Agent",
+  "short_name": "Bolloon",
+  "description": "AI Agent with Claude API integration",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#1a1a2e",
+  "theme_color": "#1a1a2e",
+  "icons": [
+    {
+      "src": "/icons/favicon-192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "/icons/favicon-512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    }
+  ]
+}