@bolloon/bolloon-agent 0.1.27 → 0.1.28

package/src/network/known-peers.ts

@@ -0,0 +1,102 @@
+/**
+ * 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

@@ -0,0 +1,184 @@
+/**
+ * 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);
+
+      // v3: 触发 'connection' 事件, 上层 (web server) 可以主动给新连接发消息
+      this.emit('connection', { remotePublicKey: remotePubKeyHex, conn });
+
+      // 收到数据时 → 触发 '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)`);
+        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);
+      });
+    });
+
+    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;
+    }
+  }
+
+  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

@@ -0,0 +1,153 @@
+/**
+ * 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());
+}