第 33 章：添加权限规则

// 文件：src/utils/permissions/PermissionRule.ts
export const permissionBehaviorSchema = z.enum(['allow', 'deny', 'ask'])

// 文件：src/types/permissions.ts
type PermissionRuleValue = {
  toolName: string           // 规则针对的工具名
  ruleContent?: string       // 可选的细粒度匹配内容
}

type PermissionRule = {
  source: PermissionRuleSource  // 规则来源：userSettings、projectSettings、cliArg、session 等
  ruleBehavior: 'allow' | 'deny' | 'ask'
  ruleValue: PermissionRuleValue
}

// 文件：src/utils/permissions/permissionRuleParser.ts
export function permissionRuleValueFromString(ruleString: string): PermissionRuleValue {
  // "Bash" → { toolName: "Bash" }
  // "Bash(npm install)" → { toolName: "Bash", ruleContent: "npm install" }
  // "Bash(git commit -m \"fix\\(bug\\)\")" → { toolName: "Bash", ruleContent: "git commit -m \"fix(bug)\"" }
}

// 文件：src/utils/permissions/permissions.ts
// 步骤 1a：整个工具被 deny 规则拒绝
const denyRule = getDenyRuleForTool(appState.toolPermissionContext, tool)
if (denyRule) {
  return {
    behavior: 'deny',
    decisionReason: { type: 'rule', rule: denyRule },
    message: `Permission to use ${tool.name} has been denied.`,
  }
}

// 步骤 1c：调用工具自身的权限检查
const parsedInput = tool.inputSchema.parse(input)
toolPermissionResult = await tool.checkPermissions(parsedInput, context)

// 步骤 3：默认行为——转成 ask
const result = toolPermissionResult.behavior === 'passthrough'
  ? { ...toolPermissionResult, behavior: 'ask' as const }
  : toolPermissionResult

// 文件：src/Tool.ts
checkPermissions(
  input: z.infer<Input>,
  context: ToolUseContext,
): Promise<PermissionResult>

type PermissionResult =
  | { behavior: 'allow'; updatedInput?: Record<string, unknown> }
  | { behavior: 'deny'; message: string }
  | { behavior: 'ask'; message: string; suggestions?: PermissionUpdate[] }
  | { behavior: 'passthrough'; message: string }

// 文件：src/tools/DBQueryTool/DBQueryTool.ts（checkPermissions 部分）
async checkPermissions(
  input: { query: string },
  context: ToolUseContext,
): Promise<PermissionResult> {
  const sql = input.query.trim().toUpperCase()

  // SELECT 查询——只读操作，自动放行
  if (sql.startsWith('SELECT')) {
    return {
      behavior: 'allow',
      updatedInput: input,
    }
  }

  // DROP 和 DELETE——危险操作，直接拒绝
  if (sql.startsWith('DROP') || sql.startsWith('DELETE')) {
    return {
      behavior: 'deny',
      message: 'Destructive SQL operations are not allowed.',
    }
  }

  // 其他操作——交给用户决定
  return {
    behavior: 'passthrough',
    message: `DBQuery tool requires permission for: ${input.query}`,
  }
}

// 文件：src/utils/permissions/permissions.ts
if (appState.toolPermissionContext.mode === 'auto') {
  // 层级 1：acceptEdits 快速路径
  const acceptEditsResult = await tool.checkPermissions(parsedInput, {
    ...context,
    getAppState: () => ({
      ...context.getAppState(),
      toolPermissionContext: { ...state.toolPermissionContext, mode: 'acceptEdits' },
    }),
  })
  if (acceptEditsResult.behavior === 'allow') {
    return { behavior: 'allow', decisionReason: { type: 'mode', mode: 'auto' } }
  }

  // 层级 2：安全工具白名单
  if (isAutoModeAllowlistedTool(tool.name)) {
    return { behavior: 'allow', decisionReason: { type: 'mode', mode: 'auto' } }
  }

  // 层级 3：运行分类器
  const classifierResult = await classifyYoloAction(...)
  if (classifierResult.shouldBlock) {
    return { behavior: 'deny', message: '...' }
  }
  return { behavior: 'allow' }
}

// 文件：src/utils/permissions/classifierDecision.ts
const SAFE_YOLO_ALLOWLISTED_TOOLS = new Set([
  FILE_READ_TOOL_NAME,
  GREP_TOOL_NAME,
  GLOB_TOOL_NAME,
  LSP_TOOL_NAME,
  TOOL_SEARCH_TOOL_NAME,
  // ... 更多只读工具
])

type PermissionDecisionReason =
  | { type: 'rule'; rule: PermissionRule }          // 命中了某条规则
  | { type: 'mode'; mode: PermissionMode }          // 当前权限模式
  | { type: 'classifier'; classifier: string; reason: string }  // AI 分类器的判断
  | { type: 'hook'; hookName: string }              // Hook 拦截
  | { type: 'safetyCheck' }                         // 安全检查

// TimestampTool 已经这样定义了
isReadOnly() {
  return true
}