opencastle 0.16.0 → 0.17.0

package/src/cli/convoy/health.test.ts

@@ -63,6 +63,7 @@ function makeTask(
     phase: 0,
     prompt: 'Do something',
     agent: 'developer',
+    adapter: null,
     model: null,
     timeout_ms: 60_000,
     status: 'running' as const,

package/src/cli/convoy/store.test.ts

@@ -43,6 +43,7 @@ function makeTask(overrides: Partial<Parameters<ConvoyStore['insertTask']>[0]> =
     phase: 0,
     prompt: 'Do something',
     agent: 'developer',
+    adapter: null as string | null,
     model: null,
     timeout_ms: 1_800_000,
     status: 'pending' as const,
@@ -83,11 +84,11 @@ describe('DB creation', () => {
     expect(row.journal_mode).toBe('wal')
   })
 
-  it('sets schema version to 1', () => {
+  it('sets schema version to 2', () => {
     const db = new DatabaseSync(dbPath)
     const row = db.prepare('PRAGMA user_version').get() as { user_version: number }
     db.close()
-    expect(row.user_version).toBe(1)
+    expect(row.user_version).toBe(2)
   })
 
   it('creates all required tables', () => {
@@ -112,7 +113,86 @@ describe('DB creation', () => {
     store2.close()
     // Reassign so afterEach does not double-close
     store = createConvoyStore(dbPath)
-    expect(row.user_version).toBe(1)
+    expect(row.user_version).toBe(2)
+  })
+})
+
+// ── schema migration ─────────────────────────────────────────────────────────
+
+describe('schema migration', () => {
+  it('schema migration v1 to v2 adds adapter column', () => {
+    // Create a v1 database manually: task table without adapter column
+    const v1DbPath = join(tmpDir, 'v1.db')
+    const rawDb = new DatabaseSync(v1DbPath)
+    rawDb.exec(`
+      CREATE TABLE convoy (
+        id          TEXT PRIMARY KEY,
+        name        TEXT NOT NULL,
+        spec_hash   TEXT NOT NULL,
+        status      TEXT NOT NULL DEFAULT 'pending',
+        branch      TEXT,
+        created_at  TEXT NOT NULL,
+        started_at  TEXT,
+        finished_at TEXT,
+        spec_yaml   TEXT NOT NULL
+      );
+      CREATE TABLE task (
+        id          TEXT PRIMARY KEY,
+        convoy_id   TEXT NOT NULL REFERENCES convoy(id),
+        phase       INTEGER NOT NULL,
+        prompt      TEXT NOT NULL,
+        agent       TEXT NOT NULL DEFAULT 'developer',
+        model       TEXT,
+        timeout_ms  INTEGER NOT NULL DEFAULT 1800000,
+        status      TEXT NOT NULL DEFAULT 'pending',
+        worker_id   TEXT,
+        worktree    TEXT,
+        output      TEXT,
+        exit_code   INTEGER,
+        started_at  TEXT,
+        finished_at TEXT,
+        retries     INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 1,
+        files       TEXT,
+        depends_on  TEXT
+      );
+      CREATE TABLE worker (
+        id             TEXT PRIMARY KEY,
+        task_id        TEXT REFERENCES task(id),
+        adapter        TEXT NOT NULL,
+        pid            INTEGER,
+        session_id     TEXT,
+        status         TEXT NOT NULL DEFAULT 'spawned',
+        worktree       TEXT,
+        created_at     TEXT NOT NULL,
+        finished_at    TEXT,
+        last_heartbeat TEXT
+      );
+      CREATE TABLE event (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        convoy_id  TEXT REFERENCES convoy(id),
+        task_id    TEXT,
+        worker_id  TEXT,
+        type       TEXT NOT NULL,
+        data       TEXT,
+        created_at TEXT NOT NULL
+      );
+    `)
+    rawDb.exec('PRAGMA user_version = 1')
+    rawDb.close()
+
+    // Open with createConvoyStore — should apply the v1→v2 migration
+    const v1Store = createConvoyStore(v1DbPath)
+    v1Store.close()
+
+    // Verify adapter column was added to task table
+    const verifyDb = new DatabaseSync(v1DbPath)
+    const cols = verifyDb.prepare('PRAGMA table_info(task)').all() as Array<{ name: string }>
+    const version = verifyDb.prepare('PRAGMA user_version').get() as { user_version: number }
+    verifyDb.close()
+
+    expect(cols.map(c => c.name)).toContain('adapter')
+    expect(version.user_version).toBe(2)
   })
 })
 
@@ -182,6 +262,12 @@ describe('task CRUD', () => {
     expect(store.getTask('does-not-exist', 'convoy-1')).toBeUndefined()
   })
 
+  it('insertTask stores adapter field', () => {
+    store.insertTask(makeTask({ adapter: 'opencode' }))
+    const retrieved = store.getTask('task-1', 'convoy-1')!
+    expect(retrieved.adapter).toBe('opencode')
+  })
+
   it('stores JSON fields as strings', () => {
     const task = makeTask({
       id: 'task-json',

package/src/cli/convoy/store.ts

@@ -9,7 +9,7 @@ import type {
   EventRecord,
 } from './types.js'
 
-const SCHEMA_VERSION = 1
+const SCHEMA_VERSION = 2
 
 export interface ConvoyStore {
   insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at'>): void
@@ -82,6 +82,7 @@ class ConvoyStoreImpl implements ConvoyStore {
           phase       INTEGER NOT NULL,
           prompt      TEXT NOT NULL,
           agent       TEXT NOT NULL DEFAULT 'developer',
+          adapter     TEXT,
           model       TEXT,
           timeout_ms  INTEGER NOT NULL DEFAULT 1800000,
           status      TEXT NOT NULL DEFAULT 'pending',
@@ -122,6 +123,10 @@ class ConvoyStoreImpl implements ConvoyStore {
       `)
       this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`)
     }
+    if (row.user_version === 1) {
+      this.db.exec('ALTER TABLE task ADD COLUMN adapter TEXT')
+      this.db.exec('PRAGMA user_version = 2')
+    }
   }
 
   insertConvoy(record: Omit<ConvoyRecord, 'started_at' | 'finished_at'>): void {
@@ -174,11 +179,11 @@ class ConvoyStoreImpl implements ConvoyStore {
     this.db
       .prepare(
         `INSERT INTO task
-           (id, convoy_id, phase, prompt, agent, model, timeout_ms, status,
+           (id, convoy_id, phase, prompt, agent, adapter, model, timeout_ms, status,
             worker_id, worktree, output, exit_code, started_at, finished_at,
             retries, max_retries, files, depends_on)
          VALUES
-           (:id, :convoy_id, :phase, :prompt, :agent, :model, :timeout_ms, :status,
+           (:id, :convoy_id, :phase, :prompt, :agent, :adapter, :model, :timeout_ms, :status,
             NULL, NULL, NULL, NULL, NULL, NULL,
             :retries, :max_retries, :files, :depends_on)`,
       )

package/src/cli/convoy/types.ts

@@ -29,6 +29,7 @@ export interface TaskRecord {
   phase: number
   prompt: string
   agent: string
+  adapter: string | null
   model: string | null
   timeout_ms: number
   status: ConvoyTaskStatus

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

@@ -7,6 +7,7 @@ const ADAPTERS: Record<string, () => Promise<AgentAdapter>> = {
   'claude-code': () => import('./claude-code.js') as Promise<AgentAdapter>,
   copilot: () => import('./copilot.js') as Promise<AgentAdapter>,
   cursor: () => import('./cursor.js') as Promise<AgentAdapter>,
+  opencode: () => import('./opencode.js') as Promise<AgentAdapter>,
 }
 
 /**
@@ -28,7 +29,7 @@ export async function getAdapter(name: string): Promise<AgentAdapter> {
  * Detection priority order — checked first-to-last.
  * The first available adapter wins.
  */
-const DETECTION_ORDER = ['copilot', 'claude-code', 'cursor'] as const
+const DETECTION_ORDER = ['copilot', 'claude-code', 'cursor', 'opencode'] as const
 
 /**
  * Auto-detect which adapter CLI is available on the system.

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

@@ -0,0 +1,88 @@
+import { spawn } from 'node:child_process'
+import type { Task, ExecuteOptions, ExecuteResult } from '../../types.js'
+
+/** Adapter name */
+export const name = 'opencode'
+
+/**
+ * Check if the `opencode` CLI is available on the system PATH.
+ */
+export async function isAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['opencode'], { stdio: 'pipe' })
+    proc.on('close', (code) => resolve(code === 0))
+    proc.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * Execute a task by invoking the OpenCode CLI in headless mode.
+ */
+export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+
+  const args = ['--headless', '-p', prompt]
+
+  return new Promise((resolve) => {
+    const proc = spawn('opencode', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: options?.cwd ?? process.cwd(),
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+      if (options.verbose) {
+        process.stdout.write(chunk)
+      }
+    })
+
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      if (options.verbose) {
+        process.stderr.write(chunk)
+      }
+    })
+
+    proc.on('close', (code) => {
+      const output = [stdout, stderr].filter(Boolean).join('\n')
+      resolve({
+        success: code === 0,
+        output: output.slice(0, 10000), // Cap output size
+        exitCode: code ?? -1,
+      })
+    })
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: `Failed to spawn opencode: ${err.message}`,
+        exitCode: -1,
+      })
+    })
+
+    // Store process ref for potential timeout kill
+    task._process = proc
+  })
+}
+
+/**
+ * Kill the process associated with a task (used by timeout enforcement).
+ */
+export function kill(task: Task): void {
+  if (task._process && !task._process.killed) {
+    task._process.kill('SIGTERM')
+    setTimeout(() => {
+      if (task._process && !task._process.killed) {
+        task._process.kill('SIGKILL')
+      }
+    }, 5000)
+  }
+}

package/src/cli/run/schema.test.ts

@@ -529,6 +529,27 @@ describe('validateSpec — branch field', () => {
   })
 })
 
+// ── validateSpec — per-task adapter ──────────────────────────
+
+describe('validateSpec — per-task adapter', () => {
+  it('task.adapter must be a string', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', adapter: 123 }],
+    })
+    expect(result.valid).toBe(false)
+    expect(result.errors).toContainEqual(expect.stringContaining('adapter'))
+  })
+
+  it('task.adapter accepts valid string', () => {
+    const result = validateSpec({
+      name: 'test',
+      tasks: [{ id: 'a', prompt: 'x', adapter: 'opencode' }],
+    })
+    expect(result.valid).toBe(true)
+  })
+})
+
 // ── validateSpec — per-task model and max_retries ──────────────
 
 describe('validateSpec — per-task model and max_retries', () => {
@@ -721,6 +742,35 @@ describe('applyDefaults — convoy spec (version: 1)', () => {
     expect(spec.gates).toEqual(['npm test'])
     expect(spec.branch).toBe('feat/convoy')
   })
+
+  it('applies defaults.adapter to tasks without explicit adapter', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      version: 1,
+      defaults: { adapter: 'opencode' },
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.tasks![0].adapter).toBe('opencode')
+  })
+
+  it('task-level adapter overrides defaults.adapter', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      version: 1,
+      defaults: { adapter: 'opencode' },
+      tasks: [{ id: 'a', prompt: 'x', adapter: 'claude-code' }],
+    })
+    expect(spec.tasks![0].adapter).toBe('claude-code')
+  })
+
+  it('tasks without adapter remain undefined when no defaults', () => {
+    const spec = applyDefaults({
+      name: 'test',
+      version: 1,
+      tasks: [{ id: 'a', prompt: 'x' }],
+    })
+    expect(spec.tasks![0].adapter).toBeUndefined()
+  })
 })
 
 // ── applyDefaults — max_retries default always applied ─────────

package/src/cli/run/schema.ts

@@ -55,6 +55,7 @@ interface RawTask {
   description?: unknown
   model?: unknown
   max_retries?: unknown
+  adapter?: unknown
 }
 
 /**
@@ -126,6 +127,9 @@ export function validateSpec(spec: unknown): ValidationResult {
       if (d.agent !== undefined && typeof d.agent !== 'string') {
         errors.push('`defaults.agent` must be a string')
       }
+      if (d.adapter !== undefined && typeof d.adapter !== 'string') {
+        errors.push('`defaults.adapter` must be a string')
+      }
     }
   }
 
@@ -219,6 +223,11 @@ export function validateSpec(spec: unknown): ValidationResult {
         )
       }
     }
+
+    // adapter
+    if (task.adapter !== undefined && typeof task.adapter !== 'string') {
+      errors.push(`${prefix}: \`adapter\` must be a string`)
+    }
   }
 
   // DAG cycle detection
@@ -308,6 +317,10 @@ export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
       task.max_retries =
         d.max_retries !== undefined ? Number(d.max_retries) : 1
     }
+    // adapter: task-level overrides defaults, no hardcoded fallback (convoy-level is used at runtime)
+    if (task.adapter === undefined && d.adapter !== undefined) {
+      task.adapter = d.adapter
+    }
   }
 
   return s as unknown as TaskSpec

package/src/cli/run.ts

@@ -124,6 +124,9 @@ function printAdapterError(detectionFailed: boolean, adapterName: string): void
         '    The Cursor agent CLI ships with the Cursor editor.\n' +
         '    Install Cursor from https://cursor.com and ensure the\n' +
         '    "agent" command is on your PATH (Cursor > Install CLI).',
+      opencode:
+        '    Install OpenCode from https://opencode.ai\n' +
+        '    Ensure the "opencode" command is on your PATH.',
     }
     const cliName = adapterName === 'claude-code' ? 'claude' : adapterName
     const hint = hints[adapterName] ?? ''

package/src/cli/types.ts

@@ -132,6 +132,7 @@ export interface TaskDefaults {
   model?: string;
   max_retries?: number;
   agent?: string;
+  adapter?: string;
 }
 
 /** Validated task spec from YAML. */
@@ -166,6 +167,8 @@ export interface Task {
   model?: string;
   /** Max retry attempts (default: 1). */
   max_retries: number;
+  /** Per-task adapter override. */
+  adapter?: string;
 }
 
 /** Task execution status. */

package/src/dashboard/node_modules/.vite/deps/_metadata.json

@@ -1,25 +1,25 @@
 {
-  "hash": "f5f05037",
+  "hash": "e38e79fd",
   "configHash": "30f8ea04",
-  "lockfileHash": "99d70434",
-  "browserHash": "d43a2a07",
+  "lockfileHash": "dc112ec5",
+  "browserHash": "ee856457",
   "optimized": {
     "astro > cssesc": {
       "src": "../../../../../node_modules/cssesc/cssesc.js",
       "file": "astro___cssesc.js",
-      "fileHash": "29d5277e",
+      "fileHash": "a803959e",
       "needsInterop": true
     },
     "astro > aria-query": {
       "src": "../../../../../node_modules/aria-query/lib/index.js",
       "file": "astro___aria-query.js",
-      "fileHash": "4ca620a4",
+      "fileHash": "8505e2b8",
       "needsInterop": true
     },
     "astro > axobject-query": {
       "src": "../../../../../node_modules/axobject-query/lib/index.js",
       "file": "astro___axobject-query.js",
-      "fileHash": "4072a265",
+      "fileHash": "e7d3a98b",
       "needsInterop": true
     }
   },