@bolloon/bolloon-agent 0.3.15 → 0.3.17

package/dist/lsp/lsp-tools.js

@@ -0,0 +1,222 @@
+/**
+ * lsp/lsp-tools.ts — 注册 LSP 工具到 Bolloon agent 工具系统
+ *
+ * 暴露 6 个工具:
+ *   - lsp_detect: 检测本机已安装的语言服务器
+ *   - lsp_hover: 悬停查看类型/文档
+ *   - lsp_completion: 代码补全
+ *   - lsp_diagnostics: 诊断当前文件
+ *   - lsp_go_to_definition: 跳转到定义
+ *   - lsp_start / lsp_stop: 手动管理 LSP 服务器生命周期
+ */
+import { detectInstalledLspServers, startLspServer, stopLspServer, stopAllLspServers, findLspForFile, lspDidOpen, lspHover, lspCompletion, lspDiagnostics, lspGoToDefinition, } from './lsp-manager.js';
+/** 已检测到的 LSP 服务器列表 (缓存) */
+let cachedSpecs = null;
+async function getSpecs() {
+    if (!cachedSpecs)
+        cachedSpecs = await detectInstalledLspServers();
+    return cachedSpecs;
+}
+/**
+ * 注册 6 个 LSP 工具到 Bolloon agent 的工具系统.
+ * 在 registerBuiltinTools 内部调用.
+ */
+export function registerLspTools(ctx) {
+    ctx.tools.set('lsp_detect', {
+        name: 'lsp_detect',
+        description: '检测本机已安装的 LSP (Language Server Protocol) 服务器, 返回可用的语言列表',
+        parameters: {},
+        execute: async (_args) => {
+            try {
+                const specs = await getSpecs();
+                if (specs.length === 0) {
+                    return { success: true, output: '⚠️ 未检测到任何 LSP 服务器。可安装:\n  npm install -g typescript-language-server\n  cargo install rust-analyzer' };
+                }
+                const lines = specs.map(s => `  ✅ ${s.displayName} (${s.language}): ${s.fileExtensions.join(', ')}`);
+                return { success: true, output: `已检测到 ${specs.length} 个 LSP 服务器:\n${lines.join('\n')}` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_start', {
+        name: 'lsp_start',
+        description: '启动指定语言的语言服务器 (如 typescript / rust / python)',
+        parameters: { language: '语言 id, 如 typescript / rust / python (必填)' },
+        execute: async (args) => {
+            try {
+                const language = String(args.language || '').trim().toLowerCase();
+                if (!language)
+                    return { success: false, error: 'language 必填' };
+                const inst = await startLspServer(language);
+                if (!inst)
+                    return { success: false, error: `未找到 ${language} 的 LSP 服务器, 请先安装` };
+                return { success: true, output: `✅ ${inst.spec.displayName} 已启动` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_hover', {
+        name: 'lsp_hover',
+        description: '在文件某位置悬停, 查看类型/文档 (需要先 lsp_start)',
+        parameters: {
+            file: '文件路径 (必填)',
+            line: '行号 (从 0 开始)',
+            character: '列号 (从 0 开始)',
+            content: '文件内容 (可选, 首次需要以触发 didOpen)',
+        },
+        execute: async (args) => {
+            try {
+                const file = String(args.file || '').trim();
+                if (!file)
+                    return { success: false, error: 'file 必填' };
+                const line = parseInt(String(args.line || '0'), 10);
+                const character = parseInt(String(args.character || '0'), 10);
+                const content = args.content ? String(args.content) : undefined;
+                const specs = await getSpecs();
+                const spec = findLspForFile(file, specs);
+                if (!spec)
+                    return { success: false, error: `未找到 ${file} 对应的 LSP 服务器` };
+                const inst = await startLspServer(spec.language);
+                if (!inst)
+                    return { success: false, error: `LSP ${spec.language} 启动失败` };
+                if (content)
+                    lspDidOpen(inst, file, content);
+                const result = await lspHover(inst, file, line, character);
+                if (!result)
+                    return { success: true, output: '(无悬停信息)' };
+                return { success: true, output: result.contents };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_completion', {
+        name: 'lsp_completion',
+        description: '在文件某位置获取代码补全建议 (需要先 lsp_start)',
+        parameters: {
+            file: '文件路径 (必填)',
+            line: '行号 (从 0 开始)',
+            character: '列号 (从 0 开始)',
+            content: '文件内容 (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const file = String(args.file || '').trim();
+                if (!file)
+                    return { success: false, error: 'file 必填' };
+                const line = parseInt(String(args.line || '0'), 10);
+                const character = parseInt(String(args.character || '0'), 10);
+                const content = args.content ? String(args.content) : undefined;
+                const specs = await getSpecs();
+                const spec = findLspForFile(file, specs);
+                if (!spec)
+                    return { success: false, error: `未找到 ${file} 对应的 LSP 服务器` };
+                const inst = await startLspServer(spec.language);
+                if (!inst)
+                    return { success: false, error: `LSP ${spec.language} 启动失败` };
+                if (content)
+                    lspDidOpen(inst, file, content);
+                const result = await lspCompletion(inst, file, line, character);
+                if (result.items.length === 0)
+                    return { success: true, output: '(无补全建议)' };
+                const items = result.items.slice(0, 20).map(i => `  ${i.label}${i.detail ? ` — ${i.detail}` : ''}`);
+                return { success: true, output: `补全建议 (显示前 20 条):\n${items.join('\n')}` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_diagnostics', {
+        name: 'lsp_diagnostics',
+        description: '获取文件的诊断结果 (错误/警告)',
+        parameters: { file: '文件路径 (必填)', content: '文件内容 (可选)' },
+        execute: async (args) => {
+            try {
+                const file = String(args.file || '').trim();
+                if (!file)
+                    return { success: false, error: 'file 必填' };
+                const content = args.content ? String(args.content) : undefined;
+                const specs = await getSpecs();
+                const spec = findLspForFile(file, specs);
+                if (!spec)
+                    return { success: false, error: `未找到 ${file} 对应的 LSP 服务器` };
+                const inst = await startLspServer(spec.language);
+                if (!inst)
+                    return { success: false, error: `LSP ${spec.language} 启动失败` };
+                if (content)
+                    lspDidOpen(inst, file, content);
+                const result = await lspDiagnostics(inst, file);
+                if (result.diagnostics.length === 0)
+                    return { success: true, output: '✅ 无诊断问题' };
+                const lines = result.diagnostics.map(d => {
+                    const sev = ['', '错误', '警告', '信息', '提示'][d.severity || 0] || '未知';
+                    const pos = `L${d.range.start.line}:${d.range.start.character}`;
+                    return `  ${sev === '错误' ? '❌' : sev === '警告' ? '⚠️' : 'ℹ️'} [${pos}] ${sev}: ${d.message}`;
+                });
+                return { success: true, output: `诊断结果 (${result.diagnostics.length} 条):\n${lines.join('\n')}` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_go_to_definition', {
+        name: 'lsp_go_to_definition',
+        description: '跳转到符号定义的位置',
+        parameters: {
+            file: '当前文件路径 (必填)',
+            line: '行号 (从 0 开始)',
+            character: '列号 (从 0 开始)',
+        },
+        execute: async (args) => {
+            try {
+                const file = String(args.file || '').trim();
+                if (!file)
+                    return { success: false, error: 'file 必填' };
+                const line = parseInt(String(args.line || '0'), 10);
+                const character = parseInt(String(args.character || '0'), 10);
+                const specs = await getSpecs();
+                const spec = findLspForFile(file, specs);
+                if (!spec)
+                    return { success: false, error: `未找到 ${file} 对应的 LSP 服务器` };
+                const inst = await startLspServer(spec.language);
+                if (!inst)
+                    return { success: false, error: `LSP ${spec.language} 启动失败` };
+                const loc = await lspGoToDefinition(inst, file, line, character);
+                if (!loc)
+                    return { success: true, output: '(未找到定义位置)' };
+                return { success: true, output: `定义位置: ${loc.uri} (L${loc.range.start.line}:${loc.range.start.character})` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+    ctx.tools.set('lsp_stop', {
+        name: 'lsp_stop',
+        description: '关闭指定语言的语言服务器 (或 all 关闭所有)',
+        parameters: { language: '语言 id, 如 typescript, 或 all 关闭全部' },
+        execute: async (args) => {
+            try {
+                const language = String(args.language || '').trim().toLowerCase();
+                if (!language)
+                    return { success: false, error: 'language 必填 (或 "all")' };
+                if (language === 'all') {
+                    stopAllLspServers();
+                    return { success: true, output: '✅ 所有 LSP 服务器已关闭' };
+                }
+                await stopLspServer(language);
+                return { success: true, output: `✅ ${language} LSP 服务器已关闭` };
+            }
+            catch (e) {
+                return { success: false, error: String(e) };
+            }
+        },
+    });
+}

package/dist/network/auto-peer-discovery.js

@@ -0,0 +1,77 @@
+/**
+ * auto-peer-discovery.ts — 基于 Hyperswarm topic 的 P2P 自动发现
+ *
+ * 当 P2PDirect 通过 topic 发现新 peer 时，自动将其加入 known_peers 好友列表，
+ * 无需用户手动添加好友。
+ *
+ * 工作流程：
+ *   1. P2PDirect 加入 topic（如 'bolloon-agent-harness'）
+ *   2. Hyperswarm DHT 自动发现同 topic 的其他节点
+ *   3. P2PDirect 触发 connection 事件
+ *   4. 本模块检查该 publicKey 是否已在 known_peers
+ *   5. 不在 → 自动添加（后续 AgentHeartbeat 的 getPeers 就会看到它）
+ *   6. 如果在 → 更新 lastConnectedAt（已经在 known-peers 做的）
+ *
+ * 不依赖 Web UI、不依赖用户交互、纯后台自动完成。
+ */
+// 不使用 logger 模块，用 console.log 保持与 bolloon 项目风格一致
+const PREFIX = '[auto-discover]';
+// 发现 peers 的缓存 key → 本机 publicKey 映射（用于去重）
+const TOPIC = 'bolloon-agent-harness';
+/**
+ * 尝试将一个通过 topic 发现的 peer 自动加入好友列表
+ *
+ * 核心逻辑：
+ *   - 跳过自己（P2PDirect 可能把自己也当 peer push 过来）
+ *   - 跳过已存在的好友（仅标记连接时间）
+ *   - 新 peer → 自动生成名字并添加
+ *
+ * @param remotePublicKey 远端 64 字符 hex publicKey
+ * @param knownPeers   { addOrUpdatePeer, listPeers, findNameByPublicKey } 接口
+ * @param localPublicKey  本机 publicKey（用于跳过自己）
+ * @returns 是否是新添加的 peer
+ */
+export async function tryAutoDiscoverPeer(remotePublicKey, localPublicKey) {
+    // 1. 跳过自己
+    if (remotePublicKey === localPublicKey) {
+        return 'self';
+    }
+    // 2. 动态 import known-peers（避免循环依赖）
+    const { findNameByPublicKey, addOrUpdatePeer } = await import('../network/known-peers.js');
+    // 3. 检查是否已存在
+    const existingName = await findNameByPublicKey(remotePublicKey);
+    if (existingName) {
+        // 已经在好友列表里了，只是更新连接状态
+        console.log(`[auto-discover] 已知好友 ${existingName} (${remotePublicKey.substring(0, 12)}...) 重新上线`);
+        return 'known';
+    }
+    // 4. 新 peer！自动添加
+    const shortId = remotePublicKey.substring(0, 8);
+    const autoName = `discovered-${shortId}`;
+    await addOrUpdatePeer(autoName, remotePublicKey, `通过 topic "${TOPIC}" 自动发现`);
+    console.log(`✅ [auto-discover] 自动发现新 peer: ${autoName} (${remotePublicKey.substring(0, 12)}...)`);
+    console.log(`   已添加到 known_peers, AgentHeartbeat 将自动开始社交`);
+    return 'discovered';
+}
+/**
+ * 从 peer 的 manifest 中提取名字，更新自动发现的 peer 名称
+ *
+ * 如果 peer 是 auto-discovered（名字为 discovered-xxxx），
+ * 且 manifest 中有 ownerName，就把名字更新为更友好的格式。
+ *
+ * @param remotePublicKey 远端 publicKey
+ * @param ownerName manifest 中的 ownerName
+ */
+export async function updateDiscoveredPeerName(remotePublicKey, ownerName) {
+    if (!ownerName)
+        return;
+    const { findNameByPublicKey, addOrUpdatePeer, removePeer } = await import('../network/known-peers.js');
+    const existingName = await findNameByPublicKey(remotePublicKey);
+    // 只有 auto-discovered 的 peer 才重命名
+    if (!existingName || !existingName.startsWith('discovered-'))
+        return;
+    // 删除旧名字的条目，用新名字重新添加
+    await removePeer(existingName);
+    await addOrUpdatePeer(ownerName, remotePublicKey, `自动发现后通过 manifest 获取名称`);
+    console.log(`[auto-discover] 更新 peer 名称: ${existingName} → ${ownerName}`);
+}

package/dist/network/did-agent-resolver.js

@@ -0,0 +1,206 @@
+/**
+ * did-agent-resolver.ts — 从 DIAP DID 文档解析并落盘远端智能体
+ *
+ * 流程:
+ *   1. 收到 peer manifest → 有 agents[i].cid 或 agents[i].ipnsName
+ *   2. 通过 IPFS 公共网关读取 DID 文档（纯只读，不需要上传能力）
+ *   3. 解析 DID 文档 → 提取 agent 身份信息（DID、公钥、服务端点）
+ *   4. 把解析后的 agent 写入本地 peers/<pk>/agents/<agentId>.md
+ *   5. 把 DID 身份信息用于更丰富的好友添加（用 DID 名而不是 generated name）
+ */
+import { IpfsClient } from '@diap/sdk';
+// ============================================================================
+// 读取 DID 文档
+// ============================================================================
+/**
+ * 通过 IPFS 公共网关读取 DID 文档
+ * 使用 @diap/sdk 的 IpfsClient（public-only 只读模式）
+ */
+async function fetchDIDDocument(cid) {
+    const ipfs = await IpfsClient.newPublicOnly(15);
+    try {
+        const content = await ipfs.get(cid);
+        const doc = JSON.parse(content);
+        // 基本校验：是合法的 DID 文档
+        if (!doc || !doc.id || !doc['@context']) {
+            console.warn(`[did-resolver] CID ${cid} 不是有效的 DID 文档（缺 id 或 @context）`);
+            return null;
+        }
+        return doc;
+    }
+    catch (e) {
+        console.warn(`[did-resolver] 从 CID ${cid} 获取 DID 文档失败: ${e.message?.substring(0, 100) || e}`);
+        return null;
+    }
+}
+/**
+ * 通过公共网关解析 IPNS 名称 → CID
+ * 大多数公共网关不支持 IPNS 解析，这是尽力而为
+ * 真实环境建议用本地 Kubo 节点
+ */
+async function resolveIPNSToCid(ipnsName) {
+    const gateways = [
+        `https://ipfs.io/ipns/${ipnsName}`,
+        `https://dweb.link/ipns/${ipnsName}`,
+    ];
+    for (const url of gateways) {
+        try {
+            const resp = await fetch(url, {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(5000),
+            });
+            // IPFS 网关会在响应头中返回 x-ipfs-path 或 x-ipfs-roots
+            const ipfsPath = resp.headers.get('x-ipfs-path') || resp.headers.get('x-ipfs-roots');
+            if (ipfsPath) {
+                const cid = ipfsPath.replace('/ipfs/', '').trim();
+                if (cid)
+                    return cid;
+            }
+            // 也可以直接 GET
+            if (resp.ok) {
+                const body = await resp.text();
+                try {
+                    const doc = JSON.parse(body);
+                    if (doc.id && doc['@context'])
+                        return ipnsName; // 已经拿到内容，用原始 IPNS 名当 key
+                }
+                catch { /* not JSON, ignore */ }
+            }
+        }
+        catch { /* timeout or network error, try next */ }
+    }
+    return null;
+}
+// ============================================================================
+// 解析 DID 文档 → ResolvedDIDAgent
+// ============================================================================
+/**
+ * 从 DID 文档解析 agent 身份信息
+ */
+function parseDIDDocument(doc, cid, ipnsName) {
+    const did = doc.id || '';
+    // 从 DID 提取友好名：did:key:z6Mk... → 取后 8 位
+    const shortDid = did.includes(':') ? did.split(':').pop() || did : did;
+    const name = shortDid.substring(0, 8);
+    // 提取公钥
+    const vm = doc.verificationMethod?.[0];
+    const publicKeyMultibase = vm?.publicKeyMultibase;
+    // 提取服务端点
+    const services = [];
+    if (Array.isArray(doc.service)) {
+        for (const s of doc.service) {
+            const ep = typeof s.serviceEndpoint === 'string'
+                ? s.serviceEndpoint
+                : JSON.stringify(s.serviceEndpoint);
+            services.push({ type: s.type || 'unknown', endpoint: ep });
+        }
+    }
+    return { did, name, publicKeyMultibase, services, cid, ipnsName };
+}
+// ============================================================================
+// 主入口
+// ============================================================================
+/**
+ * 从 CID 读取并解析 agent 的 DID 文档
+ *
+ * @param cid IPFS CID
+ * @returns 解析结果或 null
+ */
+export async function resolveAgentFromCID(cid) {
+    const doc = await fetchDIDDocument(cid);
+    if (!doc)
+        return null;
+    return parseDIDDocument(doc, cid);
+}
+/**
+ * 通过 IPNS 名称解析 agent 的 DID 文档
+ * 先尝试 IPNS → CID 解析，再用 CID 获取文档
+ *
+ * @param ipnsName IPNS 名称
+ * @returns 解析结果或 null
+ */
+export async function resolveAgentFromIPNS(ipnsName) {
+    // 先直接尝试用 IPNS 名当 CID 读取（部分场景 IPNS 名 = CIDv1 字符串）
+    const directDoc = await fetchDIDDocument(ipnsName);
+    if (directDoc)
+        return parseDIDDocument(directDoc, ipnsName, ipnsName);
+    // 再尝试 IPNS 解析
+    const cid = await resolveIPNSToCid(ipnsName);
+    if (cid) {
+        const doc = await fetchDIDDocument(cid);
+        if (doc)
+            return parseDIDDocument(doc, cid, ipnsName);
+    }
+    return null;
+}
+/**
+ * 从单个 AgentManifestEntry 解析 agent
+ * 优先用 CID，回退 IPNS
+ */
+export async function resolveAgentFromEntry(entry) {
+    if (entry.cid) {
+        const r = await resolveAgentFromCID(entry.cid);
+        if (r)
+            return r;
+    }
+    if (entry.ipnsName) {
+        const r = await resolveAgentFromIPNS(entry.ipnsName);
+        if (r)
+            return r;
+    }
+    return null;
+}
+/**
+ * 批量解析 peer manifest 中的 agents
+ * 对每个有 cid/ipnsName 的 agent 尝试解析 DID 文档
+ * 返回成功解析的列表
+ */
+export async function resolveAgentsFromManifest(agents) {
+    const results = [];
+    for (const agent of agents) {
+        if (!agent.cid && !agent.ipnsName)
+            continue;
+        const r = await resolveAgentFromEntry(agent);
+        if (r) {
+            results.push(r);
+            console.log(`[did-resolver] ✅ 解析 agent ${agent.name || agent.id}: DID=${r.did ? r.did.substring(0, 20) + '...' : 'N/A'}`);
+        }
+        else {
+            console.log(`[did-resolver] ⚠️ agent ${agent.name || agent.id} 没有可用的 cid/ipnsName，跳过 DID 解析`);
+        }
+    }
+    return results;
+}
+/**
+ * 把解析后的 DID agent 写入本地 peer-fs 目录
+ * 同时更新 known_peers 中的 name 为 DID 文档中的名字
+ */
+export async function persistResolvedAgent(peerPublicKey, resolved) {
+    try {
+        const { writeAgentDescription } = await import('../network/peer-fs.js');
+        const { addOrUpdatePeer } = await import('../network/known-peers.js');
+        // 1. 写入 agent 详细描述到 peers/<pk>/agents/<id>.md
+        const agentEntry = {
+            id: resolved.did,
+            name: resolved.name,
+            capabilities: resolved.services.map(s => s.type),
+            status: 'active',
+            cid: resolved.cid,
+            ipnsName: resolved.ipnsName,
+        };
+        await writeAgentDescription(peerPublicKey, agentEntry);
+        console.log(`[did-resolver] 📝 agent 已落盘: ${resolved.name} (${resolved.did?.substring(0, 20)}... → peers/${peerPublicKey.substring(0, 8)}.../agents/)`);
+        // 2. 如果 peer 是 auto-discovered 的，用 DID 名更新好友名称
+        const { findNameByPublicKey, removePeer } = await import('../network/known-peers.js');
+        const existingName = await findNameByPublicKey(peerPublicKey);
+        if (existingName && existingName.startsWith('discovered-')) {
+            const newName = `did-${resolved.name}`;
+            await removePeer(existingName);
+            await addOrUpdatePeer(newName, peerPublicKey, `DID: ${resolved.did}`);
+            console.log(`[did-resolver] 📛 更新 peer 名称: ${existingName} → ${newName}`);
+        }
+    }
+    catch (e) {
+        console.warn(`[did-resolver] 持久化 agent 失败:`, e.message?.substring(0, 100) || e);
+    }
+}

package/dist/network/p2p-direct.js

@@ -164,7 +164,7 @@ export class P2PDirect extends EventEmitter {
      * 上层调用: const r = await p2p.sendToWithWait(pk, rpc, 5000);
      *           if (r !== 'SENT') return 502 给前端.
      */
-    async sendToWithWait(publicKeyHex, data, timeoutMs = 5000) {
+    async sendToWithWait(publicKeyHex, data, timeoutMs = 15000) {
         // 2026-06-11: 先主动触发 joinPeer, 否则 DHT 上对面可能没 push conn
         if (this.swarm) {
             try {

package/dist/network/p2p-outbox.js

@@ -25,7 +25,7 @@ export async function sendOrQueue(publicKey, op, payload, p2p, opts = {}) {
     // 先尝试直发
     if (!opts.forceQueue && p2p) {
         try {
-            const r = await p2p.sendToWithWait(publicKey, rpc, 3000);
+            const r = await p2p.sendToWithWait(publicKey, rpc, 15000);
             if (r === 'SENT')
                 return 'SENT';
         }
@@ -74,7 +74,7 @@ export async function flushAllOutboxes(p2p) {
             for (const entry of outbox) {
                 const rpc = JSON.stringify({ v: 3, op: entry.op, payload: entry.payload });
                 try {
-                    const r = await p2p.sendToWithWait(peer.publicKey, rpc, 3000);
+                    const r = await p2p.sendToWithWait(peer.publicKey, rpc, 15000);
                     if (r === 'SENT') {
                         sent++;
                     }

package/dist/utils/auto-update.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * npm 自动更新检查器
  *
@@ -14,48 +13,11 @@
  *   开发态下若 cwd 的 package.json 就是本包则回退到 cwd，不受任意工作目录影响。
  * - 检查频率受节流缓存约束（默认 24h 一次），不会每次启动都打 npm。
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAndUpdate = checkAndUpdate;
-exports.checkForUpdates = checkForUpdates;
-exports.performUpdate = performUpdate;
-const child_process_1 = require("child_process");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const https = __importStar(require("https"));
-const http = __importStar(require("http"));
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
 // ANSI 颜色
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -113,7 +75,7 @@ function getGlobalBolloonDir() {
     const candidates = [];
     // 1. npm root -g（最可靠）
     try {
-        const npmRoot = (0, child_process_1.execSync)('npm root -g', { encoding: 'utf-8', timeout: 8000 }).trim();
+        const npmRoot = execSync('npm root -g', { encoding: 'utf-8', timeout: 8000 }).trim();
         if (npmRoot)
             candidates.push(path.join(npmRoot, '@bolloon', 'bolloon-agent'));
     }
@@ -122,7 +84,7 @@ function getGlobalBolloonDir() {
     }
     // 2. npm prefix -g
     try {
-        const npmPrefix = (0, child_process_1.execSync)('npm prefix -g', { encoding: 'utf-8', timeout: 8000 }).trim();
+        const npmPrefix = execSync('npm prefix -g', { encoding: 'utf-8', timeout: 8000 }).trim();
         if (npmPrefix)
             candidates.push(path.join(npmPrefix, 'lib', 'node_modules', '@bolloon', 'bolloon-agent'));
     }
@@ -280,7 +242,7 @@ async function checkBolloonUpdates() {
  */
 function checkNpmOutdated() {
     try {
-        const output = (0, child_process_1.execSync)('npm outdated --json', {
+        const output = execSync('npm outdated --json', {
             encoding: 'utf-8',
             timeout: 30000,
             maxBuffer: 10 * 1024 * 1024,
@@ -344,7 +306,7 @@ async function updatePackagesWithVersion(packagesWithVersion) {
     const args = ['npm', 'install', '-g', ...packagesWithVersion];
     notify(`\n${CYAN}📦 正在更新包...${RESET}\n`, RESET);
     try {
-        (0, child_process_1.execSync)(args.join(' '), {
+        execSync(args.join(' '), {
             encoding: 'utf-8',
             timeout: 300000,
             stdio: 'inherit',
@@ -462,7 +424,7 @@ function resolveAutoUpdatePolicy() {
  *                       例如 Electron 用 app.relaunch()，Node 用 detached 重新 spawn）。
  *                       若未提供或 autoRestart=false，则仅提示用户手动重启。
  */
-async function checkAndUpdate(opts = {}) {
+export async function checkAndUpdate(opts = {}) {
     const policy = resolveAutoUpdatePolicy();
     if (policy.blocked) {
         return { hasUpdate: false, info: null, updated: false, message: '跳过更新检查（已显式禁用）' };
@@ -566,13 +528,13 @@ async function checkAndUpdate(opts = {}) {
 /**
  * 仅检查更新，不自动安装
  */
-async function checkForUpdates() {
+export async function checkForUpdates() {
     return await checkBolloonUpdates();
 }
 /**
  * 手动触发更新
  */
-async function performUpdate(packages) {
+export async function performUpdate(packages) {
     return await updatePackages(packages);
 }
 // CLI 入口
@@ -595,4 +557,3 @@ if (process.argv[1]?.includes('auto-update')) {
         }
     })();
 }
-//# sourceMappingURL=auto-update.js.map