@vibe-forge/mcp 3.1.1 → 3.2.0

package/__tests__/task-tool.spec.ts

@@ -1,378 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { createToolTester } from './mcp-test-utils.js'
-
-const mocks = vi.hoisted(() => {
-  return {
-    callHook: vi.fn(),
-    createChildSession: vi.fn(),
-    getParentSessionId: vi.fn(),
-    startTask: vi.fn(),
-    sendTaskMessage: vi.fn(),
-    submitTaskInput: vi.fn(),
-    respondToTaskInteraction: vi.fn(),
-    getTask: vi.fn(),
-    stopTask: vi.fn(),
-    getAllTasks: vi.fn(),
-    uuid: vi.fn()
-  }
-})
-
-vi.mock('@vibe-forge/hooks', () => ({
-  callHook: mocks.callHook
-}))
-
-vi.mock('@vibe-forge/utils/uuid', () => ({
-  uuid: mocks.uuid
-}))
-
-vi.mock('#~/sync.js', () => ({
-  createChildSession: mocks.createChildSession,
-  getParentSessionId: mocks.getParentSessionId
-}))
-
-vi.mock('#~/tools/task/manager.js', () => ({
-  TaskManager: class {
-    startTask = mocks.startTask
-    sendTaskMessage = mocks.sendTaskMessage
-    submitTaskInput = mocks.submitTaskInput
-    respondToTaskInteraction = mocks.respondToTaskInteraction
-    getTask = mocks.getTask
-    stopTask = mocks.stopTask
-    getAllTasks = mocks.getAllTasks
-  }
-}))
-
-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.sendTaskMessage.mockResolvedValue(undefined)
-    mocks.submitTaskInput.mockResolvedValue(undefined)
-    mocks.respondToTaskInteraction.mockResolvedValue(undefined)
-    mocks.getTask.mockImplementation((taskId: string) => ({
-      taskId,
-      status: 'completed',
-      logs: []
-    }))
-    mocks.stopTask.mockReturnValue(true)
-    mocks.getAllTasks.mockReturnValue([])
-  })
-
-  it('passes resolved task ids to the StartTasks hook', async () => {
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    await tester.callTool('StartTasks', {
-      tasks: [{
-        description: 'only output ok',
-        type: 'default',
-        background: false
-      }]
-    })
-
-    expect(mocks.callHook).toHaveBeenCalledWith(
-      'StartTasks',
-      expect.objectContaining({
-        sessionId: 'sess-1',
-        tasks: [expect.objectContaining({
-          taskId: 'task-1',
-          description: 'only output ok',
-          type: 'default',
-          background: false
-        })]
-      })
-    )
-    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
-      taskId: 'task-1'
-    }))
-  })
-
-  it('accepts workspace tasks without a separate workspace tool', async () => {
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    await tester.callTool('StartTasks', {
-      tasks: [{
-        description: 'fix billing',
-        type: 'workspace',
-        name: 'billing'
-      }]
-    })
-
-    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
-      taskId: 'task-1',
-      description: 'fix billing',
-      type: 'workspace',
-      name: 'billing'
-    }))
-  })
-
-  it('passes explicit task model overrides to the hook and task manager', async () => {
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    await tester.callTool('StartTasks', {
-      tasks: [{
-        description: 'investigate flaky tests',
-        type: 'default',
-        model: 'gpt-5.4-mini'
-      }]
-    })
-
-    expect(mocks.callHook).toHaveBeenCalledWith(
-      'StartTasks',
-      expect.objectContaining({
-        tasks: [expect.objectContaining({
-          taskId: 'task-1',
-          model: 'gpt-5.4-mini'
-        })]
-      })
-    )
-    expect(mocks.startTask).toHaveBeenCalledWith(expect.objectContaining({
-      taskId: 'task-1',
-      model: 'gpt-5.4-mini'
-    }))
-  })
-
-  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('SendTaskMessage')
-    expect(tester.getRegisteredTools()).toContain('SubmitTaskInput')
-    expect(tester.getRegisteredTools()).toContain('RespondTaskInteraction')
-    expect(tester.getToolInfo('StartTasks')?.description).toContain('GetTaskInfo')
-    expect(tester.getToolInfo('StartTasks')?.description).toContain('SendTaskMessage')
-    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('10 most recent logs')
-    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('logOrder')
-    expect(tester.getToolInfo('GetTaskInfo')?.description).toContain('SendTaskMessage')
-    expect(tester.getToolInfo('SendTaskMessage')?.description).toContain('mode "direct"')
-    expect(tester.getToolInfo('SendTaskMessage')?.description).toContain('mode "steer"')
-    expect(tester.getToolInfo('ListTasks')?.description).toContain('10 most recent logs')
-    expect(tester.getToolInfo('ListTasks')?.description).toContain('SendTaskMessage')
-    expect(tester.getToolInfo('ListTasks')?.description).toContain('pendingInput')
-    expect(tester.getToolInfo('SubmitTaskInput')?.description).toContain('SendTaskMessage')
-    expect(tester.getToolInfo('SubmitTaskInput')?.description).toContain('allow_once')
-    expect(tester.getToolInfo('RespondTaskInteraction')?.description).toContain('Deprecated alias')
-  })
-
-  it('returns the 10 most recent logs in descending order by default', async () => {
-    mocks.getTask.mockReturnValue({
-      taskId: 'task-1',
-      status: 'running',
-      logs: Array.from({ length: 12 }, (_, index) => `log-${index + 1}`)
-    })
-
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    const result = await tester.callTool('GetTaskInfo', {
-      taskId: 'task-1'
-    }) as { content: Array<{ text: string }> }
-    const [task] = JSON.parse(result.content[0].text) as Array<{ logs: string[] }>
-
-    expect(task.logs).toEqual([
-      'log-12',
-      'log-11',
-      'log-10',
-      'log-9',
-      'log-8',
-      'log-7',
-      'log-6',
-      'log-5',
-      'log-4',
-      'log-3'
-    ])
-  })
-
-  it('supports custom log windows and ascending order in ListTasks', async () => {
-    mocks.getAllTasks.mockReturnValue([
-      {
-        taskId: 'task-1',
-        status: 'running',
-        logs: ['a', 'b', 'c', 'd']
-      },
-      {
-        taskId: 'task-2',
-        status: 'completed',
-        logs: ['1', '2', '3']
-      }
-    ])
-
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    const result = await tester.callTool('ListTasks', {
-      logLimit: 2,
-      logOrder: 'asc'
-    }) as { content: Array<{ text: string }> }
-    const tasks = JSON.parse(result.content[0].text) as Array<{ taskId: string; logs: string[] }>
-
-    expect(tasks).toEqual([
-      {
-        taskId: 'task-1',
-        status: 'running',
-        logs: ['c', 'd'],
-        guidance: []
-      },
-      {
-        taskId: 'task-2',
-        status: 'completed',
-        logs: ['2', '3'],
-        guidance: []
-      }
-    ])
-  })
-
-  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('forwards SendTaskMessage to the task manager', async () => {
-    mocks.getTask.mockReturnValue({
-      taskId: 'task-1',
-      status: 'running',
-      logs: ['Queued task message (steer): keep checking logs']
-    })
-
-    const { createTaskRegister } = await import('#~/tools/task/index.js')
-
-    const tester = createToolTester()
-    createTaskRegister()(tester.mockRegister)
-
-    await tester.callTool('SendTaskMessage', {
-      taskId: 'task-1',
-      message: 'keep checking logs',
-      mode: 'steer'
-    })
-
-    expect(mocks.sendTaskMessage).toHaveBeenCalledWith({
-      taskId: 'task-1',
-      message: 'keep checking logs',
-      mode: 'steer'
-    })
-  })
-
-  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/src/sync.ts

@@ -1,70 +0,0 @@
-import process from 'node:process'
-
-import type { SessionPermissionMode, WSEvent } from '@vibe-forge/types'
-import { extractTextFromMessage } from '@vibe-forge/utils/chat-message'
-
-const getServerBaseUrl = () => {
-  const host = process.env.__VF_PROJECT_AI_SERVER_HOST__ ?? 'localhost'
-  const port = process.env.__VF_PROJECT_AI_SERVER_PORT__ ?? '8787'
-  return `http://${host}:${port}`
-}
-
-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
-}
-
-export const createChildSession = async (params: {
-  id: string
-  title?: string
-  parentSessionId?: string
-  permissionMode?: SessionPermissionMode
-}) => {
-  const baseUrl = getServerBaseUrl()
-  const response = await fetch(`${baseUrl}/api/sessions`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      id: params.id,
-      title: params.title,
-      parentSessionId: params.parentSessionId,
-      permissionMode: params.permissionMode,
-      start: false
-    })
-  })
-  if (!response.ok) {
-    const errorText = await response.text()
-    throw new Error(`Failed to create session: ${response.statusText} - ${errorText}`)
-  }
-  return response.json()
-}
-
-export const postSessionEvent = async (sessionId: string, payload: Record<string, unknown>) => {
-  const baseUrl = getServerBaseUrl()
-  const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/events`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload)
-  })
-  if (!response.ok) {
-    const errorText = await response.text()
-    throw new Error(`Failed to post session event: ${response.statusText} - ${errorText}`)
-  }
-}
-
-export const fetchSessionMessages = async (sessionId: string) => {
-  const baseUrl = getServerBaseUrl()
-  const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/messages`)
-  if (!response.ok) {
-    const errorText = await response.text()
-    throw new Error(`Failed to fetch session messages: ${response.statusText} - ${errorText}`)
-  }
-  const data = await response.json() as { messages: WSEvent[] }
-  return data.messages ?? []
-}
-
-export { extractTextFromMessage }

package/src/tools/task/index.ts

@@ -1,126 +0,0 @@
-import process from 'node:process'
-
-import { callHook } from '@vibe-forge/hooks'
-import { uuid } from '@vibe-forge/utils/uuid'
-import { z } from 'zod'
-
-import { createChildSession, getParentSessionId } from '#~/sync.js'
-import type { McpManagedTaskInput } from '../../types'
-import { defineRegister } from '../types'
-import { TaskManager } from './manager'
-import {
-  SESSION_PERMISSION_MODES,
-  START_TASKS_DESCRIPTION,
-  TASK_BACKGROUND_DESCRIPTION,
-  TASK_MODEL_DESCRIPTION,
-  TASK_PERMISSION_MODE_DESCRIPTION,
-  resolveInheritedPermissionMode,
-  serializeTaskInfo
-} from './presentation'
-import { registerTaskRuntimeTools } from './register-task-runtime-tools'
-
-export const createTaskRegister = () => {
-  const taskManager = new TaskManager()
-
-  return defineRegister((server) => {
-    server.registerTool(
-      'StartTasks',
-      {
-        title: 'Start Tasks',
-        description: START_TASKS_DESCRIPTION,
-        inputSchema: z.object({
-          tasks: z
-            .array(
-              z.object({
-                description: z
-                  .string()
-                  .describe('The description or prompt for the task'),
-                type: z
-                  .enum([
-                    'default',
-                    'spec',
-                    'entity',
-                    'workspace'
-                  ])
-                  .describe('The type of definition to load (default, spec, entity or workspace)'),
-                name: z
-                  .string()
-                  .describe('The name of the spec or entity to load, if type is spec or entity. Otherwise, ignored.')
-                  .optional(),
-                adapter: z
-                  .string()
-                  .describe('The adapter to use for the task (e.g. claude-code)')
-                  .optional(),
-                model: z
-                  .string()
-                  .describe(TASK_MODEL_DESCRIPTION)
-                  .optional(),
-                permissionMode: z
-                  .enum(SESSION_PERMISSION_MODES)
-                  .describe(TASK_PERMISSION_MODE_DESCRIPTION)
-                  .optional(),
-                background: z
-                  .boolean()
-                  .describe(TASK_BACKGROUND_DESCRIPTION)
-                  .optional()
-              })
-            )
-            .describe('List of tasks to start')
-        })
-      },
-      async ({ tasks }) => {
-        const inheritedPermissionMode = resolveInheritedPermissionMode()
-        const resolvedTasks = tasks.map((task): McpManagedTaskInput & {
-          taskId: string
-          type: NonNullable<McpManagedTaskInput['type']>
-        } => ({
-          ...task,
-          permissionMode: task.permissionMode ?? inheritedPermissionMode,
-          type: task.type ?? 'default',
-          taskId: uuid()
-        }))
-        const parentSessionId = getParentSessionId()
-
-        await callHook('StartTasks', {
-          cwd: process.cwd(),
-          sessionId: process.env.__VF_PROJECT_AI_SESSION_ID__!,
-          tasks: resolvedTasks
-        })
-        const syncResults = parentSessionId
-          ? await Promise.allSettled(resolvedTasks.map(task =>
-            createChildSession({
-              id: task.taskId,
-              title: task.name ?? task.description,
-              parentSessionId,
-              permissionMode: task.permissionMode
-            })
-          ))
-          : []
-        const results = await Promise.allSettled(resolvedTasks
-          .map((task, idx) =>
-            taskManager.startTask({
-              ...task,
-              enableServerSync: parentSessionId != null && syncResults[idx]?.status === 'fulfilled'
-            })
-          ))
-
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(results.map((r, idx) => {
-              const { taskId, description } = resolvedTasks[idx]
-              return serializeTaskInfo({
-                taskId,
-                description,
-                status: r.status === 'rejected' ? 'failed' : 'running',
-                info: taskManager.getTask(taskId)
-              })
-            }))
-          }]
-        }
-      }
-    )
-
-    registerTaskRuntimeTools(server, taskManager)
-  })
-}