feat: upgrade to support opencode v2

Author: christiangalsterer

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 * support OpenCode 1.x and 2.x from one package version using separate lazy-loaded TUI adapters
 
+
 ## [1.4.0](https://github.com/christiangalsterer/opencode-requesty-plugin/compare/v1.3.1...v1.4.0) (2026-09-26)
 
 

README.md

@@ -113,7 +113,6 @@ For a project-specific installation, add the package to that project's `opencode
 }
 ```
 
-V2 loads the package's `setup` implementation using its CLI plugin API. Since this package exposes a TUI component, OpenCode 2 loads it from the `plugins` list in `opencode.json`; it does not need to be added to `cli.json`. V1 `tui.json` configuration remains for OpenCode 1.x. The v2 prompt indicator is appended to the prompt footer status area, while the usage widget remains in the sidebar.
 
 ## Updating
 

package.json

@@ -91,7 +91,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "ci": "bun run clean && bun install --frozen-lockfile && bun test && bun run build && bun run renovate:config && bun pm pack && npm i --omit=dev --dry-run *.tgz",
+    "ci": "bun run clean && bun install --frozen-lockfile && bun test && bun run build && bun run package:check && bun run renovate:config && bun pm pack --ignore-scripts && npm i --omit=dev --dry-run *.tgz",
     "biome": "biome check",
     "biome:fix": "biome check --write",
     "build": "bun run typecheck && bun run build.ts",
@@ -110,6 +110,7 @@
     "test": "bun run typecheck && bun test",
     "test:coverage": "bun run typecheck && bun test --coverage",
     "release:prepare": "bun run clean && bun install && bun run format && bun test",
+    "package:check": "bun scripts/check-package-artifact.ts",
     "publish-npm": "bun run ci && bun publish --access=public",
     "publish-npm:dry-run": "bun run ci && bun publish --access=public --dry-run",
     "prepare": "husky",

scripts/check-package-artifact.ts

@@ -0,0 +1,59 @@
+import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const temporary = await mkdtemp(path.join(os.tmpdir(), 'requesty-plugin-package-'))
+
+try {
+  const packed = Bun.spawnSync([process.execPath, 'pm', 'pack', '--ignore-scripts', '--destination', temporary, '--quiet'], { cwd: root })
+  if (packed.exitCode !== 0) {
+    throw new Error(packed.stderr.toString() || 'bun pm pack failed')
+  }
+
+  const archives = (await readdir(temporary)).filter((name) => name.endsWith('.tgz'))
+  if (archives.length !== 1) {
+    throw new Error(`Expected one package tarball, found ${archives.length}`)
+  }
+  const archive = archives[0]
+  if (!archive) {
+    throw new Error('Packed tarball name was empty')
+  }
+
+  const unpacked = Bun.spawnSync(['tar', '-xzf', path.join(temporary, archive), '-C', temporary])
+  if (unpacked.exitCode !== 0) {
+    throw new Error(unpacked.stderr.toString() || 'tar extraction failed')
+  }
+
+  const packageRoot = path.join(temporary, 'package')
+  const manifest = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8')) as {
+    exports?: { './tui'?: { import?: string } }
+  }
+  const entry = manifest.exports?.['./tui']?.import
+  if (!entry) {
+    throw new Error('Package is missing exports["./tui"].import')
+  }
+
+  const entryPath = path.join(packageRoot, entry)
+  const entrySource = await readFile(entryPath, 'utf8')
+  if (!entrySource.includes('async tui(') || !entrySource.includes('async setup(')) {
+    throw new Error('Packed TUI entrypoint is missing a v1 tui or v2 setup adapter')
+  }
+
+  const chunks = [...entrySource.matchAll(/import\("([^"]+\.js)"\)/g)].map((match) => match[1]).filter(Boolean)
+  if (chunks.length !== 2) {
+    throw new Error(`Expected two lazy adapter chunks, found ${chunks.length}`)
+  }
+  await Promise.all(chunks.map((chunk) => readFile(path.resolve(path.dirname(entryPath), chunk))))
+
+  const plugin = await import(`${pathToFileURL(entryPath).href}?package-check=${Date.now()}`)
+  if (plugin.default?.id !== 'opencode-requesty-plugin') {
+    throw new Error('Packed plugin has an unexpected id')
+  }
+  if (typeof plugin.default?.tui !== 'function' || typeof plugin.default?.setup !== 'function') {
+    throw new Error('Packed plugin must expose both the v1 tui and v2 setup adapters')
+  }
+} finally {
+  await rm(temporary, { recursive: true, force: true })
+}

src/host-store.ts

@@ -0,0 +1,31 @@
+import type { ProjectionSettings } from './settings'
+import { createRequestyStore, type ActiveSession, type RequestyStore } from './state'
+import { descendantSessionIDs, rootSessionID } from './descendants'
+
+export interface RequestyHostStoreOptions {
+  apiKey: string
+  projection: ProjectionSettings
+  createSignal: NonNullable<Parameters<typeof createRequestyStore>[0]['createSignal']>
+  getSessionParentID: (sessionID: string) => string | undefined
+  getSessionCreatedAt: (sessionID: string) => number | undefined
+  fetchSessionChildren: (sessionID: string) => Promise<string[]>
+  onError: (message: string) => void
+  onRender: () => void
+}
+
+export function createRequestyHostStore(options: RequestyHostStoreOptions): RequestyStore {
+  const activeSession = (sessionID: string): ActiveSession => {
+    const rootID = rootSessionID(sessionID, options.getSessionParentID)
+    return { id: rootID, created: options.getSessionCreatedAt(rootID) }
+  }
+
+  return createRequestyStore({
+    apiKey: options.apiKey,
+    projection: options.projection,
+    createSignal: options.createSignal,
+    activeSession,
+    fetchSessionChildren: (sessionID) => descendantSessionIDs(sessionID, options.fetchSessionChildren),
+    onError: options.onError,
+    onRender: options.onRender
+  })
+}

src/key.ts

@@ -66,7 +66,7 @@ function environmentKey(provider: ProviderConfig): string | undefined {
 }
 
 function fromConfig(config: SdkConfigLike | undefined): string | undefined {
-  const providers = config?.provider ?? config?.providers
+  const providers = { ...config?.provider, ...config?.providers }
   if (!providers) return undefined
   // Prefer the canonical provider id, then any custom Requesty provider.
   const names = Object.keys(providers).sort((a, b) => (a === 'requesty' ? -1 : b === 'requesty' ? 1 : a.localeCompare(b)))

src/tui-v1.tsx

@@ -2,13 +2,13 @@
 import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
 import { createSignal } from 'solid-js'
 import { setApiLogger } from './api'
-import { descendantSessionIDs, rootSessionID } from './descendants'
 import { RequestyDetailDialog } from './dialog'
+import { createRequestyHostStore } from './host-store'
 import { detectApiKey } from './key'
 import { RequestyPromptWidget } from './prompt'
 import { sessionIDFromRoute } from './route'
 import { readSettings } from './settings'
-import { createRequestyStore, type RequestyStore } from './state'
+import type { RequestyStore } from './state'
 import { RequestySidebarWidget } from './widget'
 
 const COMMAND_OPEN = 'requesty.open'
@@ -45,7 +45,7 @@ export function runV1(api: TuiPluginApi, rawOptions: Record<string, unknown> | u
     return
   }
 
-  const store: RequestyStore = createRequestyStore({
+  const store: RequestyStore = createRequestyHostStore({
     apiKey: key.apiKey,
     projection: settings.projection,
     // Use this module's `createSignal` (the same Solid instance the widget
@@ -54,18 +54,9 @@ export function runV1(api: TuiPluginApi, rawOptions: Record<string, unknown> | u
     onError: (message) => {
       api.ui.toast({ variant: 'error', title: 'Requesty', message })
     },
-    activeSession: (sessionID) => {
-      const rootID = rootSessionID(sessionID, (id) => api.state.session.get(id)?.parentID)
-      const session = api.state.session.get(rootID)
-      if (!session) {
-        return { id: rootID, created: undefined }
-      }
-      return { id: rootID, created: session.time?.created }
-    },
-    fetchSessionChildren: (sessionID) =>
-      descendantSessionIDs(sessionID, (id) =>
-        api.client.session.children({ sessionID: id }).then((result) => (result.data ?? []).map((child) => child.id))
-      ),
+    getSessionParentID: (sessionID) => api.state.session.get(sessionID)?.parentID,
+    getSessionCreatedAt: (sessionID) => api.state.session.get(sessionID)?.time?.created,
+    fetchSessionChildren: (sessionID) => api.client.session.children({ sessionID }).then((result) => (result.data ?? []).map((child) => child.id)),
     onRender: () => api.renderer.requestRender()
   })
 

src/tui-v2.tsx

@@ -1,17 +1,18 @@
 /** @jsxImportSource @opentui/solid */
 
-import type { ProviderInfo, SessionInfo } from '@opencode/client'
+import type { SessionInfo } from '@opencode/client'
 import type { Context } from '@opencode/plugin/tui/context'
 import { createSignal } from 'solid-js'
 import { setApiLogger } from './api'
-import { descendantSessionIDs, rootSessionID } from './descendants'
+import { createRequestyHostStore } from './host-store'
 import { RequestyDetailDialog } from './dialog'
 import { detectApiKey } from './key'
 import { RequestyPromptWidget } from './prompt'
 import { readSettings } from './settings'
-import { createRequestyStore, type RequestyStore } from './state'
+import type { RequestyStore } from './state'
 import { RequestySidebarWidget } from './widget'
 import type { RequestyTheme, RequestyWidgetHost } from './ui-types'
+import { normalizeV2ConfigDocuments, type V2ConfigDocument } from './v2-config'
 
 const REFRESH_DEBOUNCE_MS = 2000
 const REFRESH_SESSION_TYPES = new Set([
@@ -25,17 +26,6 @@ const REFRESH_SESSION_TYPES = new Set([
   'session.usage.recorded'
 ])
 
-interface V2ConfigDocument {
-  info?: {
-    providers?: Record<string, ProviderInfo | Record<string, unknown>>
-    provider?: Record<string, Record<string, unknown>>
-  }
-}
-
-interface V2Config {
-  providers?: Record<string, { options?: { apiKey?: unknown; baseURL?: unknown } }>
-}
-
 function themeFor(context: Context): RequestyTheme {
   const theme = context.theme
   return {
@@ -49,39 +39,12 @@ function themeFor(context: Context): RequestyTheme {
   }
 }
 
-function configForKey(entries: readonly V2ConfigDocument[]): V2Config {
-  const providers: Record<string, Record<string, unknown>> = {}
-  for (const entry of entries) {
-    const info = entry.info
-    for (const [id, provider] of Object.entries(info?.provider ?? {})) {
-      providers[id] = { ...providers[id], ...provider }
-    }
-    for (const [id, provider] of Object.entries(info?.providers ?? {})) {
-      const candidate = provider as Record<string, unknown>
-      providers[id] = {
-        ...providers[id],
-        env: candidate.env,
-        options: {
-          ...(providers[id]?.options as Record<string, unknown> | undefined),
-          ...(candidate.settings as Record<string, unknown> | undefined)
-        }
-      }
-    }
-  }
-  return { providers }
-}
-
 function sessionCostHost(context: Context): RequestyWidgetHost {
   return {
     sessionMessages: (sessionID) => context.data.session.message.list(sessionID)
   }
 }
 
-function rootSession(context: Context, sessionID: string): SessionInfo | undefined {
-  const rootID = context.data.session.root(sessionID)
-  return context.data.session.get(rootID)
-}
-
 function sessionChildren(context: Context, sessionID: string): Promise<string[]> {
   return Promise.resolve(context.data.session.family(sessionID).filter((id) => id !== sessionID))
 }
@@ -90,15 +53,14 @@ async function runV2(context: Context): Promise<(() => void) | undefined> {
   const settings = readSettings(context.options)
   setApiLogger(undefined)
 
-  let config: V2Config = {}
+  let config: readonly V2ConfigDocument[] = []
   try {
-    const entries = (await context.client.config.get()) as readonly V2ConfigDocument[]
-    config = configForKey(entries)
+    config = (await context.client.config.get()) as V2ConfigDocument[]
   } catch {
     // A config lookup failure is reported as the normal missing-key state.
   }
 
-  const key = detectApiKey(config)
+  const key = detectApiKey(normalizeV2ConfigDocuments(config))
   if (!key.ok) {
     if (settings.sidebar.enabled) {
       context.ui.slot({
@@ -116,18 +78,14 @@ async function runV2(context: Context): Promise<(() => void) | undefined> {
     return undefined
   }
 
-  const activeSession = (sessionID: string) => {
-    const session = rootSession(context, sessionID)
-    return { id: context.data.session.root(sessionID), created: session?.time.created }
-  }
-
-  const store: RequestyStore = createRequestyStore({
+  const store: RequestyStore = createRequestyHostStore({
     apiKey: key.apiKey,
     projection: settings.projection,
     createSignal,
+    getSessionParentID: (sessionID) => context.data.session.get(sessionID)?.parentID,
+    getSessionCreatedAt: (sessionID) => context.data.session.get(context.data.session.root(sessionID))?.time.created,
+    fetchSessionChildren: (sessionID) => sessionChildren(context, sessionID),
     onError: (message) => context.ui.toast.show({ variant: 'error', title: 'Requesty', message }),
-    activeSession,
-    fetchSessionChildren: (id) => descendantSessionIDs(id, (parentID) => sessionChildren(context, parentID)),
     onRender: () => context.renderer.requestRender()
   })
   const widgetHost = sessionCostHost(context)

src/v2-config.ts

@@ -0,0 +1,65 @@
+import type { ProviderInfo } from '@opencode/client'
+
+export interface V2ConfigDocument {
+  type?: 'document' | 'directory'
+  path?: string
+  info?: {
+    providers?: Record<string, ProviderInfo | Record<string, unknown>>
+    provider?: Record<string, Record<string, unknown>>
+  }
+}
+
+export interface RequestyProviderConfig {
+  env?: unknown
+  options?: Record<string, unknown>
+  settings?: Record<string, unknown>
+}
+
+export interface RequestyConfig {
+  providers: Record<string, RequestyProviderConfig>
+  provider: Record<string, RequestyProviderConfig>
+}
+
+/** Merge V2 config documents in precedence order into the shared key-detector shape. */
+export function normalizeV2ConfigDocuments(entries: readonly V2ConfigDocument[]): RequestyConfig {
+  const config: RequestyConfig = { provider: {}, providers: {} }
+
+  for (const entry of entries) {
+    const info = entry.info
+    if (!info) continue
+    mergeProviders(config.provider, info.provider)
+    mergeProviders(config.providers, info.providers, true)
+  }
+
+  return config
+}
+
+function mergeProviders(target: Record<string, RequestyProviderConfig>, source: Record<string, unknown> | undefined, useSettings = false): void {
+  for (const [id, value] of Object.entries(source ?? {})) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue
+    const provider = value as Record<string, unknown>
+    const current = target[id]
+    const nextSettings = asRecord(provider.settings)
+    const nextOptions = asRecord(provider.options)
+
+    target[id] = {
+      ...current,
+      ...provider,
+      env: provider.env ?? current?.env,
+      options: {
+        ...current?.options,
+        ...nextOptions,
+        ...(useSettings ? nextSettings : undefined)
+      },
+      settings: {
+        ...current?.settings,
+        ...nextSettings
+      }
+    }
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+  return value as Record<string, unknown>
+}