@bolloon/bolloon-agent 0.1.36 → 0.1.37

package/src/agents/pre-tool-validator.ts

@@ -1,213 +0,0 @@
-/**
- * Pre-Tool Validator — 4 步链式校验
- *
- * 严格对齐 Claude Code 论文 PreToolUse 4 步:
- *   1. modeGate(tool, mode)         — bypassPermissions → 直接放行(除 shell)
- *   2. blacklistGate(tool, args)    — 6 模式黑名单 (recursive rm, force push, dd 等)
- *   3. shellGuardGate(tool, args)   — **完整** shell-guard (checkCommand + checkWritePath), 永远生效
- *   4. schemaGate(tool, args)       — 第一版 stub: always allow (后续接入 tool-gate.ts)
- *
- * 每步独立 try/catch, 失败 = 跳过该步, 不阻塞 (与现有 lifecycle-hooks 风格一致)
- *
- * 失败静默: 任何 step 异常 → console.warn + 继续下一 step, 不抛错
- */
-
-import { shouldRunBlacklist, isShellTool, type PermissionMode } from './permission-mode.js';
-import { checkCommand, checkWritePath } from './shell-guard.js';
-
-export interface PreToolResult {
-  allowed: boolean;
-  reason?: string;
-  /** 哪一步拒绝的 (供 audit log) */
-  rejectedBy?: 'mode' | 'blacklist' | 'shell-guard' | 'schema';
-  mode: PermissionMode;
-  /** bypassPermissions 时记录, 区分 "完全放行" vs "shell-guard 仍生效" */
-  shellGuardRetained?: boolean;
-}
-
-const DANGEROUS_PATTERNS: Array<{ re: RegExp; reason: string }> = [
-  { re: /\brm\s+(-[a-z]*f[a-z]*\s+)?-[a-z]*r[a-z]*\s+\//, reason: '禁止递归删除根目录' },
-  { re: /\bgit\s+push\s+.*--force\b/, reason: '禁止 force push' },
-  { re: /\brm\s+-rf\s+~\//, reason: '禁止递归删除 home' },
-  { re: /\bdd\s+if=.*\s+of=\/dev\//, reason: '禁止 dd 覆盖块设备' },
-  { re: /\bcurl\s+.*\|\s*(ba)?sh\b/, reason: '禁止 curl|sh 直执行' },
-  { re: />\s*\/dev\/sd[a-z]/, reason: '禁止写裸设备' },
-];
-
-/**
- * Step 1: modeGate
- * - bypassPermissions + 非 shell → 直接放行 (但保留 shellGuardRetained 标记)
- * - 其他 → 继续
- */
-function modeGate(tool: string, mode: PermissionMode): PreToolResult | null {
-  try {
-    if (mode === 'bypassPermissions' && !isShellTool(tool)) {
-      return { allowed: true, mode, rejectedBy: undefined, shellGuardRetained: false };
-    }
-    return null;  // 不在这一步决定
-  } catch (err) {
-    console.warn('[pre-tool] modeGate failed (silent):', err);
-    return null;
-  }
-}
-
-/**
- * Step 2: blacklistGate
- * 6 模式黑名单 (现有 lifecycle-hooks.ts 行为)
- */
-function blacklistGate(tool: string, args: Record<string, unknown>, mode: PermissionMode): PreToolResult | null {
-  try {
-    if (!isShellTool(tool)) return null;
-    const cmd = String(args.command || args.cmd || '');
-    if (!cmd) return null;
-    for (const { re, reason } of DANGEROUS_PATTERNS) {
-      if (re.test(cmd)) {
-        return { allowed: false, reason, rejectedBy: 'blacklist', mode };
-      }
-    }
-    return null;
-  } catch (err) {
-    console.warn('[pre-tool] blacklistGate failed (silent):', err);
-    return null;
-  }
-}
-
-/**
- * Step 3: shellGuardGate
- * 永远跑 (绕过 mode), 是 bolloon 自身的安全底线
- *
- * 接完整 shell-guard.ts (checkCommand + checkWritePath):
- *   - checkCommand 走命令白名单 + 参数黑名单 (允许列表默认 git/node/npm/npx/tsx/tsc/vitest 等)
- *   - checkWritePath 走路径黑名单 (硬编码: pi-sdk.ts, shell-guard.ts, .env, .git/, .bolloon/, package.json, dist/ 等)
- *
- * 失败静默: 任何异常 → 跳过这步, 不阻塞
- */
-function shellGuardGate(tool: string, args: Record<string, unknown>, mode: PermissionMode): PreToolResult | null {
-  try {
-    if (!isShellTool(tool)) return null;
-
-    // 1. 命令检查 (含白名单 + arg 黑名单)
-    const cmd = String(args.command || args.cmd || '');
-    let bin = '';
-    if (cmd) {
-      // shell-guard 期望 (cmd, args[]) 形式
-      // 简单 split: 第一个 token 是 cmd, 之后是 args
-      const parts = cmd.split(/\s+/).filter(Boolean);
-      bin = parts[0] || '';
-      const rest = parts.slice(1);
-      if (bin) {
-        const cmdResult = checkCommand(bin, rest);
-        if (!cmdResult.allowed) {
-          return {
-            allowed: false,
-            reason: cmdResult.reason,
-            rejectedBy: 'shell-guard',
-            mode,
-            shellGuardRetained: true,
-          };
-        }
-      }
-    }
-
-    // 2. 写路径检查 — 从 2 个来源抽:
-    //    a) 结构化字段 (args.path / args.target / args.file)
-    //    b) 命令字符串里的 token (老测试传 args.command='cat pi-sdk.ts' 时也能拦)
-    const pathCandidates: string[] = [];
-    const structured = String(
-      args.path || args.target || args.file || args.targetPath || args.destination || ''
-    );
-    if (structured) pathCandidates.push(structured);
-    if (cmd) {
-      // 简单 tokenize: 按空白切, 取不含 shell 元字符的 token
-      const tokens = cmd.split(/\s+/).filter((t) => t && !/^[|>;&`$()<]/.test(t));
-      for (const t of tokens) {
-        if (t !== bin) pathCandidates.push(t);  // 跳过命令本身
-      }
-    }
-    // 纯文件名 denylist (兜底 — checkWritePath 的 regex 要求 /src/xxx/ 锚定, 纯文件名拦不到)
-    // 只对**写/删/改**类命令生效 (rm, cp, mv, sed -i, echo >); 读类命令 (cat, head, tail, ls) 跳过
-    const READ_BINS = new Set(['cat', 'head', 'tail', 'wc', 'ls', 'echo', 'pwd', 'date', 'mkdir', 'touch', 'find', 'grep', 'git', 'node', 'npm', 'npx', 'tsx', 'tsc', 'vitest']);
-    const FILENAME_DENYLIST = [
-      'pi-sdk.ts', 'shell-guard.ts', 'shell-tool.ts',
-      '.env', 'package.json', 'tsconfig.json',
-    ];
-    const isReadOperation = READ_BINS.has(bin);
-    for (const candidate of pathCandidates) {
-      // 2a. checkWritePath 只对写操作调用 (读类命令绕开, 避免 cat pi-sdk.ts 误拦)
-      if (!isReadOperation) {
-        const pathResult = checkWritePath(candidate);
-        if (!pathResult.allowed) {
-          return {
-            allowed: false,
-            reason: pathResult.reason,
-            rejectedBy: 'shell-guard',
-            mode,
-            shellGuardRetained: true,
-          };
-        }
-      }
-      // 2b. 纯文件名兜底 — 只对写操作生效
-      if (!isReadOperation) {
-        const baseName = candidate.split('/').pop() || '';
-        if (FILENAME_DENYLIST.includes(baseName)) {
-          return {
-            allowed: false,
-            reason: `shell-guard: 禁止 ${bin} 操作 ${candidate} (命中文件名硬编码黑名单)`,
-            rejectedBy: 'shell-guard',
-            mode,
-            shellGuardRetained: true,
-          };
-        }
-      }
-    }
-
-    return null;  // 通过
-  } catch (err) {
-    console.warn('[pre-tool] shellGuardGate failed (silent):', err);
-    return null;
-  }
-}
-
-/**
- * Step 4: schemaGate
- * 第一版 stub: always allow
- */
-function schemaGate(_tool: string, _args: Record<string, unknown>, mode: PermissionMode): PreToolResult | null {
-  return null;  // 不在这一步决定
-}
-
-/**
- * 主入口: 4 步链式, 任何一步拒绝 → 返回, 否则最终放行
- */
-export function validatePreToolUse(
-  tool: string,
-  args: Record<string, unknown>,
-  mode: PermissionMode
-): PreToolResult {
-  const steps = [
-    () => modeGate(tool, mode),
-    () => blacklistGate(tool, args, mode),
-    () => shellGuardGate(tool, args, mode),
-    () => schemaGate(tool, args, mode),
-  ];
-  for (const step of steps) {
-    const result = step();
-    if (result && !result.allowed) return result;
-  }
-  // 全部通过 → 放行
-  // bypassPermissions + shell 走到这里 = shellGuardGate 已经放过, 但要标记 shellGuardRetained
-  return {
-    allowed: true,
-    mode,
-    rejectedBy: undefined,
-    shellGuardRetained: isShellTool(tool),
-  };
-}
-
-// ============================================================
-// 测试钩子
-// ============================================================
-
-export function _resetValidatorForTest(): void {
-  // validator 是 pure, 保留 API 一致
-}

package/src/agents/protocol.ts

@@ -1,398 +0,0 @@
-import { p2pNetwork } from '../network/p2p.js';
-import { documentReader, DocumentContent } from '../documents/reader.js';
-import { getMinimax } from '../constraints/index.js';
-
-export type MessageType = 'task' | 'result' | 'report' | 'feedback' | 'improve' | 'improved';
-
-export interface AgentMessage {
-  type: MessageType;
-  from: string;
-  to?: string;
-  taskId: string;
-  payload: string;
-  timestamp: number;
-}
-
-export interface Task {
-  taskId: string;
-  action: 'read' | 'summarize' | 'improve' | 'report';
-  target?: string;
-  documentPath?: string;
-  context?: string;
-  requirements?: string;
-}
-
-export interface TaskResult {
-  taskId: string;
-  success: boolean;
-  result?: string;
-  qualityScore?: number;
-  needsApproval?: boolean;
-  autoSent?: boolean;
-}
-
-export interface ImproveResult {
-  taskId: string;
-  success: boolean;
-  originalPath?: string;
-  improvedContent?: string;
-  qualityScore?: number;
-  shouldAutoSend: boolean;
-  needsApproval: boolean;
-}
-
-export class AgentProtocol {
-  private peerId: string;
-  private identityName: string;
-  private pendingTasks: Map<string, Task> = new Map();
-  private taskQueue: Task[] = [];
-  private autoSendThreshold = 0.7;
-  private autonomousMode = true;
-
-  constructor(peerId: string, identityName?: string) {
-    this.peerId = peerId;
-    this.identityName = identityName || `Agent-${peerId.substring(0, 8)}`;
-    this.setupMessageHandler();
-  }
-
-  private setupMessageHandler(): void {
-    p2pNetwork.onMessage('task', async (data, from) => {
-      const message = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
-      await this.handleTask(message);
-    });
-
-    p2pNetwork.onMessage('result', async (data, from) => {
-      const message = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
-      await this.handleResult(message);
-    });
-
-    p2pNetwork.onMessage('feedback', async (data, from) => {
-      const message = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
-      await this.handleFeedback(message);
-    });
-
-    p2pNetwork.onMessage('improve', async (data, from) => {
-      const message = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
-      await this.handleImproveRequest(message);
-    });
-
-    p2pNetwork.onMessage('improved', async (data, from) => {
-      const message = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
-      await this.handleImprovedResult(message);
-    });
-  }
-
-  async sendTask(task: Task, targetPeer: string): Promise<void> {
-    const message: AgentMessage = {
-      type: 'task',
-      from: this.peerId,
-      to: targetPeer,
-      taskId: task.taskId,
-      payload: JSON.stringify(task),
-      timestamp: Date.now()
-    };
-
-    this.pendingTasks.set(task.taskId, task);
-    await p2pNetwork.sendMessage(targetPeer, 'task', JSON.stringify(message));
-  }
-
-  async broadcastTask(task: Task): Promise<void> {
-    const message: AgentMessage = {
-      type: 'task',
-      from: this.peerId,
-      taskId: task.taskId,
-      payload: JSON.stringify(task),
-      timestamp: Date.now()
-    };
-
-    this.pendingTasks.set(task.taskId, task);
-    await p2pNetwork.broadcast('task', JSON.stringify(message));
-  }
-
-  async requestImprove(documentPath: string, requirements: string, targetPeer?: string): Promise<void> {
-    const task: Task = {
-      taskId: `improve-${Date.now()}`,
-      action: 'improve',
-      documentPath,
-      requirements,
-      context: `Requested by ${this.identityName}`
-    };
-
-    const message: AgentMessage = {
-      type: 'improve',
-      from: this.peerId,
-      to: targetPeer,
-      taskId: task.taskId,
-      payload: JSON.stringify(task),
-      timestamp: Date.now()
-    };
-
-    this.pendingTasks.set(task.taskId, task);
-
-    if (targetPeer) {
-      await p2pNetwork.sendMessage(targetPeer, 'improve', JSON.stringify(message));
-    } else {
-      await p2pNetwork.broadcast('improve', JSON.stringify(message));
-    }
-  }
-
-  private async handleTask(message: AgentMessage): Promise<void> {
-    const task = JSON.parse(message.payload) as Task;
-
-    if (task.action === 'read' && task.documentPath) {
-      const content = await documentReader.read(task.documentPath);
-      const result = await this.processDocument(content, task.context);
-
-      const resultMsg: AgentMessage = {
-        type: 'result',
-        from: this.peerId,
-        to: message.from,
-        taskId: task.taskId,
-        payload: JSON.stringify(result),
-        timestamp: Date.now()
-      };
-
-      await p2pNetwork.sendMessage(message.from, 'result', JSON.stringify(resultMsg));
-    } else if (task.action === 'improve' && task.documentPath && task.requirements) {
-      const result = await this.processImprove(task);
-      const resultMsg: AgentMessage = {
-        type: 'improved',
-        from: this.peerId,
-        to: message.from,
-        taskId: task.taskId,
-        payload: JSON.stringify(result),
-        timestamp: Date.now()
-      };
-
-      if (result.shouldAutoSend && this.autonomousMode) {
-        console.log(`\n🤖 [${this.identityName}] 自动发送改进结果 (质量: ${(result.qualityScore! * 10).toFixed(1)}/10)`);
-        await p2pNetwork.sendMessage(message.from, 'improved', JSON.stringify(resultMsg));
-      } else if (result.needsApproval) {
-        console.log(`\n📋 [${this.identityName}] 改进完成，等待审批 (质量: ${(result.qualityScore! * 10).toFixed(1)}/10)`);
-      }
-    }
-  }
-
-  private async processImprove(task: Task): Promise<ImproveResult> {
-    const llm = getMinimax();
-    const content = await documentReader.read(task.documentPath!);
-    const improvedContent = await llm.improveContent(content.text, task.requirements!, task.context);
-    const qualityScore = llm.estimateQuality(content.text, improvedContent);
-    const shouldAutoSend = await llm.shouldAutoSend(qualityScore, this.autoSendThreshold);
-
-    return {
-      taskId: task.taskId,
-      success: true,
-      originalPath: task.documentPath,
-      improvedContent,
-      qualityScore,
-      shouldAutoSend,
-      needsApproval: !shouldAutoSend
-    };
-  }
-
-  private async processDocument(content: DocumentContent, context?: string): Promise<TaskResult> {
-    const llm = getMinimax();
-    const chunks = documentReader.chunk(content.text);
-    const summaries: string[] = [];
-    let totalQuality = 0;
-
-    for (const chunk of chunks) {
-      const result = await llm.summarize(chunk, context);
-      summaries.push(result.summary);
-      totalQuality += result.qualityScore;
-    }
-
-    const combinedSummary = summaries.join('\n\n');
-    const avgQuality = totalQuality / chunks.length;
-
-    const canAutoSend = await llm.shouldAutoSend(avgQuality, this.autoSendThreshold);
-
-    return {
-      taskId: `task-${Date.now()}`,
-      success: true,
-      result: combinedSummary,
-      qualityScore: avgQuality,
-      needsApproval: !canAutoSend,
-      autoSent: canAutoSend && this.autonomousMode
-    };
-  }
-
-  private async handleResult(message: AgentMessage): Promise<void> {
-    const result = JSON.parse(message.payload) as TaskResult;
-    const task = this.pendingTasks.get(message.taskId);
-
-    if (result.needsApproval && !result.autoSent) {
-      console.log('\n📋 文档处理完成，需要人工确认:');
-      console.log(`   质量评分: ${(result.qualityScore! * 10).toFixed(1)}/10`);
-      console.log(`   摘要预览: ${result.result?.substring(0, 200)}...\n`);
-    } else if (result.autoSent || this.autonomousMode) {
-      console.log('\n✅ 文档处理完成，自动发送汇报');
-      await this.autoReport(result, message.from);
-    }
-  }
-
-  private async handleImproveRequest(message: AgentMessage): Promise<void> {
-    const task = JSON.parse(message.payload) as Task;
-    console.log(`\n📝 [${this.identityName}] 收到改进请求: ${task.documentPath}`);
-    console.log(`   要求: ${task.requirements}`);
-  }
-
-  private async handleImprovedResult(message: AgentMessage): Promise<void> {
-    const result = JSON.parse(message.payload) as ImproveResult;
-    const task = this.pendingTasks.get(message.taskId);
-
-    console.log('\n✨ 改进结果已接收:');
-    console.log(`   原始文档: ${result.originalPath}`);
-    console.log(`   质量评分: ${(result.qualityScore! * 10).toFixed(1)}/10`);
-    console.log(`   自动发送: ${result.shouldAutoSend ? '是' : '否'}`);
-    console.log(`   改进预览: ${result.improvedContent?.substring(0, 200)}...\n`);
-  }
-
-  private async handleFeedback(message: AgentMessage): Promise<void> {
-    const { taskId, improvements } = JSON.parse(message.payload);
-    console.log(`\n📝 [${this.identityName}] 收到改进意见 for task ${taskId}:`, improvements);
-  }
-
-  private async autoReport(result: TaskResult, fromPeer: string): Promise<void> {
-    const reportMsg: AgentMessage = {
-      type: 'report',
-      from: this.peerId,
-      taskId: result.taskId,
-      payload: JSON.stringify({
-        summary: result.result,
-        qualityScore: result.qualityScore,
-        fromAgent: this.identityName
-      }),
-      timestamp: Date.now()
-    };
-
-    const peers = p2pNetwork.getPeers();
-    const failedPeers: string[] = [];
-
-    for (const peer of peers) {
-      if (peer !== fromPeer) {
-        try {
-          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(reportMsg));
-          console.log(`[${this.identityName}] 汇报已发送至 ${peer}`);
-        } catch (sendError) {
-          console.warn(`[${this.identityName}] 发送汇报至 ${peer} 失败: ${sendError}`);
-          failedPeers.push(peer);
-        }
-      }
-    }
-
-    // 重试失败的发送
-    if (failedPeers.length > 0) {
-      console.log(`[${this.identityName}] 尝试重新发送汇报至 ${failedPeers.length} 个失败节点`);
-      await this.retryFailedReports(reportMsg, failedPeers, 2);
-    }
-  }
-
-  private async retryFailedReports(
-    reportMsg: AgentMessage,
-    failedPeers: string[],
-    maxRetries: number
-  ): Promise<void> {
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      if (failedPeers.length === 0) break;
-
-      console.log(`[${this.identityName}] 重试第 ${attempt}/${maxRetries} 次`);
-      await this.sleep(1000 * attempt); // 指数退避
-
-      const stillFailed: string[] = [];
-      for (const peer of failedPeers) {
-        try {
-          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(reportMsg));
-          console.log(`[${this.identityName}] 重试成功: ${peer}`);
-        } catch {
-          stillFailed.push(peer);
-        }
-      }
-      failedPeers = stillFailed;
-    }
-
-    if (failedPeers.length > 0) {
-      console.log(`[${this.identityName}] 最终仍有 ${failedPeers.length} 个节点发送失败，将加入待重试队列`);
-      this.queueFailedReports(reportMsg, failedPeers);
-    }
-  }
-
-  private failedReportsQueue: Array<{ msg: AgentMessage; peers: string[]; timestamp: number }> = [];
-
-  private queueFailedReports(msg: AgentMessage, peers: string[]): void {
-    this.failedReportsQueue.push({
-      msg,
-      peers,
-      timestamp: Date.now()
-    });
-    // 限制队列大小
-    if (this.failedReportsQueue.length > 50) {
-      this.failedReportsQueue = this.failedReportsQueue.slice(-50);
-    }
-  }
-
-  async processFailedReportsQueue(): Promise<void> {
-    if (this.failedReportsQueue.length === 0) return;
-
-    console.log(`[${this.identityName}] 处理待重试汇报队列 (${this.failedReportsQueue.length} 条)`);
-    const processed: number[] = [];
-
-    for (let i = 0; i < this.failedReportsQueue.length; i++) {
-      const item = this.failedReportsQueue[i];
-      const stillFailed: string[] = [];
-
-      for (const peer of item.peers) {
-        try {
-          await p2pNetwork.sendMessage(peer, 'report', JSON.stringify(item.msg));
-          console.log(`[${this.identityName}] 队列重试成功: ${peer}`);
-        } catch {
-          stillFailed.push(peer);
-        }
-      }
-
-      if (stillFailed.length === 0) {
-        processed.push(i);
-      } else {
-        item.peers = stillFailed;
-        item.timestamp = Date.now();
-      }
-    }
-
-    // 移除已成功的
-    for (let i = processed.length - 1; i >= 0; i--) {
-      this.failedReportsQueue.splice(processed[i], 1);
-    }
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  async submitImprovements(taskId: string, improvements: string): Promise<void> {
-    const feedbackMsg: AgentMessage = {
-      type: 'feedback',
-      from: this.peerId,
-      taskId,
-      payload: JSON.stringify({ taskId, improvements }),
-      timestamp: Date.now()
-    };
-
-    const peers = p2pNetwork.getPeers();
-    for (const peer of peers) {
-      await p2pNetwork.sendMessage(peer, 'feedback', JSON.stringify(feedbackMsg));
-    }
-  }
-
-  setAutoSendThreshold(threshold: number): void {
-    this.autoSendThreshold = threshold;
-  }
-
-  setAutonomousMode(enabled: boolean): void {
-    this.autonomousMode = enabled;
-  }
-
-  isAutonomousMode(): boolean {
-    return this.autonomousMode;
-  }
-}