@bolloon/bolloon-agent 0.1.23 → 0.1.24

package/src/network/iroh-transport.ts

@@ -1,5 +1,6 @@
 import { Endpoint, Connection } from '@rayhanadev/iroh';
 import * as crypto from 'crypto';
+import { loadOrCreateIrohSecret } from '../agents/iroh-secret.js';
 
 export interface IrohMessage {
   type: string;
@@ -91,6 +92,19 @@ export class IrohTransport {
       };
     }
 
+    // 若调用方未传 secretKey，从 ~/.bolloon/iroh-secret-default.json 落盘/读取
+    // 保证 iroh nodeId 在同一台机器上跨重启保持稳定
+    if (!secretKey) {
+      try {
+        const sec = loadOrCreateIrohSecret('default');
+        // 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})`);
+      } catch (e) {
+        console.warn('[IrohTransport] iroh-secret 加载失败, 将使用临时身份:', e);
+      }
+    }
+
     const options: any = { alpns: [IROH_ALPN] };
     if (secretKey) {
       options.secretKey = secretKey;

package/src/utils/auto-update.ts

@@ -363,12 +363,22 @@ export async function checkAndUpdate(): Promise<{
   updated: boolean;
   message: string;
 }> {
-  // 检查是否有 --no-update 标志
+  // opt-in: 默认跳过更新检查. 想允许必须显式提供以下任一标志:
+  //   --update-check, --update-now, --allow-update
+  //   BOLLOON_AUTO_UPDATE=1
+  const allowFlag = process.argv.includes('--update-check')
+    || process.argv.includes('--update-now')
+    || process.argv.includes('--allow-update');
+  const allowEnv = process.env.BOLLOON_AUTO_UPDATE === '1';
+  if (!allowFlag && !allowEnv) {
+    return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查 (默认关闭, 用 --update-check 显式触发)' };
+  }
+
+  // 显式屏蔽仍然优先
   if (process.argv.includes('--no-update') || process.argv.includes('--skip-update')) {
     return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查' };
   }
 
-  // 检查环境变量
   if (process.env.BOLLOON_SKIP_UPDATE === 'true') {
     return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查（环境变量）' };
   }

package/src/web/agent-delegate-server.ts

@@ -0,0 +1,148 @@
+/**
+ * agent-delegate-server - 把 manifest + agent_delegate 协议挂到 Web API
+ *
+ * 启动: PORT=54189 npx tsx src/web/agent-delegate-server.ts
+ *
+ * 提供:
+ *   GET  /api/agent/local-manifest          — 本节点智能体清单
+ *   POST /api/agent/register                — 注册/更新本节点智能体
+ *   GET  /api/agent/remote-manifests        — 缓存的远端 manifest 列表
+ *   POST /api/agent/pick                    — 按 capability + 可选 ownerPublicKey 选 agent
+ *   POST /api/agent/delegate                — DOC 驱动委派 (转发到对端 agent)
+ *
+ * 该模块不直接绑 Hyperswarm — 通过注入的 transport 抽象:
+ *   - sendToNode(nodeId, frame) -> Promise<responseFrame>
+ *
+ * 主进程接入时把 Hyperswarm 拨号逻辑包成 transport 注入。
+ */
+
+import express from 'express';
+import {
+  buildAgentDelegateRequest, buildAgentResponse, buildManifestPayload, buildManifestRequest,
+  parseFrame, setLocalManifest, addLocalAgent, getLocalManifest, getRemoteManifests,
+  cacheRemoteManifest, pickAgent, type AgentManifestEntry, type AgentManifest,
+} from '../agents/agent-manifest-protocol.js';
+
+export interface DelegateTransport {
+  /** 发送 frame 到指定节点公钥, 等待回包. null 表示不实现 (同步返回占位) */
+  sendToNode(publicKey: string, frame: string, timeoutMs?: number): Promise<string | null>;
+  /** 注册 onMessage: 对方 manifest_request 来了, 我方要回 manifest_payload */
+  onIncomingFrame(handler: (fromPublicKey: string, frame: string) => Promise<string | null>): void;
+}
+
+export function createAgentDelegateApp(transport: DelegateTransport): express.Express {
+  const app = express();
+  app.use(express.json({ limit: '2mb' }));
+
+  // ---- 本地 manifest ----
+  app.get('/api/agent/local-manifest', (_req, res) => {
+    res.json(getLocalManifest());
+  });
+
+  app.post('/api/agent/register', (req, res) => {
+    const body = req.body as { agents: AgentManifestEntry[]; ownerName?: string; ownerPublicKey?: string };
+    if (!body.agents || !Array.isArray(body.agents)) {
+      return res.status(400).json({ error: 'agents array required' });
+    }
+    setLocalManifest({
+      ownerName: body.ownerName || getLocalManifest().ownerName || 'unknown',
+      ownerPublicKey: body.ownerPublicKey || getLocalManifest().ownerPublicKey || '',
+      agents: body.agents,
+    });
+    res.json({ ok: true, manifest: getLocalManifest() });
+  });
+
+  // ---- 远端 manifest 列表 ----
+  app.get('/api/agent/remote-manifests', (_req, res) => {
+    res.json({ count: getRemoteManifests().length, manifests: getRemoteManifests() });
+  });
+
+  // ---- 按 capability 选 agent ----
+  app.post('/api/agent/pick', (req, res) => {
+    const { capability, ownerPublicKey } = req.body as { capability: string; ownerPublicKey?: string };
+    if (!capability) return res.status(400).json({ error: 'capability required' });
+    const picked = pickAgent(capability, ownerPublicKey);
+    if (!picked) return res.status(404).json({ error: 'no matching agent', capability });
+    res.json({ ok: true, agent: picked.agent, owner: { name: picked.owner.ownerName, publicKey: picked.owner.ownerPublicKey } });
+  });
+
+  // ---- DOC 驱动委派 ----
+  app.post('/api/agent/delegate', async (req, res) => {
+    try {
+      const { toPublicKey, capability, docPath, docContent, instruction, fromAgentId } = req.body as {
+        toPublicKey: string;
+        capability: string;
+        docPath?: string;
+        docContent?: string;
+        instruction: string;
+        fromAgentId?: string;
+      };
+      if (!toPublicKey || !capability || !instruction) {
+        return res.status(400).json({ error: 'toPublicKey, capability, instruction required' });
+      }
+
+      // 1) 优先从已缓存的远端 manifest 里选 agent
+      let targetAgent: AgentManifestEntry | null = null;
+      const remote = getRemoteManifests().find((m) => m.ownerPublicKey === toPublicKey || m.ownerPublicKey.startsWith(toPublicKey.substring(0, 16)));
+      if (remote) {
+        targetAgent = remote.agents.find((a) => a.capabilities.includes(capability) && a.status === 'active') || null;
+      }
+
+      // 2) 构造 frame, 通过 transport 发送
+      const frame = buildAgentDelegateRequest({
+        capability,
+        docPath,
+        docContent,
+        instruction,
+        fromAgentId: fromAgentId || 'local-user',
+      });
+
+      const replyFrame = await transport.sendToNode(toPublicKey, frame, 30000);
+      if (!replyFrame) {
+        return res.status(504).json({ error: 'no response from peer (timeout or transport not wired)' });
+      }
+      const f = parseFrame(replyFrame);
+      if (!f || f.type !== 'agent_response') {
+        return res.status(502).json({ error: 'bad response', frame: replyFrame });
+      }
+      res.json({
+        ok: true,
+        targetAgent: targetAgent || { id: f.payload.delegatedTo, capabilities: [capability], status: 'active', name: f.payload.delegatedTo },
+        response: f.payload,
+      });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  // ---- 接收对方 manifest_request / agent_delegate 处理 ----
+  // 业务端需要把对端来的入站 frame 转给本 handler
+  // 简化: 把 handler 挂到 transport.onIncomingFrame
+  transport.onIncomingFrame(async (fromPublicKey, frame) => {
+    const f = parseFrame(frame);
+    if (!f) return null;
+    if (f.type === 'manifest_request') {
+      return buildManifestPayload(getLocalManifest());
+    }
+    if (f.type === 'manifest_payload') {
+      cacheRemoteManifest(f.payload as AgentManifest);
+      return null;  // 不需要回包
+    }
+    if (f.type === 'agent_delegate') {
+      // 路由到本地匹配 agent
+      const req = f.payload as any;
+      const local = getLocalManifest();
+      const target = local.agents.find((a) => a.capabilities.includes(req.capability) && a.status === 'active') || local.agents[0];
+      if (!target) return buildAgentResponse({ ok: false, delegatedTo: 'none', summary: 'no local agent available' });
+      return buildAgentResponse({
+        ok: true,
+        delegatedTo: target.id,
+        resultCid: `mock-${Date.now()}`,
+        summary: `[${target.name}] 已处理任务: ${req.instruction?.substring(0, 30)}`,
+      });
+    }
+    return null;
+  });
+
+  return app;
+}