@vibe-forge/adapter-opencode 0.1.2

package/src/runtime/common/tools.ts

@@ -0,0 +1,129 @@
+import type { AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+export const DEFAULT_OPENCODE_TOOLS = [
+  'bash',
+  'edit',
+  'glob',
+  'grep',
+  'patch',
+  'write',
+  'read',
+  'list',
+  'lsp',
+  'skill',
+  'todoread',
+  'todowrite',
+  'webfetch',
+  'websearch',
+  'question'
+]
+
+export const LEGACY_TOOL_PERMISSION_ALIASES: Record<string, string> = {
+  agent: 'task',
+  bash: 'bash',
+  edit: 'edit',
+  fetch: 'webfetch',
+  glob: 'glob',
+  grep: 'grep',
+  list: 'list',
+  ls: 'list',
+  lsp: 'lsp',
+  patch: 'edit',
+  read: 'read',
+  skill: 'skill',
+  task: 'task',
+  todoread: 'todoread',
+  todowrite: 'todowrite',
+  view: 'read',
+  webfetch: 'webfetch',
+  websearch: 'websearch',
+  write: 'edit'
+}
+
+const OPEN_CODE_TOOL_ALIASES: Record<string, string> = {
+  bash: 'bash',
+  edit: 'edit',
+  fetch: 'webfetch',
+  glob: 'glob',
+  grep: 'grep',
+  list: 'list',
+  ls: 'list',
+  lsp: 'lsp',
+  patch: 'patch',
+  question: 'question',
+  read: 'read',
+  skill: 'skill',
+  todoread: 'todoread',
+  todowrite: 'todowrite',
+  view: 'read',
+  webfetch: 'webfetch',
+  websearch: 'websearch',
+  write: 'write'
+}
+
+const PERMISSION_ONLY_TOOL_KEYS = new Set(['agent', 'task'])
+const MANAGED_FLAGS_WITH_VALUE = new Set([
+  '--agent', '--attach', '--file', '--format', '--model', '--port', '--session', '--title', '-f', '-m', '-s'
+])
+const MANAGED_FLAGS = new Set(['--continue', '--fork', '--share', '-c'])
+
+export const buildToolConfig = (tools: AdapterQueryOptions['tools']) => {
+  const result: Record<string, boolean> = {}
+
+  for (const [list, enabled] of [[tools?.exclude ?? [], false], [tools?.include ?? [], true]] as const) {
+    for (const name of list) {
+      const key = name.trim()
+      if (key === '' || key === '*' || PERMISSION_ONLY_TOOL_KEYS.has(key)) continue
+      result[OPEN_CODE_TOOL_ALIASES[key] ?? key] = enabled
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined
+}
+
+export const sanitizeOpenCodeExtraOptions = (extraOptions?: string[]) => {
+  const sanitized: string[] = []
+
+  for (let index = 0; index < (extraOptions ?? []).length; index += 1) {
+    const current = extraOptions?.[index]
+    if (current == null) continue
+    if (MANAGED_FLAGS_WITH_VALUE.has(current)) {
+      index += 1
+      continue
+    }
+    if (!MANAGED_FLAGS.has(current)) {
+      sanitized.push(current)
+    }
+  }
+
+  return sanitized
+}
+
+export const buildOpenCodeRunArgs = (params: {
+  prompt?: string
+  files: string[]
+  model?: string
+  agent?: string
+  share?: boolean
+  title?: string
+  opencodeSessionId?: string
+  extraOptions?: string[]
+}) => {
+  const args = ['run', '--format', 'default']
+
+  if (params.opencodeSessionId) {
+    args.push('--session', params.opencodeSessionId)
+  } else if (params.title) {
+    args.push('--title', params.title)
+  }
+
+  if (params.model) args.push('--model', params.model)
+  if (params.agent) args.push('--agent', params.agent)
+  if (params.share) args.push('--share')
+
+  for (const file of params.files) args.push('--file', file)
+  args.push(...sanitizeOpenCodeExtraOptions(params.extraOptions))
+  if (params.prompt != null && params.prompt !== '') args.push(params.prompt)
+
+  return args
+}

package/src/runtime/common.ts

@@ -0,0 +1,17 @@
+export { resolveOpenCodeAgent } from './common/agent'
+export { buildInlineConfigContent } from './common/inline-config'
+export { mapMcpServersToOpenCode } from './common/mcp'
+export { resolveOpenCodeModel } from './common/model'
+export { buildOpenCodeSessionTitle, normalizeOpenCodePrompt, resolveLocalAttachmentPath } from './common/prompt'
+export { buildToolPermissionConfig, mapPermissionModeToOpenCode } from './common/permissions'
+export {
+  extractOpenCodeSessionRecords,
+  selectOpenCodeSessionByTitle,
+  type OpenCodeSessionRecord
+} from './common/session-records'
+export {
+  buildOpenCodeRunArgs,
+  buildToolConfig,
+  DEFAULT_OPENCODE_TOOLS,
+  sanitizeOpenCodeExtraOptions
+} from './common/tools'

package/src/runtime/init.ts

@@ -0,0 +1,55 @@
+import { execFile } from 'node:child_process'
+import { access, lstat, mkdir, symlink } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import process from 'node:process'
+import { promisify } from 'node:util'
+
+import type { AdapterCtx } from '@vibe-forge/core/adapter'
+
+import { resolveOpenCodeBinaryPath } from '#~/paths.js'
+
+const execFileAsync = promisify(execFile)
+
+const ensureSymlink = async (sourcePath: string, targetPath: string) => {
+  try {
+    await access(sourcePath)
+  } catch {
+    return
+  }
+
+  try {
+    await lstat(targetPath)
+    return
+  } catch {
+  }
+
+  await mkdir(dirname(targetPath), { recursive: true })
+  await symlink(sourcePath, targetPath)
+}
+
+export const initOpenCodeAdapter = async (ctx: AdapterCtx) => {
+  const binaryPath = resolveOpenCodeBinaryPath(ctx.env)
+
+  try {
+    await execFileAsync(binaryPath, ['--version'])
+  } catch {
+  }
+
+  const realHome = process.env.__VF_PROJECT_REAL_HOME__
+  const aiHome = process.env.HOME
+
+  if (!realHome || !aiHome) return
+
+  await ensureSymlink(
+    join(realHome, '.config', 'opencode'),
+    join(aiHome, '.config', 'opencode')
+  )
+  await ensureSymlink(
+    join(realHome, '.local', 'share', 'opencode', 'auth.json'),
+    join(aiHome, '.local', 'share', 'opencode', 'auth.json')
+  )
+  await ensureSymlink(
+    join(realHome, '.local', 'share', 'opencode', 'mcp-auth.json'),
+    join(aiHome, '.local', 'share', 'opencode', 'mcp-auth.json')
+  )
+}

package/src/runtime/session/child-env.ts

@@ -0,0 +1,100 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import process from 'node:process'
+
+import type { Config, ModelServiceConfig } from '@vibe-forge/core'
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+import { buildInlineConfigContent, resolveOpenCodeModel } from '../common'
+import { asPlainRecord } from '../common/object-utils'
+import { ensureOpenCodeConfigDir } from './skill-config'
+import { toProcessEnv, type OpenCodeAdapterConfig } from './shared'
+
+const resolveMergedModelServices = (ctx: AdapterCtx) => ({
+  ...(ctx.configs[0]?.modelServices ?? {}),
+  ...(ctx.configs[1]?.modelServices ?? {})
+}) as Record<string, ModelServiceConfig>
+
+const resolveMergedMcpServers = (ctx: AdapterCtx) => ({
+  ...(ctx.configs[0]?.mcpServers ?? {}),
+  ...(ctx.configs[1]?.mcpServers ?? {})
+}) as Config['mcpServers']
+
+const resolveMcpServerSelection = (
+  ctx: AdapterCtx,
+  selection: AdapterQueryOptions['mcpServers']
+) => {
+  const include = selection?.include ?? Array.from(new Set([
+    ...(ctx.configs[0]?.defaultIncludeMcpServers ?? []),
+    ...(ctx.configs[1]?.defaultIncludeMcpServers ?? [])
+  ]))
+  const exclude = selection?.exclude ?? Array.from(new Set([
+    ...(ctx.configs[0]?.defaultExcludeMcpServers ?? []),
+    ...(ctx.configs[1]?.defaultExcludeMcpServers ?? [])
+  ]))
+
+  return include.length > 0 || exclude.length > 0
+    ? {
+      include: include.length > 0 ? include : undefined,
+      exclude: exclude.length > 0 ? exclude : undefined
+    }
+    : undefined
+}
+
+const parseEnvConfigContent = (env: AdapterCtx['env']) => {
+  const raw = env.OPENCODE_CONFIG_CONTENT
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+
+  try {
+    const parsed = JSON.parse(raw)
+    return asPlainRecord(parsed)
+  } catch {
+    return undefined
+  }
+}
+
+export const buildChildEnv = async (params: {
+  ctx: AdapterCtx
+  options: AdapterQueryOptions
+  adapterConfig: OpenCodeAdapterConfig
+  systemPromptFile?: string
+}) => {
+  const configDir = await ensureOpenCodeConfigDir({ ctx: params.ctx, options: params.options })
+  const { cliModel, providerConfig } = resolveOpenCodeModel(
+    params.options.model,
+    resolveMergedModelServices(params.ctx)
+  )
+
+  return {
+    cliModel,
+    env: toProcessEnv({
+      ...process.env,
+      ...params.ctx.env,
+      OPENCODE_DISABLE_AUTOUPDATE: params.ctx.env.OPENCODE_DISABLE_AUTOUPDATE ?? 'true',
+      OPENCODE_CONFIG_CONTENT: JSON.stringify(buildInlineConfigContent({
+        adapterConfigContent: params.adapterConfig.configContent,
+        envConfigContent: parseEnvConfigContent(params.ctx.env),
+        permissionMode: params.options.permissionMode,
+        tools: params.options.tools,
+        mcpServers: resolveMcpServerSelection(params.ctx, params.options.mcpServers),
+        availableMcpServers: resolveMergedMcpServers(params.ctx),
+        systemPromptFile: params.systemPromptFile,
+        providerConfig
+      })),
+      ...(configDir != null ? { OPENCODE_CONFIG_DIR: configDir } : {})
+    })
+  }
+}
+
+export const ensureSystemPromptFile = async (
+  ctx: AdapterCtx,
+  options: AdapterQueryOptions
+) => {
+  if (options.systemPrompt == null || options.systemPrompt.trim() === '') return undefined
+
+  const promptDir = resolve(ctx.cwd, '.ai', '.mock', '.opencode-adapter', options.sessionId, 'instructions')
+  const promptPath = resolve(promptDir, 'system.md')
+  await mkdir(promptDir, { recursive: true })
+  await writeFile(promptPath, options.systemPrompt)
+  return promptPath
+}

package/src/runtime/session/direct.ts

@@ -0,0 +1,109 @@
+import { spawn } from 'node:child_process'
+
+import type { AdapterCtx, AdapterOutputEvent, AdapterQueryOptions, AdapterSession } from '@vibe-forge/core/adapter'
+
+import {
+  buildOpenCodeRunArgs,
+  buildOpenCodeSessionTitle,
+  resolveOpenCodeAgent
+} from '../common'
+import { resolveOpenCodeBinaryPath } from '../../paths'
+import { buildChildEnv, ensureSystemPromptFile } from './child-env'
+import { findOpenCodeSessionId } from './process'
+import { getErrorMessage, resolveAdapterConfig, toAdapterErrorData } from './shared'
+
+export const createDirectOpenCodeSession = async (
+  ctx: AdapterCtx,
+  options: AdapterQueryOptions
+): Promise<AdapterSession> => {
+  const adapterConfig = resolveAdapterConfig(ctx)
+  const agent = resolveOpenCodeAgent({
+    agent: adapterConfig.agent,
+    planAgent: adapterConfig.planAgent,
+    permissionMode: options.permissionMode
+  })
+  const binaryPath = resolveOpenCodeBinaryPath(ctx.env)
+  const title = buildOpenCodeSessionTitle(options.sessionId, adapterConfig.titlePrefix)
+  const cachedSession = options.type === 'resume' ? await ctx.cache.get('adapter.opencode.session') : undefined
+  const systemPromptFile = await ensureSystemPromptFile(ctx, options)
+  const { cliModel, env } = await buildChildEnv({ ctx, options, adapterConfig, systemPromptFile })
+  const opencodeSessionId = options.type === 'resume'
+    ? await findOpenCodeSessionId({
+      binaryPath,
+      cwd: ctx.cwd,
+      env,
+      title,
+      maxCount: adapterConfig.sessionListMaxCount ?? 50,
+      logger: ctx.logger
+    }) ?? cachedSession?.opencodeSessionId
+    : undefined
+
+  if (options.type === 'create') await ctx.cache.set('adapter.opencode.session', { title })
+
+  const proc = spawn(binaryPath, buildOpenCodeRunArgs({
+    prompt: options.description?.trim() !== '' ? options.description?.trim() : undefined,
+    files: [],
+    model: cliModel,
+    agent,
+    share: adapterConfig.share,
+    title,
+    opencodeSessionId,
+    extraOptions: options.extraOptions
+  }), {
+    cwd: ctx.cwd,
+    env: env as Record<string, string>,
+    stdio: 'inherit'
+  })
+
+  let finished = false
+  let didEmitFatalError = false
+  const emitEvent = (event: AdapterOutputEvent) => {
+    if (event.type === 'error' && event.data.fatal !== false) {
+      didEmitFatalError = true
+    }
+    options.onEvent(event)
+  }
+  const emitExitOnce = (data: { exitCode: number; stderr?: string }) => {
+    if (finished) return
+    finished = true
+    emitEvent({ type: 'exit', data })
+  }
+
+  proc.on('error', (error) => {
+    emitEvent({ type: 'error', data: toAdapterErrorData(error) })
+    emitExitOnce({ exitCode: 1, stderr: getErrorMessage(error) })
+  })
+  proc.on('exit', (code) => {
+    void (async () => {
+      if ((code ?? 0) === 0) {
+        const resolvedSessionId = await findOpenCodeSessionId({
+          binaryPath,
+          cwd: ctx.cwd,
+          env,
+          title,
+          maxCount: adapterConfig.sessionListMaxCount ?? 50,
+          logger: ctx.logger
+        })
+        if (resolvedSessionId) {
+          await ctx.cache.set('adapter.opencode.session', { opencodeSessionId: resolvedSessionId, title })
+        }
+      } else if (!didEmitFatalError) {
+        emitEvent({
+          type: 'error',
+          data: toAdapterErrorData(`Process exited with code ${code ?? 1}`, {
+            details: { exitCode: code ?? 1 }
+          })
+        })
+      }
+      emitExitOnce({ exitCode: code ?? 0 })
+    })()
+  })
+
+  return {
+    kill: () => proc.kill(),
+    emit: () => {
+      ctx.logger.warn('emit() is not supported in direct mode for opencode')
+    },
+    pid: proc.pid
+  }
+}

package/src/runtime/session/process.ts

@@ -0,0 +1,55 @@
+import { spawn } from 'node:child_process'
+
+import type { AdapterCtx } from '@vibe-forge/core/adapter'
+
+import { extractOpenCodeSessionRecords, selectOpenCodeSessionByTitle } from '../common'
+import { execFileAsync, type OpenCodeRunResult } from './shared'
+
+export const findOpenCodeSessionId = async (params: {
+  binaryPath: string
+  cwd: string
+  env: Record<string, string | null | undefined>
+  title: string
+  maxCount: number
+  logger: AdapterCtx['logger']
+}) => {
+  try {
+    const { stdout } = await execFileAsync(
+      params.binaryPath,
+      ['session', 'list', '--format', 'json', '--max-count', String(params.maxCount)],
+      { cwd: params.cwd, env: params.env as Record<string, string>, maxBuffer: 1024 * 1024 * 8 }
+    )
+    return selectOpenCodeSessionByTitle(extractOpenCodeSessionRecords(stdout), params.title)?.id
+  } catch (err) {
+    params.logger.debug('Failed to resolve OpenCode session id from session list', { err })
+    return undefined
+  }
+}
+
+export const runOpenCodeCommand = (params: {
+  binaryPath: string
+  args: string[]
+  cwd: string
+  env: Record<string, string | null | undefined>
+  onStart?: (pid?: number) => void
+}) => new Promise<OpenCodeRunResult>((resolveResult, reject) => {
+  const proc = spawn(params.binaryPath, params.args, {
+    cwd: params.cwd,
+    env: params.env as Record<string, string>,
+    stdio: 'pipe'
+  })
+
+  params.onStart?.(proc.pid)
+  const stdoutChunks: string[] = []
+  const stderrChunks: string[] = []
+  proc.stdout.on('data', chunk => stdoutChunks.push(String(chunk)))
+  proc.stderr.on('data', chunk => stderrChunks.push(String(chunk)))
+  proc.on('error', reject)
+  proc.on('exit', code => {
+    resolveResult({
+      exitCode: code ?? 0,
+      stdout: stdoutChunks.join(''),
+      stderr: stderrChunks.join('')
+    })
+  })
+})

package/src/runtime/session/shared.ts

@@ -0,0 +1,72 @@
+import { execFile } from 'node:child_process'
+
+import type { ChatMessage } from '@vibe-forge/core'
+import type { AdapterCtx } from '@vibe-forge/core/adapter'
+import { uuid } from '@vibe-forge/core/utils/uuid'
+
+export interface OpenCodeAdapterConfig {
+  agent?: string
+  planAgent?: string | false
+  titlePrefix?: string
+  share?: boolean
+  sessionListMaxCount?: number
+  configContent?: Record<string, unknown>
+}
+
+export interface OpenCodeRunResult {
+  exitCode: number
+  stdout: string
+  stderr: string
+}
+
+export const execFileAsync = (
+  file: string,
+  args: string[],
+  options: { cwd: string; env: Record<string, string>; maxBuffer: number }
+) => new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+  execFile(file, args, options, (error, stdout, stderr) => {
+    if (error) {
+      reject(error)
+      return
+    }
+    resolve({ stdout: String(stdout), stderr: String(stderr) })
+  })
+})
+
+export const stripAnsi = (value: string) => value.replaceAll(/\u001B\[[0-9;]*[A-Za-z]/g, '')
+
+export const createAssistantMessage = (content: string, model?: string): ChatMessage => ({
+  id: uuid(),
+  role: 'assistant',
+  content,
+  createdAt: Date.now(),
+  ...(model != null ? { model } : {})
+})
+
+export const getErrorMessage = (error: unknown) => (
+  error instanceof Error ? error.message : String(error ?? 'OpenCode session failed unexpectedly')
+)
+
+export const toAdapterErrorData = (
+  error: unknown,
+  overrides: Partial<{ message: string; code: string; details: unknown; fatal: boolean }> = {}
+) => ({
+  message: overrides.message ?? getErrorMessage(error),
+  ...(overrides.code != null ? { code: overrides.code } : {}),
+  ...(overrides.details !== undefined ? { details: overrides.details } : {}),
+  fatal: overrides.fatal ?? true
+})
+
+export const toProcessEnv = (env: Record<string, string | null | undefined>) => (
+  Object.fromEntries(
+    Object.entries(env).filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+  )
+)
+
+export const resolveAdapterConfig = (ctx: AdapterCtx): OpenCodeAdapterConfig => {
+  const [config, userConfig] = ctx.configs
+  return {
+    ...(config?.adapters?.opencode ?? {}),
+    ...(userConfig?.adapters?.opencode ?? {})
+  }
+}

package/src/runtime/session/skill-config.ts

@@ -0,0 +1,84 @@
+import { lstat, mkdir, readdir, rm, symlink } from 'node:fs/promises'
+import { basename, dirname, resolve } from 'node:path'
+import process from 'node:process'
+
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/core/adapter'
+import { DefinitionLoader } from '@vibe-forge/core/utils/definition-loader'
+
+const filterResolvedSkills = async (
+  cwd: string,
+  selection: AdapterQueryOptions['skills']
+) => {
+  const loader = new DefinitionLoader(cwd)
+  const allSkills = await loader.loadDefaultSkills()
+  const include = selection?.include != null && selection.include.length > 0
+    ? new Set(selection.include)
+    : undefined
+  const exclude = new Set(selection?.exclude ?? [])
+  const result = new Map<string, string>()
+
+  for (const skill of allSkills) {
+    const name = basename(dirname(skill.path))
+    if ((include != null && !include.has(name)) || exclude.has(name) || result.has(name)) continue
+    result.set(name, dirname(skill.path))
+  }
+
+  return result
+}
+
+const ensureSymlinkTarget = async (sourcePath: string, targetPath: string) => {
+  try {
+    const existing = await lstat(targetPath)
+    if (existing.isSymbolicLink() || existing.isDirectory() || existing.isFile()) {
+      await rm(targetPath, { recursive: true, force: true })
+    }
+  } catch {
+  }
+
+  await mkdir(dirname(targetPath), { recursive: true })
+  await symlink(sourcePath, targetPath)
+}
+
+const mirrorDirectoryEntries = async (sourceDir: string, targetDir: string) => {
+  try {
+    const entries = await readdir(sourceDir, { withFileTypes: true })
+    await mkdir(targetDir, { recursive: true })
+    for (const entry of entries) {
+      await ensureSymlinkTarget(resolve(sourceDir, entry.name), resolve(targetDir, entry.name))
+    }
+  } catch {
+  }
+}
+
+export const ensureOpenCodeConfigDir = async (params: {
+  ctx: AdapterCtx
+  options: AdapterQueryOptions
+}) => {
+  const baseConfigDir = params.ctx.env.OPENCODE_CONFIG_DIR ?? process.env.OPENCODE_CONFIG_DIR ?? undefined
+  const resolvedSkills = await filterResolvedSkills(params.ctx.cwd, params.options.skills)
+  if (baseConfigDir == null && resolvedSkills.size === 0) return undefined
+
+  const configDir = resolve(
+    params.ctx.cwd,
+    '.ai',
+    '.mock',
+    '.opencode-adapter',
+    params.options.sessionId,
+    'config-dir'
+  )
+  await rm(configDir, { recursive: true, force: true })
+  await mkdir(configDir, { recursive: true })
+
+  if (baseConfigDir) {
+    for (const folderName of ['agents', 'commands', 'modes', 'plugins']) {
+      await ensureSymlinkTarget(resolve(baseConfigDir, folderName), resolve(configDir, folderName)).catch(() => undefined)
+    }
+    await mirrorDirectoryEntries(resolve(baseConfigDir, 'skills'), resolve(configDir, 'skills'))
+  }
+
+  for (const [name, sourceDir] of resolvedSkills.entries()) {
+    await ensureSymlinkTarget(sourceDir, resolve(configDir, 'skills', name))
+  }
+
+  return configDir
+}