@vibe-forge/mcp 0.11.0 → 0.11.1

package/__tests__/sync.spec.ts

@@ -0,0 +1,23 @@
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { getParentSessionId } from '#~/sync.js'
+
+describe('mcp sync helpers', () => {
+  afterEach(() => {
+    delete process.env.__VF_PROJECT_AI_SESSION_ID__
+    delete process.env.__VF_PROJECT_AI_CTX_ID__
+  })
+
+  it('prefers the current session id when resolving the parent session id', () => {
+    process.env.__VF_PROJECT_AI_SESSION_ID__ = 'session-parent'
+    process.env.__VF_PROJECT_AI_CTX_ID__ = 'ctx-parent'
+
+    expect(getParentSessionId()).toBe('session-parent')
+  })
+
+  it('falls back to ctx id when the session id is missing', () => {
+    process.env.__VF_PROJECT_AI_CTX_ID__ = 'ctx-parent'
+
+    expect(getParentSessionId()).toBe('ctx-parent')
+  })
+})

package/__tests__/task-manager.spec.ts

@@ -4,11 +4,16 @@ const mocks = vi.hoisted(() => ({
   run: vi.fn(),
   generateAdapterQueryOptions: vi.fn(),
   callHook: vi.fn(),
+  buildConfigJsonVariables: vi.fn(),
+  loadConfig: vi.fn(),
+  updateConfigFile: vi.fn(),
   loadInjectDefaultSystemPromptValue: vi.fn(),
   mergeSystemPrompts: vi.fn(),
   extractTextFromMessage: vi.fn(),
   postSessionEvent: vi.fn(),
-  fetchSessionMessages: vi.fn()
+  fetchSessionMessages: vi.fn(),
+  mkdir: vi.fn(),
+  writeFile: vi.fn()
 }))
 
 vi.mock('@vibe-forge/task', () => ({
@@ -21,6 +26,9 @@ vi.mock('@vibe-forge/hooks', () => ({
 }))
 
 vi.mock('@vibe-forge/config', () => ({
+  buildConfigJsonVariables: mocks.buildConfigJsonVariables,
+  loadConfig: mocks.loadConfig,
+  updateConfigFile: mocks.updateConfigFile,
   loadInjectDefaultSystemPromptValue: mocks.loadInjectDefaultSystemPromptValue,
   mergeSystemPrompts: mocks.mergeSystemPrompts
 }))
@@ -29,6 +37,11 @@ vi.mock('@vibe-forge/utils/chat-message', () => ({
   extractTextFromMessage: mocks.extractTextFromMessage
 }))
 
+vi.mock('node:fs/promises', () => ({
+  mkdir: mocks.mkdir,
+  writeFile: mocks.writeFile
+}))
+
 vi.mock('#~/sync.js', () => ({
   postSessionEvent: mocks.postSessionEvent,
   fetchSessionMessages: mocks.fetchSessionMessages
@@ -46,12 +59,17 @@ describe('taskManager fatal error scenarios', () => {
         mcpServers: undefined
       }
     ])
+    mocks.buildConfigJsonVariables.mockReturnValue({})
+    mocks.loadConfig.mockResolvedValue([undefined, undefined])
+    mocks.updateConfigFile.mockResolvedValue(undefined)
     mocks.callHook.mockResolvedValue(undefined)
     mocks.loadInjectDefaultSystemPromptValue.mockResolvedValue(true)
     mocks.mergeSystemPrompts.mockReturnValue(undefined)
     mocks.postSessionEvent.mockResolvedValue(undefined)
     mocks.fetchSessionMessages.mockResolvedValue([])
     mocks.extractTextFromMessage.mockReturnValue('')
+    mocks.mkdir.mockResolvedValue(undefined)
+    mocks.writeFile.mockResolvedValue(undefined)
   })
 
   it('keeps the task failed when a fatal error is followed by stop', async () => {
@@ -88,4 +106,304 @@ describe('taskManager fatal error scenarios', () => {
     expect(task?.status).toBe('failed')
     expect(task?.logs).toContain('Incomplete response returned')
   })
+
+  it('surfaces pending interactions in logs and task state', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      const session = {
+        emit: vi.fn(() => {
+          adapterOptions.onEvent({
+            type: 'interaction_request',
+            data: {
+              id: 'interaction-1',
+              payload: {
+                sessionId: 'task-waiting',
+                kind: 'permission',
+                question: 'Allow editing files?',
+                options: [
+                  { label: 'Allow once', value: 'allow_once' },
+                  { label: 'Deny once', value: 'deny_once' }
+                ]
+              }
+            }
+          })
+        }),
+        kill: vi.fn(),
+        respondInteraction: vi.fn()
+      }
+      return { session }
+    })
+
+    const managedTaskManager = new TaskManager()
+    const result = await managedTaskManager.startTask({
+      taskId: 'task-waiting',
+      description: 'trigger',
+      background: false
+    })
+
+    const task = managedTaskManager.getTask('task-waiting')
+    expect(task?.status).toBe('waiting_input')
+    expect(task?.pendingInteraction).toEqual({
+      id: 'interaction-1',
+      payload: expect.objectContaining({
+        question: 'Allow editing files?'
+      }),
+      source: 'adapter'
+    })
+    expect(result.logs).toContain(
+      'Waiting for permission input: Allow editing files? Available responses: allow_once, deny_once.'
+    )
+  })
+
+  it('responds to pending interactions and syncs the response', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    const respondInteraction = vi.fn()
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      const session = {
+        emit: vi.fn(() => {
+          adapterOptions.onEvent({
+            type: 'interaction_request',
+            data: {
+              id: 'interaction-2',
+              payload: {
+                sessionId: 'task-respond',
+                kind: 'permission',
+                question: 'Allow bash?',
+                options: [
+                  { label: 'Allow once', value: 'allow_once' }
+                ]
+              }
+            }
+          })
+        }),
+        kill: vi.fn(),
+        respondInteraction
+      }
+      return { session }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-respond',
+      description: 'trigger',
+      enableServerSync: true
+    })
+
+    await managedTaskManager.respondToTaskInteraction({
+      taskId: 'task-respond',
+      data: 'allow_once'
+    })
+
+    const task = managedTaskManager.getTask('task-respond')
+    expect(respondInteraction).toHaveBeenCalledWith('interaction-2', 'allow_once')
+    expect(task?.status).toBe('running')
+    expect(task?.pendingInteraction).toBeUndefined()
+    expect(task?.logs).toContain('Interaction response submitted: allow_once')
+    expect(mocks.postSessionEvent).toHaveBeenCalledWith('task-respond', {
+      type: 'interaction_response',
+      id: 'interaction-2',
+      data: 'allow_once'
+    })
+  })
+
+  it('builds synthetic permission recovery for claude-code and resumes after SubmitTaskInput', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+    const resumedEmit = vi.fn()
+
+    mocks.run
+      .mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+        const session = {
+          emit: vi.fn(() => {
+            adapterOptions.onEvent({
+              type: 'message',
+              data: {
+                id: 'assistant-tool-use',
+                role: 'assistant',
+                content: [{
+                  type: 'tool_use',
+                  id: 'tool-use-1',
+                  name: 'adapter:claude-code:Write',
+                  input: {
+                    file_path: '/tmp/demo.txt',
+                    content: 'ok'
+                  }
+                }],
+                createdAt: Date.now()
+              }
+            })
+            adapterOptions.onEvent({
+              type: 'error',
+              data: {
+                message: 'Permission required to continue',
+                code: 'permission_required',
+                details: {
+                  toolUseId: 'tool-use-1',
+                  permissionDenials: [{
+                    message: 'Write requires approval',
+                    deniedTools: []
+                  }]
+                },
+                fatal: true
+              }
+            })
+            adapterOptions.onEvent({
+              type: 'exit',
+              data: {
+                exitCode: 1,
+                stderr: 'permission blocked'
+              }
+            })
+          }),
+          kill: vi.fn()
+        }
+        return {
+          session,
+          resolvedAdapter: 'claude-code'
+        }
+      })
+      .mockResolvedValueOnce({
+        session: {
+          emit: resumedEmit,
+          kill: vi.fn()
+        },
+        resolvedAdapter: 'claude-code'
+      })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-claude-recovery',
+      description: 'trigger',
+      adapter: 'claude-code'
+    })
+
+    const waitingTask = managedTaskManager.getTask('task-claude-recovery')
+    expect(waitingTask?.status).toBe('waiting_input')
+    expect(waitingTask?.pendingInteraction).toMatchObject({
+      source: 'permission_recovery',
+      subjectKeys: ['Write'],
+      payload: {
+        question: '当前任务需要使用 Write 才能继续，请选择处理方式。',
+        kind: 'permission',
+        permissionContext: expect.objectContaining({
+          currentMode: undefined,
+          deniedTools: ['Write'],
+          subjectKey: 'Write',
+          subjectLabel: 'Write',
+          projectConfigPath: '.ai.config.json'
+        })
+      }
+    })
+
+    await managedTaskManager.submitTaskInput({
+      taskId: 'task-claude-recovery',
+      data: 'allow_session'
+    })
+
+    const resumedTask = managedTaskManager.getTask('task-claude-recovery')
+    expect(resumedTask?.status).toBe('running')
+    expect(resumedTask?.pendingInteraction).toBeUndefined()
+    expect(resumedTask?.permissionState).toEqual(expect.objectContaining({
+      allow: ['Write']
+    }))
+    expect(resumedTask?.logs).toContain('Permission decision applied: allow_session. Restarting task.')
+    expect(mocks.run).toHaveBeenCalledTimes(2)
+    expect(resumedEmit).toHaveBeenCalledWith({
+      type: 'message',
+      content: [{
+        type: 'text',
+        text: '权限规则已更新。请继续刚才被权限拦截的工作，并重试被阻止的操作。'
+      }]
+    })
+    expect(mocks.writeFile).toHaveBeenCalled()
+  })
+
+  it('stops blocked tasks even after the failed session has already exited', async () => {
+    const { TaskManager } = await import('#~/tools/task/manager.js')
+
+    mocks.run.mockImplementationOnce(async (_options: unknown, adapterOptions: any) => {
+      const session = {
+        emit: vi.fn(() => {
+          adapterOptions.onEvent({
+            type: 'message',
+            data: {
+              id: 'assistant-tool-use-stop',
+              role: 'assistant',
+              content: [{
+                type: 'tool_use',
+                id: 'tool-use-stop-1',
+                name: 'adapter:claude-code:Write',
+                input: {
+                  file_path: '/tmp/demo.txt',
+                  content: 'blocked'
+                }
+              }],
+              createdAt: Date.now()
+            }
+          })
+          adapterOptions.onEvent({
+            type: 'error',
+            data: {
+              message: 'Permission required to continue',
+              code: 'permission_required',
+              details: {
+                toolUseId: 'tool-use-stop-1',
+                permissionDenials: [{
+                  message: 'Write requires approval',
+                  deniedTools: []
+                }]
+              },
+              fatal: true
+            }
+          })
+          adapterOptions.onEvent({
+            type: 'exit',
+            data: {
+              exitCode: 1,
+              stderr: 'permission blocked'
+            }
+          })
+        }),
+        kill: vi.fn()
+      }
+      return {
+        session,
+        resolvedAdapter: 'claude-code'
+      }
+    })
+
+    const managedTaskManager = new TaskManager()
+    await managedTaskManager.startTask({
+      taskId: 'task-stop-waiting',
+      description: 'trigger',
+      adapter: 'claude-code',
+      enableServerSync: true
+    })
+
+    const waitingTask = managedTaskManager.getTask('task-stop-waiting')
+    expect(waitingTask?.status).toBe('waiting_input')
+    expect(waitingTask?.session).toBeUndefined()
+    expect(waitingTask?.pendingInteraction).toBeDefined()
+
+    expect(managedTaskManager.stopTask('task-stop-waiting')).toBe(true)
+    await new Promise(resolve => setTimeout(resolve, 0))
+
+    const stoppedTask = managedTaskManager.getTask('task-stop-waiting')
+    expect(stoppedTask?.status).toBe('failed')
+    expect(stoppedTask?.pendingInteraction).toBeUndefined()
+    expect(stoppedTask?.logs).toContain('Task stopped by user')
+    expect(mocks.postSessionEvent).toHaveBeenCalledWith('task-stop-waiting', {
+      type: 'interaction_response',
+      id: expect.stringContaining('task-recovery:task-stop-waiting:'),
+      data: 'cancel'
+    })
+    expect(mocks.postSessionEvent).toHaveBeenCalledWith('task-stop-waiting', {
+      type: 'error',
+      data: {
+        message: 'Task stopped by user',
+        fatal: true
+      }
+    })
+  })
 })

package/__tests__/task-tool.spec.ts

@@ -8,6 +8,8 @@ const mocks = vi.hoisted(() => {
     createChildSession: vi.fn(),
     getParentSessionId: vi.fn(),
     startTask: vi.fn(),
+    submitTaskInput: vi.fn(),
+    respondToTaskInteraction: vi.fn(),
     getTask: vi.fn(),
     stopTask: vi.fn(),
     getAllTasks: vi.fn(),
@@ -31,6 +33,8 @@ vi.mock('#~/sync.js', () => ({
 vi.mock('#~/tools/task/manager.js', () => ({
   TaskManager: class {
     startTask = mocks.startTask
+    submitTaskInput = mocks.submitTaskInput
+    respondToTaskInteraction = mocks.respondToTaskInteraction
     getTask = mocks.getTask
     stopTask = mocks.stopTask
     getAllTasks = mocks.getAllTasks
@@ -41,11 +45,15 @@ describe('task tool integration', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     process.env.__VF_PROJECT_AI_SESSION_ID__ = 'sess-1'
+    delete process.env.__VF_PROJECT_AI_PERMISSION_MODE__
     let nextTaskId = 1
     mocks.uuid.mockImplementation(() => `task-${nextTaskId++}`)
     mocks.callHook.mockResolvedValue({ continue: true })
     mocks.getParentSessionId.mockReturnValue(undefined)
+    mocks.createChildSession.mockResolvedValue({})
     mocks.startTask.mockResolvedValue(undefined)
+    mocks.submitTaskInput.mockResolvedValue(undefined)
+    mocks.respondToTaskInteraction.mockResolvedValue(undefined)
     mocks.getTask.mockImplementation((taskId: string) => ({
       taskId,
       status: 'completed',
@@ -85,4 +93,126 @@ describe('task tool integration', () => {
       taskId: 'task-1'
     }))
   })
+
+  it('inherits the parent permission mode when the task does not specify one', async () => {
+    process.env.__VF_PROJECT_AI_PERMISSION_MODE__ = 'dontAsk'
+    mocks.getParentSessionId.mockReturnValue('parent-session')
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('StartTasks', {
+      tasks: [{
+        description: 'inherit permissions',
+        type: 'default'
+      }]
+    })
+
+    expect(mocks.callHook).toHaveBeenCalledWith(
+      'StartTasks',
+      expect.objectContaining({
+        tasks: [expect.objectContaining({
+          taskId: 'task-1',
+          permissionMode: 'dontAsk'
+        })]
+      })
+    )
+    expect(mocks.createChildSession).toHaveBeenCalledWith(expect.objectContaining({
+      id: 'task-1',
+      parentSessionId: 'parent-session',
+      permissionMode: 'dontAsk'
+    }))
+    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
+      taskId: 'task-1',
+      permissionMode: 'dontAsk',
+      enableServerSync: true
+    }))
+  })
+
+  it('keeps an explicit task permission mode over the inherited parent mode', async () => {
+    process.env.__VF_PROJECT_AI_PERMISSION_MODE__ = 'dontAsk'
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('StartTasks', {
+      tasks: [{
+        description: 'override permissions',
+        type: 'default',
+        permissionMode: 'plan'
+      }]
+    })
+
+    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
+      taskId: 'task-1',
+      permissionMode: 'plan'
+    }))
+  })
+
+  it('registers recovery guidance in task tool descriptions', async () => {
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    expect(tester.getRegisteredTools()).toContain('SubmitTaskInput')
+    expect(tester.getRegisteredTools()).toContain('RespondTaskInteraction')
+    expect(tester.getToolInfo('StartTasks')?.description).toContain('GetTaskInfo')
+    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('SubmitTaskInput')
+    expect(tester.getToolInfo('ListTasks')?.description).toContain('pendingInput')
+    expect(tester.getToolInfo('SubmitTaskInput')?.description).toContain('allow_once')
+    expect(tester.getToolInfo('RespondTaskInteraction')?.description).toContain('Deprecated alias')
+  })
+
+  it('forwards SubmitTaskInput to the task manager', async () => {
+    mocks.getTask.mockReturnValue({
+      taskId: 'task-1',
+      status: 'running',
+      logs: ['Interaction response submitted: allow_once']
+    })
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('SubmitTaskInput', {
+      taskId: 'task-1',
+      data: 'allow_once'
+    })
+
+    expect(mocks.submitTaskInput).toHaveBeenCalledWith({
+      taskId: 'task-1',
+      interactionId: undefined,
+      data: 'allow_once'
+    })
+  })
+
+  it('keeps RespondTaskInteraction as a deprecated alias', async () => {
+    mocks.getTask.mockReturnValue({
+      taskId: 'task-1',
+      status: 'running',
+      logs: ['Interaction response submitted: allow_once']
+    })
+
+    const { createTaskRegister } = await import('#~/tools/task/index.js')
+
+    const tester = createToolTester()
+    createTaskRegister()(tester.mockRegister)
+
+    await tester.callTool('RespondTaskInteraction', {
+      taskId: 'task-1',
+      response: 'allow_once'
+    })
+
+    expect(mocks.submitTaskInput).toHaveBeenCalledWith({
+      taskId: 'task-1',
+      interactionId: undefined,
+      data: 'allow_once'
+    })
+  })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/mcp",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Vibe Forge MCP server",
   "imports": {
     "#~/*.js": {
@@ -33,13 +33,13 @@
     "@modelcontextprotocol/sdk": "^1.25.3",
     "commander": "^12.1.0",
     "zod": "^3.24.1",
+    "@vibe-forge/hooks": "^0.11.1",
+    "@vibe-forge/config": "^0.11.0",
     "@vibe-forge/cli-helper": "^0.11.0",
+    "@vibe-forge/types": "^0.11.1",
+    "@vibe-forge/utils": "^0.11.1",
     "@vibe-forge/register": "^0.11.0",
-    "@vibe-forge/config": "^0.11.0",
-    "@vibe-forge/hooks": "^0.11.0",
-    "@vibe-forge/task": "^0.11.0",
-    "@vibe-forge/types": "^0.11.0",
-    "@vibe-forge/utils": "^0.11.0"
+    "@vibe-forge/task": "^0.11.2"
   },
   "scripts": {
     "test": "pnpm -C ../.. exec vitest run --workspace vitest.workspace.ts --project bundler packages/mcp/__tests__"

package/src/sync.ts

@@ -1,6 +1,6 @@
 import process from 'node:process'
 
-import type { WSEvent } from '@vibe-forge/types'
+import type { SessionPermissionMode, WSEvent } from '@vibe-forge/types'
 import { extractTextFromMessage } from '@vibe-forge/utils/chat-message'
 
 const getServerBaseUrl = () => {
@@ -10,6 +10,10 @@ const getServerBaseUrl = () => {
 }
 
 export const getParentSessionId = () => {
+  const sessionId = process.env.__VF_PROJECT_AI_SESSION_ID__
+  if (sessionId != null && sessionId !== '') {
+    return sessionId
+  }
   const ctxId = process.env.__VF_PROJECT_AI_CTX_ID__
   return ctxId ?? undefined
 }
@@ -18,6 +22,7 @@ export const createChildSession = async (params: {
   id: string
   title?: string
   parentSessionId?: string
+  permissionMode?: SessionPermissionMode
 }) => {
   const baseUrl = getServerBaseUrl()
   const response = await fetch(`${baseUrl}/api/sessions`, {
@@ -27,6 +32,7 @@ export const createChildSession = async (params: {
       id: params.id,
       title: params.title,
       parentSessionId: params.parentSessionId,
+      permissionMode: params.permissionMode,
       start: false
     })
   })