@bolloon/bolloon-agent 0.1.36 → 0.1.37

package/src/network/known-peers.ts

@@ -1,102 +0,0 @@
-/**
- * known-peers.ts — 持久化 P2P 好友列表, 启动自动重连
- *
- * 文件位置: ~/.bolloon/known_peers.json
- * 格式: { version: 1, peers: { [name]: { publicKey, addedAt, lastConnected } } }
- *
- * 设计原则:
- *   - publicKey 持久化 (peerId 等同于 P2PDirect publicKey = 32 字节 hex = 64 chars)
- *   - name 是用户给的好友备注 (不参与 P2P 协议, 仅 UI 显示)
- *   - 不存 ip/port, hyperswarm DHT 自动重发现
- *   - 不存 lastConnected 详细信息, 只存时间戳 (供 UI 显示)
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-
-const SECRET_DIR = process.env.BOLLOON_HOME || path.join(os.homedir(), '.bolloon');
-const KNOWN_PEERS_FILE = path.join(SECRET_DIR, 'known_peers.json');
-
-export interface KnownPeer {
-  publicKey: string;          // 64 char hex
-  name?: string;              // 用户给的备注
-  addedAt: string;            // ISO timestamp
-  lastConnectedAt?: string;   // ISO timestamp, 最近一次 joinPeer 成功
-  notes?: string;             // 用户备注
-}
-
-interface KnownPeersFile {
-  version: 1;
-  peers: Record<string, KnownPeer>;
-}
-
-async function ensureDir(): Promise<void> {
-  await fs.mkdir(SECRET_DIR, { recursive: true });
-}
-
-async function readFile(): Promise<KnownPeersFile> {
-  try {
-    const raw = await fs.readFile(KNOWN_PEERS_FILE, 'utf-8');
-    return JSON.parse(raw);
-  } catch {
-    return { version: 1, peers: {} };
-  }
-}
-
-async function writeFile(data: KnownPeersFile): Promise<void> {
-  await ensureDir();
-  await fs.writeFile(KNOWN_PEERS_FILE, JSON.stringify(data, null, 2), 'utf-8');
-}
-
-/** 添加或更新一个 known peer (key 用 name) */
-export async function addOrUpdatePeer(name: string | null | undefined, publicKey: string, notes?: string): Promise<void> {
-  const safeName = (name && name.length > 0) ? name : `peer-${publicKey.substring(0, 8)}`;
-  const data = await readFile();
-  const existing = data.peers[safeName];
-  data.peers[safeName] = {
-    publicKey,
-    name: safeName,
-    addedAt: existing?.addedAt || new Date().toISOString(),
-    lastConnectedAt: existing?.lastConnectedAt,
-    notes: notes || existing?.notes
-  };
-  await writeFile(data);
-  console.log(`[known-peers] 添加/更新: ${safeName} = ${publicKey.substring(0, 12)}...`);
-}
-
-/** 删除 known peer */
-export async function removePeer(name: string): Promise<void> {
-  const data = await readFile();
-  if (data.peers[name]) {
-    delete data.peers[name];
-    await writeFile(data);
-    console.log(`[known-peers] 删除: ${name}`);
-  }
-}
-
-/** 标记连接成功 (更新 lastConnectedAt) */
-export async function markConnected(name: string): Promise<void> {
-  const data = await readFile();
-  if (data.peers[name]) {
-    data.peers[name].lastConnectedAt = new Date().toISOString();
-    await writeFile(data);
-  }
-}
-
-/** 列出所有 known peers */
-export async function listPeers(): Promise<KnownPeer[]> {
-  const data = await readFile();
-  return Object.values(data.peers);
-}
-
-/** 通过 publicKey 找 name (用于自动标记 lastConnectedAt) */
-export async function findNameByPublicKey(publicKey: string): Promise<string | null> {
-  const data = await readFile();
-  for (const [name, p] of Object.entries(data.peers)) {
-    if (p.publicKey === publicKey) return name;
-  }
-  return null;
-}
-
-/** 完整文件路径 (供 web server 暴露) */
-export const KNOWN_PEERS_PATH = KNOWN_PEERS_FILE;

package/src/network/p2p-direct.ts

@@ -1,262 +0,0 @@
-/**
- * p2p-direct.ts — 薄包装 hyperswarm (纯 TS, npm 包, 不改 binding)
- *
- * 为什么: @diap/sdk 的 HyperswarmCommunicator.sendToConnection 是 stub (只更新 bytesSent 计数器, 不真发).
- * 这层薄包装直接用 hyperswarm 库, 真正把数据写到 socket.
- *
- * 用法:
- *   const p2p = new P2PDirect({ name: 'bolloon' });
- *   await p2p.start();
- *   await p2p.joinTopic(Buffer.from('bolloon-agent-harness'));
- *   p2p.on('data', (data, fromPublicKey) => { ... });
- *   p2p.broadcast(Buffer.from('hello'));
- *   await p2p.stop();
- */
-// @ts-ignore — hyperswarm 没官方 .d.ts
-import Hyperswarm from 'hyperswarm';
-import crypto from 'crypto';
-import { EventEmitter } from 'events';
-// @ts-ignore — b4a 没官方 .d.ts
-import b4a from 'b4a';
-import { loadOrCreateKeyPair, writebackPublicKey } from './p2p-secret.js';
-
-export interface P2PDirectOptions {
-  /** 节点标识 (用于日志) */
-  name?: string;
-  /**
-   * 角色标识 (对应 ~/.bolloon/p2p-direct-secret-{role}.json).
-   * 留空时, P2PDirect 自动从 IROH_ROLE / BOLLOON_ROLE / 'default' 选.
-   *
-   * 同一台机器同一 role → 同一 publicKey (持久化 secretKey)
-   * 不同 role → 独立身份 (例: nodeA 和 nodeB 同机开发, 不冲突)
-   */
-  role?: string;
-  /**
-   * 跳过持久化 secret 加载, 完全随机 keyPair.
-   * (调试 / 测试用, 真实环境应保持默认 false)
-   */
-  ephemeral?: boolean;
-}
-
-export interface DataEvent {
-  data: Buffer;
-  fromPublicKey: string;  // hex
-  remoteAddress?: string; // 暂时没用到
-}
-
-export class P2PDirect extends EventEmitter {
-  private swarm: Hyperswarm | null = null;
-  private name: string;
-  private role: string;
-  private joinedTopics: Set<string> = new Set();
-  // 维护: 远端 publicKey -> conn (用于主动 send)
-  private conns: Map<string, any> = new Map();
-  private started: boolean = false;
-  private ephemeral: boolean;
-
-  constructor(opts: P2PDirectOptions = {}) {
-    super();
-    this.name = opts.name || 'p2p-direct';
-    this.role = opts.role || (process.env.IROH_ROLE || process.env.BOLLOON_ROLE || 'default');
-    this.ephemeral = !!opts.ephemeral;
-  }
-
-  async start(): Promise<void> {
-    if (this.started) return;
-
-    // 1. 加载/生成持久化 keyPair (同一 role 跨重启同一 publicKey)
-    if (this.ephemeral) {
-      console.log(`[P2PDirect:${this.name}] ephemeral 模式, 不持久化`);
-      this.swarm = new Hyperswarm();
-    } else {
-      const kp = await loadOrCreateKeyPair(this.role);
-      // hyperswarm 4.x 支持 `seed` 选项, DHT.keyPair(seed) 内部派生稳定 publicKey
-      this.swarm = new Hyperswarm({
-        seed: Buffer.from(kp.secretKey, 'hex'),  // 32-byte ed25519/X25519 seed
-      });
-      // 验证 / 写回 publicKey (首次启动时文件里是空)
-      const realPub = b4a.toString(this.swarm.keyPair.publicKey, 'hex');
-      if (kp.publicKey !== realPub) {
-        await writebackPublicKey(this.role, kp.secretKey, realPub);
-      }
-    }
-
-    this.swarm.on('connection', (conn: any, info: any) => {
-      const remotePubKeyHex = b4a.toString(info.publicKey, 'hex');
-      console.log(`[P2PDirect:${this.name}] 新连接: ${remotePubKeyHex.substring(0, 12)}... (inbound=${info.inbound || false}, type=${typeof conn}, hasWrite=${typeof conn?.write})`);
-
-      // 双向记录 (inbound + outbound 都能拿到)
-      this.conns.set(remotePubKeyHex, conn);
-
-      // 收到数据时 → 触发 'data' 事件
-      // 注意: data 监听器必须在 emit('connection') 之前注册,
-      // 否则 server 的 connection handler 发送消息后, 对端回复可能在 data 监听器就绪前到达
-      conn.on('data', (chunk: Buffer | Uint8Array) => {
-        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        console.log(`[P2PDirect:${this.name}] 收到数据 from ${remotePubKeyHex.substring(0,12)}... (${buf.length} bytes)`);
-        // P-Action 3: untrusted-input scanner (默认 silence-on-fail + log-only)
-        // 包装层 跨机器 @-mention 代发 (已 WORKING) 不能 block-on-suspicion
-        try {
-          // 动态 import 避免循环依赖 + 启动时加载
-          // (lazy require to keep cold-start fast)
-          // eslint-disable-next-line @typescript-eslint/no-var-requires
-          const { scanInput, writeScanAudit, shouldHardBlock } = require('../security/input-scanner.js') as typeof import('../security/input-scanner.js');
-          const result = scanInput(buf, { source: 'p2p' });
-          if (shouldHardBlock(result)) {
-            console.warn(`[P2PDirect:${this.name}] 阻断恶意消息 from ${remotePubKeyHex.substring(0,12)}... (verdict=${result.verdict}, threats=${result.threats.length})`);
-            writeScanAudit(result, { fromPublicKey: remotePubKeyHex, blocked: true }).catch(() => { /* silent */ });
-            return;  // 不 emit('data'), 跨机中转不传播
-          }
-          if (result.verdict !== 'pass') {
-            // log-only: 仍然 emit('data'), 但写 audit 留痕
-            writeScanAudit(result, { fromPublicKey: remotePubKeyHex, blocked: false }).catch(() => { /* silent */ });
-            console.log(`[P2PDirect:${this.name}] 输入扫描 verdict=${result.verdict} (${result.threats.length} threats) from ${remotePubKeyHex.substring(0,12)}... (audit-only)`);
-          }
-        } catch (err) {
-          // scanner 自身挂掉 → 静默, 不阻断
-          console.warn(`[P2PDirect:${this.name}] input scanner failed (silent, fail-safe):`, err);
-        }
-        this.emit('data', {
-          data: buf,
-          fromPublicKey: remotePubKeyHex,
-        } as DataEvent);
-      });
-
-      conn.on('error', (err: Error) => {
-        console.error(`[P2PDirect:${this.name}] 连接错误 (${remotePubKeyHex.substring(0,12)}...):`, err.message);
-      });
-
-      conn.on('close', () => {
-        this.conns.delete(remotePubKeyHex);
-      });
-
-      // v3: 触发 'connection' 事件, 上层 (web server) 可以主动给新连接发消息
-      // 注意: 放在 data/error/close 监听器之后, 确保 server 的 connection handler 不会先于 data 就绪
-      this.emit('connection', { remotePublicKey: remotePubKeyHex, conn });
-    });
-
-    await this.swarm.listen(); // server 模式
-    this.started = true;
-    console.log(`[P2PDirect:${this.name}] 启动 OK, publicKey: ${b4a.toString(this.swarm.keyPair.publicKey, 'hex').substring(0, 12)}...`);
-  }
-
-  async joinTopic(topic: Buffer | string): Promise<void> {
-    if (!this.swarm) throw new Error('P2PDirect not started');
-    const topicBuf = typeof topic === 'string' ? Buffer.from(topic) : topic;
-    const topicHex = b4a.toString(topicBuf, 'hex');
-    if (this.joinedTopics.has(topicHex)) return;
-    const discovery = this.swarm.join(topicBuf, { server: true, client: true });
-    await discovery.flushed();
-    this.joinedTopics.add(topicHex);
-    console.log(`[P2PDirect:${this.name}] 加入 topic: ${topicHex.substring(0, 16)}...`);
-  }
-
-  /** 广播数据给所有连接 */
-  broadcast(data: Buffer | string): void {
-    if (!this.swarm) return;
-    const buf = typeof data === 'string' ? Buffer.from(data) : data;
-    let count = 0;
-    for (const conn of this.conns.values()) {
-      try {
-        if (!conn.destroyed) {
-          conn.write(buf);
-          count++;
-        }
-      } catch (err) {
-        // 忽略单条连接错误, 不影响广播
-      }
-    }
-    if (count > 0) {
-      console.log(`[P2PDirect:${this.name}] broadcast 写到 ${count} 个连接 (${buf.length} bytes)`);
-    }
-  }
-
-  /** 主动 send 给单个 peer (已知 publicKey hex) */
-  sendTo(publicKeyHex: string, data: Buffer | string): boolean {
-    const conn = this.conns.get(publicKeyHex);
-    if (!conn || conn.destroyed) return false;
-    const buf = typeof data === 'string' ? Buffer.from(data) : data;
-    try {
-      conn.write(buf);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * 2026-06-10: 真"主动发, 等握手完成"版本 — 修复好友申请 fire-and-forget bug.
-   *
-   * 之前的问题: server.ts:2914 `await swarm.joinPeer(...)` 只触发握手, conn 还没 push 进 this.conns,
-   * 立即调 sendTo 找不到 conn → 静默返回 false → 消息扔进虚空.
-   *
-   * 现在: sendToWithWait 监听 'connection' 事件, 等到 targetPublicKey 真正出现在 this.conns,
-   * 才 write; 超时返回 NO_CONN; 写失败返回 WRITE_FAIL; 成功返回 SENT.
-   *
-   * 上层调用: const r = await p2p.sendToWithWait(pk, rpc, 5000);
-   *           if (r !== 'SENT') return 502 给前端.
-   */
-  async sendToWithWait(
-    publicKeyHex: string,
-    data: Buffer | string,
-    timeoutMs: number = 5000
-  ): Promise<'SENT' | 'NO_CONN' | 'WRITE_FAIL'> {
-    // 2026-06-11: 先主动触发 joinPeer, 否则 DHT 上对面可能没 push conn
-    if (this.swarm) {
-      try { await this.swarm.joinPeer(Buffer.from(publicKeyHex, 'hex')); } catch {}
-    }
-    // 1) 已有 conn → 立即试
-    let conn = this.conns.get(publicKeyHex);
-    if (!conn || conn.destroyed) {
-      // 2) 等 'connection' 事件 (this.emit('connection', { remotePublicKey, conn }))
-      const waitResult = await new Promise<'READY' | 'TIMEOUT'>((resolve) => {
-        const timer = setTimeout(() => {
-          this.off('connection', onConn);
-          resolve('TIMEOUT');
-        }, timeoutMs);
-        const onConn = (evt: { remotePublicKey: string; conn: any }) => {
-          if (evt.remotePublicKey === publicKeyHex) {
-            clearTimeout(timer);
-            this.off('connection', onConn);
-            resolve('READY');
-          }
-        };
-        this.on('connection', onConn);
-      });
-      if (waitResult === 'TIMEOUT') return 'NO_CONN';
-      conn = this.conns.get(publicKeyHex);
-      if (!conn || conn.destroyed) return 'NO_CONN'; // 双保险
-    }
-    const buf = typeof data === 'string' ? Buffer.from(data) : data;
-    try {
-      conn.write(buf);
-      return 'SENT';
-    } catch (err) {
-      console.error(`[P2PDirect:${this.name}] sendToWithWait 写失败 (${publicKeyHex.substring(0,12)}...):`, (err as Error).message);
-      return 'WRITE_FAIL';
-    }
-  }
-
-  getPublicKey(): string {
-    if (!this.swarm) return '';
-    return b4a.toString(this.swarm.keyPair.publicKey, 'hex');
-  }
-
-  /** 当前 P2PDirect 用的 role (对应 secret 文件名) */
-  getRole(): string {
-    return this.role;
-  }
-
-  getConnectionCount(): number {
-    return this.conns.size;
-  }
-
-  async stop(): Promise<void> {
-    if (!this.swarm) return;
-    await this.swarm.destroy();
-    this.swarm = null;
-    this.conns.clear();
-    this.started = false;
-    console.log(`[P2PDirect:${this.name}] 已停止`);
-  }
-}

package/src/network/p2p-secret.ts

@@ -1,153 +0,0 @@
-/**
- * p2p-secret.ts — 持久化 P2PDirect 的 32-byte secretKey
- *
- * 为什么: hyperswarm 4.x 的 `new Hyperswarm()` 每次启动生成新 keyPair,
- *  导致 publicKey 变化, known_peers.json 里的 publicKey 全部失效.
- *
- * 修法: 把 32-byte secretKey 存到 ~/.bolloon/p2p-direct-secret-{role}.json,
- *  下次启动读出来, 用 noise-keypair 风格构造 { publicKey, secretKey } 喂给 Hyperswarm.
- *  → 同一台机器 + 同一 role = 永远同一 publicKey.
- *
- * 文件格式: { version: 1, role, secretKey: hex64, publicKey: hex64, createdAt, lastUsedAt }
- *
- * role 来源: process.env.IROH_ROLE 或 process.env.BOLLOON_ROLE 或 'default'
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import * as crypto from 'crypto';
-
-const SECRET_DIR = process.env.BOLLOON_HOME || path.join(os.homedir(), '.bolloon');
-
-export interface P2PSecret {
-  version: 1;
-  role: string;
-  secretKey: string;     // 64 char hex (32 bytes) — noise-keypair seed
-  publicKey: string;     // 64 char hex (32 bytes) — 由 hyperswarm 算出后写回
-  createdAt: string;
-  lastUsedAt: string;
-}
-
-function resolveRole(): string {
-  return (
-    process.env.IROH_ROLE ||
-    process.env.BOLLOON_ROLE ||
-    'default'
-  );
-}
-
-function fileForRole(role: string): string {
-  return path.join(SECRET_DIR, `p2p-direct-secret-${role}.json`);
-}
-
-async function ensureDir(): Promise<void> {
-  await fs.mkdir(SECRET_DIR, { recursive: true });
-}
-
-/**
- * 读取/生成 持久化的 keyPair.
- *
- * 首次启动 → 生成 32 字节随机 secretKey, 存盘 (publicKey 留空, 待 P2PDirect 写回)
- * 之后启动 → 读 secretKey, 信任文件里存的 publicKey
- *
- * @param roleOverride 可显式覆盖 role (不传时读 IROH_ROLE)
- * @returns { publicKey, secretKey, role } 全部 hex string
- */
-export async function loadOrCreateKeyPair(roleOverride?: string): Promise<{
-  publicKey: string;
-  secretKey: string;
-  role: string;
-}> {
-  const role = roleOverride || resolveRole();
-  const file = fileForRole(role);
-
-  try {
-    const raw = await fs.readFile(file, 'utf-8');
-    const existing: P2PSecret = JSON.parse(raw);
-    if (
-      existing.version === 1 &&
-      typeof existing.secretKey === 'string' &&
-      existing.secretKey.length === 64
-    ) {
-      const sk = Buffer.from(existing.secretKey, 'hex');
-      if (sk.length === 32) {
-        existing.lastUsedAt = new Date().toISOString();
-        await ensureDir();
-        await fs.writeFile(file, JSON.stringify(existing, null, 2), 'utf-8');
-        return {
-          publicKey: existing.publicKey || '',
-          secretKey: existing.secretKey,
-          role: existing.role,
-        };
-      }
-    }
-    console.warn(`[p2p-secret] ${file} 格式无效, 重新生成`);
-  } catch (err: any) {
-    if (err.code !== 'ENOENT') {
-      console.warn(`[p2p-secret] 读 ${file} 失败: ${err.message}, 重新生成`);
-    }
-  }
-
-  // 首次生成 — publicKey 留空, 等 P2PDirect.start() 拿到真公钥后写回
-  const secretKeyBuf = crypto.randomBytes(32);
-  const now = new Date().toISOString();
-  const fresh: P2PSecret = {
-    version: 1,
-    role,
-    secretKey: secretKeyBuf.toString('hex'),
-    publicKey: '',         // P2PDirect.start() 后由 writebackPublicKey 填
-    createdAt: now,
-    lastUsedAt: now,
-  };
-  await ensureDir();
-  await fs.writeFile(file, JSON.stringify(fresh, null, 2), 'utf-8');
-  console.log(`[p2p-secret] 新生成 keyPair (role=${role}, publicKey 待算), 存到 ${file}`);
-  return { publicKey: fresh.publicKey, secretKey: fresh.secretKey, role };
-}
-
-/**
- * P2PDirect 启动后, 把 hyperswarm 算出的真实 publicKey 写回文件
- * (因为我们用 noise-keypair 风格 seed, 真正的公钥只能 Hyperswarm 算).
- */
-export async function writebackPublicKey(
-  role: string,
-  secretKey: string,
-  realPublicKey: string
-): Promise<void> {
-  const file = fileForRole(role);
-  let existing: P2PSecret | null = null;
-  try {
-    const raw = await fs.readFile(file, 'utf-8');
-    existing = JSON.parse(raw);
-  } catch {}
-  const data: P2PSecret = existing && existing.version === 1 && existing.secretKey === secretKey
-    ? { ...existing, publicKey: realPublicKey, lastUsedAt: new Date().toISOString() }
-    : {
-        version: 1,
-        role,
-        secretKey,
-        publicKey: realPublicKey,
-        createdAt: new Date().toISOString(),
-        lastUsedAt: new Date().toISOString(),
-      };
-  await ensureDir();
-  await fs.writeFile(file, JSON.stringify(data, null, 2), 'utf-8');
-  console.log(`[p2p-secret] (${role}) publicKey 写回: ${realPublicKey.substring(0, 12)}...`);
-}
-
-/** 删掉 (供调试 / "重置身份" 用) */
-export async function resetSecret(roleOverride?: string): Promise<void> {
-  const role = roleOverride || resolveRole();
-  const file = fileForRole(role);
-  try {
-    await fs.unlink(file);
-    console.log(`[p2p-secret] 删除 ${file}`);
-  } catch (err: any) {
-    if (err.code !== 'ENOENT') throw err;
-  }
-}
-
-/** 当前 role 对应的 secret 文件路径 (供 server 暴露) */
-export function secretPathForRole(roleOverride?: string): string {
-  return fileForRole(roleOverride || resolveRole());
-}