@vibe-forge/adapter-opencode 0.1.2

package/src/runtime/common/agent.ts

@@ -0,0 +1,11 @@
+import type { AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+export const resolveOpenCodeAgent = (params: {
+  agent?: string
+  planAgent?: string | false
+  permissionMode?: AdapterQueryOptions['permissionMode']
+}) => {
+  if (params.permissionMode !== 'plan') return params.agent
+  if (params.planAgent === false) return params.agent
+  return params.planAgent ?? params.agent ?? 'plan'
+}

package/src/runtime/common/inline-config.ts

@@ -0,0 +1,45 @@
+import type { Config } from '@vibe-forge/core'
+import type { AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+import { mapMcpServersToOpenCode } from './mcp'
+import { deepMerge } from './object-utils'
+import { mergePermissionNodes, normalizePermissionNode, rewritePermissionMode } from './permission-node'
+import { buildToolPermissionConfig, mapPermissionModeToOpenCode } from './permissions'
+import { buildToolConfig } from './tools'
+
+export const buildInlineConfigContent = (params: {
+  adapterConfigContent?: Record<string, unknown>
+  envConfigContent?: Record<string, unknown>
+  permissionMode?: AdapterQueryOptions['permissionMode']
+  tools?: AdapterQueryOptions['tools']
+  mcpServers?: AdapterQueryOptions['mcpServers']
+  availableMcpServers?: Config['mcpServers']
+  systemPromptFile?: string
+  providerConfig?: Record<string, unknown>
+}) => {
+  const mergedBaseConfig = deepMerge(params.envConfigContent ?? {}, params.adapterConfigContent ?? {})
+  const inheritedPermission = normalizePermissionNode(mergedBaseConfig.permission)
+  const hasToolFilter = (params.tools?.include?.length ?? 0) > 0 || (params.tools?.exclude?.length ?? 0) > 0
+  const basePermission = params.permissionMode === 'dontAsk' || params.permissionMode === 'bypassPermissions'
+    ? rewritePermissionMode(inheritedPermission, params.permissionMode)
+    : mergePermissionNodes(inheritedPermission, mapPermissionModeToOpenCode(params.permissionMode))
+  const permission = params.permissionMode == null && !hasToolFilter
+    ? undefined
+    : mergePermissionNodes(basePermission, buildToolPermissionConfig(params.tools, basePermission))
+  const tools = buildToolConfig(params.tools)
+  const mcp = mapMcpServersToOpenCode(params.availableMcpServers, params.mcpServers)
+  const inheritedInstructions = Array.isArray(mergedBaseConfig.instructions)
+    ? mergedBaseConfig.instructions.filter((value): value is string => typeof value === 'string' && value.trim() !== '')
+    : []
+  const instructions = params.systemPromptFile == null
+    ? inheritedInstructions
+    : [...inheritedInstructions, params.systemPromptFile]
+
+  return deepMerge(mergedBaseConfig, {
+    ...(instructions.length > 0 ? { instructions } : {}),
+    ...(permission != null ? { permission } : {}),
+    ...(tools ? { tools } : {}),
+    ...(mcp ? { mcp } : {}),
+    ...(params.providerConfig ? { provider: params.providerConfig } : {})
+  })
+}

package/src/runtime/common/mcp.ts

@@ -0,0 +1,47 @@
+import type { Config } from '@vibe-forge/core'
+import type { AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+const filterMcpServers = (
+  mcpServers: Config['mcpServers'] | undefined,
+  selection: AdapterQueryOptions['mcpServers']
+) => {
+  if (mcpServers == null) return {}
+
+  const include = selection?.include != null && selection.include.length > 0
+    ? new Set(selection.include)
+    : undefined
+  const exclude = new Set(selection?.exclude ?? [])
+
+  return Object.fromEntries(
+    Object.entries(mcpServers).filter(([name]) => (include == null || include.has(name)) && !exclude.has(name))
+  )
+}
+
+export const mapMcpServersToOpenCode = (
+  mcpServers: Config['mcpServers'] | undefined,
+  selection: AdapterQueryOptions['mcpServers']
+) => {
+  const filtered = filterMcpServers(mcpServers, selection)
+  const result: Record<string, Record<string, unknown>> = {}
+
+  for (const [name, server] of Object.entries(filtered)) {
+    if ('url' in server) {
+      result[name] = {
+        type: 'remote',
+        url: server.url,
+        enabled: server.enabled ?? true,
+        ...(server.headers != null ? { headers: server.headers } : {})
+      }
+      continue
+    }
+
+    result[name] = {
+      type: 'local',
+      command: [server.command, ...server.args],
+      enabled: server.enabled ?? true,
+      ...(server.env != null ? { environment: server.env } : {})
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined
+}

package/src/runtime/common/model.ts

@@ -0,0 +1,115 @@
+import type { ModelServiceConfig } from '@vibe-forge/core'
+
+import { asPlainRecord, normalizeStringRecord } from './object-utils'
+
+const normalizePositiveInteger = (value: unknown): number | undefined => (
+  typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : undefined
+)
+
+const appendQueryParams = (baseURL: string, queryParams: Record<string, string>) => {
+  if (Object.keys(queryParams).length === 0) return baseURL
+
+  const url = new URL(baseURL)
+  for (const [key, value] of Object.entries(queryParams)) {
+    url.searchParams.set(key, value)
+  }
+  return url.toString()
+}
+
+const normalizeProviderBaseURL = (baseURL: string, npmPackage: string) => {
+  if (npmPackage === '@ai-sdk/openai-compatible') return baseURL.replace(/\/chat\/completions\/?$/u, '')
+  if (npmPackage === '@ai-sdk/openai') return baseURL.replace(/\/responses\/?$/u, '')
+  return baseURL
+}
+
+const getProviderExtra = (service: ModelServiceConfig) => ({
+  ...asPlainRecord(asPlainRecord(service.extra)?.codex),
+  ...asPlainRecord(asPlainRecord(service.extra)?.opencode)
+})
+
+const inferProviderPackage = (service: ModelServiceConfig, providerExtra: Record<string, unknown>) => {
+  if (typeof providerExtra.npm === 'string' && providerExtra.npm.trim() !== '') return providerExtra.npm
+  const wireApi = typeof providerExtra.wireApi === 'string' ? providerExtra.wireApi : undefined
+  return wireApi === 'responses' || service.apiBaseUrl.includes('/responses')
+    ? '@ai-sdk/openai'
+    : '@ai-sdk/openai-compatible'
+}
+
+export const resolveOpenCodeModel = (
+  rawModel: string | undefined,
+  modelServices: Record<string, ModelServiceConfig>
+) => {
+  const normalized = rawModel?.trim()
+  if (normalized == null || normalized === '' || normalized.toLowerCase() === 'default') {
+    return { cliModel: undefined, providerConfig: undefined }
+  }
+
+  if (!normalized.includes(',')) {
+    return { cliModel: normalized, providerConfig: undefined }
+  }
+
+  const commaIndex = normalized.indexOf(',')
+  const serviceKey = normalized.slice(0, commaIndex).trim()
+  const modelId = normalized.slice(commaIndex + 1).trim()
+  const service = modelServices[serviceKey]
+
+  if (!service || modelId === '') {
+    return {
+      cliModel: serviceKey !== '' && modelId !== '' ? `${serviceKey}/${modelId}` : (modelId || normalized),
+      providerConfig: undefined
+    }
+  }
+
+  const providerExtra = getProviderExtra(service)
+  const providerId = typeof providerExtra.providerId === 'string' && providerExtra.providerId.trim() !== ''
+    ? providerExtra.providerId
+    : serviceKey
+  const npm = inferProviderPackage(service, providerExtra)
+  const baseURL = appendQueryParams(
+    normalizeProviderBaseURL(service.apiBaseUrl, npm),
+    normalizeStringRecord(providerExtra.queryParams)
+  )
+  const normalizedTimeoutMs = normalizePositiveInteger(service.timeoutMs)
+  const normalizedMaxOutputTokens = normalizePositiveInteger(service.maxOutputTokens)
+
+  return {
+    cliModel: `${providerId}/${modelId}`,
+    providerConfig: {
+      [providerId]: {
+        npm,
+        name: service.title?.trim() !== '' ? service.title : serviceKey,
+        options: {
+          apiKey: service.apiKey,
+          baseURL,
+          ...(normalizedTimeoutMs != null
+            ? {
+              timeout: normalizedTimeoutMs,
+              chunkTimeout: normalizedTimeoutMs
+            }
+            : {}),
+          ...(() => {
+            const headers = normalizeStringRecord(providerExtra.headers)
+            return Object.keys(headers).length > 0 ? { headers } : {}
+          })()
+        },
+        models: {
+          [modelId]: {
+            name: modelId,
+            ...(normalizedMaxOutputTokens != null
+              ? {
+                limit: {
+                  output: normalizedMaxOutputTokens
+                },
+                options: {
+                  maxOutputTokens: normalizedMaxOutputTokens
+                }
+              }
+              : {})
+          }
+        }
+      }
+    }
+  }
+}

package/src/runtime/common/object-utils.ts

@@ -0,0 +1,35 @@
+export const asPlainRecord = (value: unknown): Record<string, unknown> | undefined => (
+  value != null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined
+)
+
+export const normalizeStringRecord = (value: unknown) => {
+  const result: Record<string, string> = {}
+  const record = asPlainRecord(value)
+  if (!record) return result
+
+  for (const [key, entry] of Object.entries(record)) {
+    if (typeof entry === 'string' && entry !== '') {
+      result[key] = entry
+    }
+  }
+
+  return result
+}
+
+export const deepMerge = (base: Record<string, unknown>, override: Record<string, unknown>) => {
+  const result: Record<string, unknown> = { ...base }
+
+  for (const [key, value] of Object.entries(override)) {
+    const baseRecord = asPlainRecord(result[key])
+    const valueRecord = asPlainRecord(value)
+    if (baseRecord && valueRecord) {
+      result[key] = deepMerge(baseRecord, valueRecord)
+      continue
+    }
+    result[key] = value
+  }
+
+  return result
+}

package/src/runtime/common/permission-node.ts

@@ -0,0 +1,119 @@
+import { asPlainRecord } from './object-utils'
+import { LEGACY_TOOL_PERMISSION_ALIASES } from './tools'
+
+export type PermissionValue = 'allow' | 'ask' | 'deny'
+export type PermissionNode = PermissionValue | PermissionRecord
+export interface PermissionRecord {
+  [key: string]: PermissionNode
+}
+
+export const isPermissionValue = (value: unknown): value is PermissionValue => (
+  value === 'allow' || value === 'ask' || value === 'deny'
+)
+
+export const normalizePermissionNode = (value: unknown): PermissionNode | undefined => {
+  if (isPermissionValue(value)) return value
+
+  const record = asPlainRecord(value)
+  if (!record) return undefined
+
+  const result: PermissionRecord = {}
+  for (const [key, entry] of Object.entries(record)) {
+    const normalized = normalizePermissionNode(entry)
+    if (normalized != null) result[key] = normalized
+  }
+
+  return Object.keys(result).length > 0 ? result : {}
+}
+
+const clonePermissionNode = (value: PermissionNode | undefined): PermissionNode | undefined => {
+  if (value == null || isPermissionValue(value)) return value
+  const result: PermissionRecord = {}
+  for (const [key, entry] of Object.entries(value)) {
+    const cloned = clonePermissionNode(entry)
+    if (cloned != null) result[key] = cloned
+  }
+  return result
+}
+
+const asPermissionRecord = (value: PermissionNode | undefined): PermissionRecord | undefined => (
+  value != null && !isPermissionValue(value) ? value : undefined
+)
+
+const transformPermissionNode = (
+  value: PermissionNode | undefined,
+  transform: (entry: PermissionValue) => PermissionValue
+): PermissionNode | undefined => {
+  if (value == null || isPermissionValue(value)) return value == null ? undefined : transform(value)
+
+  const result: PermissionRecord = {}
+  for (const [key, entry] of Object.entries(value)) {
+    const transformed = transformPermissionNode(entry, transform)
+    if (transformed != null) result[key] = transformed
+  }
+  return result
+}
+
+const applyPermissionLevel = (base: PermissionNode | undefined, level: PermissionValue): PermissionNode => {
+  if (base == null) return level
+  if (isPermissionValue(base)) {
+    if (level === 'deny') return 'deny'
+    if (level === 'allow') return base === 'ask' ? 'allow' : base
+    return base === 'allow' ? 'ask' : base
+  }
+
+  if (level === 'deny') return 'deny'
+  const record = asPermissionRecord(transformPermissionNode(base, (entry) => (
+    level === 'allow'
+      ? (entry === 'ask' ? 'allow' : entry)
+      : (entry === 'allow' ? 'ask' : entry)
+  ))) ?? {}
+  if (!('*' in record)) record['*'] = level
+  return record
+}
+
+export const mergePermissionNodes = (
+  base: PermissionNode | undefined,
+  override: PermissionNode | undefined
+): PermissionNode | undefined => {
+  if (override == null) return clonePermissionNode(base)
+  if (base == null) return clonePermissionNode(override)
+  if (isPermissionValue(base)) return isPermissionValue(override) ? override : mergePermissionNodes({ '*': base }, override)
+  if (isPermissionValue(override)) return applyPermissionLevel(base, override)
+
+  const result: PermissionRecord = { ...(clonePermissionNode(base) as PermissionRecord) }
+  for (const [key, value] of Object.entries(override)) {
+    result[key] = mergePermissionNodes(result[key], value) as PermissionNode
+  }
+  return result
+}
+
+export const rewritePermissionMode = (
+  value: PermissionNode | undefined,
+  mode: 'dontAsk' | 'bypassPermissions'
+): PermissionNode => {
+  const transformed = transformPermissionNode(value, (entry) => (
+    mode === 'bypassPermissions' || entry === 'ask' ? 'allow' : entry
+  ))
+
+  if (transformed == null || isPermissionValue(transformed)) return transformed ?? { '*': 'allow' }
+  if (!('*' in transformed)) transformed['*'] = 'allow'
+  return transformed
+}
+
+export const findPermissionEntry = (
+  permission: PermissionNode | undefined,
+  key: string
+): PermissionNode | undefined => {
+  const record = asPermissionRecord(permission)
+  if (!record) return undefined
+  if (key in record) return clonePermissionNode(record[key])
+
+  for (const [alias, normalized] of Object.entries(LEGACY_TOOL_PERMISSION_ALIASES)) {
+    if (normalized === key && alias in record) {
+      return clonePermissionNode(record[alias] as PermissionNode)
+    }
+  }
+
+  return undefined
+}

package/src/runtime/common/permissions.ts

@@ -0,0 +1,73 @@
+import type { AdapterQueryOptions } from '@vibe-forge/core/adapter'
+
+import {
+  findPermissionEntry,
+  isPermissionValue,
+  type PermissionNode,
+  type PermissionRecord,
+  type PermissionValue
+} from './permission-node'
+import { LEGACY_TOOL_PERMISSION_ALIASES } from './tools'
+
+const OPENCODE_PERMISSION_KEYS = [
+  'bash', 'edit', 'glob', 'grep', 'question', 'read', 'list', 'lsp', 'skill',
+  'task', 'todoread', 'todowrite', 'webfetch', 'websearch', 'codesearch'
+]
+
+export const mapPermissionModeToOpenCode = (
+  permissionMode: AdapterQueryOptions['permissionMode']
+): PermissionRecord | undefined => {
+  if (permissionMode == null) return undefined
+  if (permissionMode === 'dontAsk' || permissionMode === 'bypassPermissions') return { '*': 'allow' as const }
+  if (permissionMode === 'acceptEdits') return { '*': 'allow' as const, bash: 'ask', edit: 'allow', task: 'ask' }
+  if (permissionMode === 'plan') return { '*': 'allow' as const, bash: 'ask', edit: 'deny', task: 'deny' }
+  return { '*': 'allow' as const, bash: 'ask', edit: 'ask', task: 'ask' }
+}
+
+const normalizePermissionToolKey = (value: string) => {
+  const key = value.trim()
+  if (key === '') return undefined
+  return LEGACY_TOOL_PERMISSION_ALIASES[key] ?? key
+}
+
+const resolvePermissionValue = (
+  key: string,
+  basePermission: PermissionNode | undefined
+): PermissionValue => {
+  const explicit = findPermissionEntry(basePermission, key)
+  if (isPermissionValue(explicit)) return explicit
+
+  const wildcard = findPermissionEntry(basePermission, '*')
+  if (isPermissionValue(wildcard)) return wildcard
+
+  return isPermissionValue(basePermission) ? basePermission : 'allow'
+}
+
+export const buildToolPermissionConfig = (
+  tools: AdapterQueryOptions['tools'],
+  basePermission: PermissionNode | undefined = undefined
+) => {
+  const includes = new Set((tools?.include ?? []).map(normalizePermissionToolKey).filter(Boolean) as string[])
+  const excludes = new Set((tools?.exclude ?? []).map(normalizePermissionToolKey).filter(Boolean) as string[])
+  const allowAllTools = includes.delete('*')
+
+  if (includes.size === 0 && excludes.size === 0) return undefined
+
+  const result: PermissionRecord = {}
+  const explicitKeys = Object.keys(
+    isPermissionValue(basePermission) || basePermission == null ? {} : basePermission
+  ).map(normalizePermissionToolKey).filter((value): value is string => value != null && value !== '*')
+
+  if (includes.size > 0 && !allowAllTools) {
+    result['*'] = 'deny'
+    for (const key of new Set([...OPENCODE_PERMISSION_KEYS, ...explicitKeys])) {
+      if (!includes.has(key)) result[key] = 'deny'
+    }
+    for (const key of includes) {
+      result[key] = findPermissionEntry(basePermission, key) ?? resolvePermissionValue(key, basePermission)
+    }
+  }
+
+  for (const key of excludes) result[key] = 'deny'
+  return result
+}

package/src/runtime/common/prompt.ts

@@ -0,0 +1,56 @@
+import { isAbsolute } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import type { AdapterMessageContent } from '@vibe-forge/core/adapter'
+
+export const resolveLocalAttachmentPath = (value: string) => {
+  if (value.startsWith('file://')) {
+    try {
+      return fileURLToPath(value)
+    } catch {
+      return undefined
+    }
+  }
+
+  return isAbsolute(value) ? value : undefined
+}
+
+export const normalizeOpenCodePrompt = (content: AdapterMessageContent[]) => {
+  const promptParts: string[] = []
+  const files = new Set<string>()
+
+  for (const item of content) {
+    if (item.type === 'text') {
+      const text = item.text.trim()
+      if (text !== '') promptParts.push(text)
+      continue
+    }
+
+    if (item.type === 'image') {
+      const filePath = resolveLocalAttachmentPath(item.url)
+      if (filePath) files.add(filePath)
+      continue
+    }
+
+    if (item.type === 'tool_result') {
+      promptParts.push(String(item.content))
+      continue
+    }
+
+    if (item.type === 'tool_use') {
+      promptParts.push(`Tool request: ${item.name}`)
+    }
+  }
+
+  return {
+    prompt: promptParts.join('\n\n').trim() || (
+      files.size > 0 ? 'Please inspect the attached file(s).' : 'Continue.'
+    ),
+    files: Array.from(files)
+  }
+}
+
+export const buildOpenCodeSessionTitle = (
+  sessionId: string,
+  titlePrefix: string = 'Vibe Forge'
+) => `${titlePrefix}:${sessionId}`

package/src/runtime/common/session-records.ts

@@ -0,0 +1,61 @@
+import { asPlainRecord } from './object-utils'
+
+const parseTimestamp = (value: unknown) => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Date.parse(value)
+    return Number.isNaN(parsed) ? undefined : parsed
+  }
+
+  return undefined
+}
+
+export interface OpenCodeSessionRecord {
+  id: string
+  title?: string
+  updatedAt?: number
+}
+
+export const extractOpenCodeSessionRecords = (input: unknown): OpenCodeSessionRecord[] => {
+  const parsed = typeof input === 'string' ? JSON.parse(input) : input
+  const record = asPlainRecord(parsed)
+  const payload = Array.isArray(parsed)
+    ? parsed
+    : Array.isArray(record?.sessions)
+      ? record.sessions as unknown[]
+      : Array.isArray(record?.items)
+        ? record.items as unknown[]
+        : []
+
+  return payload.flatMap((entry) => {
+    const current = asPlainRecord(entry)
+    if (!current) return []
+
+    const id = [current.id, current.sessionId, current.sessionID]
+      .find((value): value is string => typeof value === 'string' && value.trim() !== '')
+    if (id == null) return []
+
+    return [{
+      id,
+      title: typeof current.title === 'string' && current.title.trim() !== '' ? current.title : undefined,
+      updatedAt: parseTimestamp(
+        current.updatedAt ??
+        current.updated_at ??
+        current.modifiedAt ??
+        current.modified_at ??
+        current.createdAt ??
+        current.created_at
+      )
+    }]
+  })
+}
+
+export const selectOpenCodeSessionByTitle = (
+  sessions: OpenCodeSessionRecord[],
+  title: string
+) => (
+  sessions
+    .filter(session => session.title === title)
+    .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0]
+)