openvisio-agent 0.6.2 → 0.7.0

package/bin/cli.mjs

@@ -24,8 +24,8 @@ const HELP = `openvisio-agent ${VERSION}
 Connect your coding agent to an OpenVisio team.
 
 Usage:
-  openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>]
-  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>]
+  openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>] [--agent claude|opencode]
+  openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>] [--agent claude|opencode]
   openvisio-agent watch   --name <agent> [--install] [--workspace <dir>] [--chat-only] [--model <m>] [--chat-model <m>] [--debug]
   openvisio-agent --help | --version
 
@@ -50,6 +50,9 @@ connect --backend
                      pushes its agent/* branch and opens PRs. Defaults to
                      ~/openvisio-workspace; point it at an existing clones folder to
                      reuse those. (--workdir is an accepted alias.)
+    --agent <name>   the coding-agent RUNTIME the cycles run on: claude (Claude Code,
+                     default) or opencode (opencode.ai). opencode is authenticated
+                     separately (opencode auth login) and uses provider/model ids.
     --chat-only      disable code work — chat/ticket tools only.
     --model <m>      the model the agent runs on (opus | sonnet | haiku | a full
                      claude-… id). Defaults to sonnet — cost-effective, so the agent
@@ -94,6 +97,24 @@ function ensureAgentInstalled() {
   spawnSync('npm', ['i', '-g', 'openvisio-agent@latest'], { stdio: 'inherit', shell: process.platform === 'win32' })
 }
 
+// The chosen coding-agent RUNTIME the cycles run on. Default claude.
+function agentFlag(flags) {
+  const a = String(flags.agent || flags.runtime || 'claude').toLowerCase()
+  if (a !== 'claude' && a !== 'opencode') fail(`Unknown --agent "${a}". Supported runtimes: claude | opencode.`)
+  return a
+}
+
+// opencode runtime: ensure the `opencode` CLI exists (best-effort install), and
+// remind about its one-time auth. Unlike Claude Code we don't register an MCP here
+// — the watcher writes an `opencode.json` with the openvisio-team server at runtime.
+function ensureOpencode() {
+  if (onPath('opencode')) return
+  info('opencode not found on PATH — installing (npm i -g opencode-ai)…')
+  spawnSync('npm', ['i', '-g', 'opencode-ai'], { stdio: 'inherit', shell: process.platform === 'win32' })
+  if (!onPath('opencode')) info('Could not auto-install opencode. Install it — https://opencode.ai/docs/ — then run:  opencode auth login')
+  else info('Installed opencode. Authenticate it once if you haven\'t:  opencode auth login')
+}
+
 async function runConnect({ positional, flags }) {
   if (flags.backend) return runConnectBackend({ positional, flags })
   const token = positional[0] || flags.token
@@ -107,21 +128,28 @@ async function runConnect({ positional, flags }) {
   const mcpUrl = (flags['mcp-url'] && String(flags['mcp-url'])) || srvMcp || stripSlash(host) + '/api/agent/mcp'
   const name = (flags.name && String(flags.name)) || 'openvisio-team'
   const slug = slugify(name)
+  const agent = agentFlag(flags)
 
-  const claude = ensureClaude()
-
-  // Register with Claude Code — remove any stale entry first so a changed URL sticks.
-  mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, '--header', `Authorization: Bearer ${key}`])
-
-  // A scoped MCP config (for the watcher's --strict-mcp-config) + a saved profile.
-  const mcpCfg = mcpConfigPath(slug)
-  writeJson(mcpCfg, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${key}` } } } }, true)
+  // Register the openvisio-team MCP with the chosen runtime.
+  let mcpCfg = ''
+  if (agent === 'claude') {
+    const claude = ensureClaude()
+    // Remove any stale entry first so a changed URL sticks, then add at user scope.
+    mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, '--header', `Authorization: Bearer ${key}`])
+    // A scoped MCP config for the watcher's --strict-mcp-config.
+    mcpCfg = mcpConfigPath(slug)
+    writeJson(mcpCfg, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${key}` } } } }, true)
+  } else {
+    ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
+  }
   const wsWorkdir = flags.workdir === true ? process.cwd() : flags.workdir ? String(flags.workdir) : flags.workspace ? String(flags.workspace) : ''
-  writeJson(configPath(slug), { host: stripSlash(host), key, mcpUrl, name, slug, mcpConfig: mcpCfg, ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  writeJson(configPath(slug), { host: stripSlash(host), key, mcpUrl, name, slug, ...(mcpCfg ? { mcpConfig: mcpCfg } : {}), ...(agent !== 'claude' ? { agent } : {}), ...(wsWorkdir ? { workspace: wsWorkdir } : {}), ...(flags['chat-only'] ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
 
   ok(`Connected "${name}" to ${host}.`)
   info()
-  info('Claude Code now has the openvisio-team tools. Run  /mcp  in Claude Code to confirm.')
+  info(agent === 'opencode'
+    ? 'Runtime: opencode. The watcher writes an opencode.json with the openvisio-team tools; make sure opencode is authenticated (opencode auth login).'
+    : 'Claude Code now has the openvisio-team tools. Run  /mcp  in Claude Code to confirm.')
   info()
   info('To let it work on its own (reply to mentions, pick up tickets, AND do real')
   info('coding — it clones/branches/pushes and opens PRs out of the box):')
@@ -160,6 +188,7 @@ async function runConnectBackend({ flags }) {
 
   const name = (flags.name && String(flags.name)) || 'backend-agent'
   const slug = slugify(name)
+  const agent = agentFlag(flags)
 
   // Code workspace preference (optional). CODE mode is on by default; this only
   // pins WHERE the agent works. Persisted so the always-on `watch` reuses it.
@@ -177,15 +206,19 @@ async function runConnectBackend({ flags }) {
 
   let mcpConfig = ''
   if (mcpUrl) {
-    const claude = ensureClaude()
-    // Backend agents authenticate with the agent header pair, not a Bearer JWT.
-    const hdr = ['--header', `x-agent-api-key: ${apiKey}`, '--header', `x-agent-identifier: ${identifier}`]
-    mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, ...hdr])
-    mcpConfig = mcpConfigPath(slug)
-    writeJson(mcpConfig, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier } } } }, true)
+    if (agent === 'claude') {
+      const claude = ensureClaude()
+      // Backend agents authenticate with the agent header pair, not a Bearer JWT.
+      const hdr = ['--header', `x-agent-api-key: ${apiKey}`, '--header', `x-agent-identifier: ${identifier}`]
+      mcpReplace(claude, ['--transport', 'http', 'openvisio-team', mcpUrl, ...hdr])
+      mcpConfig = mcpConfigPath(slug)
+      writeJson(mcpConfig, { mcpServers: { 'openvisio-team': { type: 'http', url: mcpUrl, headers: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier } } } }, true)
+    } else {
+      ensureOpencode() // the watcher writes opencode.json with the remote MCP at runtime
+    }
   }
 
-  writeJson(configPath(slug), { mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
+  writeJson(configPath(slug), { mode: 'backend', backend, apiKey, identifier, name, slug, wsUrl, mcpUrl, mcpConfig, ...(agent !== 'claude' ? { agent } : {}), ...(workdir ? { workspace: workdir } : {}), ...(chatOnly ? { chatOnly: true } : {}), ...(flags.model ? { model: String(flags.model) } : {}), ...(flags['chat-model'] ? { chatModel: String(flags['chat-model']) } : {}) }, true)
   // A sourceable env file, matching the setup snippet OpenVisio shows.
   const envPath = join(OV_DIR, `${slug}.env`)
   mkdirSync(OV_DIR, { recursive: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Connect your coding agent (Claude Code) to an OpenVisio team — MCP tools + optional autonomy — in one command. No shell scripts.",
   "type": "module",
   "bin": {

package/src/watch.mjs

@@ -136,6 +136,11 @@ export async function runWatch({ flags }) {
   const saved = slug ? readConfig(slug) : null
   const claude = String(flags.claude || onPath('claude') || 'claude')
   const mcpConfig = String(flags['mcp-config'] || (saved && saved.mcpConfig) || '')
+  // Which coding-agent runtime drives the cycles: Claude Code (warm stream-json
+  // session) or opencode (headless `opencode run` per cycle). Default claude.
+  const agent = String(flags.agent || flags.runtime || (saved && saved.agent) || 'claude').toLowerCase()
+  if (agent !== 'claude' && agent !== 'opencode') fail(`Unknown --agent "${agent}". Supported runtimes: claude | opencode.`)
+  const mcpUrl = String(flags['mcp-url'] || (saved && saved.mcpUrl) || '')
   // Code mode is the DEFAULT: an agent lives on the user's laptop and should just be
   // able to work across the org's repos with no per-repo setup. So `workdir` resolves
   // to (in order) an explicit --workdir/--workspace, the saved workspace, or the
@@ -149,12 +154,11 @@ export async function runWatch({ flags }) {
   const workdir = chatOnly ? '' : (explicitWorkdir || (saved && (saved.workspace || saved.workdir)) || DEFAULT_WORKSPACE)
   if (workdir) { try { mkdirSync(workdir, { recursive: true }) } catch { /* best-effort; spawn will surface a real problem */ } }
 
-  // Model the agent runs on. Default SONNET (cost-effective) rather than whatever
-  // `claude` defaults to — the agent shouldn't burn Opus tokens on routine chatter.
-  // Optional --chat-model runs the lighter chat/mention cycles on an even cheaper
-  // model while code cycles stay on the main one. Both persisted + live-changeable
-  // via the in-chat `/model` command (see loopBackendWs).
-  const model = String(flags.model || (saved && saved.model) || 'sonnet')
+  // Model the agent runs on. For Claude Code default SONNET (cost-effective) rather
+  // than whatever `claude` defaults to. For opencode, models are `provider/model`
+  // and multi-provider, so default to empty (use opencode's own configured default)
+  // unless set. Optional --chat-model runs the lighter chat/mention cycles cheaper.
+  const model = String(flags.model || (saved && saved.model) || (agent === 'opencode' ? '' : 'sonnet'))
   const chatModel = String(flags['chat-model'] || (saved && saved.chatModel) || '')
 
   // Backend agents (connect --backend) drive autonomy over a real-time WS instead
@@ -168,7 +172,7 @@ export async function runWatch({ flags }) {
     if (!apiKey || !identifier) fail('No saved backend credentials for that agent.\n  Run `openvisio-agent connect --backend …` first, or pass --key and --id.')
     assertWebSocket(fail)
     if (flags.install) return installService({ slug: slug || 'openvisio', claude, mcpConfig, workdir })
-    return loopBackendWs({ wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, mcpConfig, workdir, model, chatModel, debug: !!flags.debug })
+    return loopBackendWs({ wsUrl, apiKey, identifier, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
   }
 
   const host = stripSlash(flags.host || (saved && saved.host) || '')
@@ -177,15 +181,70 @@ export async function runWatch({ flags }) {
 
   if (flags.install) return installService({ slug: slug || 'openvisio', claude, mcpConfig, workdir })
 
-  return loop({ host, key, slug: slug || 'openvisio', claude, mcpConfig, workdir, model, chatModel, debug: !!flags.debug })
+  return loop({ host, key, slug: slug || 'openvisio', claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug: !!flags.debug })
+}
+
+// ── opencode cycle runner ─────────────────────────────────────────────────────
+// opencode (opencode.ai) has no persistent stream-json protocol like Claude Code,
+// so each cycle is a headless `opencode run <prompt> --auto [--model provider/model]`.
+// The openvisio-team MCP is declared in an `opencode.json` written into the run cwd
+// (opencode reads it from there). `--auto` approves tool use non-interactively.
+// Same { runCycle, canCode } contract as the Claude runner.
+function createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model }) {
+  // opencode reads opencode.json from its CWD: the code workspace, or a dedicated
+  // per-agent dir for chat-only agents.
+  const cwd = workdir || join(OV_DIR, 'opencode-' + (cfgKey || 'agent'))
+  const bin = onPath('opencode') || 'opencode'
+  let configured = false
+  const ensureConfig = () => {
+    if (configured) return
+    configured = true
+    try {
+      mkdirSync(cwd, { recursive: true })
+      if (mcpUrl) {
+        writeJson(join(cwd, 'opencode.json'), {
+          $schema: 'https://opencode.ai/config.json',
+          mcp: { 'openvisio-team': { type: 'remote', url: mcpUrl, enabled: true, ...(mcpHeaders && Object.keys(mcpHeaders).length ? { headers: mcpHeaders } : {}) } },
+        }, true)
+      } else {
+        log('WARNING: no --mcp-url — opencode has no openvisio-team tools to act with. Re-connect with --mcp-url.')
+      }
+    } catch (e) { log('opencode config write failed: ' + (e && e.message ? e.message : e)) }
+  }
+
+  function runCycle(prompt, cycleModel) {
+    return new Promise((resolve) => {
+      ensureConfig()
+      const m = cycleModel || model
+      const args = ['run', prompt, '--auto', ...(m ? ['--model', m] : [])]
+      let child = null, done = false
+      const finish = (o) => { if (done) return; done = true; clearTimeout(timer); resolve(o) }
+      const timer = setTimeout(() => {
+        log('opencode cycle TIMED OUT after ' + Math.round(maxCycleMs / 1000) + 's — killing')
+        try { child && child.kill() } catch { /* gone */ }
+        finish({ type: 'result', subtype: 'timeout' })
+      }, maxCycleMs)
+      log('running opencode cycle…' + (m ? ' [' + m + ']' : ''))
+      try { child = spawn(bin, args, { cwd, stdio: ['ignore', debug ? 'inherit' : 'ignore', 'inherit'] }) }
+      catch (e) { log('opencode spawn failed: ' + (e && e.message ? e.message : e) + ' — is opencode installed? (npm i -g opencode-ai, then `opencode auth login`)'); return finish({ type: 'result', subtype: 'spawn-failed' }) }
+      child.on('exit', (code) => { log('opencode cycle done (' + (code === 0 ? 'ok' : 'exit ' + code) + ')'); finish({ type: 'result', subtype: code === 0 ? 'ok' : 'error' }) })
+      child.on('error', (e) => { log('opencode error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
+    })
+  }
+
+  log('opencode runner ready' + (model ? ' [model ' + model + ']' : '') + (canCode ? ' [CODE workspace ' + cwd + ']' : ' [CHAT-ONLY — cfg ' + cwd + ']'))
+  return { runCycle, canCode }
 }
 
 // ── Claude Code warm-session cycle runner (shared by the REST + WS loops) ─────
 // One persistent stream-json session, poked with a prompt per cycle. Recycled
 // after MAX_TURNS or SESSION_IDLE_MS. Returns { runCycle, canCode }.
-function createCycleRunner({ claude, mcpConfig, workdir, log, debug, model }) {
+function createCycleRunner({ claude, agent, mcpUrl, mcpHeaders, cfgKey, mcpConfig, workdir, log, debug, model }) {
   const canCode = !!workdir
   const maxCycleMs = canCode ? MAX_CODE_CYCLE_MS : MAX_CYCLE_MS
+  // opencode drives cycles differently — a headless `opencode run` per cycle rather
+  // than a persistent stream-json session. Same { runCycle, canCode } contract.
+  if (agent === 'opencode') return createOpencodeRunner({ mcpUrl, mcpHeaders, cfgKey, workdir, canCode, maxCycleMs, log, debug, model })
   let child = null
   // The model the CURRENT session was spawned with. runCycle can pass a different
   // model per cycle (cheap for chat, stronger for code) — a change recycles the
@@ -280,9 +339,9 @@ function createCycleRunner({ claude, mcpConfig, workdir, log, debug, model }) {
 // over the WS; each pushes ONE Claude cycle. Serialized (one cycle at a time) — events
 // arriving while busy are coalesced into a single follow-up cycle so a burst doesn't
 // stack up N sessions. Plus a one-time intro on first connect and a daily catch-up sweep.
-function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, workdir, model, chatModel, debug }) {
+function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
   const log = (m) => process.stdout.write('[ws ' + new Date().toISOString() + '] ' + m + '\n')
-  const { runCycle, canCode } = createCycleRunner({ claude, mcpConfig, workdir, log, debug, model })
+  const { runCycle, canCode } = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { 'x-agent-api-key': apiKey, 'x-agent-identifier': identifier }, cfgKey: identifier, mcpConfig, workdir, log, debug, model })
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
   // Live model state — changeable at runtime by the in-chat `/model` command.
@@ -348,7 +407,9 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
   const normalizeModel = (s) => {
     const x = String(s || '').toLowerCase().replace(/[.,!?]+$/, '')
     if (x === 'opus' || x === 'sonnet' || x === 'haiku') return x
-    return /^claude-[a-z0-9.\-\[\]]+$/i.test(x) ? x : null
+    if (/^claude-[a-z0-9.\-\[\]]+$/i.test(x)) return x
+    // opencode models are provider/model (e.g. anthropic/claude-sonnet-4, openai/gpt-4o).
+    return /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9.\-:]*$/i.test(x) ? x : null
   }
   // Optional target tier: "chat"/"lite" → chat cycles only, "code"/"full" → code
   // cycles only, absent → both.
@@ -485,10 +546,10 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, mcpConfig, wor
 }
 
 // ── the warm loop ────────────────────────────────────────────────────────────
-function loop({ host, key, slug, claude, mcpConfig, workdir, model, chatModel, debug }) {
+function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, model, chatModel, debug }) {
   const log = (m) => process.stdout.write('[warm ' + new Date().toISOString() + '] ' + m + '\n')
   const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
-  const { runCycle, canCode } = createCycleRunner({ claude, mcpConfig, workdir, log, debug, model })
+  const { runCycle, canCode } = createCycleRunner({ claude, agent, mcpUrl, mcpHeaders: { Authorization: 'Bearer ' + key }, cfgKey: slug, mcpConfig, workdir, log, debug, model })
   const fullPrompt = canCode ? CODE_FULL : CYCLE
   const fastPrompt = canCode ? CODE_FAST : CYCLE_FAST
   const liteModel = chatModel || model // cheaper model for chat/quick cycles
@@ -593,7 +654,8 @@ export function installService({ slug, workdir }) {
   const bin = onPath('openvisio-agent') || 'openvisio-agent'
   const nodeDir = dirname(process.execPath)
   const claudeBin = onPath('claude')
-  const runPath = [nodeDir, claudeBin ? dirname(claudeBin) : '', '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'].filter(Boolean).join(':')
+  const opencodeBin = onPath('opencode')
+  const runPath = [nodeDir, claudeBin ? dirname(claudeBin) : '', opencodeBin ? dirname(opencodeBin) : '', join(homedir(), '.opencode', 'bin'), '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'].filter(Boolean).join(':')
   const args = ['watch', '--name', slug, ...(workdir ? ['--workdir', workdir] : [])]
   mkdirSync(OV_DIR, { recursive: true })
   const logFile = join(OV_DIR, `${slug}.log`)