@bolloon/bolloon-agent 0.1.23 → 0.1.25

package/dist/agents/agent-manifest-protocol.js

@@ -0,0 +1,81 @@
+/**
+ * agent-manifest-protocol - 节点握手后立刻互换"我有哪些 agent + capabilities"
+ *
+ * 核心目的：实现 "建联一次，访问对方所有智能体"。
+ *   - 节点连上 (Hyperswarm 主题 / iroh) 后立刻发 'manifest_request'
+ *   - 对端回 'manifest_payload'，写入本地 agentRegistry
+ *   - 之后任何指令可以 pickAgent(capability, ownerDid) → 直接委派
+ *
+ * 协议消息 (Hyperswarm 字符串帧):
+ *   manifest_request: { }
+ *   manifest_payload: { ownerName, ownerPublicKey, agents:[{id,name,capabilities,status}], publishedAt }
+ *
+ * 本文件不绑定 transport — 只提供 build/parse/dispatch 帮助函数。
+ * 调用方在自己 transport 上挂 onMessage('manifest_request', ...) 和 onMessage('manifest_payload', ...)。
+ */
+// ============== 帧构造 ==============
+export function buildManifestRequest() {
+    return JSON.stringify({ type: 'manifest_request', payload: {}, ts: Date.now(), fromDid: '' });
+}
+export function buildManifestPayload(manifest) {
+    return JSON.stringify({ type: 'manifest_payload', payload: manifest, ts: Date.now(), fromDid: '' });
+}
+export function buildAgentDelegateRequest(opts) {
+    return JSON.stringify({ type: 'agent_delegate', payload: opts, ts: Date.now(), fromDid: '' });
+}
+export function buildAgentResponse(opts) {
+    return JSON.stringify({ type: 'agent_response', payload: opts, ts: Date.now(), fromDid: '' });
+}
+// ============== 帧解析 ==============
+export function parseFrame(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+// ============== 本地 manifest registry ==============
+const localManifest = {
+    ownerName: '',
+    ownerPublicKey: '',
+    agents: [],
+    publishedAt: 0,
+};
+export function setLocalManifest(m) {
+    Object.assign(localManifest, m, { publishedAt: Date.now() });
+    return localManifest;
+}
+export function getLocalManifest() {
+    return localManifest;
+}
+export function addLocalAgent(agent) {
+    const idx = localManifest.agents.findIndex((a) => a.id === agent.id);
+    if (idx >= 0)
+        localManifest.agents[idx] = agent;
+    else
+        localManifest.agents.push(agent);
+    localManifest.publishedAt = Date.now();
+    return localManifest;
+}
+// ============== 远端 manifest 缓存 ==============
+const remoteManifests = new Map(); // key = ownerPublicKey
+export function cacheRemoteManifest(m) {
+    if (m.ownerPublicKey)
+        remoteManifests.set(m.ownerPublicKey, m);
+    return m;
+}
+export function getRemoteManifests() {
+    return Array.from(remoteManifests.values());
+}
+export function pickAgent(capability, ownerPublicKey) {
+    const owners = ownerPublicKey
+        ? [remoteManifests.get(ownerPublicKey)].filter(Boolean)
+        : getRemoteManifests();
+    for (const owner of owners) {
+        const a = owner.agents.find((x) => x.capabilities.includes(capability) && x.status === 'active');
+        if (a)
+            return { agent: a, owner };
+    }
+    return null;
+}

package/dist/agents/iroh-secret.js

@@ -0,0 +1,32 @@
+/**
+ * iroh-secret - 把 iroh secretKey 落 ~/.bolloon/iroh-secret.json
+ *
+ * iroh 默认每次启动生成新节点 ID；落盘后可实现"跨重启稳定 nodeId"。
+ * 对应 Issue: "建联一次访问所有智能体"需要稳定标识, 不然对方缓存的 nodeId 失效
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+const SECRET_DIR = path.join(os.homedir(), '.bolloon');
+export function loadOrCreateIrohSecret(role = 'default') {
+    if (!fs.existsSync(SECRET_DIR))
+        fs.mkdirSync(SECRET_DIR, { recursive: true });
+    const fp = path.join(SECRET_DIR, `iroh-secret-${role}.json`);
+    if (fs.existsSync(fp)) {
+        const j = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+        return { secretKey: Buffer.from(j.secretKey, 'hex'), createdAt: j.createdAt, reused: true };
+    }
+    const sk = crypto.randomBytes(32);
+    const createdAt = new Date().toISOString();
+    fs.writeFileSync(fp, JSON.stringify({ secretKey: sk.toString('hex'), createdAt }, null, 2), { mode: 0o600 });
+    // chmod in case the file already existed and umask produced looser perms
+    try {
+        fs.chmodSync(fp, 0o600);
+    }
+    catch { }
+    return { secretKey: sk, createdAt, reused: false };
+}
+export function irohSecretFilePath(role = 'default') {
+    return path.join(SECRET_DIR, `iroh-secret-${role}.json`);
+}

package/dist/index.js

@@ -11,7 +11,7 @@ import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
-import { checkAndUpdate } from './utils/auto-update.js';
+// 启动时自动检查更新已禁用 (改用 --update-check / --update-now 显式触发)
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
@@ -1324,13 +1324,10 @@ async function main() {
         printHelp();
         process.exit(0);
     }
-    // 启动时检查 npm 包更新
-    const updateResult = await checkAndUpdate();
-    if (updateResult.hasUpdate && updateResult.updated) {
-        console.log(`\n${YELLOW}更新完成，请重新启动 bolloon${RESET}\n`);
-        // 更新完成后退出，让用户重新启动
-        process.exit(0);
-    }
+    // 自动更新已禁用: 启动时不再自动检查/安装更新.
+    // 想手动检查: bolloon --update-check
+    // 想手动更新: bolloon --update-now [package]
+    // 想完全屏蔽 (CI / sandbox): BOLLOON_SKIP_UPDATE=true
     const mode = args.web ? 'web' : 'cli';
     const isNonInteractive = !!(args.tool || args.prompt);
     const isTuiMode = mode === 'cli' && !isNonInteractive && args.tui;

package/dist/network/iroh-transport.js

@@ -1,5 +1,6 @@
 import { Endpoint } from '@rayhanadev/iroh';
 import * as crypto from 'crypto';
+import { loadOrCreateIrohSecret } from '../agents/iroh-secret.js';
 const IROH_ALPN = 'bolloon/iroh/1';
 export class IrohTransport {
     endpoint = null;
@@ -24,6 +25,19 @@ export class IrohTransport {
                 addr: this.ownNodeId // iroh 没有 listenAddresses，用 nodeId 作为 addr
             };
         }
+        // 若调用方未传 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 = { alpns: [IROH_ALPN] };
         if (secretKey) {
             options.secretKey = secretKey;

package/dist/pi-ecosystem-judgment/human-value-store.js

@@ -130,6 +130,44 @@ export async function learnFromCorrection(original, corrected, reason) {
 // ============================================================
 // 读取操作
 // ============================================================
+/**
+ * 修改一个判断 (手动编辑). 允许改: decision, reasons, context, values_derived, decision_type, confidence.
+ * 不能改 id, timestamp (id 不暴露, 靠 id 查).
+ */
+export async function updateJudgment(id, patch) {
+    const judgments = await loadAllJudgments();
+    const idx = judgments.findIndex((j) => j.id === id);
+    if (idx < 0)
+        return null;
+    const cur = judgments[idx];
+    const next = {
+        ...cur,
+        ...(patch.decision !== undefined ? { decision: patch.decision } : {}),
+        ...(patch.decision_type !== undefined ? { decision_type: patch.decision_type } : {}),
+        ...(patch.reasons !== undefined ? { reasons: patch.reasons } : {}),
+        ...(patch.values_derived !== undefined ? { values_derived: patch.values_derived } : {}),
+        ...(patch.context !== undefined ? { context: { ...cur.context, ...patch.context } } : {}),
+        ...(patch.outcome !== undefined ? { outcome: { ...cur.outcome, ...patch.outcome } } : {}),
+    };
+    judgments[idx] = next;
+    await saveJudgments(judgments);
+    // 价值画像缓存失效 (内容变了画像也得重算)
+    valueProfileCache.clear();
+    return next;
+}
+/**
+ * 删除一个判断.
+ */
+export async function deleteJudgment(id) {
+    const judgments = await loadAllJudgments();
+    const idx = judgments.findIndex((j) => j.id === id);
+    if (idx < 0)
+        return false;
+    judgments.splice(idx, 1);
+    await saveJudgments(judgments);
+    valueProfileCache.clear();
+    return true;
+}
 /**
  * 加载所有人类判断
  */
@@ -238,6 +276,8 @@ export async function getPriorityRules() {
 async function saveJudgments(judgments) {
     await fs.mkdir(VALUE_STORE_DIR, { recursive: true });
     await fs.writeFile(JUDGMENTS_FILE, JSON.stringify(judgments, null, 2), 'utf-8');
+    // 让 loadAllJudgments 下次重新读盘, 避免缓存与磁盘脱节
+    judgmentCache = judgments;
 }
 function buildValueProfile(agentId, judgments) {
     const profile = {

package/dist/utils/auto-update.js

@@ -312,11 +312,20 @@ async function updatePackagesWithVersion(packagesWithVersion) {
  * 检查并自动更新（启动时调用）
  */
 export async function checkAndUpdate() {
-    // 检查是否有 --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/dist/web/agent-delegate-server.js

@@ -0,0 +1,123 @@
+/**
+ * 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, parseFrame, setLocalManifest, getLocalManifest, getRemoteManifests, cacheRemoteManifest, pickAgent, } from '../agents/agent-manifest-protocol.js';
+export function createAgentDelegateApp(transport) {
+    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;
+        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;
+        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;
+            if (!toPublicKey || !capability || !instruction) {
+                return res.status(400).json({ error: 'toPublicKey, capability, instruction required' });
+            }
+            // 1) 优先从已缓存的远端 manifest 里选 agent
+            let targetAgent = 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) {
+            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);
+            return null; // 不需要回包
+        }
+        if (f.type === 'agent_delegate') {
+            // 路由到本地匹配 agent
+            const req = f.payload;
+            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;
+}