work-agent 0.1.0

package/lib/secure-bash-tool.ts

@@ -0,0 +1,413 @@
+/**
+ * 安全 Bash 工具
+ *
+ * 扩展默认的 bash 工具，在执行前检查命令是否危险。
+ * 危险命令会被拦截并自动创建工单，而不是直接执行。
+ */
+
+import { createBashTool, type BashSpawnContext, type BashSpawnHook } from '@mariozechner/pi-coding-agent';
+import { checkDangerousCommand, estimateRiskLevel } from './dangerous-commands';
+import { createTicket } from './db';
+import { resolve } from 'path';
+
+/**
+ * 待处理的工单缓存（用于追踪最近创建的工单）
+ */
+const pendingTickets = new Map<string, {
+  ticketId: string;
+  command: string;
+  createdAt: Date;
+}>();
+
+/**
+ * 最近的命令结果缓存
+ */
+const recentResults = new Map<string, {
+  type: 'blocked' | 'executed';
+  command: string;
+  ticketId?: string;
+  output?: string;
+  error?: string;
+}>();
+
+/**
+ * 创建安全的 Bash 工具
+ *
+ * 使用 spawnHook 在命令执行前进行检查：
+ * - 安全命令：正常执行
+ * - API 调用命令：返回错误提示，告诉 AI 使用 create_ticket 工具
+ * - 危险命令：创建工单，返回提示信息
+ * - 本地操作（非管理员）：限制只能执行远程命令
+ *
+ * @param cwd 工作目录
+ * @param userId 用户ID（可选，用于日志）
+ * @param isAdmin 是否管理员（管理员无限制）
+ */
+export function createSecureBashTool(cwd: string, userId?: string, isAdmin: boolean = false) {
+  console.error('[secure-bash] Creating secure bash tool for cwd:', cwd, 'userId:', userId, 'isAdmin:', isAdmin);
+
+  // 创建 spawnHook
+  const spawnHook: BashSpawnHook = (context: BashSpawnContext): BashSpawnContext => {
+    console.error('[secure-bash] ========== spawnHook called! ==========');
+    console.error('[secure-bash] Command:', context.command);
+
+    const { command } = context;
+
+    // 非管理员用户：检查操作范围
+    let skipDangerousCheck = false; // 是否跳过危险命令检查（用于允许目录内的文件操作）
+    
+    if (!isAdmin) {
+      // 远程命令允许执行
+      const isRemote = checkIsRemoteCommand(command);
+      if (isRemote) {
+        console.error('[secure-bash] Remote command allowed for non-admin user');
+        // 继续后续的危险命令检查
+      } else {
+        // 本地命令：检查路径是否在允许目录内
+        const allowedDirs = getAllowedDirectories(userId);
+        const isPathAllowed = areAllPathsAllowed(command, cwd, allowedDirs);
+        
+        if (!isPathAllowed) {
+          console.error('[secure-bash] Local operation outside allowed directories blocked');
+          return {
+            ...context,
+            command: `echo "❌ 本地操作被限制在以下目录内：
+- /tmp
+- /var/tmp  
+- /data/users/{userId}
+
+当前命令涉及不允许的路径。
+
+如需在其他目录执行操作，请使用 create_ticket 工具创建工单。"`,
+          };
+        }
+        
+        // 路径在允许目录内，但删除命令仍需审批
+        if (isDeleteCommand(command)) {
+          console.error('[secure-bash] Delete command in allowed dir still requires approval');
+          // 继续后续的危险命令检查，rm 会被检测为危险命令
+        } else {
+          console.error('[secure-bash] Local operation in allowed directory, skipping dangerous check');
+          // 允许目录内的非删除操作，跳过危险命令检查
+          skipDangerousCheck = true;
+        }
+      }
+    }
+
+    // 检查是否是 API 调用（AI 尝试绕过工具系统）
+    if (isApiCallCommand(command)) {
+      console.error('[secure-bash] API call detected - blocking');
+      return {
+        ...context,
+        command: `echo "❌ 不允许直接调用内部 API
+
+请使用 create_ticket 工具创建工单，而不是通过 curl 调用 API。
+
+示例：
+create_ticket(command=\\"kubectl create namespace my-namespace\\", title=\\"创建命名空间\\")
+
+所有危险操作必须通过工单系统进行审批。"`,
+      };
+    }
+
+    // 如果标记跳过危险检查，直接返回原命令
+    if (skipDangerousCheck) {
+      console.error('[secure-bash] Skipping dangerous command check, executing directly');
+      return context;
+    }
+
+    const result = checkDangerousCommand(command);
+    console.error('[secure-bash] Check result:', JSON.stringify(result));
+
+    if (result.isDangerous && result.rule) {
+      const { riskLevel } = result.rule;
+
+      if (riskLevel === 'medium') {
+        console.log('[secure-bash] MEDIUM risk command - warning but executing');
+        const warningMessage = `⚠️ [警告] 检测到修改操作: ${result.rule.description}
+操作将被记录,请谨慎执行。`;
+
+        return {
+          ...context,
+          command: `echo "${warningMessage.replace(/"/g, '\\"').replace(/\n/g, '\\n')}" && ${command}`,
+        };
+      }
+
+      console.log('[secure-bash] HIGH/CRITICAL command detected! Creating ticket...');
+
+      setTimeout(() => {
+        try {
+          const ticket = createTicket({
+            type: 'bash-execute',
+            title: `执行命令: ${command.substring(0, 50)}${command.length > 50 ? '...' : ''}`,
+            description: `## 命令详情\n\n\`\`\`bash\n${command}\n\`\`\`\n\n**风险等级:** ${result.rule!.riskLevel}\n**规则匹配:** ${result.rule!.description}${result.rule!.category ? `\n**分类:** ${result.rule!.category}` : ''}\n\n---\n\n此工单由系统自动创建，因为检测到危险命令。需要审批后才能执行。`,
+            status: 'pending',
+            priority: result.rule!.riskLevel,
+            command,
+            commandType: detectCommandType(command),
+            riskLevel: result.rule!.riskLevel,
+            affectedResources: extractAffectedResources(command),
+            approvals: [],
+            createdBy: 'ai-assistant',
+            aiGenerated: true,
+          });
+
+          pendingTickets.set(command, {
+            ticketId: ticket.id,
+            command,
+            createdAt: new Date(),
+          });
+
+          recentResults.set(command, {
+            type: 'blocked',
+            command,
+            ticketId: ticket.id,
+          });
+
+          cleanupCache();
+          console.log('[secure-bash] Ticket created:', ticket.id);
+        } catch (error) {
+          console.error('[secure-bash] Failed to create ticket:', error);
+        }
+      }, 0);
+
+      const warningMessage = `⚠️ 此命令需要审批
+
+检测到危险命令: ${result.rule.description}
+风险等级: ${result.rule.riskLevel}
+
+工单正在创建中，请稍后在工单管理界面查看和审批。`;
+
+      return {
+        ...context,
+        command: `echo "${warningMessage.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+      };
+    }
+
+    // 安全命令，正常执行
+    return context;
+  };
+
+  // 创建并返回 bash 工具
+  return createBashTool(cwd, {
+    spawnHook,
+  });
+}
+
+/**
+ * 获取最近创建的工单
+ */
+export function getRecentTicket(command: string): string | undefined {
+  const entry = pendingTickets.get(command);
+  return entry?.ticketId;
+}
+
+/**
+ * 获取命令执行结果
+ */
+export function getCommandResult(command: string) {
+  return recentResults.get(command);
+}
+
+/**
+ * 检查命令是否是 API 调用（AI 尝试绕过工具系统）
+ */
+function isApiCallCommand(command: string): boolean {
+  const lowerCommand = command.toLowerCase();
+
+  // 检查是否是调用 localhost 或 127.0.0.1 的 API
+  const apiPatterns = [
+    /curl\s+.*localhost/i,
+    /curl\s+.*127\.0\.0\.1/i,
+    /curl\s+.*:11024/i,  // 默认端口
+    /curl\s+.*\/api\/tickets/i,
+    /curl\s+.*\/api\/bash/i,
+    /wget\s+.*localhost/i,
+    /wget\s+.*127\.0\.0\.1/i,
+  ];
+
+  return apiPatterns.some(pattern => pattern.test(command));
+}
+
+/**
+ * 清理旧缓存
+ */
+function cleanupCache(): void {
+  const now = Date.now();
+  const maxAge = 5 * 60 * 1000; // 5 分钟
+
+  // 清理 pendingTickets
+  for (const [key, entry] of pendingTickets) {
+    if (now - entry.createdAt.getTime() > maxAge) {
+      pendingTickets.delete(key);
+    }
+  }
+
+  // 清理 recentResults（保持最近 100 条）
+  if (recentResults.size > 100) {
+    const keys = Array.from(recentResults.keys());
+    for (let i = 0; i < keys.length - 100; i++) {
+      recentResults.delete(keys[i]);
+    }
+  }
+}
+
+/**
+ * 检测命令类型
+ */
+function detectCommandType(command: string): string {
+  const trimmed = command.toLowerCase().trim();
+
+  if (trimmed.startsWith('kubectl')) return 'kubectl';
+  if (trimmed.startsWith('docker')) return 'docker';
+  if (trimmed.startsWith('helm')) return 'helm';
+  if (trimmed.startsWith('git')) return 'git';
+  if (trimmed.startsWith('npm') || trimmed.startsWith('yarn')) return 'package-manager';
+  if (trimmed.startsWith('curl') || trimmed.startsWith('wget')) return 'network';
+
+  return 'bash';
+}
+
+/**
+ * 从命令中提取受影响的资源
+ */
+function extractAffectedResources(command: string): string[] | undefined {
+  const resources: string[] = [];
+
+  // 提取 kubectl 资源
+  const kubectlMatch = command.match(/kubectl\s+.*?\s+(\S+)(?:\s+(-n|--namespace)\s+(\S+))?/);
+  if (kubectlMatch) {
+    const resource = kubectlMatch[1];
+    if (!resource.startsWith('-')) {
+      resources.push(resource);
+    }
+  }
+
+  // 提取文件路径
+  const fileMatches = command.match(/(?:^|\s)(\/[\w\/.-]+)/g);
+  if (fileMatches) {
+    for (const match of fileMatches) {
+      const path = match.trim();
+      if (path.length > 1 && !path.startsWith('/dev/')) {
+        resources.push(path);
+      }
+    }
+  }
+
+  return resources.length > 0 ? resources : undefined;
+}
+
+/**
+ * 导出工具类型
+ */
+export type SecureBashTool = ReturnType<typeof createSecureBashTool>;
+
+/**
+ * 获取允许操作的目录列表
+ */
+function getAllowedDirectories(userId?: string): string[] {
+  const allowed = ['/tmp', '/var/tmp'];
+  if (userId) {
+    allowed.push(`/data/users/${userId}`);
+  }
+  return allowed;
+}
+
+/**
+ * 从命令中提取文件路径
+ */
+function extractPathsFromCommand(command: string, cwd: string): string[] {
+  const paths: string[] = [];
+  
+  // 匹配绝对路径: /xxx
+  const absolutePaths = command.match(/(?:^|\s|=)(\/[^\s;|&<>'"]+)/g);
+  if (absolutePaths) {
+    for (const p of absolutePaths) {
+      const cleanPath = p.trim().replace(/^[=:]/, '');
+      if (cleanPath && cleanPath !== '/') {
+        paths.push(cleanPath);
+      }
+    }
+  }
+  
+  // 匹配相对路径: ./xxx, ../xxx, 或文件名
+  const relativePathPattern = /(?:^|\s)((?:\.\.?\/|[^\s/>|&]+\.\w+)(?:[^\s;|&<>'"]*)?)/g;
+  let match;
+  while ((match = relativePathPattern.exec(command)) !== null) {
+    const relativePath = match[1].trim();
+    if (relativePath && !relativePath.startsWith('-') && !relativePath.startsWith('/')) {
+      // 跳过明显的命令参数
+      if (!['true', 'false', 'null', 'undefined'].includes(relativePath)) {
+        paths.push(resolve(cwd, relativePath));
+      }
+    }
+  }
+  
+  // 匹配重定向目标: > xxx, >> xxx
+  const redirectPattern = />>?\s*([^\s;|&]+)/g;
+  while ((match = redirectPattern.exec(command)) !== null) {
+    const target = match[1].trim();
+    if (target && !target.startsWith('/dev/')) {
+      if (target.startsWith('/')) {
+        paths.push(target);
+      } else {
+        paths.push(resolve(cwd, target));
+      }
+    }
+  }
+  
+  // 去重
+  return [...new Set(paths)];
+}
+
+/**
+ * 检查路径是否在允许目录内
+ */
+function isPathAllowed(filePath: string, allowedDirs: string[]): boolean {
+  const normalized = resolve(filePath);
+  return allowedDirs.some(dir => {
+    const normalizedDir = resolve(dir);
+    return normalized === normalizedDir || normalized.startsWith(normalizedDir + '/');
+  });
+}
+
+/**
+ * 检查命令中的所有路径是否都在允许目录内
+ */
+function areAllPathsAllowed(command: string, cwd: string, allowedDirs: string[]): boolean {
+  const paths = extractPathsFromCommand(command, cwd);
+  if (paths.length === 0) {
+    return false; // 没有提取到路径，保守处理
+  }
+  return paths.every(p => isPathAllowed(p, allowedDirs));
+}
+
+/**
+ * 检查是否是删除命令
+ */
+function isDeleteCommand(command: string): boolean {
+  const trimmed = command.trim().toLowerCase();
+  return /^\s*rm\s/.test(trimmed);
+}
+
+/**
+ * 检查是否是远程命令
+ *
+ * 远程命令：kubectl, docker, ssh, sshpass, helm, scp, rsync
+ * 这些命令都是操作远程资源，允许普通用户执行
+ */
+function checkIsRemoteCommand(command: string): boolean {
+  const trimmed = command.trim().toLowerCase();
+  
+  const remotePrefixes = [
+    'kubectl',
+    'docker',
+    'ssh ',
+    'sshpass',
+    'helm',
+    'scp',
+    'rsync',
+  ];
+  
+  return remotePrefixes.some(prefix => trimmed.startsWith(prefix));
+}