@bolloon/bolloon-agent 0.4.14 → 0.4.15

package/dist/web/mobile-data.js

@@ -0,0 +1,346 @@
+/**
+ * mobile-data.ts — 手机端数据同步层 (2026-08-15)
+ *
+ * 独立子系统 #1: 手机是"独立存储副本", 不是桌面的缓存.
+ *   - IndexedDB 是手机的本地方言数据 (channels / sessions / messages)
+ *   - 与远端 (桌面/其他节点) 通过 P2P 协议双向同步
+ *   - 协议类型 (复用桌面消息协议格式 DID:<did>|type:payload):
+ *       data.sync      : 请求全量 (channels + 所有 session)   → 响应 data.snapshot
+ *       data.snapshot  : 全量快照 (channels + sessions)
+ *       data.channels  : channels 列表 (增量更新)
+ *       data.session   : 单个 session (增量更新, 合并去重)
+ *       data.pull      : 拉取指定 channelId 的 session → 响应 data.session
+ *       data.llm-config      : 请求 LLM 配置 (桌面 llm-config.json 同步) → 响应 data.llm-config.reply
+ *       data.llm-config.reply: 收到远端 LLM 配置 → 保存 + 通知 agent 层注入
+ *   - 与 agent 功能无关: 本层只做数据一致, 不跑 LLM. LLM 配置同步是"数据"不是"智能".
+ *
+ * 离线: 读写本地 IndexedDB, 静默.
+ * 在线: 通过 mobile-p2p 与 peer 同步, 冲突按 ts 最新合并.
+ */
+// ============ IndexedDB 存储 (独立于 agent 层) ============
+const DB_NAME = 'bolloon-mobile-data';
+const DB_VERSION = 1;
+let _db = null;
+function openDb() {
+    if (_db)
+        return Promise.resolve(_db);
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains('kv')) {
+                db.createObjectStore('kv');
+            }
+        };
+        req.onsuccess = () => { _db = req.result; resolve(_db); };
+        req.onerror = () => reject(req.error);
+    });
+}
+/** 测试用: 关闭并清空当前库 (避免 deleteDatabase 阻塞) */
+export async function resetDataDb() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+    await new Promise((resolve) => {
+        try {
+            const req = indexedDB.deleteDatabase(DB_NAME);
+            req.onsuccess = () => resolve();
+            req.onerror = () => resolve();
+            req.onblocked = () => resolve();
+        }
+        catch {
+            resolve();
+        }
+    });
+}
+async function idbGet(key) {
+    const db = await openDb();
+    return new Promise((resolve) => {
+        const tx = db.transaction('kv', 'readonly');
+        const req = tx.objectStore('kv').get(key);
+        req.onsuccess = () => resolve(req.result ?? null);
+        req.onerror = () => resolve(null);
+    });
+}
+async function idbSet(key, val) {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('kv', 'readwrite');
+        tx.objectStore('kv').put(val, key);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/** 手机端默认 LLM 配置 (未同步时用, 对应 Kotlin AgentLlmConfig 默认 deepseek) */
+export function defaultLlmConfig() {
+    return {
+        activeProvider: 'deepseek',
+        providers: {
+            deepseek: { enabled: true, apiKey: '', baseUrl: 'https://api.deepseek.com/v1', model: 'deepseek-chat', temperature: 0.7, maxTokens: 4096, requiresApiKey: true },
+        },
+    };
+}
+/** 从 LlmConfigSnapshot 提取对 agent 层最有用的单 provider 配置 (activeProvider 优先) */
+export function activeProviderConfig(cfg) {
+    if (!cfg)
+        return {};
+    const name = cfg.activeProvider || 'deepseek';
+    const p = cfg.providers?.[name] || cfg.providers?.deepseek;
+    return { baseUrl: p?.baseUrl, apiKey: p?.apiKey, model: p?.model, maxTokens: p?.maxTokens };
+}
+// ============ 本地存储 API (手机独立副本) ============
+/** 读取 channels (本地) */
+export async function getChannels() {
+    return (await idbGet('channels')) || [];
+}
+/** 保存 channels (本地) */
+export async function saveChannels(channels) {
+    await idbSet('channels', channels);
+}
+/** 读取单个 session (本地), 不存在返回空 */
+export async function getSession(channelId) {
+    const s = await idbGet('session:' + channelId);
+    if (s)
+        return s;
+    return { channelId, messages: [], updatedAt: 0 };
+}
+/** 保存单个 session (本地, 按 ts 去重合并) */
+export async function saveSession(session) {
+    const prev = await getSession(session.channelId);
+    const merged = [];
+    const seen = new Set();
+    for (const m of [...(prev.messages || []), ...(session.messages || [])]) {
+        const k = m.role + ':' + m.content + ':' + (m.ts || 0);
+        if (!seen.has(k)) {
+            seen.add(k);
+            merged.push(m);
+        }
+    }
+    merged.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    await idbSet('session:' + session.channelId, {
+        channelId: session.channelId,
+        messages: merged,
+        updatedAt: Math.max(prev.updatedAt || 0, session.updatedAt || 0, Date.now()),
+    });
+}
+/** 追加消息到 session (本地) */
+export async function appendMessage(channelId, msg) {
+    const s = await getSession(channelId);
+    s.messages.push(msg);
+    await saveSession(s);
+}
+/** 全量快照 (本地当前状态, 用于响应 data.sync / data.pull) */
+export async function snapshot() {
+    return {
+        channels: await getChannels(),
+        sessions: await listSessions(),
+        syncedAt: Date.now(),
+    };
+}
+// ============ LLM 配置存储 (桌面同步 / 手机默认) ============
+/** 读取本地 LLM 配置, 无则返回默认 (手机端) */
+export async function getLlmConfig() {
+    const c = await idbGet('llm-config');
+    return c || defaultLlmConfig();
+}
+/** 保存本地 LLM 配置 */
+export async function saveLlmConfig(cfg) {
+    const merged = { ...defaultLlmConfig(), ...cfg, updatedAt: cfg.updatedAt || Date.now() };
+    await idbSet('llm-config', merged);
+}
+/** 是否有过桌面同步的 LLM 配置 (未同步时 mobile-agent 用手机默认) */
+export async function hasSyncedLlmConfig() {
+    const c = await idbGet('llm-config');
+    return !!(c && (c.updatedAt || c.providers));
+}
+const llmConfigListeners = new Set();
+/** 注册 LLM 配置变更回调 */
+export function onLlmConfig(fn) {
+    llmConfigListeners.add(fn);
+}
+function notifyLlmConfig(cfg) {
+    for (const fn of llmConfigListeners) {
+        try {
+            fn(cfg);
+        }
+        catch { /* 忽略 */ }
+    }
+}
+/** 向 peer 请求 LLM 配置 (data.llm-config → data.llm-config.reply) */
+export async function requestLlmConfigFromPeer(peerId) {
+    const send = getSend();
+    if (!send)
+        return false;
+    return await send('data.llm-config', JSON.stringify({}), peerId);
+}
+/** 列出所有 session (遍历 kv) */
+export async function listSessions() {
+    const db = await openDb();
+    return new Promise((resolve) => {
+        const tx = db.transaction('kv', 'readonly');
+        const req = tx.objectStore('kv').openCursor();
+        const out = [];
+        req.onsuccess = () => {
+            const c = req.result;
+            if (c) {
+                if (typeof c.key === 'string' && c.key.startsWith('session:')) {
+                    out.push(c.value);
+                }
+                c.continue();
+            }
+            else {
+                resolve(out);
+            }
+        };
+        req.onerror = () => resolve(out);
+    });
+}
+// ============ 合并远端数据 (增量同步核心) ============
+/** 合并远端快照: channels 以 ts 新者优先; sessions 逐条合并去重 */
+export async function mergeSnapshot(remote) {
+    const localCh = await getChannels();
+    const chMap = new Map();
+    for (const c of localCh)
+        chMap.set(c.id, c);
+    for (const c of remote.channels || []) {
+        const prev = chMap.get(c.id);
+        if (!prev || (c.ts || 0) >= (prev.ts || 0))
+            chMap.set(c.id, c);
+    }
+    const mergedChannels = chMap.size - localCh.length;
+    await saveChannels(Array.from(chMap.values()));
+    let mergedSessions = 0;
+    for (const s of remote.sessions || []) {
+        const prev = await getSession(s.channelId);
+        if ((s.updatedAt || 0) >= (prev.updatedAt || 0)) {
+            await saveSession(s);
+            mergedSessions++;
+        }
+    }
+    return { mergedChannels, mergedSessions };
+}
+/** 合并单个远端 session */
+export async function mergeRemoteSession(s) {
+    const prev = await getSession(s.channelId);
+    if ((s.updatedAt || 0) >= (prev.updatedAt || 0)) {
+        await saveSession(s);
+        return true;
+    }
+    return false;
+}
+let _send = null;
+/** 由 mobile-core 注入发送函数 (对 mobile-p2p 的封装) */
+export function setDataTransport(fn) {
+    _send = fn;
+}
+function getSend() {
+    return _send;
+}
+let _syncStatus = { lastSyncAt: 0, mergedChannels: 0, mergedSessions: 0, mode: 'offline' };
+export function syncStatus() {
+    return { ..._syncStatus };
+}
+/** 向 peer 请求全量同步 (data.sync → data.snapshot), 成功则合并 */
+export async function syncFromPeer(peerId, timeoutMs = 8000) {
+    const send = getSend();
+    if (!send)
+        return { ..._syncStatus, mode: 'offline' };
+    const ok = await send('data.sync', JSON.stringify({ since: _syncStatus.lastSyncAt }), peerId);
+    if (!ok)
+        return { ..._syncStatus, mode: 'offline' };
+    // 响应 data.snapshot 由 mobile-core 的 onMessage 分发到 mergeRemoteSnapshot
+    return { ..._syncStatus, mode: 'online', lastSyncAt: Date.now() };
+}
+/** 处理入站 data.* 消息 (由 mobile-core 的 P2P 消息路由调用) */
+export async function handleIncomingDataMessage(type, payload, fromPeer) {
+    const send = getSend();
+    switch (type) {
+        case 'data.sync': {
+            // 远端请求全量 → 回 data.snapshot
+            if (send) {
+                const snap = await snapshot();
+                await send('data.snapshot', JSON.stringify(snap), fromPeer);
+            }
+            break;
+        }
+        case 'data.snapshot': {
+            // 远端快照 → 合并本地
+            try {
+                const snap = JSON.parse(payload);
+                const r = await mergeSnapshot(snap);
+                _syncStatus = { lastSyncAt: Date.now(), mergedChannels: r.mergedChannels, mergedSessions: r.mergedSessions, mode: 'online' };
+            }
+            catch { /* 解析失败忽略 */ }
+            break;
+        }
+        case 'data.channels': {
+            try {
+                const chs = JSON.parse(payload);
+                await saveChannels(chs);
+                _syncStatus = { ..._syncStatus, mergedChannels: chs.length, mode: 'online' };
+            }
+            catch { /* 忽略 */ }
+            break;
+        }
+        case 'data.session': {
+            try {
+                const s = JSON.parse(payload);
+                const merged = await mergeRemoteSession(s);
+                _syncStatus = { ..._syncStatus, mergedSessions: merged ? 1 : 0, mode: 'online' };
+            }
+            catch { /* 忽略 */ }
+            break;
+        }
+        case 'data.pull': {
+            // 远端拉取指定 session → 回 data.session
+            if (send) {
+                try {
+                    const { channelId } = JSON.parse(payload);
+                    const s = await getSession(channelId);
+                    await send('data.session', JSON.stringify(s), fromPeer);
+                }
+                catch { /* 忽略 */ }
+            }
+            break;
+        }
+        case 'data.llm-config': {
+            // 远端请求本机 LLM 配置 → 回 data.llm-config.reply
+            if (send) {
+                try {
+                    const cfg = await getLlmConfig();
+                    await send('data.llm-config.reply', JSON.stringify(cfg), fromPeer);
+                }
+                catch { /* 忽略 */ }
+            }
+            break;
+        }
+        case 'data.llm-config.reply': {
+            // 收到远端 LLM 配置 → 保存 + 通知 agent 层注入 bridge
+            try {
+                const cfg = JSON.parse(payload);
+                if (cfg && (cfg.providers || cfg.activeProvider)) {
+                    await saveLlmConfig(cfg);
+                    notifyLlmConfig(await getLlmConfig());
+                }
+            }
+            catch { /* 解析失败忽略 */ }
+            break;
+        }
+        default:
+            break;
+    }
+}
+/** 广播本地最新状态给所有已连接 peer (主动推送) */
+export async function pushLocal(toPeer) {
+    const send = getSend();
+    if (!send)
+        return;
+    const chs = await getChannels();
+    await send('data.channels', JSON.stringify(chs), toPeer);
+    const sessions = await listSessions();
+    for (const s of sessions) {
+        await send('data.session', JSON.stringify(s), toPeer);
+    }
+}
+export default { getChannels, saveChannels, getSession, saveSession, appendMessage, snapshot, mergeSnapshot, syncFromPeer, pushLocal, syncStatus, handleIncomingDataMessage, setDataTransport, getLlmConfig, saveLlmConfig, hasSyncedLlmConfig, onLlmConfig, requestLlmConfigFromPeer, defaultLlmConfig, activeProviderConfig };

package/dist/web/mobile-http-api.js

@@ -0,0 +1,71 @@
+/**
+ * mobile-http-api.ts — 手机端本地 HTTP API (2026-08-15)
+ *
+ * 手机是自治节点: 外部控制端 (桌面/真机验证脚本/局域网工具) 经 HTTP 触发
+ * 手机端独立 AgentLoop 执行, 不需要经过电脑同意.
+ *
+ * 端点:
+ *   GET  /health                      存活检查
+ *   GET  /api/phone/status            Agent 状态 (did/mode/llm/capabilities)
+ *   POST /api/phone/agent/run         { goal, requestId? } → 手机自治执行 → { ok, result, mode }
+ *   POST /api/phone/agent/cancel      { reason? } → 取消当前任务
+ *
+ * 运行环境:
+ *   - Capacitor WebView (浏览器): 无 node:http, 提供 handleHttpRequest (fetch 风格) 供原生 HTTP server 调用
+ *   - Node (测试/真机验证脚本): startLocalHttpServer() 起真实 localhost server
+ */
+import core from './mobile-core.js';
+/** 处理一个 HTTP 请求 (返回 fetch 风格 Response 或对象) — 供 WebView 原生 HTTP server / Node server 共用 */
+export async function handleHttpRequest(method, path, bodyStr) {
+    if (method === 'GET' && (path === '/' || path === '/health')) {
+        return { status: 200, body: { ok: true, service: 'bolloon-mobile', time: Date.now() } };
+    }
+    if (method === 'GET' && path === '/api/phone/status') {
+        const st = await core.phone.status();
+        return { status: 200, body: st };
+    }
+    if (method === 'POST' && path === '/api/phone/agent/run') {
+        const req = JSON.parse(bodyStr || '{}');
+        const result = await core.phone.run(String(req.goal || ''));
+        return { status: 200, body: { requestId: req.requestId || '', ...result } };
+    }
+    if (method === 'POST' && path === '/api/phone/agent/cancel') {
+        const req = JSON.parse(bodyStr || '{}');
+        const r = await core.phone.cancel(String(req.reason || '本地取消'));
+        return { status: 200, body: r };
+    }
+    return { status: 404, body: { error: `no route: ${method} ${path}` } };
+}
+/** Node 环境: 起真实 localhost HTTP server (真机验证/测试用). 浏览器环境自动降级为 null */
+export async function startLocalHttpServer(port = 7788) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const hasNode = typeof process !== 'undefined' && !!(process.versions?.node);
+    if (!hasNode) {
+        console.log('[mobile-http-api] 非 Node 环境, 不启动本地 HTTP server (走 handleHttpRequest 供原生层)');
+        return null;
+    }
+    const http = await import('node:http');
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url || '/', 'http://localhost');
+        let body = '';
+        req.on('data', (c) => { body += c; });
+        req.on('end', async () => {
+            try {
+                const r = await handleHttpRequest(req.method || 'GET', url.pathname, body);
+                res.writeHead(r.status, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(r.body));
+            }
+            catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: String(e?.message || e).slice(0, 100) }));
+            }
+        });
+    });
+    await new Promise((resolve) => server.listen(port, '127.0.0.1', () => resolve()));
+    console.log(`[mobile-http-api] 本地 HTTP API 已启动: http://127.0.0.1:${port}`);
+    return {
+        close() { server.close(); },
+        port,
+    };
+}
+export default { handleHttpRequest, startLocalHttpServer };

package/dist/web/mobile-p2p.js

@@ -0,0 +1,250 @@
+/**
+ * mobile-p2p.ts — 手机端浏览器 P2P 节点 (2026-08-15, Phase 2)
+ *
+ * 目标: 让手机端 (Capacitor WebView) 真正独立 P2P 入网, 不依赖桌面.
+ *
+ * 与桌面 p2p.ts (node libp2p + tcp) 兼容:
+ *   - 浏览器只能用 WebSockets 传输 (@libp2p/websockets) — 桌面已加 /ws listen
+ *   - 同一协议栈: noise + yamux + gossipsub + kad-dht
+ *   - 同一消息协议: '/agent/message' 流, 格式 "DID:<did>|type:payload"
+ *
+ * 连接方式: 手机 ws 连桌面节点 wss 地址 (joinNetwork 时传入), 或经 relay.
+ * 离线时静默降级为单机模式 (mobile-core 内置回复).
+ */
+import { createLibp2p } from 'libp2p';
+import { webSockets } from '@libp2p/websockets';
+import { noise } from '@chainsafe/libp2p-noise';
+import { yamux } from '@chainsafe/libp2p-yamux';
+import { identify } from '@libp2p/identify';
+import { kadDHT } from '@libp2p/kad-dht';
+import { gossipsub } from '@libp2p/gossipsub';
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2';
+import { ping } from '@libp2p/ping';
+import { multiaddr as createMultiaddr } from '@multiformats/multiaddr';
+let node = null;
+let state = { connected: false, peerCount: 0, peerIds: [] };
+const msgHandlers = [];
+/** 持久化好友地址 (localStorage), 供 addMobilePeer 写入 + startMobileP2P 自动重连 */
+let peerAddrs = [];
+function loadPeerAddrs() {
+    try {
+        peerAddrs = JSON.parse(localStorage.getItem('bolloon_mobile_peers') || '[]');
+    }
+    catch {
+        peerAddrs = [];
+    }
+}
+function savePeerAddrs() {
+    try {
+        localStorage.setItem('bolloon_mobile_peers', JSON.stringify(peerAddrs));
+    }
+    catch { }
+}
+loadPeerAddrs();
+/** 创建浏览器 libp2p 节点 (websockets) */
+export async function startMobileP2P(cfg = {}) {
+    if (node)
+        return state;
+    try {
+        node = await createLibp2p({
+            transports: [webSockets(), circuitRelayTransport()],
+            connectionEncrypters: [noise()],
+            streamMuxers: [yamux()],
+            services: {
+                identify: identify(),
+                ping: ping(),
+                dht: kadDHT({ clientMode: true }),
+                pubsub: gossipsub({ emitSelf: false }),
+            },
+        });
+        // 处理入站 '/agent/message' (libp2p 3.x handler 签名: (stream, connection))
+        node.handle('/agent/message', async (stream, connection) => {
+            const chunks = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk instanceof Uint8Array ? chunk : chunk.subarray());
+            }
+            const data = new Uint8Array(chunks.reduce((acc, c) => acc + c.length, 0));
+            let off = 0;
+            for (const c of chunks) {
+                data.set(c, off);
+                off += c.length;
+            }
+            const text = new TextDecoder().decode(data);
+            const fromPeer = connection.remotePeer.toString();
+            console.log(`[mobile-p2p] 入站消息 ${text.slice(0, 60)} from ${fromPeer.slice(0, 10)}`);
+            for (const h of msgHandlers) {
+                try {
+                    h(text, fromPeer);
+                }
+                catch { }
+            }
+        });
+        node.addEventListener('peer:connect', () => refreshState());
+        node.addEventListener('peer:disconnect', () => refreshState());
+        await node.start();
+        state = {
+            connected: true,
+            peerCount: 0,
+            peerIds: [],
+            nodeId: node.peerId.toString(),
+        };
+        // 连接种子节点 (桌面 wss / relay)
+        for (const addr of cfg.seedAddrs || []) {
+            try {
+                await node.dial(createMultiaddr(addr));
+                console.log(`[mobile-p2p] connected to ${addr}`);
+            }
+            catch (e) {
+                console.warn(`[mobile-p2p] failed to dial ${addr}:`, String(e).slice(0, 100));
+            }
+        }
+        // 连接已保存的好友地址 (上次 addMobilePeer 记录)
+        for (const addr of peerAddrs) {
+            try {
+                await node.dial(createMultiaddr(addr));
+                console.log(`[mobile-p2p] connected to saved peer ${addr}`);
+            }
+            catch (e) {
+                console.warn(`[mobile-p2p] failed to dial saved ${addr}:`, String(e).slice(0, 100));
+            }
+        }
+        refreshState();
+        return state;
+    }
+    catch (e) {
+        console.warn('[mobile-p2p] start failed (单机模式):', String(e).slice(0, 150));
+        return { connected: false, peerCount: 0, peerIds: [] };
+    }
+}
+function refreshState() {
+    if (!node)
+        return;
+    try {
+        const peers = node.getPeers() || [];
+        state = {
+            connected: node.isStarted(),
+            peerCount: peers.length,
+            peerIds: peers.map((p) => p.toString()),
+            nodeId: node.peerId.toString(),
+        };
+    }
+    catch {
+        /* 保持上次 */
+    }
+}
+/** 订阅入站消息 (与 mobile-core 集成) */
+export function onMobileP2PMessage(fn) {
+    msgHandlers.push(fn);
+}
+/** 向指定 peer 发送 /agent/message (peerIdOrAddr: peerId 或 multiaddr 字符串) */
+export async function sendMobileP2PMessage(peerIdOrAddr, type, payload, ownDid) {
+    if (!node)
+        return false;
+    const build = () => {
+        const full = ownDid
+            ? `DID:${ownDid}|${type}:${payload}`
+            : `${type}:${payload}`;
+        return new TextEncoder().encode(full);
+    };
+    // 0. '*' = 广播给所有已连接 peer
+    if (peerIdOrAddr === '*') {
+        const conns = node.getConnections() || [];
+        let sentAny = false;
+        for (const c of conns) {
+            try {
+                const stream = await node.dialProtocol(c.remotePeer, '/agent/message');
+                stream.send(build());
+                await stream.close();
+                sentAny = true;
+            }
+            catch { /* 单个失败跳过 */ }
+        }
+        return sentAny;
+    }
+    // 1. 若已连接, 直接复用连接 (remotePeer 是 PeerId 对象, 最稳)
+    const conns = node.getConnections() || [];
+    for (const c of conns) {
+        const peerStr = c.remotePeer.toString();
+        if (peerIdOrAddr.includes(peerStr) || peerStr.includes(peerIdOrAddr)) {
+            try {
+                const stream = await node.dialProtocol(c.remotePeer, '/agent/message');
+                stream.send(build());
+                await stream.close();
+                return true;
+            }
+            catch (e) {
+                console.warn('[mobile-p2p] dial on existing conn failed:', String(e).slice(0, 100));
+            }
+        }
+    }
+    // 2. 未连接 → 尝试 dial multiaddr 字符串
+    try {
+        const target = /^\/ip/.test(peerIdOrAddr) || /^\/dns/.test(peerIdOrAddr)
+            ? createMultiaddr(peerIdOrAddr)
+            : createMultiaddr(`/p2p/${peerIdOrAddr}`);
+        const stream = await node.dialProtocol(target, '/agent/message');
+        stream.send(build());
+        await stream.close();
+        return true;
+    }
+    catch (err) {
+        console.warn('[mobile-p2p] send failed:', String(err).slice(0, 120));
+        return false;
+    }
+}
+/** 当前节点状态 */
+export function getMobileP2PState() {
+    return { ...state };
+}
+/** 诊断: 当前活跃连接数 (getConnections) */
+export function getMobileP2PConnections() {
+    if (!node)
+        return [];
+    try {
+        return (node.getConnections() || []).map((c) => ({
+            peer: c.remotePeer.toString(),
+            addr: c.remoteAddr?.toString?.() || '',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/** 已保存的好友地址 */
+export function listMobilePeerAddrs() {
+    return [...peerAddrs];
+}
+/**
+ * 添加 P2P 好友 (按 multiaddr 地址 dial 连接)。
+ * 校验 → 记录到 localStorage (startMobileP2P 会自动重连) → 若节点已启动则立即 dial。
+ */
+export async function addMobilePeer(addr) {
+    const normalized = (addr || '').trim();
+    if (!normalized)
+        return { ok: false, error: '地址不能为空' };
+    try {
+        createMultiaddr(normalized);
+    }
+    catch (e) {
+        return { ok: false, error: '非法 multiaddr: ' + String(e?.message || e) };
+    }
+    if (!peerAddrs.includes(normalized)) {
+        peerAddrs.push(normalized);
+        savePeerAddrs();
+    }
+    if (!node || !node.isStarted()) {
+        return { ok: true, connected: false, error: '已记录好友地址, P2P 启动后自动连接' };
+    }
+    try {
+        await node.dial(createMultiaddr(normalized));
+        refreshState();
+        return { ok: true, connected: true };
+    }
+    catch (e) {
+        return { ok: false, error: '连接失败: ' + String(e?.message || e).slice(0, 120) };
+    }
+}
+// 暴露同步状态读取 (mobile-core.network.status 用)
+if (typeof globalThis !== 'undefined') {
+    globalThis.__mobileP2PStateSync = () => ({ ...state });
+}