@vibe-forge/mcp 0.11.0 → 0.11.1

package/src/tools/task/permission-recovery.ts

@@ -0,0 +1,172 @@
+import type {
+  AdapterErrorData,
+  AskUserQuestionParams,
+  PermissionInteractionContext,
+  PermissionInteractionDecision,
+  SessionPermissionMode
+} from '@vibe-forge/types'
+import { normalizePermissionToolName } from '@vibe-forge/utils'
+import type { PermissionToolSubject } from '@vibe-forge/utils'
+
+export { applyTaskPermissionDecision, syncTaskPermissionStateMirror } from './permission-state'
+
+const PERMISSION_PROJECT_CONFIG_PATH = '.ai.config.json'
+export const PERMISSION_DECISION_CANCEL = 'cancel'
+
+const uniqueStrings = (values: string[]) => [...new Set(values)]
+
+const normalizeKeys = (values: string[]) =>
+  uniqueStrings(
+    values
+      .map((value) => normalizePermissionToolName(value)?.key ?? value.trim())
+      .filter((value): value is string => value.trim() !== '')
+  )
+
+const buildPermissionOption = (
+  label: string,
+  value: PermissionInteractionDecision,
+  description: string
+) => ({ label, value, description })
+
+const resolvePermissionToolSubject = (value: string): PermissionToolSubject | undefined => (
+  normalizePermissionToolName(value)
+)
+
+export interface PermissionErrorContext {
+  subjectKeys: string[]
+  deniedTools: string[]
+  reasons: string[]
+}
+
+export const extractPermissionErrorContext = (error: AdapterErrorData): PermissionErrorContext => {
+  const details = error.details != null && typeof error.details === 'object'
+    ? error.details as Record<string, unknown>
+    : {}
+  const rawDeniedTools = new Set<string>()
+  const reasons = new Set<string>()
+
+  const permissionDenials = Array.isArray(details.permissionDenials) ? details.permissionDenials : []
+  for (const denial of permissionDenials) {
+    if (denial == null || typeof denial !== 'object') continue
+    const record = denial as Record<string, unknown>
+    if (typeof record.message === 'string' && record.message.trim() !== '') {
+      reasons.add(record.message.trim())
+    }
+    if (Array.isArray(record.deniedTools)) {
+      for (const tool of record.deniedTools) {
+        if (typeof tool === 'string' && tool.trim() !== '') {
+          rawDeniedTools.add(tool.trim())
+        }
+      }
+    }
+  }
+
+  if (Array.isArray(details.deniedTools)) {
+    for (const tool of details.deniedTools) {
+      if (typeof tool === 'string' && tool.trim() !== '') {
+        rawDeniedTools.add(tool.trim())
+      }
+    }
+  }
+
+  if (typeof details.toolName === 'string' && details.toolName.trim() !== '') {
+    rawDeniedTools.add(details.toolName.trim())
+  }
+
+  if (typeof error.message === 'string' && error.message.trim() !== '') {
+    reasons.add(error.message.trim())
+  }
+
+  const deniedTools = [...rawDeniedTools]
+  const subjectKeys = uniqueStrings(
+    deniedTools
+      .map(tool => resolvePermissionToolSubject(tool)?.key)
+      .filter((key): key is string => key != null && key.trim() !== '')
+  )
+
+  return {
+    subjectKeys,
+    deniedTools,
+    reasons: [...reasons]
+  }
+}
+
+export const resolvePermissionInteractionDecision = (
+  answer: string | string[]
+): PermissionInteractionDecision | typeof PERMISSION_DECISION_CANCEL | undefined => {
+  const normalizedAnswer = Array.isArray(answer) ? answer[0] : answer
+  if (typeof normalizedAnswer !== 'string') return undefined
+
+  const raw = normalizedAnswer.trim()
+  if (raw === '') return undefined
+  if (raw === PERMISSION_DECISION_CANCEL) return PERMISSION_DECISION_CANCEL
+
+  if (
+    raw === 'allow_once' ||
+    raw === 'allow_session' ||
+    raw === 'allow_project' ||
+    raw === 'deny_once' ||
+    raw === 'deny_session' ||
+    raw === 'deny_project'
+  ) {
+    return raw
+  }
+
+  return undefined
+}
+
+export const buildPermissionRecoveryPayload = (params: {
+  sessionId: string
+  adapter?: string
+  currentMode?: SessionPermissionMode
+  context: PermissionErrorContext
+}): AskUserQuestionParams | undefined => {
+  const subjectKeys = normalizeKeys(params.context.subjectKeys)
+  if (subjectKeys.length === 0) {
+    return undefined
+  }
+
+  const primarySubjectKey = subjectKeys[0] ?? 'UnknownTool'
+  const subjectLabel = subjectKeys.length <= 1
+    ? primarySubjectKey
+    : `${subjectKeys[0]} 等 ${subjectKeys.length} 项工具`
+  const deniedTools = uniqueStrings([
+    ...params.context.deniedTools,
+    ...subjectKeys
+  ])
+  const permissionContext: PermissionInteractionContext = {
+    adapter: params.adapter,
+    currentMode: params.currentMode,
+    deniedTools,
+    reasons: uniqueStrings(params.context.reasons),
+    subjectKey: primarySubjectKey,
+    subjectLabel,
+    scope: 'tool',
+    projectConfigPath: PERMISSION_PROJECT_CONFIG_PATH
+  }
+
+  return {
+    sessionId: params.sessionId,
+    kind: 'permission',
+    question: subjectKeys.length <= 1
+      ? `当前任务需要使用 ${subjectLabel} 才能继续，请选择处理方式。`
+      : `当前任务涉及 ${subjectKeys.join('、')} 等工具，请选择处理方式。`,
+    options: [
+      buildPermissionOption('同意本次', 'allow_once', '仅继续这次被拦截的操作。'),
+      buildPermissionOption('同意并在当前会话忽略类似调用', 'allow_session', '本会话内同类工具不再重复询问。'),
+      buildPermissionOption(
+        '同意并在当前项目忽略类似调用',
+        'allow_project',
+        `写入 ${PERMISSION_PROJECT_CONFIG_PATH}，后续新会话仍生效。`
+      ),
+      buildPermissionOption('拒绝本次', 'deny_once', '拒绝当前这次操作。'),
+      buildPermissionOption('拒绝并在当前会话阻止类似调用', 'deny_session', '本会话内同类工具直接拒绝。'),
+      buildPermissionOption(
+        '拒绝并在当前项目阻止类似调用',
+        'deny_project',
+        `写入 ${PERMISSION_PROJECT_CONFIG_PATH}，后续新会话仍生效。`
+      )
+    ],
+    permissionContext
+  }
+}

package/src/tools/task/permission-state.ts

@@ -0,0 +1,200 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import process from 'node:process'
+
+import { buildConfigJsonVariables, loadConfig, updateConfigFile } from '@vibe-forge/config'
+import type { Config, PermissionInteractionDecision } from '@vibe-forge/types'
+import {
+  normalizePermissionToolName,
+  normalizeSessionPermissionState,
+  resolvePermissionMirrorPath
+} from '@vibe-forge/utils'
+import type { SessionPermissionState } from '@vibe-forge/utils'
+
+const PERMISSION_PROJECT_CONFIG_PATH = '.ai.config.json'
+
+const uniqueStrings = (values: string[]) => [...new Set(values)]
+
+const normalizeKeys = (values: string[]) =>
+  uniqueStrings(
+    values
+      .map((value) => normalizePermissionToolName(value)?.key ?? value.trim())
+      .filter((value): value is string => value.trim() !== '')
+  )
+
+const removeKeys = (values: string[], keys: Set<string>) => (
+  values.filter((value) => {
+    const normalized = normalizePermissionToolName(value)?.key ?? value.trim()
+    return !keys.has(normalized)
+  })
+)
+
+const buildGeneralSectionValue = (config: Config | undefined, permissions: Config['permissions']) => ({
+  baseDir: config?.baseDir,
+  effort: config?.effort,
+  defaultAdapter: config?.defaultAdapter,
+  defaultModelService: config?.defaultModelService,
+  defaultModel: config?.defaultModel,
+  recommendedModels: config?.recommendedModels,
+  interfaceLanguage: config?.interfaceLanguage,
+  modelLanguage: config?.modelLanguage,
+  announcements: config?.announcements,
+  permissions,
+  env: config?.env,
+  notifications: config?.notifications,
+  shortcuts: config?.shortcuts
+})
+
+const mutateSessionPermissionState = (
+  state: SessionPermissionState,
+  keys: string[],
+  action: PermissionInteractionDecision
+): SessionPermissionState => {
+  const targetKeys = normalizeKeys(keys)
+  const keySet = new Set(targetKeys)
+  const next = normalizeSessionPermissionState(state)
+
+  switch (action) {
+    case 'allow_once':
+      next.onceAllow = uniqueStrings([...removeKeys(next.onceAllow, keySet), ...targetKeys])
+      next.onceDeny = removeKeys(next.onceDeny, keySet)
+      return next
+    case 'allow_session':
+      next.allow = uniqueStrings([...removeKeys(next.allow, keySet), ...targetKeys])
+      next.deny = removeKeys(next.deny, keySet)
+      next.onceDeny = removeKeys(next.onceDeny, keySet)
+      next.onceAllow = removeKeys(next.onceAllow, keySet)
+      return next
+    case 'allow_project':
+      next.allow = uniqueStrings([...removeKeys(next.allow, keySet), ...targetKeys])
+      next.deny = removeKeys(next.deny, keySet)
+      next.onceDeny = removeKeys(next.onceDeny, keySet)
+      next.onceAllow = removeKeys(next.onceAllow, keySet)
+      return next
+    case 'deny_once':
+      return next
+    case 'deny_session':
+      next.deny = uniqueStrings([...removeKeys(next.deny, keySet), ...targetKeys])
+      next.allow = removeKeys(next.allow, keySet)
+      next.onceAllow = removeKeys(next.onceAllow, keySet)
+      next.onceDeny = removeKeys(next.onceDeny, keySet)
+      return next
+    case 'deny_project':
+      next.deny = uniqueStrings([...removeKeys(next.deny, keySet), ...targetKeys])
+      next.allow = removeKeys(next.allow, keySet)
+      next.onceAllow = removeKeys(next.onceAllow, keySet)
+      next.onceDeny = removeKeys(next.onceDeny, keySet)
+      return next
+  }
+}
+
+const loadTaskConfig = async (cwd: string) =>
+  await loadConfig({
+    cwd,
+    jsonVariables: buildConfigJsonVariables(cwd, process.env)
+  })
+
+const buildMergedProjectPermissions = async (cwd: string) => {
+  const [projectConfig, userConfig] = await loadTaskConfig(cwd)
+  return {
+    allow: [
+      ...(projectConfig?.permissions?.allow ?? []),
+      ...(userConfig?.permissions?.allow ?? [])
+    ],
+    deny: [
+      ...(projectConfig?.permissions?.deny ?? []),
+      ...(userConfig?.permissions?.deny ?? [])
+    ],
+    ask: [
+      ...(projectConfig?.permissions?.ask ?? []),
+      ...(userConfig?.permissions?.ask ?? [])
+    ]
+  }
+}
+
+const updateProjectPermissionLists = async (
+  cwd: string,
+  keys: string[],
+  target: 'allow' | 'deny'
+) => {
+  const targetKeys = normalizeKeys(keys)
+  const keySet = new Set(targetKeys)
+  const [projectConfig] = await loadTaskConfig(cwd)
+  const existingPermissions = projectConfig?.permissions ?? {}
+  const nextPermissions: Config['permissions'] = {
+    ...existingPermissions,
+    allow: removeKeys(existingPermissions.allow ?? [], keySet),
+    deny: removeKeys(existingPermissions.deny ?? [], keySet),
+    ask: removeKeys(existingPermissions.ask ?? [], keySet)
+  }
+  nextPermissions[target] = uniqueStrings([...(nextPermissions[target] ?? []), ...targetKeys])
+
+  await updateConfigFile({
+    workspaceFolder: cwd,
+    source: 'project',
+    section: 'general',
+    value: buildGeneralSectionValue(projectConfig, nextPermissions)
+  })
+}
+
+export const syncTaskPermissionStateMirror = async (params: {
+  cwd: string
+  adapter?: string
+  sessionId: string
+  permissionState: SessionPermissionState
+}) => {
+  if (params.adapter !== 'claude-code' && params.adapter !== 'opencode') {
+    return
+  }
+
+  const mirrorPath = resolvePermissionMirrorPath(params.cwd, params.adapter, params.sessionId)
+  const projectPermissions = await buildMergedProjectPermissions(params.cwd)
+  await mkdir(dirname(mirrorPath), { recursive: true })
+  await writeFile(
+    mirrorPath,
+    `${
+      JSON.stringify(
+        {
+          sessionId: params.sessionId,
+          adapter: params.adapter,
+          permissionState: normalizeSessionPermissionState(params.permissionState),
+          projectPermissions,
+          updatedAt: Date.now()
+        },
+        null,
+        2
+      )
+    }\n`,
+    'utf8'
+  )
+}
+
+export const applyTaskPermissionDecision = async (params: {
+  cwd: string
+  sessionId: string
+  adapter?: string
+  permissionState: SessionPermissionState
+  subjectKeys: string[]
+  action: PermissionInteractionDecision
+}) => {
+  const subjectKeys = normalizeKeys(params.subjectKeys)
+  if (subjectKeys.length === 0) {
+    return normalizeSessionPermissionState(params.permissionState)
+  }
+
+  if (params.action === 'allow_project') await updateProjectPermissionLists(params.cwd, subjectKeys, 'allow')
+  if (params.action === 'deny_project') await updateProjectPermissionLists(params.cwd, subjectKeys, 'deny')
+
+  const nextState = mutateSessionPermissionState(
+    params.permissionState,
+    subjectKeys,
+    params.action
+  )
+  await syncTaskPermissionStateMirror({
+    cwd: params.cwd,
+    adapter: params.adapter,
+    sessionId: params.sessionId,
+    permissionState: nextState
+  })
+  return nextState
+}

package/src/tools/task/presentation.ts

@@ -0,0 +1,95 @@
+import process from 'node:process'
+
+import type { SessionPermissionMode } from '@vibe-forge/types'
+
+import type { TaskInfo } from './manager'
+
+export const SESSION_PERMISSION_MODES = ['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'] as const
+
+export const START_TASKS_DESCRIPTION =
+  'Start multiple tasks in background or foreground. If a task stalls, fails, or asks for permission/input, call GetTaskInfo. If GetTaskInfo returns pendingInput or pendingInteraction, resolve it with SubmitTaskInput. If logs show permission_required, you can answer the recovery prompt with SubmitTaskInput instead of restarting manually.'
+
+export const GET_TASK_INFO_DESCRIPTION =
+  'Get the detailed status, logs, pendingInput, pendingInteraction, lastError, and guidance for a task. Use this when a task seems stuck, is waiting for permission/input, or has failed. If pendingInput is present, answer it with SubmitTaskInput.'
+
+export const SUBMIT_TASK_INPUT_DESCRIPTION =
+  'Submit input for a task that is blocked waiting for permission or user input. First call GetTaskInfo or ListTasks, then use taskId plus one of pendingInput.payload.options[].value when available. Common permission answers are allow_once, allow_session, allow_project, deny_once, deny_session, or deny_project.'
+
+export const RESPOND_TASK_INTERACTION_DESCRIPTION =
+  'Deprecated alias of SubmitTaskInput. Use SubmitTaskInput for both permission prompts and generic task input.'
+
+export const STOP_TASK_DESCRIPTION =
+  'Stop a running or blocked task. Use this when the task is no longer needed or cannot recover cleanly.'
+
+export const LIST_TASKS_DESCRIPTION =
+  'List all managed tasks with status, pendingInput, pendingInteraction, lastError, and guidance. Use this first to find which tasks are blocked; then call GetTaskInfo for one task or SubmitTaskInput if it is waiting for input.'
+
+export const TASK_PERMISSION_MODE_DESCRIPTION =
+  'Permission mode for the task. If omitted, inherits the parent session. Raise it only when the task is blocked by permission errors.'
+
+export const TASK_BACKGROUND_DESCRIPTION =
+  'Whether to run in background (default: true). If false, waits until the task completes, fails, or becomes blocked waiting for input, then returns the current logs.'
+
+export const resolveInheritedPermissionMode = (): SessionPermissionMode | undefined => {
+  const value = process.env.__VF_PROJECT_AI_PERMISSION_MODE__?.trim()
+  if (value == null || value === '') return undefined
+  return (SESSION_PERMISSION_MODES as readonly string[]).includes(value)
+    ? value as SessionPermissionMode
+    : undefined
+}
+
+const buildTaskGuidance = (task: {
+  status?: string
+  pendingInteraction?: { payload?: { options?: Array<{ label: string; value?: string }> } }
+  lastError?: { code?: string }
+}) => {
+  const hints: string[] = []
+
+  if (task.pendingInteraction != null) {
+    const optionValues = task.pendingInteraction.payload?.options
+      ?.map(option => option.value ?? option.label)
+      .filter((value): value is string => value.trim() !== '')
+    hints.push(
+      optionValues != null && optionValues.length > 0
+        ? `Task is waiting for input. Call SubmitTaskInput with one of: ${optionValues.join(', ')}.`
+        : 'Task is waiting for input. Call SubmitTaskInput with the desired answer.'
+    )
+  }
+
+  if (task.lastError?.code === 'permission_required') {
+    hints.push(
+      'Task hit a permission error. Retry StartTasks with a more suitable permissionMode, or update project permissions before retrying.'
+    )
+  }
+
+  if (task.status === 'failed' && hints.length === 0) {
+    hints.push('Task failed. Inspect logs and lastError, then restart the task if needed.')
+  }
+
+  return hints
+}
+
+export const serializeTaskInfo = (params: {
+  taskId: string
+  description?: string
+  status?: TaskInfo['status']
+  info?: TaskInfo
+}) => {
+  const info = params.info
+  const safeInfo = (() => {
+    if (info == null) {
+      return undefined
+    }
+    const { session, onStop, serverSync, createdAt, ...rest } = info
+    return rest
+  })()
+  return {
+    taskId: params.taskId,
+    description: params.description ?? info?.description,
+    status: info?.status ?? params.status,
+    logs: info?.logs ?? [],
+    pendingInput: safeInfo?.pendingInteraction,
+    ...safeInfo,
+    guidance: buildTaskGuidance(safeInfo ?? {})
+  }
+}

package/src/tools/task/register-task-runtime-tools.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod'
+
+import type { Register } from '../types'
+import type { TaskManager } from './manager'
+import {
+  GET_TASK_INFO_DESCRIPTION,
+  LIST_TASKS_DESCRIPTION,
+  RESPOND_TASK_INTERACTION_DESCRIPTION,
+  STOP_TASK_DESCRIPTION,
+  SUBMIT_TASK_INPUT_DESCRIPTION,
+  serializeTaskInfo
+} from './presentation'
+
+export const registerTaskRuntimeTools = (
+  server: Parameters<Register>[0],
+  taskManager: TaskManager
+) => {
+  server.registerTool(
+    'GetTaskInfo',
+    {
+      title: 'Get Task Info',
+      description: GET_TASK_INFO_DESCRIPTION,
+      inputSchema: z.object({
+        taskId: z.string().describe('The ID of the task to check')
+      })
+    },
+    async ({ taskId }) => {
+      const task = taskManager.getTask(taskId)
+      if (!task) {
+        return {
+          content: [{ type: 'text', text: `Task ${taskId} not found.` }],
+          isError: true
+        }
+      }
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+        }]
+      }
+    }
+  )
+
+  server.registerTool(
+    'SubmitTaskInput',
+    {
+      title: 'Submit Task Input',
+      description: SUBMIT_TASK_INPUT_DESCRIPTION,
+      inputSchema: z.object({
+        taskId: z.string().describe('The ID of the task that is waiting for input'),
+        interactionId: z
+          .string()
+          .describe('Optional interaction ID. Omit it when the task only has one pending input.')
+          .optional(),
+        data: z
+          .union([z.string(), z.array(z.string()).min(1)])
+          .describe('The input to submit. Prefer pendingInput.payload.options[].value when available.')
+      })
+    },
+    async ({ taskId, interactionId, data }) => {
+      await taskManager.submitTaskInput({
+        taskId,
+        interactionId,
+        data
+      })
+      const task = taskManager.getTask(taskId)
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+        }]
+      }
+    }
+  )
+
+  server.registerTool(
+    'RespondTaskInteraction',
+    {
+      title: 'Respond Task Interaction',
+      description: RESPOND_TASK_INTERACTION_DESCRIPTION,
+      inputSchema: z.object({
+        taskId: z.string().describe('The ID of the task that is waiting for input'),
+        interactionId: z
+          .string()
+          .describe('Optional interaction ID. Omit it when the task only has one pending interaction.')
+          .optional(),
+        response: z
+          .union([z.string(), z.array(z.string()).min(1)])
+          .describe('The selected answer. Prefer pendingInteraction.options[].value when available.')
+      })
+    },
+    async ({ taskId, interactionId, response }) => {
+      await taskManager.submitTaskInput({
+        taskId,
+        interactionId,
+        data: response
+      })
+      const task = taskManager.getTask(taskId)
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify([serializeTaskInfo({ taskId, info: task })])
+        }]
+      }
+    }
+  )
+
+  server.registerTool(
+    'StopTask',
+    {
+      title: 'Stop Task',
+      description: STOP_TASK_DESCRIPTION,
+      inputSchema: z.object({
+        taskId: z.string().describe('The ID of the task to stop')
+      })
+    },
+    async ({ taskId }) => {
+      const success = taskManager.stopTask(taskId)
+      return {
+        content: [{
+          type: 'text',
+          text: success ? `Task ${taskId} stopped.` : `Failed to stop task ${taskId} (not found or already stopped).`
+        }]
+      }
+    }
+  )
+
+  server.registerTool(
+    'ListTasks',
+    {
+      title: 'List Tasks',
+      description: LIST_TASKS_DESCRIPTION,
+      inputSchema: z.object({})
+    },
+    async () => {
+      const tasks = taskManager.getAllTasks()
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(tasks.map(task => serializeTaskInfo({ taskId: task.taskId, info: task })))
+        }]
+      }
+    }
+  )
+}