@bolloon/bolloon-agent 0.1.27 → 0.1.29

package/dist/network/iroh-transport.js

@@ -25,14 +25,16 @@ export class IrohTransport {
                 addr: this.ownNodeId // iroh 没有 listenAddresses，用 nodeId 作为 addr
             };
         }
-        // 若调用方未传 secretKey，从 ~/.bolloon/iroh-secret-default.json 落盘/读取
-        // 保证 iroh nodeId 在同一台机器上跨重启保持稳定
+        // 若调用方未传 secretKey，从 ~/.bolloon/iroh-secret-{role}.json 落盘/读取
+        // role 可通过 IROH_ROLE 环境变量覆盖, 方便同机起多个实例 (A/B 跨用户测试)
+        // 不设 IROH_ROLE 时 = 'default', 与旧行为一致
         if (!secretKey) {
+            const role = process.env.IROH_ROLE || 'default';
             try {
-                const sec = loadOrCreateIrohSecret('default');
+                const sec = loadOrCreateIrohSecret(role);
                 // iroh binding 的 secretKey 字段是 hex 字符串 (32 字节 Ed25519 种子)
                 secretKey = Buffer.from(sec.secretKey).toString('hex');
-                console.log(`[IrohTransport] ${sec.reused ? '复用' : '新建'} iroh-secret-default.json (createdAt=${sec.createdAt})`);
+                console.log(`[IrohTransport] ${sec.reused ? '复用' : '新建'} iroh-secret-${role}.json (createdAt=${sec.createdAt})`);
             }
             catch (e) {
                 console.warn('[IrohTransport] iroh-secret 加载失败, 将使用临时身份:', e);
@@ -442,6 +444,21 @@ export class IrohTransport {
     getNodeId() {
         return this.ownNodeId;
     }
+    /**
+     * v3: 返回 iroh endpoint 完整地址字符串 (含 relay URL)
+     * 这是 connect() 真正需要的"网络地址", 光有 nodeId 不足以建连
+     * 如果 endpoint 还没 online, 返回纯 nodeId
+     */
+    getEndpointAddr() {
+        if (!this.endpoint)
+            return null;
+        try {
+            return this.endpoint.addr();
+        }
+        catch (e) {
+            return this.endpoint.nodeId();
+        }
+    }
     getPeers() {
         return Array.from(this.peers.values());
     }

package/dist/network/known-peers.js

@@ -0,0 +1,81 @@
+/**
+ * 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');
+async function ensureDir() {
+    await fs.mkdir(SECRET_DIR, { recursive: true });
+}
+async function readFile() {
+    try {
+        const raw = await fs.readFile(KNOWN_PEERS_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { version: 1, peers: {} };
+    }
+}
+async function writeFile(data) {
+    await ensureDir();
+    await fs.writeFile(KNOWN_PEERS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+/** 添加或更新一个 known peer (key 用 name) */
+export async function addOrUpdatePeer(name, publicKey, notes) {
+    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) {
+    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) {
+    const data = await readFile();
+    if (data.peers[name]) {
+        data.peers[name].lastConnectedAt = new Date().toISOString();
+        await writeFile(data);
+    }
+}
+/** 列出所有 known peers */
+export async function listPeers() {
+    const data = await readFile();
+    return Object.values(data.peers);
+}
+/** 通过 publicKey 找 name (用于自动标记 lastConnectedAt) */
+export async function findNameByPublicKey(publicKey) {
+    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/dist/network/p2p-direct.js

@@ -0,0 +1,151 @@
+/**
+ * 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 { EventEmitter } from 'events';
+// @ts-ignore — b4a 没官方 .d.ts
+import b4a from 'b4a';
+import { loadOrCreateKeyPair, writebackPublicKey } from './p2p-secret.js';
+export class P2PDirect extends EventEmitter {
+    swarm = null;
+    name;
+    role;
+    joinedTopics = new Set();
+    // 维护: 远端 publicKey -> conn (用于主动 send)
+    conns = new Map();
+    started = false;
+    ephemeral;
+    constructor(opts = {}) {
+        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() {
+        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, info) => {
+            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) => {
+                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,
+                });
+            });
+            conn.on('error', (err) => {
+                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) {
+        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) {
+        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, data) {
+        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() {
+        if (!this.swarm)
+            return '';
+        return b4a.toString(this.swarm.keyPair.publicKey, 'hex');
+    }
+    /** 当前 P2PDirect 用的 role (对应 secret 文件名) */
+    getRole() {
+        return this.role;
+    }
+    getConnectionCount() {
+        return this.conns.size;
+    }
+    async stop() {
+        if (!this.swarm)
+            return;
+        await this.swarm.destroy();
+        this.swarm = null;
+        this.conns.clear();
+        this.started = false;
+        console.log(`[P2PDirect:${this.name}] 已停止`);
+    }
+}

package/dist/network/p2p-secret.js

@@ -0,0 +1,126 @@
+/**
+ * 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');
+function resolveRole() {
+    return (process.env.IROH_ROLE ||
+        process.env.BOLLOON_ROLE ||
+        'default');
+}
+function fileForRole(role) {
+    return path.join(SECRET_DIR, `p2p-direct-secret-${role}.json`);
+}
+async function ensureDir() {
+    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) {
+    const role = roleOverride || resolveRole();
+    const file = fileForRole(role);
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        const existing = 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) {
+        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 = {
+        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, secretKey, realPublicKey) {
+    const file = fileForRole(role);
+    let existing = null;
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        existing = JSON.parse(raw);
+    }
+    catch { }
+    const data = 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) {
+    const role = roleOverride || resolveRole();
+    const file = fileForRole(role);
+    try {
+        await fs.unlink(file);
+        console.log(`[p2p-secret] 删除 ${file}`);
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+}
+/** 当前 role 对应的 secret 文件路径 (供 server 暴露) */
+export function secretPathForRole(roleOverride) {
+    return fileForRole(roleOverride || resolveRole());
+}