@bolloon/bolloon-agent 0.3.44 → 0.3.46

package/dist/web/manifest.json

@@ -1,21 +1,21 @@
-{
-  "name": "Bolloon Agent",
-  "short_name": "Bolloon",
-  "description": "AI Agent with Claude API integration",
-  "start_url": "/",
-  "display": "standalone",
-  "background_color": "#1a1a2e",
-  "theme_color": "#1a1a2e",
-  "icons": [
-    {
-      "src": "/icons/favicon-192x192.png",
-      "sizes": "192x192",
-      "type": "image/png"
-    },
-    {
-      "src": "/icons/favicon-512x512.png",
-      "sizes": "512x512",
-      "type": "image/png"
-    }
-  ]
+{
+  "name": "Bolloon Agent",
+  "short_name": "Bolloon",
+  "description": "AI Agent with Claude API integration",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#1a1a2e",
+  "theme_color": "#1a1a2e",
+  "icons": [
+    {
+      "src": "/icons/favicon-192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "/icons/favicon-512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    }
+  ]
 }

package/dist/web/server.js

@@ -1669,6 +1669,40 @@ export async function createWebServer(port = 3000, options = {}) {
             console.warn('[mcp] 初始化失败 (非致命):', e?.message?.slice(0, 120));
         }
     })();
+    // 2026-08-08: DID 目录启动接入 — 回填既有磁盘数据 + 启动 OrbitDB 自动复制.
+    //   fire-and-forget: 不阻塞启动; 失败静默 (catalog 是增强层, 原磁盘路径永远可用).
+    (async () => {
+        try {
+            const { openUserCatalog, backfillDidCatalog } = await import('../storage/did-catalog-bridge.js');
+            const cat = await openUserCatalog();
+            if (!cat) {
+                console.log('[did-catalog] 未生成用户 DID, 跳过回填 (首次启动会由 /api/user/identity 生成)');
+                return;
+            }
+            const r = await backfillDidCatalog(cat);
+            const total = r.reduce((a, x) => a + x.added, 0);
+            console.log(`[did-catalog] 启动回填完成: ${total} 行新写入 (${r.map(x => `${x.table}=${x.added}+${x.skipped}跳过`).join(', ')})`);
+        }
+        catch (e) {
+            console.warn('[did-catalog] 启动回填失败 (非致命):', e?.message?.slice(0, 120));
+        }
+    })();
+    // 2026-08-08: DID 目录 → OrbitDB 自动复制 (WAL 事件流驱动跨设备合并).
+    //   懒启动: 等 identity 就绪后再开; 失败静默 (离线时 catalog 照常工作).
+    (async () => {
+        try {
+            const identity = await loadOrCreateUserIdentity();
+            if (!identity.did)
+                return;
+            const { startDidCatalogReplication } = await import('../orbitdb/did-catalog-replication.js');
+            const rep = await startDidCatalogReplication(identity.did, { intervalMs: 30_000 });
+            console.log(`[did-catalog] OrbitDB 自动复制已启动: store=${rep.storeName} address=${String(rep.storeAddress).slice(0, 48)}...`);
+            globalThis.__didCatalogReplication = rep;
+        }
+        catch (e) {
+            console.warn('[did-catalog] OrbitDB 复制启动失败 (非致命, 稍后可用 API 重试):', e?.message?.slice(0, 120));
+        }
+    })();
     // 重置旧的 agent session，确保使用新的 LLM 配置
     const { resetAgentSession } = await import('../agents/pi-sdk.js');
     resetAgentSession();
@@ -1839,6 +1873,13 @@ export async function createWebServer(port = 3000, options = {}) {
         // 尝试发布 DID 到 IPFS
         try {
             const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+            // 2026-08-09: 归属用户 DID — 智能体身份归属用户唯一身份 (DID 文档带 controller+alsoKnownAs)
+            try {
+                const owner = await loadOrCreateUserIdentity();
+                if (owner?.did)
+                    auth.setOwnerDid(owner.did);
+            }
+            catch { /* 归属设置失败不阻塞 */ }
             await auth.registerAgent({ name, services: [] }, kp, '');
             console.log('P2P DID 已发布到 IPFS');
         }
@@ -2313,19 +2354,19 @@ export async function createWebServer(port = 3000, options = {}) {
                         .map((p) => `- ${p.name || p.publicKey.slice(0, 8)} (pk=${p.publicKey.slice(0, 12)}…): 渠道[${p.channels.map((c) => c.name).join(', ') || '无'}]`)
                         .join('\n');
                     const goalDesc = ctx.goal ? `当前目标: ${ctx.goal.description} (已发起 ${ctx.goal.initiationsUsed}/${ctx.goal.maxInitiations}, 有效回复 ${ctx.goal.effectfulReplies}/${ctx.goal.effectThreshold})` : '当前无明确目标';
-                    const prompt = `你是智能体「${ctx.self.name || '本地智能体'}」。你通过 P2P 网络认识以下其他智能体:
-${peerLines}
-
-${goalDesc}
-
-规则:
-1. 社交是为了达成上述目标, 不是闲聊。只在你有真正有价值的信息要分享/询问、且能推进目标时才主动发起。
-2. 不要重复最近已经聊过的话题, 不要每条心跳都发消息, 保持克制。
-3. 如果目标已经通过已有交流达成 (或你认为无需再聊), 输出 {"initiate": false, "goalAchieved": true}。
-4. 如果决定发起, 选一个最合适的目标渠道 (用对方渠道的真实 id)。
-
-现在是否要主动联系其中某个智能体? 只输出一个 JSON 对象, 不要任何其他文字:
-{"initiate": true 或 false, "goalAchieved": true 或 false, "targetPeerPublicKey": "对方 pk", "targetChannelId": "对方渠道 id", "message": "你要说的话"}
+                    const prompt = `你是智能体「${ctx.self.name || '本地智能体'}」。你通过 P2P 网络认识以下其他智能体:
+${peerLines}
+
+${goalDesc}
+
+规则:
+1. 社交是为了达成上述目标, 不是闲聊。只在你有真正有价值的信息要分享/询问、且能推进目标时才主动发起。
+2. 不要重复最近已经聊过的话题, 不要每条心跳都发消息, 保持克制。
+3. 如果目标已经通过已有交流达成 (或你认为无需再聊), 输出 {"initiate": false, "goalAchieved": true}。
+4. 如果决定发起, 选一个最合适的目标渠道 (用对方渠道的真实 id)。
+
+现在是否要主动联系其中某个智能体? 只输出一个 JSON 对象, 不要任何其他文字:
+{"initiate": true 或 false, "goalAchieved": true 或 false, "targetPeerPublicKey": "对方 pk", "targetChannelId": "对方渠道 id", "message": "你要说的话"}
 若不想发起, 输出 {"initiate": false}。`;
                     const raw = await agent.promptStream(prompt, () => { }, undefined, local.id);
                     const m = raw.match(/\{[\s\S]*\}/);
@@ -2759,6 +2800,117 @@ ${goalDesc}
             res.status(500).json({ error: err.message });
         }
     });
+    // ========== 登录框架 (2026-08-09) — GitHub/Google/邮箱/手机号, 仅骨架 ==========
+    // 所有登录方式最终都归属到用户 DID (右下角唯一身份).
+    // 真实 OAuth / 验证码后续接入, 这里先做: 记录账号 + 绑定用户 DID + 提供状态查询.
+    const ACCOUNTS_FILE = `${process.env.HOME || '/tmp'}/.bolloon/accounts.json`;
+    async function loadAccounts() {
+        try {
+            const { readFile } = await import('fs/promises');
+            const parsed = JSON.parse(await readFile(ACCOUNTS_FILE, 'utf-8'));
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async function saveAccounts(accs) {
+        const { mkdir, writeFile } = await import('fs/promises');
+        await mkdir(`${process.env.HOME || '/tmp'}/.bolloon`, { recursive: true });
+        await writeFile(ACCOUNTS_FILE, JSON.stringify(accs, null, 2), { mode: 0o600 });
+    }
+    // GET /api/auth/status — 当前用户 DID + 已绑定账号列表
+    app.get('/api/auth/status', async (_req, res) => {
+        try {
+            const identity = await loadOrCreateUserIdentity();
+            const accs = await loadAccounts();
+            res.json({
+                did: identity.did,
+                didShort: identity.didShort,
+                name: identity.name,
+                // 只返回脱敏视图 (不含 token)
+                accounts: accs.map((a) => ({
+                    provider: a.provider,
+                    identifier: a.identifier || a.email || a.username || '',
+                    loggedAt: a.loggedAt,
+                    skeleton: !!a.skeleton,
+                })),
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/auth/login — 登录骨架 (记录账号 + 绑定用户 DID)
+    // body: { provider: 'github'|'google'|'email'|'phone', identifier?: string }
+    app.post('/api/auth/login', async (req, res) => {
+        try {
+            const { provider, identifier } = req.body || {};
+            const prov = String(provider || '').trim().toLowerCase();
+            const VALID = ['github', 'google', 'email', 'phone'];
+            if (!VALID.includes(prov)) {
+                return res.status(400).json({ error: `provider 必须是 ${VALID.join('/')}` });
+            }
+            // 邮箱/手机号必填 identifier
+            if ((prov === 'email' || prov === 'phone') && !String(identifier || '').trim()) {
+                return res.status(400).json({ error: `${prov === 'email' ? '邮箱' : '手机号'}必填` });
+            }
+            const identity = await loadOrCreateUserIdentity();
+            const accs = await loadAccounts();
+            const idStr = String(identifier || '').trim();
+            const existing = accs.find((a) => a.provider === prov && (!idStr || a.identifier === idStr || a.email === idStr));
+            const now = new Date().toISOString();
+            if (existing) {
+                // 已绑定 → 更新归属 DID + 时间
+                existing.ownerDid = identity.did;
+                existing.loggedAt = now;
+                existing.skeleton = true;
+            }
+            else {
+                accs.push({
+                    provider: prov,
+                    identifier: idStr || '',
+                    email: prov === 'email' ? idStr : '',
+                    phone: prov === 'phone' ? idStr : '',
+                    username: idStr || '',
+                    token: '', // 真实 OAuth 后填
+                    ownerDid: identity.did, // 归属用户唯一 DID
+                    loggedAt: now,
+                    skeleton: true, // 骨架标记: 未做真实 OAuth/验证码
+                });
+            }
+            await saveAccounts(accs);
+            console.log(`[auth] 登录骨架: ${prov}${idStr ? ' ' + idStr : ''} → 归属 DID ${identity.did.substring(0, 20)}...`);
+            res.json({
+                ok: true,
+                provider: prov,
+                identifier: idStr,
+                ownerDid: identity.did,
+                skeleton: true,
+                message: `${prov} 登录骨架已记录 (归属用户 DID), 真实 OAuth/验证码后续接入`,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/auth/logout — 解除某个 provider 的绑定 (骨架)
+    app.post('/api/auth/logout', async (req, res) => {
+        try {
+            const { provider } = req.body || {};
+            const prov = String(provider || '').trim().toLowerCase();
+            const accs = await loadAccounts();
+            const before = accs.length;
+            const remaining = accs.filter((a) => a.provider !== prov);
+            if (remaining.length === before)
+                return res.status(404).json({ error: `未绑定 ${prov} 账号` });
+            await saveAccounts(remaining);
+            res.json({ ok: true, provider: prov });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // 2026-08-08: DID 目录 (Postgres 式) — 以用户 DID 为主键, 绑定 memory/persona/skills/on_policy/context_os 等表
     app.get('/api/did-catalog/:table', async (req, res) => {
         try {
@@ -2818,6 +2970,104 @@ ${goalDesc}
             res.status(500).json({ error: err.message });
         }
     });
+    // 手动触发启动回填 (既有磁盘数据 → DID 目录表, 幂等)
+    app.post('/api/did-catalog/backfill', async (_req, res) => {
+        try {
+            const identity = await loadOrCreateUserIdentity();
+            if (!identity.did)
+                return res.status(404).json({ error: '未生成用户 DID' });
+            const { openUserCatalog, backfillDidCatalog } = await import('../storage/did-catalog-bridge.js');
+            const cat = await openUserCatalog();
+            if (!cat)
+                return res.status(404).json({ error: '目录未打开' });
+            const r = await backfillDidCatalog(cat);
+            res.json({ ok: true, did: identity.did, tables: r });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // OrbitDB 复制状态 / 启动 (自动复制失败后的手动入口)
+    app.get('/api/did-catalog/replication', async (_req, res) => {
+        try {
+            const identity = await loadOrCreateUserIdentity();
+            if (!identity.did)
+                return res.status(404).json({ error: '未生成用户 DID' });
+            const rep = globalThis.__didCatalogReplication;
+            if (!rep)
+                return res.json({ ok: false, did: identity.did, running: false });
+            const { publishPending, syncNow } = rep;
+            const published = await publishPending();
+            const synced = await syncNow();
+            res.json({
+                ok: true, did: identity.did, running: true,
+                storeName: rep.storeName, storeAddress: rep.storeAddress,
+                stats: rep.stats, publishedNow: published, syncedNow: synced,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/did-catalog/replication/start', async (_req, res) => {
+        try {
+            const identity = await loadOrCreateUserIdentity();
+            if (!identity.did)
+                return res.status(404).json({ error: '未生成用户 DID' });
+            if (globalThis.__didCatalogReplication) {
+                return res.json({ ok: true, did: identity.did, running: true, storeAddress: globalThis.__didCatalogReplication.storeAddress });
+            }
+            const { startDidCatalogReplication } = await import('../orbitdb/did-catalog-replication.js');
+            const rep = await startDidCatalogReplication(identity.did, { intervalMs: 30_000 });
+            globalThis.__didCatalogReplication = rep;
+            res.json({ ok: true, did: identity.did, running: true, storeName: rep.storeName, storeAddress: rep.storeAddress });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 智能体运行轨迹 (trajectory): 列表 + 单条 (落盘 ~/.bolloon/trajectories/)
+    app.get('/api/trajectories', async (_req, res) => {
+        try {
+            const { listTrajectories } = await import('../orbitdb/trajectory-store.js');
+            const list = await listTrajectories();
+            const summary = [];
+            for (const { runId, file } of list) {
+                try {
+                    const { loadTrajectory } = await import('../orbitdb/trajectory-store.js');
+                    const run = await loadTrajectory(runId);
+                    summary.push({
+                        runId, file,
+                        agentId: run?.agentId, channelId: run?.channelId,
+                        startedAt: run?.startedAt, endedAt: run?.endedAt,
+                        durationMs: run?.durationMs, status: run?.status,
+                        input: run?.input?.slice(0, 120), reply: run?.reply?.slice(0, 120),
+                        steps: run?.steps?.length ?? 0,
+                    });
+                }
+                catch { /* 单条失败跳过 */ }
+            }
+            res.json({ ok: true, count: list.length, runs: summary });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/trajectories/:runId', async (req, res) => {
+        try {
+            const { loadTrajectory } = await import('../orbitdb/trajectory-store.js');
+            const runId = String(req.params.runId || '');
+            if (!runId)
+                return res.status(400).json({ error: 'runId 必填' });
+            const run = await loadTrajectory(runId);
+            if (!run)
+                return res.status(404).json({ error: `轨迹不存在: ${runId}` });
+            res.json({ ok: true, run });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // 2026-07-01 (v0.2.6): 前后端分离核心 — 后端切 LLM 输出为结构化 segments
     //   - POST /api/segment-reply { reply, knownTools }
     //   - 返回 ChatSegment[] (think / text / env_details / tool_call / final)
@@ -3419,6 +3669,26 @@ ${goalDesc}
                         const memBlock = summariesToRead.map(s => s.trim().slice(-1500)).join('\n\n---\n\n');
                         contextHint += `[系统上下文] 动态状态层 · chat-worksite (上次做到哪 — 本 channel 历史记忆, 来自 memory-compressor 摘要, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
                     }
+                    else {
+                        // 2026-08-08 (DID 目录读侧): 磁盘无摘要时, 回退读 DID 目录 memory 表 (跨设备同步来的记忆)
+                        try {
+                            const { openUserCatalog, catalogMemoryRows } = await import('../storage/did-catalog-bridge.js');
+                            const cat = await openUserCatalog();
+                            if (cat) {
+                                const rows = catalogMemoryRows(cat, agentId);
+                                if (rows.length > 0) {
+                                    const memBlock = rows.slice(0, 2)
+                                        .map(({ row }) => String(row.data.summary || '').slice(-1500))
+                                        .filter(Boolean)
+                                        .join('\n\n---\n\n');
+                                    if (memBlock) {
+                                        contextHint += `[系统上下文] 动态状态层 · chat-worksite (DID 目录同步记忆, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                                    }
+                                }
+                            }
+                        }
+                        catch { /* 目录读失败静默 */ }
+                    }
                 }
             }
             catch (memErr) {
@@ -4024,6 +4294,13 @@ ${goalDesc}
             const pkBytes = Buffer.from(channel.publicKey, 'hex');
             const kp = { privateKey: new Uint8Array(32), publicKey: pkBytes, did: channel.did };
             const auth = await AgentAuthManager.newWithRemoteIpfs('http://127.0.0.1:5001', 'http://127.0.0.1:8080');
+            // 2026-08-09: 归属用户 DID — 子智能体身份归属用户唯一身份
+            try {
+                const owner = await loadOrCreateUserIdentity();
+                if (owner?.did)
+                    auth.setOwnerDid(owner.did);
+            }
+            catch { /* 归属设置失败不阻塞 */ }
             const result = await auth.registerAgent({ name: channel.name, services: [] }, kp, '');
             channel.cid = result.cid || channel.cid;
             // 关键: 不再保存整份 didDocument, 只留 cid/ipnsName 两个引用字段