opencastle 0.27.0 → 0.27.2

package/src/cli/run/adapters/cursor.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync, readFileSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Task } from '../../types.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTask(): Task {
+  return {
+    id: 'test-task',
+    agent: 'developer',
+    prompt: 'Do something',
+    files: [],
+    timeout: '5m',
+    depends_on: [],
+    description: 'test task',
+    max_retries: 0,
+  } as unknown as Task
+}
+
+function makeMockProc(exitCode = 0, stdoutData = '{"result":"ok"}') {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter
+    stderr: EventEmitter
+    killed: boolean
+    kill: ReturnType<typeof vi.fn>
+  }
+  proc.stdout = new EventEmitter()
+  proc.stderr = new EventEmitter()
+  proc.killed = false
+  proc.kill = vi.fn()
+  process.nextTick(() => {
+    if (stdoutData) proc.stdout.emit('data', Buffer.from(stdoutData))
+    proc.emit('close', exitCode)
+  })
+  return proc
+}
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('cursor adapter — MCP support', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cursor-test-')))
+
+    mockSpawn = vi.fn().mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"ok"}')
+    })
+    vi.doMock('node:child_process', () => ({ spawn: mockSpawn }))
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  })
+
+  it('writes mcp.json to cwd with correct format when mcpServers provided', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) {
+        capturedContent = readFileSync(mcpPath, 'utf8')
+      }
+      return makeMockProc(0, '{}')
+    })
+
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    expect(capturedContent).not.toBeNull()
+    expect(JSON.parse(capturedContent!)).toEqual({
+      mcpServers: { 'my-mcp': { command: 'node', args: ['server.js'] } },
+    })
+  })
+
+  it('passes --approve-mcps when mcp_approve_all is true', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+  })
+
+  it('cleans up mcp.json after successful execution', async () => {
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('cleans up mcp.json after failed execution (non-zero exit)', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(1, '')
+    })
+    const { execute } = await import('./cursor.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT add --approve-mcps when mcp_approve_all is not set', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).not.toContain('--approve-mcps')
+  })
+
+  it('includes --approve-mcps when mcp_approve_all is true (no mcpServers)', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./cursor.js')
+    await execute(makeTask(), { mcp_approve_all: true, cwd: tmpDir })
+    expect(capturedArgs).toContain('--approve-mcps')
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+})

package/src/cli/run/adapters/cursor.ts

@@ -1,9 +1,12 @@
 import { spawn } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
 import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
 
 /** Adapter name */
 export const name = 'cursor'
 
+export function supportsSessionContinuity(): boolean { return false }
 /**
  * Check if the Cursor CLI (`agent`) is available on the system PATH.
  */
@@ -33,11 +36,34 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     'json',
   ]
 
-  return new Promise((resolve) => {
+  const cwd = options?.cwd ?? process.cwd()
+  const mcpJsonPath = join(cwd, 'mcp.json')
+  let wroteJson = false
+
+  if (options.mcpServers?.length) {
+    const mcpJson: Record<string, Record<string, unknown>> = {}
+    for (const server of options.mcpServers) {
+      const entry: Record<string, unknown> = {}
+      if (server.command) entry.command = server.command
+      if (server.args) entry.args = server.args
+      if (server.url) entry.url = server.url
+      if (server.config) Object.assign(entry, server.config)
+      mcpJson[server.name] = entry
+    }
+    writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: mcpJson }, null, 2), 'utf8')
+    wroteJson = true
+  }
+
+  if (options.mcp_approve_all) {
+    args.push('--approve-mcps')
+  }
+
+  try {
+  return await new Promise<ExecuteResult>((resolve) => {
     const proc = spawn('agent', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: options?.cwd ?? process.cwd(),
+      cwd,
     })
 
     let stdout = ''
@@ -89,6 +115,11 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     // Store process ref for potential timeout kill
     task._process = proc
   })
+  } finally {
+    if (wroteJson) {
+      try { unlinkSync(mcpJsonPath) } catch { /* ignore */ }
+    }
+  }
 }
 
 /**

package/src/cli/run/adapters/opencode.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync, readFileSync, realpathSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { EventEmitter } from 'node:events'
+import type { Task } from '../../types.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTask(): Task {
+  return {
+    id: 'test-task',
+    agent: 'developer',
+    prompt: 'Do something',
+    files: [],
+    timeout: '5m',
+    depends_on: [],
+    description: 'test task',
+    max_retries: 0,
+  } as unknown as Task
+}
+
+function makeMockProc(exitCode = 0, stdoutData = '{"result":"ok"}') {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: EventEmitter
+    stderr: EventEmitter
+    killed: boolean
+    kill: ReturnType<typeof vi.fn>
+  }
+  proc.stdout = new EventEmitter()
+  proc.stderr = new EventEmitter()
+  proc.killed = false
+  proc.kill = vi.fn()
+  process.nextTick(() => {
+    if (stdoutData) proc.stdout.emit('data', Buffer.from(stdoutData))
+    proc.emit('close', exitCode)
+  })
+  return proc
+}
+
+// ── CLI mode ──────────────────────────────────────────────────────────────────
+
+describe('opencode adapter — MCP support', () => {
+  let tmpDir: string
+  let mockSpawn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.resetModules()
+    tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'opencode-test-')))
+
+    mockSpawn = vi.fn().mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"ok"}')
+    })
+    vi.doMock('node:child_process', () => ({ spawn: mockSpawn }))
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  })
+
+  it('writes mcp.json to cwd with correct format when mcpServers provided', async () => {
+    let capturedContent: string | null = null
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      const mcpPath = join(tmpDir, 'mcp.json')
+      if (existsSync(mcpPath)) {
+        capturedContent = readFileSync(mcpPath, 'utf8')
+      }
+      return makeMockProc(0, '{}')
+    })
+
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    expect(capturedContent).not.toBeNull()
+    expect(JSON.parse(capturedContent!)).toEqual({
+      mcpServers: { 'my-mcp': { command: 'node', args: ['server.js'] } },
+    })
+  })
+
+  it('passes --mcp-config flag pointing to mcp.json path', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+
+    const idx = capturedArgs.indexOf('--mcp-config')
+    expect(idx).toBeGreaterThanOrEqual(0)
+    expect(capturedArgs[idx + 1]).toBe(join(tmpDir, 'mcp.json'))
+  })
+
+  it('cleans up mcp.json after successful execution', async () => {
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'my-mcp', type: 'local', command: 'node', args: ['server.js'] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('cleans up mcp.json after failed execution (non-zero exit)', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(1, '')
+    })
+    const { execute } = await import('./opencode.js')
+    const mcpServers = [{ name: 'err-mcp', type: 'local', command: 'node', args: [] }]
+    await execute(makeTask(), { mcpServers, cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT write mcp.json when mcpServers not configured', async () => {
+    const { execute } = await import('./opencode.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
+  })
+
+  it('does NOT add --mcp-config when mcpServers not provided', async () => {
+    const capturedArgs: string[] = []
+    mockSpawn.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      capturedArgs.push(...args)
+      return makeMockProc(0, '{}')
+    })
+    const { execute } = await import('./opencode.js')
+    await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).not.toContain('--mcp-config')
+  })
+})

package/src/cli/run/adapters/opencode.ts

@@ -1,9 +1,12 @@
 import { spawn } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
 import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
 
 /** Adapter name */
 export const name = 'opencode'
 
+export function supportsSessionContinuity(): boolean { return false }
 /**
  * Check if the `opencode` CLI is available on the system PATH.
  */
@@ -27,11 +30,31 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
 
   const args = ['--headless', '-p', prompt]
 
-  return new Promise((resolve) => {
+  const cwd = options?.cwd ?? process.cwd()
+  const mcpJsonPath = join(cwd, 'mcp.json')
+  let wroteJson = false
+
+  if (options.mcpServers?.length) {
+    const mcpJson: Record<string, Record<string, unknown>> = {}
+    for (const server of options.mcpServers) {
+      const entry: Record<string, unknown> = {}
+      if (server.command) entry.command = server.command
+      if (server.args) entry.args = server.args
+      if (server.url) entry.url = server.url
+      if (server.config) Object.assign(entry, server.config)
+      mcpJson[server.name] = entry
+    }
+    writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: mcpJson }, null, 2), 'utf8')
+    args.push('--mcp-config', mcpJsonPath)
+    wroteJson = true
+  }
+
+  try {
+  return await new Promise<ExecuteResult>((resolve) => {
     const proc = spawn('opencode', args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env },
-      cwd: options?.cwd ?? process.cwd(),
+      cwd,
     })
 
     let stdout = ''
@@ -83,6 +106,11 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     // Store process ref for potential timeout kill
     task._process = proc
   })
+  } finally {
+    if (wroteJson) {
+      try { unlinkSync(mcpJsonPath) } catch { /* ignore */ }
+    }
+  }
 }
 
 /**

package/src/cli/run/executor.ts

@@ -190,7 +190,7 @@ export function createExecutor(
       reporter.onPhaseStart(phaseIdx + 1, eligible)
 
       // Process eligible tasks in batches limited by concurrency
-      const concurrency = spec.concurrency
+      const concurrency = spec.concurrency === 'auto' ? eligible.length : spec.concurrency
       for (let i = 0; i < eligible.length; i += concurrency) {
         if (halted) break
         const batch = eligible.slice(i, i + concurrency)