@bolloon/bolloon-agent 0.4.5 → 0.4.7

package/bin/bolloon.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+const path = require("path");
+const { spawn } = require("child_process");
+const fs = require("fs");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const MAGENTA = "\x1b[35m";
+
+function log(msg, color) {
+  console.log((color || RESET) + msg + RESET);
+}
+
+function printBanner() {
+  console.log("\n" + CYAN + BOLD + [
+    "   ╔═══════════════════════════════════════════╗",
+    "   ║      🤖 Bolloon Agent                     ║",
+    "   ║      P2P AI Document Processor            ║",
+    "   ╚═══════════════════════════════════════════╝"
+  ].join("\n") + RESET + "\n");
+}
+
+function getMainEntry() {
+  const distDir = path.dirname(require.main.filename);
+  const distIndex = path.join(distDir, "index.js");
+  if (fs.existsSync(distIndex)) {
+    return distIndex;
+  }
+  return path.join(process.cwd(), "src", "index.ts");
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    return { mode: "gui", args: [] };
+  }
+  const first = args[0];
+  switch (first) {
+    case "-v":
+    case "--version":
+      return { mode: "version", args: [] };
+    case "-h":
+    case "--help":
+      return { mode: "help", args: [] };
+    case "-g":
+    case "--gui":
+      return { mode: "gui", args: args.slice(1) };
+    case "-w":
+    case "--web":
+      return { mode: "web", args: args.slice(1) };
+    case "-c":
+    case "--cli":
+      return { mode: "cli", args: args.slice(1) };
+    default:
+      return { mode: "passthrough", args };
+  }
+}
+
+async function startElectron(additionalArgs) {
+  try {
+    const electron = require("electron");
+    const distDir = path.dirname(require.main.filename);
+    let mainPath = path.join(distDir, "electron.js");
+    if (!fs.existsSync(mainPath)) {
+      mainPath = path.join(process.cwd(), "src", "electron.ts");
+    }
+    log("启动 Electron...", CYAN);
+    const child = spawn(electron, [mainPath, ...additionalArgs], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "development" }
+    });
+    child.on("error", (err) => {
+      log("Electron 启动失败: " + err.message, MAGENTA);
+      process.exit(1);
+    });
+    child.on("exit", (code) => process.exit(code || 0));
+  } catch (err) {
+    log("Electron 不可用，切换到 Web 模式...", CYAN);
+    await startWebServer(additionalArgs);
+  }
+}
+
+async function startWebServer(additionalArgs) {
+  const mainPath = getMainEntry();
+  const webArgs = ["--web", ...additionalArgs];
+  log("启动 Web 服务...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...webArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("Web 服务启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function startCLI(additionalArgs) {
+  const mainPath = getMainEntry();
+  log("启动命令行界面...", CYAN);
+  const child = spawn(process.execPath, [mainPath, ...additionalArgs], { stdio: "inherit" });
+  child.on("error", (err) => {
+    log("CLI 启动失败: " + err.message, MAGENTA);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function main() {
+  const { mode, args } = parseArgs();
+  switch (mode) {
+    case "version":
+      console.log("Bolloon Agent v0.1.1");
+      break;
+    case "help":
+      printBanner();
+      console.log(BOLD + "用法:" + RESET + "  bolloon [选项] [命令] [参数]");
+      console.log(BOLD + "选项:" + RESET + "  --gui, -g           启动图形界面");
+      console.log("         --web, -w           启动 Web UI");
+      console.log("         --cli, -c           启动命令行界面");
+      console.log("         --version, -v       显示版本");
+      console.log("         --help, -h          显示帮助");
+      console.log(BOLD + "示例:" + RESET + "  bolloon              # 启动图形界面");
+      console.log("         bolloon --web        # 启动 Web UI");
+      console.log("         bolloon --read file  # 读取文档");
+      break;
+    case "gui":
+      printBanner();
+      await startElectron(args);
+      break;
+    case "web":
+      printBanner();
+      await startWebServer(args);
+      break;
+    case "cli":
+      await startCLI(args);
+      break;
+    case "passthrough":
+      const mainPath = getMainEntry();
+      const child = spawn(process.execPath, [mainPath, ...args], { stdio: "inherit" });
+      child.on("error", (err) => {
+        log("执行失败: " + err.message, MAGENTA);
+        process.exit(1);
+      });
+      child.on("exit", (code) => process.exit(code || 0));
+      break;
+    default:
+      log("未知模式: " + mode, MAGENTA);
+      printBanner();
+      console.log("输入 --help 查看帮助");
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/agents/constraint-layer.js

@@ -7,25 +7,25 @@ import { ToolPermissionContext, BudgetTracker } from '@bolloon/constraint-runtim
  * System prompt for constraint layer
  * Defines boundaries and autonomous permissions
  */
-export const SYSTEM_PROMPT = `
-你是一个文档处理Agent，在以下规则下运行：
-
-【边界规则】
-1. 只处理：txt, md, pdf, docx 格式文档
-2. 不修改原始文件，只输出改进版本
-3. 发送前必须记录操作日志
-
-【自主权限】
-- ✅ 自主决定：摘要详细程度、chunk分块策略
-- ✅ 自主决定：重试次数（最多3次）
-- ✅ 自主决定：是否需要补充信息
-- ❌ 必须确认：首次向新对等节点发送文档
-- ❌ 必须确认：删除操作
-
-【敏感操作拦截】
-if (操作 === '发送文档' && 对等节点不在已知列表) {
-  拦截 → 记录 → 等待确认
-}
+export const SYSTEM_PROMPT = `
+你是一个文档处理Agent，在以下规则下运行：
+
+【边界规则】
+1. 只处理：txt, md, pdf, docx 格式文档
+2. 不修改原始文件，只输出改进版本
+3. 发送前必须记录操作日志
+
+【自主权限】
+- ✅ 自主决定：摘要详细程度、chunk分块策略
+- ✅ 自主决定：重试次数（最多3次）
+- ✅ 自主决定：是否需要补充信息
+- ❌ 必须确认：首次向新对等节点发送文档
+- ❌ 必须确认：删除操作
+
+【敏感操作拦截】
+if (操作 === '发送文档' && 对等节点不在已知列表) {
+  拦截 → 记录 → 等待确认
+}
 `;
 /**
  * Actions that can be executed autonomously without confirmation

package/dist/agents/judgment-protocol.js

@@ -148,20 +148,20 @@ export async function distillDissent(ask) {
         .slice(-10)
         .flatMap((j) => j.reasons || [])
         .slice(0, 20);
-    const prompt = `你是用户的判断力代理. 用户发起了一个决定: "${ask.decision}"
-${ask.context ? `\n补充: ${ask.context}` : ''}
-
-[用户价值画像] ${valueHint}
-[相关历史判断 (${relevant.length} 条)] ${relevant.slice(0, 3).map((j) => j.decision || '').join(' | ').slice(0, 300)}
-[历史理由样本] ${recentReasons.join(' | ').slice(0, 400) || '(无)'}
-
-请基于上述判断力, 生成正好 3 个"反方观点" (用户应该考虑但可能忽略的风险/盲点).
-要求:
-- 每个反方 1-2 句, 总长 < 80 字
-- 必须是这个特定决定的"反对声音", 不是通用建议
-- 第 1 个: 历史/经验类风险
-- 第 2 个: 关系/信任类风险
-- 第 3 个: 隐藏代价/时间类风险
+    const prompt = `你是用户的判断力代理. 用户发起了一个决定: "${ask.decision}"
+${ask.context ? `\n补充: ${ask.context}` : ''}
+
+[用户价值画像] ${valueHint}
+[相关历史判断 (${relevant.length} 条)] ${relevant.slice(0, 3).map((j) => j.decision || '').join(' | ').slice(0, 300)}
+[历史理由样本] ${recentReasons.join(' | ').slice(0, 400) || '(无)'}
+
+请基于上述判断力, 生成正好 3 个"反方观点" (用户应该考虑但可能忽略的风险/盲点).
+要求:
+- 每个反方 1-2 句, 总长 < 80 字
+- 必须是这个特定决定的"反对声音", 不是通用建议
+- 第 1 个: 历史/经验类风险
+- 第 2 个: 关系/信任类风险
+- 第 3 个: 隐藏代价/时间类风险
 - 用 JSON 数组返回: ["反方1", "反方2", "反方3"]`;
     // LLM 调用 (OpenAI 兼容, 复用 p2p-chat-tools 的方式)
     let dissents = [];

package/dist/agents/pi-sdk-tools.js

@@ -32,8 +32,58 @@ import { delegateToEngine } from '../external-engines/delegate.js';
  */
 export const SIDE_EFFECT_TOOLS = new Set([
     'write_file', 'edit_file', 'shell_exec', 'git_commit', 'git_push', 'git_branch',
-    'create_task', 'update_task',
+    'create_task', 'update_task', 'terminal', 'process',
 ]);
+export async function runTerminalCommand(raw, opts = {}) {
+    const { checkTerminalCommand } = await import('./shell-guard.js');
+    const timeoutMs = opts.timeoutMs ?? 30000;
+    const list = (opts.commands && opts.commands.length > 0) ? opts.commands : [raw];
+    for (const c of list) {
+        const guard = checkTerminalCommand(String(c || '').trim());
+        if (!guard.allowed) {
+            return { success: false, error: `[terminal-guard] ${guard.reason}`, deniedByGuard: true };
+        }
+    }
+    // 2026-08-12 (TaskD): 后台执行 — 长命令不阻塞对话.
+    if (opts.background) {
+        const cmdStr = list.join(' && ');
+        const { spawnBackground } = await import('./process-runner.js');
+        const session = spawnBackground(cmdStr, opts.cwd ?? process.cwd());
+        return {
+            success: true,
+            background: true,
+            sessionId: session.id,
+            cmd: cmdStr.slice(0, 200),
+            message: `已在后台启动 (${session.id}). 用 process 工具轮询/等待: process(session_id="${session.id}", action="poll"|"wait"|"kill")`,
+        };
+    }
+    const { exec } = await import('child_process');
+    const runOne = (cmdStr) => new Promise((resolve) => {
+        exec(cmdStr, {
+            cwd: opts.cwd ?? process.cwd(),
+            timeout: timeoutMs,
+            maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        }, (err, stdout, stderr) => {
+            const output = ((stdout || '') + (stderr ? `\n[stderr]\n${stderr}` : '')).trim().slice(0, 8000);
+            if (err) {
+                resolve({ success: false, cmd: cmdStr.slice(0, 120), error: `exit ${err.code ?? '?'}: ${String(err.message || '').slice(0, 200)}`, output: output || undefined });
+            }
+            else {
+                resolve({ success: true, cmd: cmdStr.slice(0, 120), output: output || '(无输出)' });
+            }
+        });
+    });
+    if (list.length === 1)
+        return runOne(list[0]);
+    const results = await Promise.all(list.map((c) => runOne(c)));
+    const failed = results.filter((r) => !r.success);
+    const allOutput = results.map((r) => `${r.cmd}\n${r.output || r.error || ''}`).join('\n\n---\n\n');
+    if (failed.length > 0) {
+        return { success: false, error: `${failed.length}/${list.length} 条命令失败: ${failed[0].error}`, output: allOutput, partial: results };
+    }
+    return { success: true, output: allOutput, count: list.length, parallel: true };
+}
 export function registerBuiltinTools(ctx) {
     ctx.tools.set('read_document', {
         name: 'read_document',
@@ -621,17 +671,22 @@ export function registerBuiltinTools(ctx) {
     for (const tool of p2pDocumentTools) {
         ctx.tools.set(tool.name, tool);
     }
-    // shell_exec
+    // 2026-08-12 (Task2): shell_exec / terminal 统一走模块级 runTerminalCommand (宽松护栏 + 多命令并行).
+    // shell_exec — 2026-08-12 (Task2): 与 terminal 统一走宽松护栏 (denylist-only).
+    //   兼容旧格式 (command + args 数组), 内部转成完整命令字符串交给 runTerminal,
+    //   不再用窄白名单 → 模型不会因 "command 不在白名单" 报错.
     ctx.tools.set('shell_exec', {
         name: 'shell_exec',
-        description: '在 cwd 跑 shell 命令. 仅支持白名单内命令: git, npm, npx, tsx, tsc, vitest, cat, head, tail, ls, wc, echo, pwd, date, mkdir, touch. 禁止管道/重定向/rm -rf/sudo. 命中护栏黑名单会被拒.',
-        parameters: { command: '可执行文件 (必填, 必须在白名单)', args: '参数数组, 逗号分隔', timeoutMs: '超时毫秒, 默认 30000' },
+        description: '执行 shell 命令 (兼容模式, 参数数组或命令字符串均可). 护栏只挡高危破坏操作 (sudo/格式化/rm -rf 根目录/写 ~/.bolloon 数据). 推荐直接用 terminal 传完整命令字符串.',
+        parameters: { command: '可执行文件 或 完整命令 (必填)', args: '参数数组, 逗号分隔 (可选)', timeoutMs: '超时毫秒, 默认 30000' },
         execute: async (args) => {
             const cmd = String(args.command || '').trim();
             if (!cmd)
                 return { success: false, error: 'command 必填' };
-            let argList = [];
+            // 兼容参数数组 → 拼成命令字符串
+            let full = cmd;
             const rawArgs = args.args;
+            let argList = [];
             if (Array.isArray(rawArgs)) {
                 argList = rawArgs.map((s) => String(s).trim()).filter(Boolean);
             }
@@ -640,61 +695,76 @@ export function registerBuiltinTools(ctx) {
                 if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
                     try {
                         const parsed = JSON.parse(trimmed);
-                        if (Array.isArray(parsed)) {
+                        if (Array.isArray(parsed))
                             argList = parsed.map((s) => String(s).trim()).filter(Boolean);
-                        }
                     }
-                    catch { /* fall through to comma split */ }
+                    catch { /* 非 JSON 数组 */ }
                 }
-                if (argList.length === 0) {
+                if (argList.length === 0)
                     argList = trimmed.split(',').map(s => s.trim()).filter(Boolean);
-                }
             }
-            const timeoutMs = Number(args.timeoutMs) || 30000;
-            const result = await shellExec(cmd, argList, { timeoutMs });
-            if (result.deniedByGuard) {
-                return { success: false, error: result.error };
+            // 若 command 只是可执行文件名且带 args → 拼成 "cmd arg1 arg2"; 否则原样
+            if (argList.length > 0 && !/\s/.test(cmd) && !cmd.includes('&&') && !cmd.includes(';') && !cmd.includes('|')) {
+                full = `${cmd} ${argList.map(a => (/[\s"&|<>^()%!`]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a)).join(' ')}`;
             }
-            if (!result.success) {
-                return { success: false, error: result.error, output: result.output };
-            }
-            return { success: true, output: result.output };
+            const timeoutMs = Number(args.timeoutMs) || 30000;
+            return await runTerminalCommand(full, { timeoutMs, cwd: ctx.cwd });
         }
     });
     // 2026-08-10: terminal — 灵活终端写命令 (用户要求: bolloon 自己写命令进 terminal, 少围栏).
-    //   与 shell_exec 的区别: 接受**完整 shell 命令字符串** (管道/重定向/写文件都行),
-    //   护栏只挡高危破坏模式 (checkTerminalCommand: 提权/格式化/删根/.bolloon 数据), 其余放行.
+    //   2026-08-12 (Task2): 支持 commands 数组并行执行; 与 shell_exec 统一走 runTerminalCommand.
+    //   与 shell_exec 的区别: 直接接受完整 shell 命令字符串, 更适合模型自主写命令.
     ctx.tools.set('terminal', {
         name: 'terminal',
-        description: '执行完整 shell 命令 (支持管道/重定向/写文件/跑脚本). 护栏只挡高危破坏操作 (sudo/格式化/rm -rf 根目录/写 ~/.bolloon 数据), 其余灵活放行. 适合: 写 HTML 文件、跑 python/node 脚本、查系统状态、装依赖.',
-        parameters: { command: '完整 shell 命令 (必填, 如: echo "<html>" > /tmp/site/index.html && ls /tmp/site)', timeoutMs: '超时毫秒, 默认 30000' },
+        description: '执行完整 shell 命令 (支持管道/重定向/写文件/跑脚本). 护栏只挡高危破坏操作 (sudo/格式化/rm -rf 根目录/写 ~/.bolloon 数据), 其余灵活放行. 适合: 写 HTML 文件、跑 python/node 脚本、查系统状态、装依赖. 多条命令用 commands 数组并行执行. 长命令 (服务器/构建/后台任务) 设 background=true 后台执行不阻塞对话.',
+        parameters: { command: '完整 shell 命令 (必填, 如: echo "<html>" > /tmp/site/index.html && ls /tmp/site)', commands: '可选: 多条命令数组 (并行执行), 每条独立字符串', timeoutMs: '超时毫秒, 默认 30000', background: '可选: true 后台执行, 立即返回 session_id (用 process 工具 poll/wait/kill)' },
         execute: async (args) => {
             const raw = String(args.command || '').trim();
-            if (!raw)
-                return { success: false, error: 'command 必填' };
-            const { checkTerminalCommand } = await import('./shell-guard.js');
-            const guard = checkTerminalCommand(raw);
-            if (!guard.allowed) {
-                return { success: false, error: `[terminal-guard] ${guard.reason}`, deniedByGuard: true };
-            }
-            const { exec } = await import('child_process');
+            const commands = Array.isArray(args.commands) ? args.commands.map((c) => String(c || '').trim()).filter(Boolean) : [];
+            if (!raw && commands.length === 0)
+                return { success: false, error: 'command 或 commands 必填' };
             const timeoutMs = Number(args.timeoutMs) || 30000;
-            return new Promise((resolve) => {
-                exec(raw, {
-                    cwd: process.cwd(),
-                    timeout: timeoutMs,
-                    maxBuffer: 8 * 1024 * 1024,
-                    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-                }, (err, stdout, stderr) => {
-                    const output = ((stdout || '') + (stderr ? `\n[stderr]\n${stderr}` : '')).trim().slice(0, 8000);
-                    if (err) {
-                        resolve({ success: false, error: `exit ${err.code ?? '?'}: ${String(err.message || '').slice(0, 200)}`, output: output || undefined });
-                    }
-                    else {
-                        resolve({ success: true, output: output || '(无输出)' });
-                    }
-                });
-            });
+            return await runTerminalCommand(raw, { timeoutMs, cwd: ctx.cwd, commands: commands.length > 0 ? commands : undefined, background: String(args.background).toLowerCase() === 'true' });
+        }
+    });
+    // 2026-08-12 (TaskD): process — 后台进程管理 (学 hermes terminal background session + poll/wait/kill).
+    //   长命令不阻塞对话: terminal(background=true) 启动 → process 工具轮询/等待/终止.
+    ctx.tools.set('process', {
+        name: 'process',
+        description: '管理后台进程 (terminal background=true 启动的). action: poll(查状态, 不阻塞) / wait(等结束, 最多 timeoutMs) / kill(终止) / list(列全部). 长期运行命令的阻塞问题用它解决.',
+        parameters: { session_id: '后台进程 session_id (必填, poll/wait/kill 用)', action: 'poll | wait | kill | list (默认 poll)', timeoutMs: 'wait 模式等待上限毫秒, 默认 30000' },
+        execute: async (args) => {
+            const action = String(args.action || 'poll').trim().toLowerCase();
+            try {
+                const { pollSession, waitSession, killSession, listSessions, isValidSessionId } = await import('./process-runner.js');
+                if (action === 'list') {
+                    const all = listSessions();
+                    return { success: true, output: all.length === 0 ? '(无后台进程)' : all.map((s) => `  [${s.status}] ${s.id} ${s.cmd}`).join('\n') };
+                }
+                const sid = String(args.session_id || '').trim();
+                if (!sid)
+                    return { success: false, error: 'session_id 必填' };
+                if (!isValidSessionId(sid))
+                    return { success: false, error: 'session_id 非法' };
+                if (action === 'kill') {
+                    const r = killSession(sid);
+                    return { success: r.ok, output: r.reason ?? `已终止 ${sid}` };
+                }
+                if (action === 'wait') {
+                    const t = Number(args.timeoutMs) || 30000;
+                    const r = await waitSession(sid, t);
+                    return { success: r.ok, output: r.session ? `${r.session.status} exit=${r.session.exitCode}${r.session.timedOut ? ' (超时)' : ''}\n${r.session.output || '(无输出)'}` : '未知 session' };
+                }
+                // poll
+                const r = pollSession(sid);
+                if (!r.ok || !r.session)
+                    return { success: false, error: `未知 session ${sid}` };
+                const s = r.session;
+                return { success: true, output: `[${s.status}] exit=${s.exitCode}${s.status === 'running' ? ' (运行中)' : ''}\n${s.output || '(无输出)'}` };
+            }
+            catch (e) {
+                return { success: false, error: `process ${action} 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
         }
     });
     // self_improve
@@ -729,6 +799,15 @@ export function registerBuiltinTools(ctx) {
             }
             try {
                 const absPath = path.resolve(ctx.cwd, relPath);
+                // 2026-08-12 (TaskC): 写前暂存 (准备阶段) — 记录变更前快照, 支持审计/撤销. 失败静默.
+                let before = '';
+                try {
+                    before = await fs.readFile(absPath, 'utf-8');
+                }
+                catch { /* 新文件 */ }
+                const action = before.length > 0 ? 'overwrite' : 'create';
+                const { stageWrite } = await import('./write-staging.js');
+                await stageWrite(relPath, before, content, action, ctx.cwd).catch(() => { });
                 await fs.mkdir(path.dirname(absPath), { recursive: true });
                 await fs.writeFile(absPath, content, 'utf-8');
                 return { success: true, output: `✅ wrote ${relPath} (${content.length} bytes)` };
@@ -761,6 +840,9 @@ export function registerBuiltinTools(ctx) {
                     return { success: false, error: `old_text 在 ${relPath} 中未找到, 拒绝静默写入. 请先用 read_document 读最新内容.` };
                 }
                 const updated = original.replace(oldText, newText);
+                // 2026-08-12 (TaskC): 写前暂存 (准备阶段) — 记录变更前快照, 支持审计/撤销. 失败静默.
+                const { stageWrite } = await import('./write-staging.js');
+                await stageWrite(relPath, original, updated, 'edit', ctx.cwd).catch(() => { });
                 await fs.writeFile(absPath, updated, 'utf-8');
                 return { success: true, output: `✅ edited ${relPath} (${oldText.length} → ${newText.length} 字节)` };
             }

package/dist/agents/pi-sdk-types.js

@@ -1,13 +1,13 @@
-export const TOOL_DEFINITIONS = `
-可用工具:
-1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
-2. summarize_document(path, context?) - 总结文档内容，可选提供上下文
-3. improve_document(path, requirements) - 改进文档，需提供文件路径和改进要求
-4. list_peers() - 列出已连接的对等节点
-5. send_message(peer_id, message) - 向指定对等节点发送消息
-6. broadcast_message(message) - 向所有对等节点广播消息
-7. get_identity() - 获取当前智能体身份信息
-8. set_persona(persona_json) - 更新智能体 persona，包含 name、description、personality、greeting 等
-9. run_workflow(steps) - 执行预定义工作流
-10. get_operation_logs() - 获取操作日志
+export const TOOL_DEFINITIONS = `
+可用工具:
+1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
+2. summarize_document(path, context?) - 总结文档内容，可选提供上下文
+3. improve_document(path, requirements) - 改进文档，需提供文件路径和改进要求
+4. list_peers() - 列出已连接的对等节点
+5. send_message(peer_id, message) - 向指定对等节点发送消息
+6. broadcast_message(message) - 向所有对等节点广播消息
+7. get_identity() - 获取当前智能体身份信息
+8. set_persona(persona_json) - 更新智能体 persona，包含 name、description、personality、greeting 等
+9. run_workflow(steps) - 执行预定义工作流
+10. get_operation_logs() - 获取操作日志
 `;