remove strays

.opencode/plugins/smoke-theme.json

@@ -48,11 +48,11 @@
       "light": "nord10"
     },
     "text": {
-      "dark": "nord4",
+      "dark": "nord6",
       "light": "nord0"
     },
     "textMuted": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord1"
     },
     "background": {
@@ -64,7 +64,7 @@
       "light": "nord5"
     },
     "backgroundElement": {
-      "dark": "nord1",
+      "dark": "nord2",
       "light": "nord4"
     },
     "border": {
@@ -88,11 +88,11 @@
       "light": "nord11"
     },
     "diffContext": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord3"
     },
     "diffHunkHeader": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord3"
     },
     "diffHighlightAdded": {
@@ -104,12 +104,12 @@
       "light": "nord11"
     },
     "diffAddedBg": {
-      "dark": "#3B4252",
-      "light": "#E5E9F0"
+      "dark": "#36413C",
+      "light": "#E6EBE7"
     },
     "diffRemovedBg": {
-      "dark": "#3B4252",
-      "light": "#E5E9F0"
+      "dark": "#43393D",
+      "light": "#ECE6E8"
     },
     "diffContextBg": {
       "dark": "nord1",
@@ -120,12 +120,12 @@
       "light": "nord4"
     },
     "diffAddedLineNumberBg": {
-      "dark": "#3B4252",
-      "light": "#E5E9F0"
+      "dark": "#303A35",
+      "light": "#DDE4DF"
     },
     "diffRemovedLineNumberBg": {
-      "dark": "#3B4252",
-      "light": "#E5E9F0"
+      "dark": "#3C3336",
+      "light": "#E4DDE0"
     },
     "markdownText": {
       "dark": "nord4",
@@ -148,7 +148,7 @@
       "light": "nord14"
     },
     "markdownBlockQuote": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord3"
     },
     "markdownEmph": {
@@ -160,7 +160,7 @@
       "light": "nord13"
     },
     "markdownHorizontalRule": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord3"
     },
     "markdownListItem": {
@@ -184,7 +184,7 @@
       "light": "nord0"
     },
     "syntaxComment": {
-      "dark": "nord3",
+      "dark": "#8B95A7",
       "light": "nord3"
     },
     "syntaxKeyword": {

.opencode/plugins/tui-smoke.tsx

@@ -0,0 +1,912 @@
+/** @jsxImportSource @opentui/solid */
+import { extend, useKeyboard, useTerminalDimensions, type RenderableConstructor } from "@opentui/solid"
+import { RGBA, VignetteEffect, type OptimizedBuffer, type RenderContext } from "@opentui/core"
+import { ThreeRenderable, THREE } from "@opentui/core/3d"
+import type { TuiApi, TuiKeybindSet, TuiPluginInit, TuiPluginInput } from "@opencode-ai/plugin/tui"
+
+const tabs = ["overview", "counter", "help"]
+const bind = {
+  modal: "ctrl+shift+m",
+  screen: "ctrl+shift+o",
+  home: "escape,ctrl+h",
+  left: "left,h",
+  right: "right,l",
+  up: "up,k",
+  down: "down,j",
+  alert: "a",
+  confirm: "c",
+  prompt: "p",
+  select: "s",
+  modal_accept: "enter,return",
+  modal_close: "escape",
+  dialog_close: "escape",
+  local: "x",
+  local_push: "enter,return",
+  local_close: "q,backspace",
+  host: "z",
+}
+
+const pick = (value: unknown, fallback: string) => {
+  if (typeof value !== "string") return fallback
+  if (!value.trim()) return fallback
+  return value
+}
+
+const num = (value: unknown, fallback: number) => {
+  if (typeof value !== "number") return fallback
+  return value
+}
+
+const rec = (value: unknown) => {
+  if (!value || typeof value !== "object") return
+  return value as Record<string, unknown>
+}
+
+type Cfg = {
+  label: string
+  route: string
+  vignette: number
+  keybinds: Record<string, unknown> | undefined
+}
+
+type Route = {
+  modal: string
+  screen: string
+}
+
+type State = {
+  tab: number
+  count: number
+  source: string
+  note: string
+  selected: string
+  local: number
+}
+
+const cfg = (options: Record<string, unknown> | undefined) => {
+  return {
+    label: pick(options?.label, "smoke"),
+    route: pick(options?.route, "workspace-smoke"),
+    vignette: Math.max(0, num(options?.vignette, 0.35)),
+    keybinds: rec(options?.keybinds),
+  }
+}
+
+const names = (input: Cfg) => {
+  return {
+    modal: `${input.route}.modal`,
+    screen: `${input.route}.screen`,
+  }
+}
+
+type Keys = TuiKeybindSet
+const ui = {
+  panel: "#1d1d1d",
+  border: "#4a4a4a",
+  text: "#f0f0f0",
+  muted: "#a5a5a5",
+  accent: "#5f87ff",
+}
+
+type Color = RGBA | string
+
+const tone = (api: TuiApi) => {
+  const map = api.theme.current as Record<string, unknown>
+  const get = (name: string, fallback: string): Color => {
+    const value = map[name]
+    if (typeof value === "string") return value
+    if (value && typeof value === "object") return value as RGBA
+    return fallback
+  }
+  return {
+    panel: get("backgroundPanel", ui.panel),
+    border: get("border", ui.border),
+    text: get("text", ui.text),
+    muted: get("textMuted", ui.muted),
+    accent: get("primary", ui.accent),
+    selected: get("selectedListItemText", ui.text),
+  }
+}
+
+type Skin = {
+  panel: Color
+  border: Color
+  text: Color
+  muted: Color
+  accent: Color
+  selected: Color
+}
+type CubeOpts = ConstructorParameters<typeof ThreeRenderable>[1] & {
+  tint?: Color
+  spec?: Color
+  ambient?: Color
+  key_light?: Color
+  fill_light?: Color
+}
+
+const rgb = (value: unknown, fallback: string) => {
+  if (typeof value === "string") return new THREE.Color(value)
+  if (value && typeof value === "object") {
+    const item = value as { r?: unknown; g?: unknown; b?: unknown }
+    if (typeof item.r === "number" && typeof item.g === "number" && typeof item.b === "number") {
+      return new THREE.Color(item.r, item.g, item.b)
+    }
+  }
+  return new THREE.Color(fallback)
+}
+
+class Cube extends ThreeRenderable {
+  private cube: THREE.Mesh
+  private mat: THREE.MeshPhongMaterial
+  private amb: THREE.AmbientLight
+  private key: THREE.DirectionalLight
+  private fill: THREE.DirectionalLight
+
+  constructor(ctx: RenderContext, opts: CubeOpts) {
+    const scene = new THREE.Scene()
+    const camera = new THREE.PerspectiveCamera(40, 1, 0.1, 100)
+    camera.position.set(0, 0, 2.55)
+
+    const amb = new THREE.AmbientLight(rgb(opts.ambient, "#666666"), 1.0)
+    scene.add(amb)
+
+    const key = new THREE.DirectionalLight(rgb(opts.key_light, "#fff2e6"), 1.2)
+    key.position.set(2.5, 2.0, 3.0)
+    scene.add(key)
+
+    const fill = new THREE.DirectionalLight(rgb(opts.fill_light, "#80b3ff"), 0.6)
+    fill.position.set(-2.0, -1.5, 2.5)
+    scene.add(fill)
+
+    const geo = new THREE.BoxGeometry(1.0, 1.0, 1.0)
+    const mat = new THREE.MeshPhongMaterial({
+      color: rgb(opts.tint, "#40ccff"),
+      shininess: 80,
+      specular: rgb(opts.spec, "#e6e6ff"),
+    })
+    const cube = new THREE.Mesh(geo, mat)
+    cube.scale.setScalar(1.12)
+    scene.add(cube)
+
+    super(ctx, {
+      ...opts,
+      scene,
+      camera,
+      renderer: {
+        focalLength: 8,
+        alpha: true,
+        backgroundColor: RGBA.fromValues(0, 0, 0, 0),
+      },
+    })
+
+    this.cube = cube
+    this.mat = mat
+    this.amb = amb
+    this.key = key
+    this.fill = fill
+  }
+
+  set tint(value: Color | undefined) {
+    this.mat.color.copy(rgb(value, "#40ccff"))
+  }
+
+  set spec(value: Color | undefined) {
+    this.mat.specular.copy(rgb(value, "#e6e6ff"))
+  }
+
+  set ambient(value: Color | undefined) {
+    this.amb.color.copy(rgb(value, "#666666"))
+  }
+
+  set key_light(value: Color | undefined) {
+    this.key.color.copy(rgb(value, "#fff2e6"))
+  }
+
+  set fill_light(value: Color | undefined) {
+    this.fill.color.copy(rgb(value, "#80b3ff"))
+  }
+
+  protected override renderSelf(buf: OptimizedBuffer, dt: number): void {
+    const delta = dt / 1000
+    this.cube.rotation.x += delta * 0.6
+    this.cube.rotation.y += delta * 0.4
+    this.cube.rotation.z += delta * 0.2
+    super.renderSelf(buf, dt)
+  }
+}
+
+declare module "@opentui/solid" {
+  interface OpenTUIComponents {
+    smoke_cube: RenderableConstructor
+  }
+}
+
+extend({ smoke_cube: Cube as unknown as RenderableConstructor })
+
+const Btn = (props: { txt: string; run: () => void; skin: Skin; on?: boolean }) => {
+  return (
+    <box
+      onMouseUp={() => {
+        props.run()
+      }}
+      backgroundColor={props.on ? props.skin.accent : props.skin.border}
+      paddingLeft={1}
+      paddingRight={1}
+    >
+      <text fg={props.on ? props.skin.selected : props.skin.text}>{props.txt}</text>
+    </box>
+  )
+}
+
+const parse = (params: Record<string, unknown> | undefined) => {
+  const tab = typeof params?.tab === "number" ? params.tab : 0
+  const count = typeof params?.count === "number" ? params.count : 0
+  const source = typeof params?.source === "string" ? params.source : "unknown"
+  const note = typeof params?.note === "string" ? params.note : ""
+  const selected = typeof params?.selected === "string" ? params.selected : ""
+  const local = typeof params?.local === "number" ? params.local : 0
+  return {
+    tab: Math.max(0, Math.min(tab, tabs.length - 1)),
+    count,
+    source,
+    note,
+    selected,
+    local: Math.max(0, local),
+  }
+}
+
+const current = (api: TuiApi, route: Route) => {
+  const value = api.route.current
+  const ok = Object.values(route).includes(value.name)
+  if (!ok) return parse(undefined)
+  if (!("params" in value)) return parse(undefined)
+  return parse(value.params)
+}
+
+const opts = [
+  {
+    title: "Overview",
+    value: 0,
+    description: "Switch to overview tab",
+  },
+  {
+    title: "Counter",
+    value: 1,
+    description: "Switch to counter tab",
+  },
+  {
+    title: "Help",
+    value: 2,
+    description: "Switch to help tab",
+  },
+]
+
+const host = (api: TuiApi, input: Cfg, skin: Skin) => {
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <box paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1} flexDirection="column">
+      <text fg={skin.text}>
+        <b>{input.label} host overlay</b>
+      </text>
+      <text fg={skin.muted}>Using api.ui.dialog stack with built-in backdrop</text>
+      <text fg={skin.muted}>esc closes · depth {api.ui.dialog.depth}</text>
+      <box flexDirection="row" gap={1}>
+        <Btn txt="close" run={() => api.ui.dialog.clear()} skin={skin} on />
+      </box>
+    </box>
+  ))
+}
+
+const warn = (api: TuiApi, route: Route, value: State) => {
+  const DialogAlert = api.ui.DialogAlert
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogAlert
+      title="Smoke alert"
+      message="Testing built-in alert dialog"
+      onConfirm={() => api.route.navigate(route.screen, { ...value, source: "alert" })}
+    />
+  ))
+}
+
+const check = (api: TuiApi, route: Route, value: State) => {
+  const DialogConfirm = api.ui.DialogConfirm
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogConfirm
+      title="Smoke confirm"
+      message="Apply +1 to counter?"
+      onConfirm={() => api.route.navigate(route.screen, { ...value, count: value.count + 1, source: "confirm" })}
+      onCancel={() => api.route.navigate(route.screen, { ...value, source: "confirm-cancel" })}
+    />
+  ))
+}
+
+const entry = (api: TuiApi, route: Route, value: State) => {
+  const DialogPrompt = api.ui.DialogPrompt
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogPrompt
+      title="Smoke prompt"
+      value={value.note}
+      onConfirm={(note) => {
+        api.ui.dialog.clear()
+        api.route.navigate(route.screen, { ...value, note, source: "prompt" })
+      }}
+      onCancel={() => {
+        api.ui.dialog.clear()
+        api.route.navigate(route.screen, value)
+      }}
+    />
+  ))
+}
+
+const picker = (api: TuiApi, route: Route, value: State) => {
+  const DialogSelect = api.ui.DialogSelect
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogSelect
+      title="Smoke select"
+      options={opts}
+      current={value.tab}
+      onSelect={(item) => {
+        api.ui.dialog.clear()
+        api.route.navigate(route.screen, {
+          ...value,
+          tab: typeof item.value === "number" ? item.value : value.tab,
+          selected: item.title,
+          source: "select",
+        })
+      }}
+    />
+  ))
+}
+
+const Screen = (props: {
+  api: TuiApi
+  input: Cfg
+  route: Route
+  keys: Keys
+  meta: TuiPluginInit
+  params?: Record<string, unknown>
+}) => {
+  const dim = useTerminalDimensions()
+  const value = parse(props.params)
+  const skin = tone(props.api)
+  const set = (local: number, base?: State) => {
+    const next = base ?? current(props.api, props.route)
+    props.api.route.navigate(props.route.screen, { ...next, local: Math.max(0, local), source: "local" })
+  }
+  const push = (base?: State) => {
+    const next = base ?? current(props.api, props.route)
+    set(next.local + 1, next)
+  }
+  const open = () => {
+    const next = current(props.api, props.route)
+    if (next.local > 0) return
+    set(1, next)
+  }
+  const pop = (base?: State) => {
+    const next = base ?? current(props.api, props.route)
+    const local = Math.max(0, next.local - 1)
+    set(local, next)
+  }
+  const show = () => {
+    setTimeout(() => {
+      open()
+    }, 0)
+  }
+  useKeyboard((evt) => {
+    if (props.api.route.current.name !== props.route.screen) return
+    const next = current(props.api, props.route)
+    if (props.api.ui.dialog.open) {
+      if (props.keys.match("dialog_close", evt)) {
+        evt.preventDefault()
+        evt.stopPropagation()
+        props.api.ui.dialog.clear()
+        return
+      }
+      return
+    }
+
+    if (next.local > 0) {
+      if (evt.name === "escape" || props.keys.match("local_close", evt)) {
+        evt.preventDefault()
+        evt.stopPropagation()
+        pop(next)
+        return
+      }
+
+      if (props.keys.match("local_push", evt)) {
+        evt.preventDefault()
+        evt.stopPropagation()
+        push(next)
+        return
+      }
+      return
+    }
+
+    if (props.keys.match("home", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate("home")
+      return
+    }
+
+    if (props.keys.match("left", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.screen, { ...next, tab: (next.tab - 1 + tabs.length) % tabs.length })
+      return
+    }
+
+    if (props.keys.match("right", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.screen, { ...next, tab: (next.tab + 1) % tabs.length })
+      return
+    }
+
+    if (props.keys.match("up", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.screen, { ...next, count: next.count + 1 })
+      return
+    }
+
+    if (props.keys.match("down", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.screen, { ...next, count: next.count - 1 })
+      return
+    }
+
+    if (props.keys.match("modal", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.modal, next)
+      return
+    }
+
+    if (props.keys.match("local", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      open()
+      return
+    }
+
+    if (props.keys.match("host", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      host(props.api, props.input, skin)
+      return
+    }
+
+    if (props.keys.match("alert", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      warn(props.api, props.route, next)
+      return
+    }
+
+    if (props.keys.match("confirm", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      check(props.api, props.route, next)
+      return
+    }
+
+    if (props.keys.match("prompt", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      entry(props.api, props.route, next)
+      return
+    }
+
+    if (props.keys.match("select", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      picker(props.api, props.route, next)
+    }
+  })
+
+  return (
+    <box width={dim().width} height={dim().height} backgroundColor={skin.panel} position="relative">
+      <box
+        flexDirection="column"
+        width="100%"
+        height="100%"
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+        paddingRight={2}
+      >
+        <box flexDirection="row" justifyContent="space-between" paddingBottom={1}>
+          <text fg={skin.text}>
+            <b>{props.input.label} screen</b>
+            <span style={{ fg: skin.muted }}> plugin route</span>
+          </text>
+          <text fg={skin.muted}>{props.keys.print("home")} home</text>
+        </box>
+
+        <box flexDirection="row" gap={1} paddingBottom={1}>
+          {tabs.map((item, i) => {
+            const on = value.tab === i
+            return (
+              <Btn
+                txt={item}
+                run={() => props.api.route.navigate(props.route.screen, { ...value, tab: i })}
+                skin={skin}
+                on={on}
+              />
+            )
+          })}
+        </box>
+
+        <box
+          border
+          borderColor={skin.border}
+          paddingTop={1}
+          paddingBottom={1}
+          paddingLeft={2}
+          paddingRight={2}
+          flexGrow={1}
+        >
+          {value.tab === 0 ? (
+            <box flexDirection="column" gap={1}>
+              <text fg={skin.text}>Route: {props.route.screen}</text>
+              <text fg={skin.muted}>plugin state: {props.meta.state}</text>
+              <text fg={skin.muted}>
+                first: {props.meta.state === "first" ? "yes" : "no"} · updated:{" "}
+                {props.meta.state === "updated" ? "yes" : "no"} · loads: {props.meta.entry.load_count}
+              </text>
+              <text fg={skin.muted}>plugin source: {props.meta.entry.source}</text>
+              <text fg={skin.muted}>source: {value.source}</text>
+              <text fg={skin.muted}>note: {value.note || "(none)"}</text>
+              <text fg={skin.muted}>selected: {value.selected || "(none)"}</text>
+              <text fg={skin.muted}>local stack depth: {value.local}</text>
+              <text fg={skin.muted}>host stack open: {props.api.ui.dialog.open ? "yes" : "no"}</text>
+            </box>
+          ) : null}
+
+          {value.tab === 1 ? (
+            <box flexDirection="column" gap={1}>
+              <text fg={skin.text}>Counter: {value.count}</text>
+              <text fg={skin.muted}>
+                {props.keys.print("up")} / {props.keys.print("down")} change value
+              </text>
+            </box>
+          ) : null}
+
+          {value.tab === 2 ? (
+            <box flexDirection="column" gap={1}>
+              <text fg={skin.muted}>
+                {props.keys.print("modal")} modal | {props.keys.print("alert")} alert | {props.keys.print("confirm")}{" "}
+                confirm | {props.keys.print("prompt")} prompt | {props.keys.print("select")} select
+              </text>
+              <text fg={skin.muted}>
+                {props.keys.print("local")} local stack | {props.keys.print("host")} host stack
+              </text>
+              <text fg={skin.muted}>
+                local open: {props.keys.print("local_push")} push nested · esc or {props.keys.print("local_close")}{" "}
+                close
+              </text>
+              <text fg={skin.muted}>{props.keys.print("home")} returns home</text>
+            </box>
+          ) : null}
+        </box>
+
+        <box flexDirection="row" gap={1} paddingTop={1}>
+          <Btn txt="go home" run={() => props.api.route.navigate("home")} skin={skin} />
+          <Btn txt="modal" run={() => props.api.route.navigate(props.route.modal, value)} skin={skin} on />
+          <Btn txt="local overlay" run={show} skin={skin} />
+          <Btn txt="host overlay" run={() => host(props.api, props.input, skin)} skin={skin} />
+          <Btn txt="alert" run={() => warn(props.api, props.route, value)} skin={skin} />
+          <Btn txt="confirm" run={() => check(props.api, props.route, value)} skin={skin} />
+          <Btn txt="prompt" run={() => entry(props.api, props.route, value)} skin={skin} />
+          <Btn txt="select" run={() => picker(props.api, props.route, value)} skin={skin} />
+        </box>
+      </box>
+
+      <box
+        visible={value.local > 0}
+        width={dim().width}
+        height={dim().height}
+        alignItems="center"
+        position="absolute"
+        zIndex={3000}
+        paddingTop={dim().height / 4}
+        left={0}
+        top={0}
+        backgroundColor={RGBA.fromInts(0, 0, 0, 160)}
+        onMouseUp={() => {
+          pop()
+        }}
+      >
+        <box
+          onMouseUp={(evt) => {
+            evt.stopPropagation()
+          }}
+          width={60}
+          maxWidth={dim().width - 2}
+          backgroundColor={skin.panel}
+          border
+          borderColor={skin.border}
+          paddingTop={1}
+          paddingBottom={1}
+          paddingLeft={2}
+          paddingRight={2}
+          gap={1}
+          flexDirection="column"
+        >
+          <text fg={skin.text}>
+            <b>{props.input.label} local overlay</b>
+          </text>
+          <text fg={skin.muted}>Plugin-owned stack depth: {value.local}</text>
+          <text fg={skin.muted}>
+            {props.keys.print("local_push")} push nested · {props.keys.print("local_close")} pop/close
+          </text>
+          <box flexDirection="row" gap={1}>
+            <Btn txt="push" run={push} skin={skin} on />
+            <Btn txt="pop" run={pop} skin={skin} />
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}
+
+const Modal = (props: { api: TuiApi; input: Cfg; route: Route; keys: Keys; params?: Record<string, unknown> }) => {
+  const Dialog = props.api.ui.Dialog
+  const value = parse(props.params)
+  const skin = tone(props.api)
+
+  useKeyboard((evt) => {
+    if (props.api.route.current.name !== props.route.modal) return
+
+    if (props.keys.match("modal_accept", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate(props.route.screen, { ...value, source: "modal" })
+      return
+    }
+
+    if (props.keys.match("modal_close", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      props.api.route.navigate("home")
+    }
+  })
+
+  return (
+    <box width="100%" height="100%" backgroundColor={skin.panel}>
+      <Dialog onClose={() => props.api.route.navigate("home")}>
+        <box paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1} flexDirection="column">
+          <text fg={skin.text}>
+            <b>{props.input.label} modal</b>
+          </text>
+          <text fg={skin.muted}>{props.keys.print("modal")} modal command</text>
+          <text fg={skin.muted}>{props.keys.print("screen")} screen command</text>
+          <text fg={skin.muted}>
+            {props.keys.print("modal_accept")} opens screen · {props.keys.print("modal_close")} closes
+          </text>
+          <box flexDirection="row" gap={1}>
+            <Btn
+              txt="open screen"
+              run={() => props.api.route.navigate(props.route.screen, { ...value, source: "modal" })}
+              skin={skin}
+              on
+            />
+            <Btn txt="cancel" run={() => props.api.route.navigate("home")} skin={skin} />
+          </box>
+        </box>
+      </Dialog>
+    </box>
+  )
+}
+
+const slot = (input: Cfg) => ({
+  id: "workspace-smoke",
+  slots: {
+    home_logo(ctx) {
+      const map = ctx.theme.current as Record<string, unknown>
+      const get = (name: string, fallback: string) => {
+        const value = map[name]
+        if (typeof value === "string") return value
+        if (value && typeof value === "object") return value as RGBA
+        return fallback
+      }
+      const art = [
+        "                                  $$\\",
+        "                                  $$ |",
+        " $$$$$$$\\ $$$$$$\\$$$$\\   $$$$$$\\  $$ |  $$\\  $$$$$$\\",
+        "$$  _____|$$  _$$  _$$\\ $$  __$$\\ $$ | $$  |$$  __$$\\",
+        "\\$$$$$$\\  $$ / $$ / $$ |$$ /  $$ |$$$$$$  / $$$$$$$$ |",
+        " \\____$$\\ $$ | $$ | $$ |$$ |  $$ |$$  _$$<  $$   ____|",
+        "$$$$$$$  |$$ | $$ | $$ |\\$$$$$$  |$$ | \\$$\\ \\$$$$$$$\\",
+        "\\_______/ \\__| \\__| \\__| \\______/ \\__|  \\__| \\_______|",
+      ]
+      const ink = [
+        get("primary", ui.accent),
+        get("textMuted", ui.muted),
+        get("info", ui.accent),
+        get("text", ui.text),
+        get("success", ui.accent),
+        get("warning", ui.accent),
+        get("secondary", ui.accent),
+        get("error", ui.accent),
+      ]
+
+      return (
+        <box flexDirection="column">
+          {art.map((line, i) => (
+            <text fg={ink[i]}>{line}</text>
+          ))}
+        </box>
+      )
+    },
+    sidebar_top(ctx, value) {
+      const map = ctx.theme.current as Record<string, unknown>
+      const get = (name: string, fallback: string) => {
+        const item = map[name]
+        if (typeof item === "string") return item
+        if (item && typeof item === "object") return item as RGBA
+        return fallback
+      }
+
+      return (
+        <smoke_cube
+          id={`smoke-cube-${value.session_id.slice(0, 8)}`}
+          width="100%"
+          height={16}
+          tint={get("primary", ui.accent)}
+          spec={get("text", ui.text)}
+          ambient={get("textMuted", ui.muted)}
+          key_light={get("success", ui.accent)}
+          fill_light={get("info", ui.accent)}
+        />
+      )
+    },
+  },
+})
+
+const reg = (api: TuiApi, input: Cfg, keys: Keys) => {
+  const route = names(input)
+  api.command.register(() => [
+    {
+      title: `${input.label} modal`,
+      value: "plugin.smoke.modal",
+      keybind: keys.get("modal"),
+      category: "Plugin",
+      slash: {
+        name: "smoke",
+      },
+      onSelect: () => {
+        api.route.navigate(route.modal, { source: "command" })
+      },
+    },
+    {
+      title: `${input.label} screen`,
+      value: "plugin.smoke.screen",
+      keybind: keys.get("screen"),
+      category: "Plugin",
+      slash: {
+        name: "smoke-screen",
+      },
+      onSelect: () => {
+        api.route.navigate(route.screen, { source: "command", tab: 0, count: 0 })
+      },
+    },
+    {
+      title: `${input.label} alert dialog`,
+      value: "plugin.smoke.alert",
+      category: "Plugin",
+      slash: {
+        name: "smoke-alert",
+      },
+      onSelect: () => {
+        warn(api, route, current(api, route))
+      },
+    },
+    {
+      title: `${input.label} confirm dialog`,
+      value: "plugin.smoke.confirm",
+      category: "Plugin",
+      slash: {
+        name: "smoke-confirm",
+      },
+      onSelect: () => {
+        check(api, route, current(api, route))
+      },
+    },
+    {
+      title: `${input.label} prompt dialog`,
+      value: "plugin.smoke.prompt",
+      category: "Plugin",
+      slash: {
+        name: "smoke-prompt",
+      },
+      onSelect: () => {
+        entry(api, route, current(api, route))
+      },
+    },
+    {
+      title: `${input.label} select dialog`,
+      value: "plugin.smoke.select",
+      category: "Plugin",
+      slash: {
+        name: "smoke-select",
+      },
+      onSelect: () => {
+        picker(api, route, current(api, route))
+      },
+    },
+    {
+      title: `${input.label} host overlay`,
+      value: "plugin.smoke.host",
+      keybind: keys.get("host"),
+      category: "Plugin",
+      slash: {
+        name: "smoke-host",
+      },
+      onSelect: () => {
+        host(api, input, tone(api))
+      },
+    },
+    {
+      title: `${input.label} go home`,
+      value: "plugin.smoke.home",
+      category: "Plugin",
+      enabled: api.route.current.name !== "home",
+      onSelect: () => {
+        api.route.navigate("home")
+      },
+    },
+    {
+      title: `${input.label} toast`,
+      value: "plugin.smoke.toast",
+      category: "Plugin",
+      onSelect: () => {
+        api.ui.toast({
+          variant: "info",
+          title: "Smoke",
+          message: "Plugin toast works",
+          duration: 2000,
+        })
+      },
+    },
+  ])
+}
+
+const tui = async (input: TuiPluginInput, options: Record<string, unknown> | null, meta: TuiPluginInit) => {
+  if (options?.enabled === false) return
+
+  await input.api.theme.install("./smoke-theme.json")
+  input.api.theme.set("smoke-theme")
+
+  const value = cfg(options ?? undefined)
+  const route = names(value)
+  const keys = input.api.keybind.create(bind, value.keybinds)
+  const fx = new VignetteEffect(value.vignette)
+  input.renderer.addPostProcessFn(fx.apply.bind(fx))
+
+  input.api.route.register([
+    {
+      name: route.screen,
+      render: ({ params }) => (
+        <Screen api={input.api} input={value} route={route} keys={keys} meta={meta} params={params} />
+      ),
+    },
+    {
+      name: route.modal,
+      render: ({ params }) => <Modal api={input.api} input={value} route={route} keys={keys} params={params} />,
+    },
+  ])
+
+  reg(input.api, value, keys)
+  input.slots.register(slot(value))
+}
+
+export default {
+  tui,
+}

.opencode/themes/.gitignore

@@ -0,0 +1 @@
+smoke-theme.json

.opencode/tui.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "theme": "smoke-theme",
+  "plugin": [
+    [
+      "./plugins/tui-smoke.tsx",
+      {
+        "enabled": true,
+        "label": "workspace",
+        "keybinds": {
+          "modal": "ctrl+alt+m",
+          "screen": "ctrl+alt+o",
+          "home": "escape,ctrl+shift+h",
+          "dialog_close": "escape,q"
+        }
+      }
+    ]
+  ]
+}

AGENTS.md

@@ -122,7 +122,3 @@ const table = sqliteTable("session", {
 - Avoid mocks as much as possible
 - Test actual implementation, do not duplicate logic into tests
 - Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.
-
-## Type Checking
-
-- Always run `bun typecheck` from package directories (e.g., `packages/opencode`), never `tsc` directly.

package.json

@@ -43,7 +43,6 @@
       "dompurify": "3.3.1",
       "drizzle-kit": "1.0.0-beta.16-ea816b6",
       "drizzle-orm": "1.0.0-beta.16-ea816b6",
-      "effect": "4.0.0-beta.29",
       "ai": "5.0.124",
       "hono": "4.10.7",
       "hono-openapi": "1.1.2",

packages/app/src/components/status-popover.tsx

@@ -185,7 +185,9 @@ export function StatusPopover() {
   const mcpConnected = createMemo(() => mcpNames().filter((name) => mcpStatus(name) === "connected").length)
   const lspItems = createMemo(() => sync.data.lsp ?? [])
   const lspCount = createMemo(() => lspItems().length)
-  const plugins = createMemo(() => sync.data.config.plugin ?? [])
+  const plugins = createMemo(() =>
+    (sync.data.config.plugin ?? []).map((item) => (typeof item === "string" ? item : item[0])),
+  )
   const pluginCount = createMemo(() => plugins().length)
   const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
   const overallHealthy = createMemo(() => {

packages/opencode/migration/20260228203230_blue_harpoon/migration.sql

@@ -1,17 +0,0 @@
-CREATE TABLE `account` (
-	`id` text PRIMARY KEY,
-	`email` text NOT NULL,
-	`url` text NOT NULL,
-	`access_token` text NOT NULL,
-	`refresh_token` text NOT NULL,
-	`token_expiry` integer,
-	`selected_org_id` text,
-	`time_created` integer NOT NULL,
-	`time_updated` integer NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE `account_state` (
-	`id` integer PRIMARY KEY NOT NULL,
-	`active_account_id` text,
-	FOREIGN KEY (`active_account_id`) REFERENCES `account`(`id`) ON UPDATE no action ON DELETE set null
-);

packages/opencode/migration/20260309230000_move_org_to_state/migration.sql

@@ -1,3 +0,0 @@
-ALTER TABLE `account_state` ADD `active_org_id` text;--> statement-breakpoint
-UPDATE `account_state` SET `active_org_id` = (SELECT `selected_org_id` FROM `account` WHERE `account`.`id` = `account_state`.`active_account_id`);--> statement-breakpoint
-ALTER TABLE `account` DROP COLUMN `selected_org_id`;

packages/opencode/package.json

@@ -27,7 +27,6 @@
   },
   "devDependencies": {
     "@babel/core": "7.28.4",
-    "@effect/language-service": "0.79.0",
     "@octokit/webhooks-types": "7.6.1",
     "@opencode-ai/script": "workspace:*",
     "@parcel/watcher-darwin-arm64": "2.5.1",
@@ -92,8 +91,8 @@
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/util": "workspace:*",
     "@openrouter/ai-sdk-provider": "1.5.4",
-    "@opentui/core": "0.1.86",
-    "@opentui/solid": "0.1.86",
+    "@opentui/core": "0.0.0-20260307-536c401b",
+    "@opentui/solid": "0.0.0-20260307-536c401b",
     "@parcel/watcher": "2.5.1",
     "@pierre/diffs": "catalog:",
     "@solid-primitives/event-bus": "1.1.2",
@@ -109,7 +108,6 @@
     "decimal.js": "10.5.0",
     "diff": "catalog:",
     "drizzle-orm": "1.0.0-beta.16-ea816b6",
-    "effect": "catalog:",
     "fuzzysort": "3.1.0",
     "glob": "13.0.5",
     "google-auth-library": "10.5.0",

packages/opencode/script/build.ts

@@ -4,7 +4,7 @@ import { $ } from "bun"
 import fs from "fs"
 import path from "path"
 import { fileURLToPath } from "url"
-import solidPlugin from "@opentui/solid/bun-plugin"
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -59,6 +59,7 @@ console.log(`Loaded ${migrations.length} migrations`)
 const singleFlag = process.argv.includes("--single")
 const baselineFlag = process.argv.includes("--baseline")
 const skipInstall = process.argv.includes("--skip-install")
+const plugin = createSolidTransformPlugin({ mode: "build" })
 
 const allTargets: {
   os: string
@@ -173,7 +174,7 @@ for (const item of targets) {
   await Bun.build({
     conditions: ["browser"],
     tsconfig: "./tsconfig.json",
-    plugins: [solidPlugin],
+    plugins: [plugin],
     sourcemap: "external",
     compile: {
       autoloadBunfig: false,

packages/opencode/src/account/index.ts

@@ -1,43 +0,0 @@
-import { Effect, Option, ServiceMap } from "effect"
-
-import {
-  Account as AccountSchema,
-  type AccountError,
-  type AccessToken,
-  AccountID,
-  AccountService,
-  OrgID,
-} from "./service"
-
-export { AccessToken, AccountID, OrgID } from "./service"
-
-import { runtime } from "@/effect/runtime"
-
-type AccountServiceShape = ServiceMap.Service.Shape<typeof AccountService>
-
-function runSync<A>(f: (service: AccountServiceShape) => Effect.Effect<A, AccountError>) {
-  return runtime.runSync(AccountService.use(f))
-}
-
-function runPromise<A>(f: (service: AccountServiceShape) => Effect.Effect<A, AccountError>) {
-  return runtime.runPromise(AccountService.use(f))
-}
-
-export namespace Account {
-  export const Account = AccountSchema
-  export type Account = AccountSchema
-
-  export function active(): Account | undefined {
-    return Option.getOrUndefined(runSync((service) => service.active()))
-  }
-
-  export async function config(accountID: AccountID, orgID: OrgID): Promise<Record<string, unknown> | undefined> {
-    const config = await runPromise((service) => service.config(accountID, orgID))
-    return Option.getOrUndefined(config)
-  }
-
-  export async function token(accountID: AccountID): Promise<AccessToken | undefined> {
-    const token = await runPromise((service) => service.token(accountID))
-    return Option.getOrUndefined(token)
-  }
-}

packages/opencode/src/account/repo.ts

@@ -1,138 +0,0 @@
-import { eq } from "drizzle-orm"
-import { Effect, Layer, Option, Schema, ServiceMap } from "effect"
-
-import { Database } from "@/storage/db"
-import { AccountStateTable, AccountTable } from "./account.sql"
-import { Account, AccountID, AccountRepoError, OrgID } from "./schema"
-
-export type AccountRow = (typeof AccountTable)["$inferSelect"]
-
-const decodeAccount = Schema.decodeUnknownSync(Account)
-
-type DbClient = Parameters<typeof Database.use>[0] extends (db: infer T) => unknown ? T : never
-
-const ACCOUNT_STATE_ID = 1
-
-const db = <A>(run: (db: DbClient) => A) =>
-  Effect.try({
-    try: () => Database.use(run),
-    catch: (cause) => new AccountRepoError({ message: "Database operation failed", cause }),
-  })
-
-const current = (db: DbClient) => {
-  const state = db.select().from(AccountStateTable).where(eq(AccountStateTable.id, ACCOUNT_STATE_ID)).get()
-  if (!state?.active_account_id) return
-  const account = db.select().from(AccountTable).where(eq(AccountTable.id, state.active_account_id)).get()
-  if (!account) return
-  return { ...account, active_org_id: state.active_org_id ?? null }
-}
-
-const setState = (db: DbClient, accountID: AccountID, orgID: string | null) =>
-  db
-    .insert(AccountStateTable)
-    .values({ id: ACCOUNT_STATE_ID, active_account_id: accountID, active_org_id: orgID })
-    .onConflictDoUpdate({
-      target: AccountStateTable.id,
-      set: { active_account_id: accountID, active_org_id: orgID },
-    })
-    .run()
-
-export class AccountRepo extends ServiceMap.Service<
-  AccountRepo,
-  {
-    readonly active: () => Effect.Effect<Option.Option<Account>, AccountRepoError>
-    readonly list: () => Effect.Effect<Account[], AccountRepoError>
-    readonly remove: (accountID: AccountID) => Effect.Effect<void, AccountRepoError>
-    readonly use: (accountID: AccountID, orgID: Option.Option<OrgID>) => Effect.Effect<void, AccountRepoError>
-    readonly getRow: (accountID: AccountID) => Effect.Effect<Option.Option<AccountRow>, AccountRepoError>
-    readonly persistToken: (input: {
-      accountID: AccountID
-      accessToken: string
-      refreshToken: string
-      expiry: Option.Option<number>
-    }) => Effect.Effect<void, AccountRepoError>
-    readonly persistAccount: (input: {
-      id: AccountID
-      email: string
-      url: string
-      accessToken: string
-      refreshToken: string
-      expiry: number
-      orgID: Option.Option<OrgID>
-    }) => Effect.Effect<void, AccountRepoError>
-  }
->()("@opencode/AccountRepo") {
-  static readonly layer: Layer.Layer<AccountRepo> = Layer.succeed(
-    AccountRepo,
-    AccountRepo.of({
-      active: Effect.fn("AccountRepo.active")(() =>
-        db((db) => current(db)).pipe(Effect.map((row) => (row ? Option.some(decodeAccount(row)) : Option.none()))),
-      ),
-
-      list: Effect.fn("AccountRepo.list")(() => db((db) => db.select().from(AccountTable).all().map((row) => decodeAccount({ ...row, active_org_id: null })))),
-
-      remove: Effect.fn("AccountRepo.remove")((accountID: AccountID) =>
-        db((db) =>
-          Database.transaction((tx) => {
-            tx.update(AccountStateTable)
-              .set({ active_account_id: null, active_org_id: null })
-              .where(eq(AccountStateTable.active_account_id, accountID))
-              .run()
-            tx.delete(AccountTable).where(eq(AccountTable.id, accountID)).run()
-          }),
-        ).pipe(Effect.asVoid),
-      ),
-
-      use: Effect.fn("AccountRepo.use")((accountID: AccountID, orgID: Option.Option<OrgID>) =>
-        db((db) => setState(db, accountID, Option.getOrNull(orgID))).pipe(Effect.asVoid),
-      ),
-
-      getRow: Effect.fn("AccountRepo.getRow")((accountID: AccountID) =>
-        db((db) => db.select().from(AccountTable).where(eq(AccountTable.id, accountID)).get()).pipe(
-          Effect.map(Option.fromNullishOr),
-        ),
-      ),
-
-      persistToken: Effect.fn("AccountRepo.persistToken")((input) =>
-        db((db) =>
-          db
-            .update(AccountTable)
-            .set({
-              access_token: input.accessToken,
-              refresh_token: input.refreshToken,
-              token_expiry: Option.getOrNull(input.expiry),
-            })
-            .where(eq(AccountTable.id, input.accountID))
-            .run(),
-        ).pipe(Effect.asVoid),
-      ),
-
-      persistAccount: Effect.fn("AccountRepo.persistAccount")((input) => {
-        const orgID = Option.getOrNull(input.orgID)
-        return db((db) =>
-          Database.transaction((tx) => {
-            tx.insert(AccountTable)
-              .values({
-                id: input.id,
-                email: input.email,
-                url: input.url,
-                access_token: input.accessToken,
-                refresh_token: input.refreshToken,
-                token_expiry: input.expiry,
-              })
-              .onConflictDoUpdate({
-                target: AccountTable.id,
-                set: {
-                  access_token: input.accessToken,
-                  refresh_token: input.refreshToken,
-                  token_expiry: input.expiry,
-                },
-              })
-              .run()
-            setState(tx, input.id, orgID)
-          }),
-        ).pipe(Effect.asVoid)
-      }),
-    }),
-  )
-}

packages/opencode/src/account/schema.ts

@@ -1,73 +0,0 @@
-import { Schema } from "effect"
-
-import { withStatics } from "@/util/schema"
-
-export const AccountID = Schema.String.pipe(
-  Schema.brand("AccountId"),
-  withStatics((s) => ({ make: (id: string) => s.makeUnsafe(id) })),
-)
-export type AccountID = Schema.Schema.Type<typeof AccountID>
-
-export const OrgID = Schema.String.pipe(
-  Schema.brand("OrgId"),
-  withStatics((s) => ({ make: (id: string) => s.makeUnsafe(id) })),
-)
-export type OrgID = Schema.Schema.Type<typeof OrgID>
-
-export const AccessToken = Schema.String.pipe(
-  Schema.brand("AccessToken"),
-  withStatics((s) => ({ make: (token: string) => s.makeUnsafe(token) })),
-)
-export type AccessToken = Schema.Schema.Type<typeof AccessToken>
-
-export class Account extends Schema.Class<Account>("Account")({
-  id: AccountID,
-  email: Schema.String,
-  url: Schema.String,
-  active_org_id: Schema.NullOr(OrgID),
-}) {}
-
-export class Org extends Schema.Class<Org>("Org")({
-  id: OrgID,
-  name: Schema.String,
-}) {}
-
-export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export type AccountError = AccountRepoError | AccountServiceError
-
-export class Login extends Schema.Class<Login>("Login")({
-  code: Schema.String,
-  user: Schema.String,
-  url: Schema.String,
-  server: Schema.String,
-  expiry: Schema.Number,
-  interval: Schema.Number,
-}) {}
-
-export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
-  email: Schema.String,
-}) {}
-
-export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
-
-export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
-
-export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
-
-export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
-
-export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
-  cause: Schema.Defect,
-}) {}
-
-export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
-export type PollResult = Schema.Schema.Type<typeof PollResult>

packages/opencode/src/account/service.ts

@@ -1,385 +0,0 @@
-import { Clock, Effect, Layer, Option, Schema, ServiceMap } from "effect"
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientError,
-  HttpClientRequest,
-  HttpClientResponse,
-} from "effect/unstable/http"
-
-import { withTransientReadRetry } from "@/util/effect-http-client"
-import { AccountRepo, type AccountRow } from "./repo"
-import {
-  type AccountError,
-  AccessToken,
-  Account,
-  AccountID,
-  AccountRepoError,
-  AccountServiceError,
-  Login,
-  Org,
-  OrgID,
-  PollDenied,
-  PollError,
-  PollExpired,
-  PollPending,
-  type PollResult,
-  PollSlow,
-  PollSuccess,
-} from "./schema"
-
-export * from "./schema"
-
-export type AccountOrgs = {
-  account: Account
-  orgs: Org[]
-}
-
-const RemoteOrg = Schema.Struct({
-  id: Schema.optional(OrgID),
-  name: Schema.optional(Schema.String),
-})
-
-const RemoteOrgs = Schema.Array(RemoteOrg)
-
-const RemoteConfig = Schema.Struct({
-  config: Schema.Record(Schema.String, Schema.Json),
-})
-
-const TokenRefresh = Schema.Struct({
-  access_token: Schema.String,
-  refresh_token: Schema.optional(Schema.String),
-  expires_in: Schema.optional(Schema.Number),
-})
-
-const DeviceCode = Schema.Struct({
-  device_code: Schema.String,
-  user_code: Schema.String,
-  verification_uri_complete: Schema.String,
-  expires_in: Schema.Number,
-  interval: Schema.Number,
-})
-
-const DeviceToken = Schema.Struct({
-  access_token: Schema.optional(Schema.String),
-  refresh_token: Schema.optional(Schema.String),
-  expires_in: Schema.optional(Schema.Number),
-  error: Schema.optional(Schema.String),
-  error_description: Schema.optional(Schema.String),
-})
-
-const User = Schema.Struct({
-  id: Schema.optional(AccountID),
-  email: Schema.optional(Schema.String),
-})
-
-const ClientId = Schema.Struct({ client_id: Schema.String })
-
-const DeviceTokenRequest = Schema.Struct({
-  grant_type: Schema.String,
-  device_code: Schema.String,
-  client_id: Schema.String,
-})
-
-const serverDefault = "https://web-14275-d60e67f5-pyqs0590.onporter.run"
-const clientId = "opencode-cli"
-
-const toAccountServiceError = (message: string, cause?: unknown) => new AccountServiceError({ message, cause })
-
-const mapAccountServiceError =
-  (operation: string, message = "Account service operation failed") =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, AccountServiceError, R> =>
-    effect.pipe(
-      Effect.mapError((error) =>
-        error instanceof AccountServiceError ? error : toAccountServiceError(`${message} (${operation})`, error),
-      ),
-    )
-
-export class AccountService extends ServiceMap.Service<
-  AccountService,
-  {
-    readonly active: () => Effect.Effect<Option.Option<Account>, AccountError>
-    readonly list: () => Effect.Effect<Account[], AccountError>
-    readonly orgsByAccount: () => Effect.Effect<AccountOrgs[], AccountError>
-    readonly remove: (accountID: AccountID) => Effect.Effect<void, AccountError>
-    readonly use: (accountID: AccountID, orgID: Option.Option<OrgID>) => Effect.Effect<void, AccountError>
-    readonly orgs: (accountID: AccountID) => Effect.Effect<Org[], AccountError>
-    readonly config: (
-      accountID: AccountID,
-      orgID: OrgID,
-    ) => Effect.Effect<Option.Option<Record<string, unknown>>, AccountError>
-    readonly token: (accountID: AccountID) => Effect.Effect<Option.Option<AccessToken>, AccountError>
-    readonly login: (url?: string) => Effect.Effect<Login, AccountError>
-    readonly poll: (input: Login) => Effect.Effect<PollResult, AccountError>
-  }
->()("@opencode/Account") {
-  static readonly layer: Layer.Layer<AccountService, never, AccountRepo | HttpClient.HttpClient> = Layer.effect(
-    AccountService,
-    Effect.gen(function* () {
-      const repo = yield* AccountRepo
-      const http = yield* HttpClient.HttpClient
-      const httpRead = withTransientReadRetry(http)
-
-      const execute = (operation: string, request: HttpClientRequest.HttpClientRequest) =>
-        http.execute(request).pipe(mapAccountServiceError(operation, "HTTP request failed"))
-
-      const executeRead = (operation: string, request: HttpClientRequest.HttpClientRequest) =>
-        httpRead.execute(request).pipe(mapAccountServiceError(operation, "HTTP request failed"))
-
-      const executeEffect = <E>(operation: string, request: Effect.Effect<HttpClientRequest.HttpClientRequest, E>) =>
-        request.pipe(
-          Effect.flatMap((req) => http.execute(req)),
-          mapAccountServiceError(operation, "HTTP request failed"),
-        )
-
-      const okOrNone = (operation: string, response: HttpClientResponse.HttpClientResponse) =>
-        HttpClientResponse.filterStatusOk(response).pipe(
-          Effect.map(Option.some),
-          Effect.catch((error) =>
-            HttpClientError.isHttpClientError(error) && error.reason._tag === "StatusCodeError"
-              ? Effect.succeed(Option.none<HttpClientResponse.HttpClientResponse>())
-              : Effect.fail(error),
-          ),
-          mapAccountServiceError(operation),
-        )
-
-      const tokenForRow = Effect.fn("AccountService.tokenForRow")(function* (found: AccountRow) {
-        const now = yield* Clock.currentTimeMillis
-        if (found.token_expiry && found.token_expiry > now) return Option.some(AccessToken.make(found.access_token))
-
-        const response = yield* execute(
-          "token.refresh",
-          HttpClientRequest.post(`${found.url}/oauth/token`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.bodyUrlParams({
-              grant_type: "refresh_token",
-              refresh_token: found.refresh_token,
-            }),
-          ),
-        )
-
-        const ok = yield* okOrNone("token.refresh", response)
-        if (Option.isNone(ok)) return Option.none()
-
-        const parsed = yield* HttpClientResponse.schemaBodyJson(TokenRefresh)(ok.value).pipe(
-          mapAccountServiceError("token.refresh", "Failed to decode response"),
-        )
-
-        const expiry = Option.fromNullishOr(parsed.expires_in).pipe(Option.map((e) => now + e * 1000))
-
-        yield* repo.persistToken({
-          accountID: AccountID.make(found.id),
-          accessToken: parsed.access_token,
-          refreshToken: parsed.refresh_token ?? found.refresh_token,
-          expiry,
-        })
-
-        return Option.some(AccessToken.make(parsed.access_token))
-      })
-
-      const resolveAccess = Effect.fn("AccountService.resolveAccess")(function* (accountID: AccountID) {
-        const maybeAccount = yield* repo.getRow(accountID)
-        if (Option.isNone(maybeAccount)) return Option.none<{ account: AccountRow; accessToken: AccessToken }>()
-
-        const account = maybeAccount.value
-        const accessToken = yield* tokenForRow(account)
-        if (Option.isNone(accessToken)) return Option.none<{ account: AccountRow; accessToken: AccessToken }>()
-
-        return Option.some({ account, accessToken: accessToken.value })
-      })
-
-      const token = Effect.fn("AccountService.token")((accountID: AccountID) =>
-        resolveAccess(accountID).pipe(Effect.map(Option.map((r) => r.accessToken))),
-      )
-
-      const orgsByAccount = Effect.fn("AccountService.orgsByAccount")(function* () {
-        const accounts = yield* repo.list()
-        return yield* Effect.forEach(
-          accounts,
-          (account) => orgs(account.id).pipe(Effect.map((orgs) => ({ account, orgs }))),
-          { concurrency: 3 },
-        )
-      })
-
-      const orgs = Effect.fn("AccountService.orgs")(function* (accountID: AccountID) {
-        const resolved = yield* resolveAccess(accountID)
-        if (Option.isNone(resolved)) return []
-
-        const { account, accessToken } = resolved.value
-
-        const response = yield* executeRead(
-          "orgs",
-          HttpClientRequest.get(`${account.url}/api/orgs`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.bearerToken(accessToken),
-          ),
-        )
-
-        const ok = yield* okOrNone("orgs", response)
-        if (Option.isNone(ok)) return []
-
-        const orgs = yield* HttpClientResponse.schemaBodyJson(RemoteOrgs)(ok.value).pipe(
-          mapAccountServiceError("orgs", "Failed to decode response"),
-        )
-        return orgs
-          .filter((org) => org.id !== undefined && org.name !== undefined)
-          .map((org) => new Org({ id: org.id!, name: org.name! }))
-      })
-
-      const config = Effect.fn("AccountService.config")(function* (accountID: AccountID, orgID: OrgID) {
-        const resolved = yield* resolveAccess(accountID)
-        if (Option.isNone(resolved)) return Option.none()
-
-        const { account, accessToken } = resolved.value
-
-        const response = yield* executeRead(
-          "config",
-          HttpClientRequest.get(`${account.url}/api/config`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.bearerToken(accessToken),
-            HttpClientRequest.setHeaders({ "x-org-id": orgID }),
-          ),
-        )
-
-        const ok = yield* okOrNone("config", response)
-        if (Option.isNone(ok)) return Option.none()
-
-        const parsed = yield* HttpClientResponse.schemaBodyJson(RemoteConfig)(ok.value).pipe(
-          mapAccountServiceError("config", "Failed to decode response"),
-        )
-        return Option.some(parsed.config)
-      })
-
-      const login = Effect.fn("AccountService.login")(function* (url?: string) {
-        const server = url ?? serverDefault
-
-        const response = yield* executeEffect(
-          "login",
-          HttpClientRequest.post(`${server}/auth/device/code`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.schemaBodyJson(ClientId)({ client_id: clientId }),
-          ),
-        )
-
-        const ok = yield* okOrNone("login", response)
-        if (Option.isNone(ok)) {
-          const body = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
-          return yield* toAccountServiceError(`Failed to initiate device flow: ${body || response.status}`)
-        }
-
-        const parsed = yield* HttpClientResponse.schemaBodyJson(DeviceCode)(ok.value).pipe(
-          mapAccountServiceError("login", "Failed to decode response"),
-        )
-        return new Login({
-          code: parsed.device_code,
-          user: parsed.user_code,
-          url: `${server}${parsed.verification_uri_complete}`,
-          server,
-          expiry: parsed.expires_in,
-          interval: parsed.interval,
-        })
-      })
-
-      const poll = Effect.fn("AccountService.poll")(function* (input: Login) {
-        const response = yield* executeEffect(
-          "poll",
-          HttpClientRequest.post(`${input.server}/auth/device/token`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.schemaBodyJson(DeviceTokenRequest)({
-              grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-              device_code: input.code,
-              client_id: clientId,
-            }),
-          ),
-        )
-
-        const parsed = yield* HttpClientResponse.schemaBodyJson(DeviceToken)(response).pipe(
-          mapAccountServiceError("poll", "Failed to decode response"),
-        )
-
-        if (!parsed.access_token) {
-          if (parsed.error === "authorization_pending") return new PollPending()
-          if (parsed.error === "slow_down") return new PollSlow()
-          if (parsed.error === "expired_token") return new PollExpired()
-          if (parsed.error === "access_denied") return new PollDenied()
-          return new PollError({ cause: parsed.error })
-        }
-
-        const access = parsed.access_token
-
-        const fetchUser = executeRead(
-          "poll.user",
-          HttpClientRequest.get(`${input.server}/api/user`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.bearerToken(access),
-          ),
-        ).pipe(
-          Effect.flatMap((r) =>
-            HttpClientResponse.schemaBodyJson(User)(r).pipe(
-              mapAccountServiceError("poll.user", "Failed to decode response"),
-            ),
-          ),
-        )
-
-        const fetchOrgs = executeRead(
-          "poll.orgs",
-          HttpClientRequest.get(`${input.server}/api/orgs`).pipe(
-            HttpClientRequest.acceptJson,
-            HttpClientRequest.bearerToken(access),
-          ),
-        ).pipe(
-          Effect.flatMap((r) =>
-            HttpClientResponse.schemaBodyJson(RemoteOrgs)(r).pipe(
-              mapAccountServiceError("poll.orgs", "Failed to decode response"),
-            ),
-          ),
-        )
-
-        const [user, remoteOrgs] = yield* Effect.all([fetchUser, fetchOrgs], { concurrency: 2 })
-
-        const userId = user.id
-        const userEmail = user.email
-
-        if (!userId || !userEmail) {
-          return new PollError({ cause: "No id or email in response" })
-        }
-
-        const firstOrgID = remoteOrgs.length > 0 ? Option.fromNullishOr(remoteOrgs[0].id) : Option.none()
-
-        const now = yield* Clock.currentTimeMillis
-        const expiry = now + (parsed.expires_in ?? 0) * 1000
-        const refresh = parsed.refresh_token ?? ""
-
-        yield* repo.persistAccount({
-          id: userId,
-          email: userEmail,
-          url: input.server,
-          accessToken: access,
-          refreshToken: refresh,
-          expiry,
-          orgID: firstOrgID,
-        })
-
-        return new PollSuccess({ email: userEmail })
-      })
-
-      return AccountService.of({
-        active: repo.active,
-        list: repo.list,
-        orgsByAccount,
-        remove: repo.remove,
-        use: repo.use,
-        orgs,
-        config,
-        token,
-        login,
-        poll,
-      })
-    }),
-  )
-
-  static readonly defaultLayer = AccountService.layer.pipe(
-    Layer.provide(AccountRepo.layer),
-    Layer.provide(FetchHttpClient.layer),
-  )
-}

packages/opencode/src/bun/index.ts

@@ -72,12 +72,13 @@ export namespace BunProc {
 
     if (!modExists || !cachedVersion) {
       // continue to install
-    } else if (version !== "latest" && cachedVersion === version) {
-      return mod
     } else if (version === "latest") {
-      const isOutdated = await PackageRegistry.isOutdated(pkg, cachedVersion, Global.Path.cache)
-      if (!isOutdated) return mod
+      if (!PackageRegistry.online()) return mod
+      const stale = await PackageRegistry.isOutdated(pkg, cachedVersion, Global.Path.cache)
+      if (!stale) return mod
       log.info("Cached version is outdated, proceeding with install", { pkg, cachedVersion })
+    } else if (cachedVersion === version) {
+      return mod
     }
 
     // Build command arguments

packages/opencode/src/bun/registry.ts

@@ -10,11 +10,24 @@ export namespace PackageRegistry {
     return process.execPath
   }
 
+  export function online() {
+    const nav = globalThis.navigator
+    if (!nav || typeof nav.onLine !== "boolean") return true
+    return nav.onLine
+  }
+
   export async function info(pkg: string, field: string, cwd?: string): Promise<string | null> {
+    if (!online()) {
+      log.debug("offline, skipping bun info", { pkg, field })
+      return null
+    }
+
     const result = Process.spawn([which(), "info", pkg, field], {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      abort: AbortSignal.timeout(4_000),
+      timeout: 750,
       env: {
         ...process.env,
         BUN_BE_BUN: "1",

packages/opencode/src/cli/cmd/account.ts

@@ -1,177 +0,0 @@
-import { cmd } from "./cmd"
-import { Duration, Effect, Match, Option } from "effect"
-import { UI } from "../ui"
-import { runtime } from "@/effect/runtime"
-import { AccountID, AccountService, OrgID, PollExpired, type PollResult } from "@/account/service"
-import { type AccountError } from "@/account/schema"
-import * as Prompt from "../effect/prompt"
-import open from "open"
-
-const openBrowser = (url: string) => Effect.promise(() => open(url).catch(() => undefined))
-
-const println = (msg: string) => Effect.sync(() => UI.println(msg))
-
-const loginEffect = Effect.fn("login")(function* (url?: string) {
-  const service = yield* AccountService
-
-  yield* Prompt.intro("Log in")
-  const login = yield* service.login(url)
-
-  yield* Prompt.log.info("Go to: " + login.url)
-  yield* Prompt.log.info("Enter code: " + login.user)
-  yield* openBrowser(login.url)
-
-  const s = Prompt.spinner()
-  yield* s.start("Waiting for authorization...")
-
-  const poll = (wait: number): Effect.Effect<PollResult, AccountError> =>
-    Effect.gen(function* () {
-      yield* Effect.sleep(wait)
-      const result = yield* service.poll(login)
-      if (result._tag === "PollPending") return yield* poll(wait)
-      if (result._tag === "PollSlow") return yield* poll(wait + 5000)
-      return result
-    })
-
-  const result = yield* poll(login.interval * 1000).pipe(
-    Effect.timeout(Duration.seconds(login.expiry)),
-    Effect.catchTag("TimeoutError", () => Effect.succeed(new PollExpired())),
-  )
-
-  yield* Match.valueTags(result, {
-    PollSuccess: (r) =>
-      Effect.gen(function* () {
-        yield* s.stop("Logged in as " + r.email)
-        yield* Prompt.outro("Done")
-      }),
-    PollExpired: () => s.stop("Device code expired", 1),
-    PollDenied: () => s.stop("Authorization denied", 1),
-    PollError: (r) => s.stop("Error: " + String(r.cause), 1),
-    PollPending: () => s.stop("Unexpected state", 1),
-    PollSlow: () => s.stop("Unexpected state", 1),
-  })
-})
-
-const logoutEffect = Effect.fn("logout")(function* (email?: string) {
-  const service = yield* AccountService
-
-  if (email) {
-    const accounts = yield* service.list()
-    const match = accounts.find((a) => a.email === email)
-    if (!match) return yield* println("Account not found: " + email)
-    yield* service.remove(match.id)
-    yield* println("Logged out from " + email)
-    return
-  }
-
-  const active = yield* service.active()
-  if (Option.isNone(active)) return yield* println("Not logged in")
-  yield* service.remove(active.value.id)
-  yield* println("Logged out from " + active.value.email)
-})
-
-interface OrgChoice {
-  orgID: OrgID
-  accountID: AccountID
-  label: string
-}
-
-const switchEffect = Effect.fn("switch")(function* () {
-  const service = yield* AccountService
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("Not logged in")
-
-  const active = yield* service.active()
-  const activeOrgID = Option.flatMap(active, (a) => Option.fromNullishOr(a.active_org_id))
-
-  const opts = groups.flatMap((group) =>
-    group.orgs.map((org) => {
-      const isActive = Option.isSome(activeOrgID) && activeOrgID.value === org.id
-      return {
-        value: { orgID: org.id, accountID: group.account.id, label: org.name },
-        label: isActive
-          ? `${org.name} (${group.account.email})` + UI.Style.TEXT_DIM + " (active)"
-          : `${org.name} (${group.account.email})`,
-      }
-    }),
-  )
-  if (opts.length === 0) return yield* println("No orgs found")
-
-  yield* Prompt.intro("Switch org")
-
-  const selected = yield* Prompt.select<OrgChoice>({ message: "Select org", options: opts })
-  if (Option.isNone(selected)) return
-
-  const choice = selected.value
-  yield* service.use(choice.accountID, Option.some(choice.orgID))
-  yield* Prompt.outro("Switched to " + choice.label)
-})
-
-const orgsEffect = Effect.fn("orgs")(function* () {
-  const service = yield* AccountService
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("No accounts found")
-  if (!groups.some((group) => group.orgs.length > 0)) return yield* println("No orgs found")
-
-  const active = yield* service.active()
-  const activeOrgID = Option.flatMap(active, (a) => Option.fromNullishOr(a.active_org_id))
-
-  for (const group of groups) {
-    for (const org of group.orgs) {
-      const isActive = Option.isSome(activeOrgID) && activeOrgID.value === org.id
-      const dot = isActive ? UI.Style.TEXT_SUCCESS + "●" + UI.Style.TEXT_NORMAL : " "
-      const name = isActive ? UI.Style.TEXT_HIGHLIGHT_BOLD + org.name + UI.Style.TEXT_NORMAL : org.name
-      const email = UI.Style.TEXT_DIM + group.account.email + UI.Style.TEXT_NORMAL
-      const id = UI.Style.TEXT_DIM + org.id + UI.Style.TEXT_NORMAL
-      yield* println(`  ${dot} ${name}  ${email}  ${id}`)
-    }
-  }
-})
-
-export const LoginCommand = cmd({
-  command: "login [url]",
-  describe: "log in to an opencode account",
-  builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "server URL",
-      type: "string",
-    }),
-  async handler(args) {
-    UI.empty()
-    await runtime.runPromise(loginEffect(args.url))
-  },
-})
-
-export const LogoutCommand = cmd({
-  command: "logout [email]",
-  describe: "log out from an account",
-  builder: (yargs) =>
-    yargs.positional("email", {
-      describe: "account email to log out from",
-      type: "string",
-    }),
-  async handler(args) {
-    UI.empty()
-    await runtime.runPromise(logoutEffect(args.email))
-  },
-})
-
-export const SwitchCommand = cmd({
-  command: "switch",
-  describe: "switch active org",
-  async handler() {
-    UI.empty()
-    await runtime.runPromise(switchEffect())
-  },
-})
-
-export const OrgsCommand = cmd({
-  command: "orgs",
-  describe: "list all orgs",
-  async handler() {
-    UI.empty()
-    await runtime.runPromise(orgsEffect())
-  },
-})

packages/opencode/src/cli/cmd/auth.ts

@@ -13,13 +13,27 @@ import { Instance } from "../../project/instance"
 import type { Hooks } from "@opencode-ai/plugin"
 import { Process } from "../../util/process"
 import { text } from "node:stream/consumers"
+import { setTimeout as sleep } from "node:timers/promises"
 
 type PluginAuth = NonNullable<Hooks["auth"]>
 
-async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string): Promise<boolean> {
+/**
+ * Handle plugin-based authentication flow.
+ * Returns true if auth was handled, false if it should fall through to default handling.
+ */
+async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string, methodName?: string): Promise<boolean> {
   let index = 0
-  if (plugin.auth.methods.length > 1) {
-    const method = await prompts.select({
+  if (methodName) {
+    const match = plugin.auth.methods.findIndex((x) => x.label.toLowerCase() === methodName.toLowerCase())
+    if (match === -1) {
+      prompts.log.error(
+        `Unknown method "${methodName}" for ${provider}. Available: ${plugin.auth.methods.map((x) => x.label).join(", ")}`,
+      )
+      process.exit(1)
+    }
+    index = match
+  } else if (plugin.auth.methods.length > 1) {
+    const selected = await prompts.select({
       message: "Login method",
       options: [
         ...plugin.auth.methods.map((x, index) => ({
@@ -28,12 +42,13 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string):
         })),
       ],
     })
-    if (prompts.isCancel(method)) throw new UI.CancelledError()
-    index = parseInt(method)
+    if (prompts.isCancel(selected)) throw new UI.CancelledError()
+    index = parseInt(selected)
   }
   const method = plugin.auth.methods[index]
 
-  await Bun.sleep(10)
+  // Handle prompts for all auth types
+  await sleep(10)
   const inputs: Record<string, string> = {}
   if (method.prompts) {
     for (const prompt of method.prompts) {
@@ -156,6 +171,11 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string):
   return false
 }
 
+/**
+ * Build a deduplicated list of plugin-registered auth providers that are not
+ * already present in models.dev, respecting enabled/disabled provider lists.
+ * Pure function with no side effects; safe to test without mocking.
+ */
 export function resolvePluginProviders(input: {
   hooks: Hooks[]
   existingProviders: Record<string, unknown>
@@ -183,20 +203,19 @@ export function resolvePluginProviders(input: {
   return result
 }
 
-export const ProvidersCommand = cmd({
-  command: "providers",
-  aliases: ["auth"],
-  describe: "manage AI providers and credentials",
+export const AuthCommand = cmd({
+  command: "auth",
+  describe: "manage credentials",
   builder: (yargs) =>
-    yargs.command(ProvidersListCommand).command(ProvidersLoginCommand).command(ProvidersLogoutCommand).demandCommand(),
+    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
   async handler() {},
 })
 
-export const ProvidersListCommand = cmd({
+export const AuthListCommand = cmd({
   command: "list",
   aliases: ["ls"],
-  describe: "list providers and credentials",
-  async handler(_args) {
+  describe: "list providers",
+  async handler() {
     UI.empty()
     const authPath = path.join(Global.Path.data, "auth.json")
     const homedir = os.homedir()
@@ -212,6 +231,7 @@ export const ProvidersListCommand = cmd({
 
     prompts.outro(`${results.length} credentials`)
 
+    // Environment variables section
     const activeEnvVars: Array<{ provider: string; envVar: string }> = []
 
     for (const [providerID, provider] of Object.entries(database)) {
@@ -238,14 +258,25 @@ export const ProvidersListCommand = cmd({
   },
 })
 
-export const ProvidersLoginCommand = cmd({
+export const AuthLoginCommand = cmd({
   command: "login [url]",
   describe: "log in to a provider",
   builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "opencode auth provider",
-      type: "string",
-    }),
+    yargs
+      .positional("url", {
+        describe: "opencode auth provider",
+        type: "string",
+      })
+      .option("provider", {
+        alias: ["p"],
+        describe: "provider id or name to log in to (skips provider selection)",
+        type: "string",
+      })
+      .option("method", {
+        alias: ["m"],
+        describe: "login method label (skips method selection)",
+        type: "string",
+      }),
   async handler(args) {
     await Instance.provide({
       directory: process.cwd(),
@@ -253,7 +284,8 @@ export const ProvidersLoginCommand = cmd({
         UI.empty()
         prompts.intro("Add credential")
         if (args.url) {
-          const wellknown = await fetch(`${args.url}/.well-known/opencode`).then((x) => x.json() as any)
+          const url = args.url.replace(/\/+$/, "")
+          const wellknown = await fetch(`${url}/.well-known/opencode`).then((x) => x.json() as any)
           prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
           const proc = Process.spawn(wellknown.auth.command, {
             stdout: "pipe",
@@ -269,12 +301,12 @@ export const ProvidersLoginCommand = cmd({
             prompts.outro("Done")
             return
           }
-          await Auth.set(args.url, {
+          await Auth.set(url, {
             type: "wellknown",
             key: wellknown.auth.env,
             token: token.trim(),
           })
-          prompts.log.success("Logged into " + args.url)
+          prompts.log.success("Logged into " + url)
           prompts.outro("Done")
           return
         }
@@ -311,59 +343,76 @@ export const ProvidersLoginCommand = cmd({
           enabled,
           providerNames: Object.fromEntries(Object.entries(config.provider ?? {}).map(([id, p]) => [id, p.name])),
         })
-        let provider = await prompts.autocomplete({
-          message: "Select provider",
-          maxItems: 8,
-          options: [
-            ...pipe(
-              providers,
-              values(),
-              sortBy(
-                (x) => priority[x.id] ?? 99,
-                (x) => x.name ?? x.id,
-              ),
-              map((x) => ({
-                label: x.name,
-                value: x.id,
-                hint: {
-                  opencode: "recommended",
-                  anthropic: "Claude Max or API key",
-                  openai: "ChatGPT Plus/Pro or API key",
-                }[x.id],
-              })),
+        const options = [
+          ...pipe(
+            providers,
+            values(),
+            sortBy(
+              (x) => priority[x.id] ?? 99,
+              (x) => x.name ?? x.id,
             ),
-            ...pluginProviders.map((x) => ({
+            map((x) => ({
               label: x.name,
               value: x.id,
-              hint: "plugin",
+              hint: {
+                opencode: "recommended",
+                anthropic: "Claude Max or API key",
+                openai: "ChatGPT Plus/Pro or API key",
+              }[x.id],
             })),
-            {
-              value: "other",
-              label: "Other",
-            },
-          ],
-        })
+          ),
+          ...pluginProviders.map((x) => ({
+            label: x.name,
+            value: x.id,
+            hint: "plugin",
+          })),
+        ]
 
-        if (prompts.isCancel(provider)) throw new UI.CancelledError()
+        let provider: string
+        if (args.provider) {
+          const input = args.provider
+          const byID = options.find((x) => x.value === input)
+          const byName = options.find((x) => x.label.toLowerCase() === input.toLowerCase())
+          const match = byID ?? byName
+          if (!match) {
+            prompts.log.error(`Unknown provider "${input}"`)
+            process.exit(1)
+          }
+          provider = match.value
+        } else {
+          const selected = await prompts.autocomplete({
+            message: "Select provider",
+            maxItems: 8,
+            options: [
+              ...options,
+              {
+                value: "other",
+                label: "Other",
+              },
+            ],
+          })
+          if (prompts.isCancel(selected)) throw new UI.CancelledError()
+          provider = selected as string
+        }
 
         const plugin = await Plugin.list().then((x) => x.findLast((x) => x.auth?.provider === provider))
         if (plugin && plugin.auth) {
-          const handled = await handlePluginAuth({ auth: plugin.auth }, provider)
+          const handled = await handlePluginAuth({ auth: plugin.auth }, provider, args.method)
           if (handled) return
         }
 
         if (provider === "other") {
-          provider = await prompts.text({
+          const custom = await prompts.text({
             message: "Enter provider id",
             validate: (x) => (x && x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
           })
-          if (prompts.isCancel(provider)) throw new UI.CancelledError()
-          provider = provider.replace(/^@ai-sdk\//, "")
-          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+          if (prompts.isCancel(custom)) throw new UI.CancelledError()
+          provider = custom.replace(/^@ai-sdk\//, "")
 
+          // Check if a plugin provides auth for this custom provider
           const customPlugin = await Plugin.list().then((x) => x.findLast((x) => x.auth?.provider === provider))
           if (customPlugin && customPlugin.auth) {
-            const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider)
+            const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider, args.method)
             if (handled) return
           }
 
@@ -412,10 +461,10 @@ export const ProvidersLoginCommand = cmd({
   },
 })
 
-export const ProvidersLogoutCommand = cmd({
+export const AuthLogoutCommand = cmd({
   command: "logout",
   describe: "log out from a configured provider",
-  async handler(_args) {
+  async handler() {
     UI.empty()
     const credentials = await Auth.all().then((x) => Object.entries(x))
     prompts.intro("Remove credential")

packages/opencode/src/cli/cmd/import.ts

@@ -10,7 +10,7 @@ import { ShareNext } from "../../share/share-next"
 import { EOL } from "os"
 import { Filesystem } from "../../util/filesystem"
 
-/** Discriminated union returned by the ShareNext API (GET /api/shares/:id/data) */
+/** Discriminated union returned by the ShareNext API (GET /api/share/:id/data) */
 export type ShareData =
   | { type: "session"; data: SDKSession }
   | { type: "message"; data: Message }
@@ -24,14 +24,6 @@ export function parseShareUrl(url: string): string | null {
   return match ? match[1] : null
 }
 
-export function shouldAttachShareAuthHeaders(shareUrl: string, controlBaseUrl: string): boolean {
-  try {
-    return new URL(shareUrl).origin === new URL(controlBaseUrl).origin
-  } catch {
-    return false
-  }
-}
-
 /**
  * Transform ShareNext API response (flat array) into the nested structure for local file storage.
  *
@@ -105,21 +97,8 @@ export const ImportCommand = cmd({
           return
         }
 
-        const parsed = new URL(args.file)
-        const baseUrl = parsed.origin
-        const req = await ShareNext.request()
-        const headers = shouldAttachShareAuthHeaders(args.file, req.baseUrl) ? req.headers : {}
-
-        const dataPath = req.api.data(slug)
-        let response = await fetch(`${baseUrl}${dataPath}`, {
-          headers,
-        })
-
-        if (!response.ok && dataPath !== `/api/share/${slug}/data`) {
-          response = await fetch(`${baseUrl}/api/share/${slug}/data`, {
-            headers,
-          })
-        }
+        const baseUrl = await ShareNext.url()
+        const response = await fetch(`${baseUrl}/api/share/${slug}/data`)
 
         if (!response.ok) {
           process.stdout.write(`Failed to fetch share data: ${response.statusText}`)

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -1,13 +1,25 @@
-import { render, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/solid"
+import { render, TimeToFirstDraw, useKeyboard, useRenderer, useTerminalDimensions, type JSX } from "@opentui/solid"
 import { Clipboard } from "@tui/util/clipboard"
 import { Selection } from "@tui/util/selection"
-import { MouseButton, TextAttributes } from "@opentui/core"
+import { createCliRenderer, MouseButton, TextAttributes, type CliRendererConfig, type ParsedKey } from "@opentui/core"
 import { RouteProvider, useRoute } from "@tui/context/route"
-import { Switch, Match, createEffect, untrack, ErrorBoundary, createSignal, onMount, batch, Show, on } from "solid-js"
+import {
+  Switch,
+  Match,
+  createEffect,
+  createMemo,
+  untrack,
+  ErrorBoundary,
+  createSignal,
+  onMount,
+  batch,
+  Show,
+  on,
+} from "solid-js"
 import { win32DisableProcessedInput, win32FlushInputBuffer, win32InstallCtrlCGuard } from "./win32"
 import { Installation } from "@/installation"
 import { Flag } from "@/flag/flag"
-import { DialogProvider, useDialog } from "@tui/ui/dialog"
+import { Dialog as DialogUI, DialogProvider, useDialog } from "@tui/ui/dialog"
 import { DialogProvider as DialogProviderList } from "@tui/component/dialog-provider"
 import { SDKProvider, useSDK } from "@tui/context/sdk"
 import { SyncProvider, useSync } from "@tui/context/sync"
@@ -21,7 +33,7 @@ import { CommandProvider, useCommandDialog } from "@tui/component/dialog-command
 import { DialogAgent } from "@tui/component/dialog-agent"
 import { DialogSessionList } from "@tui/component/dialog-session-list"
 import { DialogWorkspaceList } from "@tui/component/dialog-workspace-list"
-import { KeybindProvider } from "@tui/context/keybind"
+import { KeybindProvider, useKeybind } from "@tui/context/keybind"
 import { ThemeProvider, useTheme } from "@tui/context/theme"
 import { Home } from "@tui/routes/home"
 import { Session } from "@tui/routes/session"
@@ -29,6 +41,9 @@ import { PromptHistoryProvider } from "./component/prompt/history"
 import { FrecencyProvider } from "./component/prompt/frecency"
 import { PromptStashProvider } from "./component/prompt/stash"
 import { DialogAlert } from "./ui/dialog-alert"
+import { DialogConfirm } from "./ui/dialog-confirm"
+import { DialogPrompt } from "./ui/dialog-prompt"
+import { DialogSelect } from "./ui/dialog-select"
 import { ToastProvider, useToast } from "./ui/toast"
 import { ExitProvider, useExit } from "./context/exit"
 import { Session as SessionApi } from "@/session"
@@ -41,6 +56,8 @@ import { writeHeapSnapshot } from "v8"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { TuiConfigProvider } from "./context/tui-config"
 import { TuiConfig } from "@/config/tui"
+import type { TuiApi, TuiRouteDefinition } from "@opencode-ai/plugin/tui"
+import { TuiPlugin } from "./plugin"
 
 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
   // can't set raw mode if not a TTY
@@ -104,6 +121,25 @@ async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
 
 import type { EventSource } from "./context/sdk"
 
+function rendererConfig(_config: TuiConfig.Info): CliRendererConfig {
+  return {
+    targetFps: 60,
+    gatherStats: false,
+    exitOnCtrlC: false,
+    useKittyKeyboard: {},
+    autoFocus: false,
+    openConsoleOnError: false,
+    consoleOptions: {
+      keyBindings: [{ name: "y", ctrl: true, action: "copy-selection" }],
+      onCopySelection: (text) => {
+        Clipboard.copy(text).catch((error) => {
+          console.error(`Failed to copy console selection to clipboard: ${error}`)
+        })
+      },
+    },
+  }
+}
+
 export function tui(input: {
   url: string
   args: Args
@@ -129,73 +165,57 @@ export function tui(input: {
       resolve()
     }
 
-    render(
-      () => {
-        return (
-          <ErrorBoundary
-            fallback={(error, reset) => <ErrorComponent error={error} reset={reset} onExit={onExit} mode={mode} />}
-          >
-            <ArgsProvider {...input.args}>
-              <ExitProvider onExit={onExit}>
-                <KVProvider>
-                  <ToastProvider>
-                    <RouteProvider>
-                      <TuiConfigProvider config={input.config}>
-                        <SDKProvider
-                          url={input.url}
-                          directory={input.directory}
-                          fetch={input.fetch}
-                          headers={input.headers}
-                          events={input.events}
-                        >
-                          <SyncProvider>
-                            <ThemeProvider mode={mode}>
-                              <LocalProvider>
-                                <KeybindProvider>
-                                  <PromptStashProvider>
-                                    <DialogProvider>
-                                      <CommandProvider>
-                                        <FrecencyProvider>
-                                          <PromptHistoryProvider>
-                                            <PromptRefProvider>
-                                              <App />
-                                            </PromptRefProvider>
-                                          </PromptHistoryProvider>
-                                        </FrecencyProvider>
-                                      </CommandProvider>
-                                    </DialogProvider>
-                                  </PromptStashProvider>
-                                </KeybindProvider>
-                              </LocalProvider>
-                            </ThemeProvider>
-                          </SyncProvider>
-                        </SDKProvider>
-                      </TuiConfigProvider>
-                    </RouteProvider>
-                  </ToastProvider>
-                </KVProvider>
-              </ExitProvider>
-            </ArgsProvider>
-          </ErrorBoundary>
-        )
-      },
-      {
-        targetFps: 60,
-        gatherStats: false,
-        exitOnCtrlC: false,
-        useKittyKeyboard: {},
-        autoFocus: false,
-        openConsoleOnError: false,
-        consoleOptions: {
-          keyBindings: [{ name: "y", ctrl: true, action: "copy-selection" }],
-          onCopySelection: (text) => {
-            Clipboard.copy(text).catch((error) => {
-              console.error(`Failed to copy console selection to clipboard: ${error}`)
-            })
-          },
-        },
-      },
-    )
+    const renderer = await createCliRenderer(rendererConfig(input.config))
+
+    await render(() => {
+      return (
+        <ErrorBoundary
+          fallback={(error, reset) => <ErrorComponent error={error} reset={reset} onExit={onExit} mode={mode} />}
+        >
+          <ArgsProvider {...input.args}>
+            <ExitProvider onExit={onExit}>
+              <KVProvider>
+                <ToastProvider>
+                  <RouteProvider>
+                    <TuiConfigProvider config={input.config}>
+                      <SDKProvider
+                        url={input.url}
+                        directory={input.directory}
+                        fetch={input.fetch}
+                        headers={input.headers}
+                        events={input.events}
+                      >
+                        <SyncProvider>
+                          <ThemeProvider mode={mode}>
+                            <LocalProvider>
+                              <KeybindProvider>
+                                <PromptStashProvider>
+                                  <DialogProvider>
+                                    <CommandProvider>
+                                      <FrecencyProvider>
+                                        <PromptHistoryProvider>
+                                          <PromptRefProvider>
+                                            <App />
+                                          </PromptRefProvider>
+                                        </PromptHistoryProvider>
+                                      </FrecencyProvider>
+                                    </CommandProvider>
+                                  </DialogProvider>
+                                </PromptStashProvider>
+                              </KeybindProvider>
+                            </LocalProvider>
+                          </ThemeProvider>
+                        </SyncProvider>
+                      </SDKProvider>
+                    </TuiConfigProvider>
+                  </RouteProvider>
+                </ToastProvider>
+              </KVProvider>
+            </ExitProvider>
+          </ArgsProvider>
+        </ErrorBoundary>
+      )
+    }, renderer)
   })
 }
 
@@ -208,12 +228,226 @@ function App() {
   const local = useLocal()
   const kv = useKV()
   const command = useCommandDialog()
+  const keybind = useKeybind()
   const sdk = useSDK()
   const toast = useToast()
-  const { theme, mode, setMode } = useTheme()
+  const themeState = useTheme()
+  const { theme, mode, setMode } = themeState
   const sync = useSync()
   const exit = useExit()
   const promptRef = usePromptRef()
+  const routes = new Map<string, { key: symbol; render: TuiRouteDefinition["render"] }[]>()
+  const [routeRev, setRouteRev] = createSignal(0)
+  const routeView = (name: string) => {
+    routeRev()
+    return routes.get(name)?.at(-1)?.render
+  }
+
+  const api: TuiApi<JSX.Element> = {
+    command: {
+      register(cb) {
+        command.register(() => cb())
+      },
+      trigger(value) {
+        command.trigger(value)
+      },
+    },
+    route: {
+      register(input) {
+        const key = Symbol()
+        for (const item of input) {
+          const list = routes.get(item.name) ?? []
+          list.push({ key, render: item.render })
+          routes.set(item.name, list)
+        }
+        setRouteRev((x) => x + 1)
+        return () => {
+          for (const item of input) {
+            const list = routes.get(item.name)
+            if (!list) continue
+            routes.set(
+              item.name,
+              list.filter((x) => x.key !== key),
+            )
+            if (!routes.get(item.name)?.length) routes.delete(item.name)
+          }
+          setRouteRev((x) => x + 1)
+        }
+      },
+      navigate(name, params) {
+        if (name === "home") {
+          route.navigate({ type: "home" })
+          return
+        }
+
+        if (name === "session") {
+          const sessionID = params?.sessionID
+          if (typeof sessionID !== "string") return
+          route.navigate({ type: "session", sessionID })
+          return
+        }
+
+        route.navigate({ type: "plugin", id: name, data: params })
+      },
+      get current() {
+        if (route.data.type === "home") return { name: "home" }
+        if (route.data.type === "session") {
+          return {
+            name: "session",
+            params: {
+              sessionID: route.data.sessionID,
+              initialPrompt: route.data.initialPrompt,
+            },
+          }
+        }
+
+        return {
+          name: route.data.id,
+          params: route.data.data,
+        }
+      },
+    },
+    ui: {
+      Dialog(props) {
+        return (
+          <DialogUI size={props.size} onClose={props.onClose}>
+            {props.children as JSX.Element}
+          </DialogUI>
+        )
+      },
+      DialogAlert(props) {
+        return <DialogAlert {...props} />
+      },
+      DialogConfirm(props) {
+        return <DialogConfirm {...props} />
+      },
+      DialogPrompt(props) {
+        return <DialogPrompt {...props} description={props.description as (() => JSX.Element) | undefined} />
+      },
+      DialogSelect(props) {
+        const list = props.options.map((item) => ({
+          ...item,
+          footer: item.footer as JSX.Element | string | undefined,
+          onSelect: () => item.onSelect?.(),
+        }))
+        return (
+          <DialogSelect
+            title={props.title}
+            placeholder={props.placeholder}
+            options={list}
+            flat={props.flat}
+            onMove={
+              props.onMove
+                ? (item) =>
+                    props.onMove?.({
+                      title: item.title,
+                      value: item.value,
+                      description: item.description,
+                      footer: item.footer,
+                      category: item.category,
+                      disabled: item.disabled,
+                    })
+                : undefined
+            }
+            onFilter={props.onFilter}
+            onSelect={
+              props.onSelect
+                ? (item) =>
+                    props.onSelect?.({
+                      title: item.title,
+                      value: item.value,
+                      description: item.description,
+                      footer: item.footer,
+                      category: item.category,
+                      disabled: item.disabled,
+                    })
+                : undefined
+            }
+            skipFilter={props.skipFilter}
+            current={props.current}
+          />
+        )
+      },
+      toast(input) {
+        toast.show({
+          title: input.title,
+          message: input.message,
+          variant: input.variant ?? "info",
+          duration: input.duration,
+        })
+      },
+      dialog: {
+        replace(render, onClose) {
+          dialog.replace(render, onClose)
+        },
+        clear() {
+          dialog.clear()
+        },
+        setSize(size) {
+          dialog.setSize(size)
+        },
+        get size() {
+          return dialog.size
+        },
+        get depth() {
+          return dialog.stack.length
+        },
+        get open() {
+          return dialog.stack.length > 0
+        },
+      },
+    },
+    keybind: {
+      parse(evt: ParsedKey) {
+        return keybind.parse(evt)
+      },
+      match(key, evt: ParsedKey) {
+        return keybind.match(key, evt)
+      },
+      print(key) {
+        return keybind.print(key)
+      },
+      create(defaults, overrides) {
+        return keybind.create(defaults, overrides)
+      },
+    },
+    theme: {
+      get current() {
+        return theme
+      },
+      get selected() {
+        return themeState.selected
+      },
+      has(name) {
+        return themeState.has(name)
+      },
+      set(name) {
+        return themeState.set(name)
+      },
+      async install(_jsonPath) {
+        throw new Error("theme.install is only available in plugin context")
+      },
+      mode() {
+        return themeState.mode()
+      },
+      get ready() {
+        return themeState.ready
+      },
+    },
+  }
+  const [ready, setReady] = createSignal(false)
+  TuiPlugin.init({
+    client: sdk.client,
+    event: sdk.event,
+    renderer,
+    api,
+  })
+    .catch((error) => {
+      console.error("Failed to load TUI plugins", error)
+    })
+    .finally(() => {
+      setReady(true)
+    })
 
   useKeyboard((evt) => {
     if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) return
@@ -256,10 +490,6 @@ function App() {
   }
   const [terminalTitleEnabled, setTerminalTitleEnabled] = createSignal(kv.get("terminal_title_enabled", true))
 
-  createEffect(() => {
-    console.log(JSON.stringify(route.data))
-  })
-
   // Update terminal window title based on current route and session
   createEffect(() => {
     if (!terminalTitleEnabled() || Flag.OPENCODE_DISABLE_TERMINAL_TITLE) return
@@ -276,9 +506,13 @@ function App() {
         return
       }
 
-      // Truncate title to 40 chars max
       const title = session.title.length > 40 ? session.title.slice(0, 37) + "..." : session.title
       renderer.setTerminalTitle(`OC | ${title}`)
+      return
+    }
+
+    if (route.data.type === "plugin") {
+      renderer.setTerminalTitle(`OC | ${route.data.id}`)
     }
   })
 
@@ -749,29 +983,58 @@ function App() {
     })
   })
 
-  return (
-    <box
-      width={dimensions().width}
-      height={dimensions().height}
-      backgroundColor={theme.background}
-      onMouseDown={(evt) => {
-        if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) return
-        if (evt.button !== MouseButton.RIGHT) return
+  const plugin = createMemo(() => {
+    if (route.data.type !== "plugin") return
+    const render = routeView(route.data.id)
+    if (!render) return <PluginRouteMissing id={route.data.id} onHome={() => route.navigate({ type: "home" })} />
+    return render({ params: route.data.data })
+  })
 
-        if (!Selection.copy(renderer, toast)) return
-        evt.preventDefault()
-        evt.stopPropagation()
-      }}
-      onMouseUp={Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT ? undefined : () => Selection.copy(renderer, toast)}
-    >
-      <Switch>
-        <Match when={route.data.type === "home"}>
-          <Home />
-        </Match>
-        <Match when={route.data.type === "session"}>
-          <Session />
-        </Match>
-      </Switch>
+  return (
+    <Show when={ready()}>
+      <box
+        width={dimensions().width}
+        height={dimensions().height}
+        backgroundColor={theme.background}
+        onMouseDown={(evt) => {
+          if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) return
+          if (evt.button !== MouseButton.RIGHT) return
+
+          if (!Selection.copy(renderer, toast)) return
+          evt.preventDefault()
+          evt.stopPropagation()
+        }}
+        onMouseUp={
+          Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT ? undefined : () => Selection.copy(renderer, toast)
+        }
+      >
+        <Show when={Flag.OPENCODE_SHOW_TTFD}>
+          <TimeToFirstDraw />
+        </Show>
+        <Switch>
+          <Match when={route.data.type === "home"}>
+            <Home />
+          </Match>
+          <Match when={route.data.type === "session"}>
+            <Session />
+          </Match>
+        </Switch>
+        {plugin()}
+        <TuiPlugin.Slot name="app" />
+      </box>
+    </Show>
+  )
+}
+
+function PluginRouteMissing(props: { id: string; onHome: () => void }) {
+  const { theme } = useTheme()
+
+  return (
+    <box width="100%" height="100%" alignItems="center" justifyContent="center" flexDirection="column" gap={1}>
+      <text fg={theme.warning}>Unknown plugin route: {props.id}</text>
+      <box onMouseUp={props.onHome} backgroundColor={theme.backgroundElement} paddingLeft={1} paddingRight={1}>
+        <text fg={theme.text}>go home</text>
+      </box>
     </box>
   )
 }

packages/opencode/src/cli/cmd/tui/component/dialog-command.tsx

@@ -10,7 +10,7 @@ import {
   type ParentProps,
 } from "solid-js"
 import { useKeyboard } from "@opentui/solid"
-import { type KeybindKey, useKeybind } from "@tui/context/keybind"
+import { useKeybind } from "@tui/context/keybind"
 
 type Context = ReturnType<typeof init>
 const ctx = createContext<Context>()
@@ -21,7 +21,7 @@ export type Slash = {
 }
 
 export type CommandOption = DialogSelectOption<string> & {
-  keybind?: KeybindKey
+  keybind?: string
   suggested?: boolean
   slash?: Slash
   hidden?: boolean

packages/opencode/src/cli/cmd/tui/component/dialog-status.tsx

@@ -16,7 +16,8 @@ export function DialogStatus() {
 
   const plugins = createMemo(() => {
     const list = sync.data.config.plugin ?? []
-    const result = list.map((value) => {
+    const result = list.map((item) => {
+      const value = typeof item === "string" ? item : item[0]
       if (value.startsWith("file://")) {
         const path = fileURLToPath(value)
         const parts = path.split("/")

packages/opencode/src/cli/cmd/tui/context/keybind-plugin.ts

@@ -0,0 +1,44 @@
+import type { ParsedKey } from "@opentui/core"
+
+export type PluginKeybindMap = Record<string, string>
+
+type Base<Info> = {
+  parse: (evt: ParsedKey) => Info
+  match: (key: string, evt: ParsedKey) => boolean
+  print: (key: string) => string
+}
+
+export type PluginKeybind<Info> = {
+  readonly all: PluginKeybindMap
+  get: (name: string) => string
+  parse: (evt: ParsedKey) => Info
+  match: (name: string, evt: ParsedKey) => boolean
+  print: (name: string) => string
+}
+
+const txt = (value: unknown) => {
+  if (typeof value !== "string") return
+  if (!value.trim()) return
+  return value
+}
+
+export function createPluginKeybind<Info>(
+  base: Base<Info>,
+  defaults: PluginKeybindMap,
+  overrides?: Record<string, unknown>,
+): PluginKeybind<Info> {
+  const all = Object.freeze(
+    Object.fromEntries(Object.entries(defaults).map(([name, value]) => [name, txt(overrides?.[name]) ?? value])),
+  ) as PluginKeybindMap
+  const get = (name: string) => all[name] ?? name
+
+  return {
+    get all() {
+      return all
+    },
+    get,
+    parse: (evt) => base.parse(evt),
+    match: (name, evt) => base.match(get(name), evt),
+    print: (name) => base.print(get(name)),
+  }
+}

packages/opencode/src/cli/cmd/tui/context/keybind.tsx

@@ -6,6 +6,7 @@ import type { ParsedKey, Renderable } from "@opentui/core"
 import { createStore } from "solid-js/store"
 import { useKeyboard, useRenderer } from "@opentui/solid"
 import { createSimpleContext } from "./helper"
+import { createPluginKeybind, type PluginKeybindMap } from "./keybind-plugin"
 import { useTuiConfig } from "./tui-config"
 
 export type KeybindKey = keyof NonNullable<TuiConfig.Info["keybinds"]> & string
@@ -80,21 +81,27 @@ export const { use: useKeybind, provider: KeybindProvider } = createSimpleContex
         }
         return Keybind.fromParsedKey(evt, store.leader)
       },
-      match(key: KeybindKey, evt: ParsedKey) {
-        const keybind = keybinds()[key]
-        if (!keybind) return false
+      match(key: string, evt: ParsedKey) {
+        const list = keybinds()[key] ?? Keybind.parse(key)
+        if (!list.length) return false
         const parsed: Keybind.Info = result.parse(evt)
-        for (const key of keybind) {
-          if (Keybind.match(key, parsed)) {
+        for (const item of list) {
+          if (Keybind.match(item, parsed)) {
             return true
           }
         }
+        return false
       },
-      print(key: KeybindKey) {
-        const first = keybinds()[key]?.at(0)
+      print(key: string) {
+        const first = keybinds()[key]?.at(0) ?? Keybind.parse(key).at(0)
         if (!first) return ""
-        const result = Keybind.toString(first)
-        return result.replace("<leader>", Keybind.toString(keybinds().leader![0]!))
+        const text = Keybind.toString(first)
+        const lead = keybinds().leader?.[0]
+        if (!lead) return text
+        return text.replace("<leader>", Keybind.toString(lead))
+      },
+      create(defaults: PluginKeybindMap, overrides?: Record<string, unknown>) {
+        return createPluginKeybind(result, defaults, overrides)
       },
     }
     return result

packages/opencode/src/cli/cmd/tui/context/route.tsx

@@ -13,7 +13,13 @@ export type SessionRoute = {
   initialPrompt?: PromptInfo
 }
 
-export type Route = HomeRoute | SessionRoute
+export type PluginRoute = {
+  type: "plugin"
+  id: string
+  data?: Record<string, unknown>
+}
+
+export type Route = HomeRoute | SessionRoute | PluginRoute
 
 export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
   name: "Route",
@@ -31,7 +37,6 @@ export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
         return store
       },
       navigate(route: Route) {
-        console.log("navigate", route)
         setStore(route)
       },
     }

packages/opencode/src/cli/cmd/tui/context/theme.tsx

@@ -42,6 +42,7 @@ import { createStore, produce } from "solid-js/store"
 import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
 import { useTuiConfig } from "./tui-config"
+import { isRecord } from "@/util/record"
 
 type ThemeColors = {
   primary: RGBA
@@ -174,6 +175,56 @@ export const DEFAULT_THEMES: Record<string, ThemeJson> = {
   carbonfox,
 }
 
+type State = {
+  themes: Record<string, ThemeJson>
+  mode: "dark" | "light"
+  active: string
+  ready: boolean
+}
+
+const [store, setStore] = createStore<State>({
+  themes: DEFAULT_THEMES,
+  mode: "dark",
+  active: "opencode",
+  ready: false,
+})
+
+function mergeThemes(themes: Record<string, ThemeJson>) {
+  setStore(
+    produce((draft) => {
+      for (const [name, theme] of Object.entries(themes)) {
+        if (draft.themes[name]) continue
+        draft.themes[name] = theme
+      }
+    }),
+  )
+}
+
+export function allThemes() {
+  return store.themes
+}
+
+function isTheme(theme: unknown): theme is ThemeJson {
+  if (!isRecord(theme)) return false
+  if (!isRecord(theme.theme)) return false
+  return true
+}
+
+export function hasTheme(name: string) {
+  if (!name) return false
+  return allThemes()[name] !== undefined
+}
+
+export function addTheme(name: string, theme: unknown) {
+  if (!name) return false
+  if (!isTheme(theme)) return false
+  if (hasTheme(name)) return false
+  mergeThemes({
+    [name]: theme,
+  })
+  return true
+}
+
 function resolveTheme(theme: ThemeJson, mode: "dark" | "light") {
   const defs = theme.defs ?? {}
   function resolveColor(c: ColorValue): RGBA {
@@ -282,12 +333,14 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
   init: (props: { mode: "dark" | "light" }) => {
     const config = useTuiConfig()
     const kv = useKV()
-    const [store, setStore] = createStore({
-      themes: DEFAULT_THEMES,
-      mode: kv.get("theme_mode", props.mode),
-      active: (config.theme ?? kv.get("theme", "opencode")) as string,
-      ready: false,
-    })
+
+    setStore(
+      produce((draft) => {
+        draft.mode = kv.get("theme_mode", props.mode)
+        draft.active = (config.theme ?? kv.get("theme", "opencode")) as string
+        draft.ready = false
+      }),
+    )
 
     createEffect(() => {
       const theme = config.theme
@@ -295,55 +348,49 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
     })
 
     function init() {
-      resolveSystemTheme()
-      getCustomThemes()
-        .then((custom) => {
-          setStore(
-            produce((draft) => {
-              Object.assign(draft.themes, custom)
-            }),
-          )
-        })
-        .catch(() => {
-          setStore("active", "opencode")
-        })
-        .finally(() => {
-          if (store.active !== "system") {
-            setStore("ready", true)
-          }
-        })
+      Promise.allSettled([
+        resolveSystemTheme(),
+        getCustomThemes()
+          .then((custom) => {
+            setStore(
+              produce((draft) => {
+                Object.assign(draft.themes, custom)
+              }),
+            )
+          })
+          .catch(() => {
+            setStore("active", "opencode")
+          }),
+      ]).finally(() => {
+        setStore("ready", true)
+      })
     }
 
     onMount(init)
 
     function resolveSystemTheme() {
-      console.log("resolveSystemTheme")
-      renderer
+      return renderer
         .getPalette({
           size: 16,
         })
         .then((colors) => {
-          console.log(colors.palette)
           if (!colors.palette[0]) {
             if (store.active === "system") {
-              setStore(
-                produce((draft) => {
-                  draft.active = "opencode"
-                  draft.ready = true
-                }),
-              )
+              setStore("active", "opencode")
             }
             return
           }
           setStore(
             produce((draft) => {
               draft.themes.system = generateSystem(colors, store.mode)
-              if (store.active === "system") {
-                draft.ready = true
-              }
             }),
           )
         })
+        .catch(() => {
+          if (store.active === "system") {
+            setStore("active", "opencode")
+          }
+        })
     }
 
     const renderer = useRenderer()
@@ -370,7 +417,10 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
         return store.active
       },
       all() {
-        return store.themes
+        return allThemes()
+      },
+      has(name: string) {
+        return hasTheme(name)
       },
       syntax,
       subtleSyntax,
@@ -382,8 +432,10 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
         kv.set("theme_mode", mode)
       },
       set(theme: string) {
+        if (!hasTheme(theme)) return false
         setStore("active", theme)
         kv.set("theme", theme)
+        return true
       },
       get ready() {
         return store.ready

packages/opencode/src/cli/cmd/tui/plugin.ts

@@ -0,0 +1,323 @@
+import {
+  type TuiPlugin as TuiPluginFn,
+  type TuiPluginInit,
+  type TuiPluginInput,
+  type TuiTheme,
+  type TuiSlotContext,
+  type TuiSlotMap,
+  type TuiSlots,
+  type SlotMode,
+} from "@opencode-ai/plugin/tui"
+import { createSlot, createSolidSlotRegistry, type JSX, type SolidPlugin } from "@opentui/solid"
+import type { CliRenderer } from "@opentui/core"
+import "@opentui/solid/preload"
+import path from "path"
+import { fileURLToPath } from "url"
+
+import { Config } from "@/config/config"
+import { TuiConfig } from "@/config/tui"
+import { Log } from "@/util/log"
+import { isRecord } from "@/util/record"
+import { Instance } from "@/project/instance"
+import { resolvePluginTarget, uniqueModuleEntries } from "@/plugin/shared"
+import { PluginMeta } from "@/plugin/meta"
+import { addTheme, hasTheme } from "./context/theme"
+import { Global } from "@/global"
+import { Filesystem } from "@/util/filesystem"
+
+type SlotProps<K extends keyof TuiSlotMap> = {
+  name: K
+  mode?: SlotMode
+  children?: JSX.Element
+} & TuiSlotMap[K]
+
+type Slot = <K extends keyof TuiSlotMap>(props: SlotProps<K>) => JSX.Element | null
+type InitInput = Omit<TuiPluginInput<CliRenderer>, "slots">
+
+function empty<K extends keyof TuiSlotMap>(_props: SlotProps<K>) {
+  return null
+}
+
+function isTuiSlotPlugin(value: unknown): value is SolidPlugin<TuiSlotMap, TuiSlotContext> {
+  if (!isRecord(value)) return false
+  if (typeof value.id !== "string") return false
+  if (!isRecord(value.slots)) return false
+  return true
+}
+
+function getTuiSlotPlugin(value: unknown) {
+  if (isTuiSlotPlugin(value)) return value
+  if (!isRecord(value)) return
+  if (!isTuiSlotPlugin(value.slots)) return
+  return value.slots
+}
+
+function isTuiPlugin(value: unknown): value is TuiPluginFn<CliRenderer> {
+  return typeof value === "function"
+}
+
+function getTuiPlugin(value: unknown) {
+  if (!isRecord(value) || !("tui" in value)) return
+  if (!isTuiPlugin(value.tui)) return
+  return value.tui
+}
+
+function isTheme(value: unknown) {
+  if (!isRecord(value)) return false
+  if (!isRecord(value.theme)) return false
+  return true
+}
+
+function localDir(file: string) {
+  const dir = path.dirname(file)
+  if (path.basename(dir) === ".opencode") return path.join(dir, "themes")
+  return path.join(dir, ".opencode", "themes")
+}
+
+function scopeDir(pluginMeta: TuiConfig.PluginMeta) {
+  if (pluginMeta.scope === "local") return localDir(pluginMeta.source)
+  return path.join(Global.Path.config, "themes")
+}
+
+function pluginRoot(spec: string, target: string) {
+  if (spec.startsWith("file://")) return path.dirname(fileURLToPath(spec))
+  if (target.startsWith("file://")) return path.dirname(fileURLToPath(target))
+  return target
+}
+
+function resolveThemePath(root: string, file: string) {
+  if (file.startsWith("file://")) return fileURLToPath(file)
+  if (path.isAbsolute(file)) return file
+  return path.resolve(root, file)
+}
+
+function themeName(file: string) {
+  return path.basename(file, path.extname(file))
+}
+
+function getPluginMeta(config: TuiConfig.Info, item: Config.PluginSpec) {
+  const key = Config.getPluginName(item)
+  const value = config.plugin_meta?.[key]
+  if (!value) {
+    throw new Error(`missing plugin metadata for ${key}`)
+  }
+  return value
+}
+
+function makeInstallFn(meta: TuiConfig.PluginMeta, root: string): TuiTheme["install"] {
+  return async (file) => {
+    const src = resolveThemePath(root, file)
+    const theme = themeName(src)
+    if (hasTheme(theme)) return
+
+    const text = await Bun.file(src)
+      .text()
+      .catch((error) => {
+        throw new Error(`failed to read theme at ${src}: ${error}`)
+      })
+    const data = JSON.parse(text)
+    if (!isTheme(data)) {
+      throw new Error(`invalid theme at ${src}`)
+    }
+
+    const dest = path.join(scopeDir(meta), `${theme}.json`)
+    if (!(await Filesystem.exists(dest))) {
+      await Filesystem.write(dest, text)
+    }
+
+    addTheme(theme, data)
+  }
+}
+
+export namespace TuiPlugin {
+  const log = Log.create({ service: "tui.plugin" })
+  let loaded: Promise<void> | undefined
+  let view: Slot = empty
+
+  export const Slot: Slot = (props) => view(props)
+
+  function setupSlots(input: InitInput): TuiSlots {
+    const reg = createSolidSlotRegistry<TuiSlotMap, TuiSlotContext>(
+      input.renderer,
+      {
+        theme: input.api.theme,
+      },
+      {
+        onPluginError(event) {
+          console.error("[tui.slot] plugin error", {
+            plugin: event.pluginId,
+            slot: event.slot,
+            phase: event.phase,
+            source: event.source,
+            message: event.error.message,
+          })
+        },
+      },
+    )
+
+    const slot = createSlot<TuiSlotMap, TuiSlotContext>(reg)
+    view = (props) => slot(props)
+    return {
+      register(pluginSlot) {
+        if (!isTuiSlotPlugin(pluginSlot)) return () => {}
+        return reg.register(pluginSlot)
+      },
+    }
+  }
+
+  export async function init(input: InitInput) {
+    if (loaded) return loaded
+    loaded = load({
+      ...input,
+      slots: setupSlots(input),
+    })
+    return loaded
+  }
+
+  async function load(input: TuiPluginInput<CliRenderer>) {
+    const dir = process.cwd()
+
+    await Instance.provide({
+      directory: dir,
+      fn: async () => {
+        const config = await TuiConfig.get()
+        const plugins = config.plugin ?? []
+        let deps: Promise<void> | undefined
+        const wait = async () => {
+          if (deps) {
+            await deps
+            return
+          }
+          deps = TuiConfig.waitForDependencies().catch((error) => {
+            log.warn("failed waiting for tui plugin dependencies", { error })
+          })
+          await deps
+        }
+
+        const prep = async (item: (typeof plugins)[number], retry = false) => {
+          const spec = Config.pluginSpecifier(item)
+          log.info("loading tui plugin", { path: spec, retry })
+          const target = await resolvePluginTarget(spec).catch((error) => {
+            log.error("failed to resolve tui plugin", { path: spec, retry, error })
+            return
+          })
+          if (!target) return
+          const meta = await PluginMeta.touch(spec, target).catch((error) => {
+            log.warn("failed to track tui plugin", { path: spec, retry, error })
+          })
+          if (meta && meta.state !== "same") {
+            log.info("tui plugin metadata updated", {
+              path: spec,
+              retry,
+              state: meta.state,
+              source: meta.entry.source,
+              version: meta.entry.version,
+              modified: meta.entry.modified,
+            })
+          }
+
+          const now = Date.now()
+          const init: TuiPluginInit = meta
+            ? {
+                state: meta.state,
+                entry: meta.entry,
+              }
+            : {
+                state: "first",
+                entry: {
+                  name: spec,
+                  source: spec.startsWith("file://") ? "file" : "npm",
+                  spec,
+                  target,
+                  first_time: now,
+                  last_time: now,
+                  time_changed: now,
+                  load_count: 1,
+                  fingerprint: target,
+                },
+              }
+
+          const root = pluginRoot(spec, target)
+          const install = makeInstallFn(getPluginMeta(config, item), root)
+          const mod = await import(target).catch((error) => {
+            log.error("failed to load tui plugin", { path: spec, retry, error })
+            return
+          })
+          if (!mod) return
+
+          return {
+            item,
+            spec,
+            mod,
+            install,
+            init,
+          }
+        }
+
+        try {
+          const loaded = await Promise.all(plugins.map((item) => prep(item)))
+
+          for (let i = 0; i < plugins.length; i++) {
+            let load = loaded[i]
+            if (!load) {
+              const item = plugins[i]
+              if (!item) continue
+              const spec = Config.pluginSpecifier(item)
+              if (!spec.startsWith("file://")) continue
+              await wait()
+              load = await prep(item, true)
+            }
+            if (!load) continue
+
+            // Keep plugin execution sequential for deterministic side effects:
+            // command registration order affects keybind/command precedence,
+            // route registration is last-wins when ids collide,
+            // and hook chains rely on stable plugin ordering.
+            for (const [name, value] of uniqueModuleEntries(load.mod)) {
+              if (!value || typeof value !== "object") {
+                log.warn("ignoring non-object tui plugin export", {
+                  path: load.spec,
+                  name,
+                  type: value === null ? "null" : typeof value,
+                })
+                continue
+              }
+
+              const slotPlugin = getTuiSlotPlugin(value)
+              if (slotPlugin) input.slots.register(slotPlugin)
+
+              const tuiPlugin = getTuiPlugin(value)
+              if (!tuiPlugin) continue
+              await tuiPlugin(
+                {
+                  ...input,
+                  api: {
+                    command: input.api.command,
+                    route: input.api.route,
+                    ui: input.api.ui,
+                    keybind: input.api.keybind,
+                    theme: Object.create(input.api.theme, {
+                      install: {
+                        value: load.install,
+                        configurable: true,
+                        enumerable: true,
+                      },
+                    }),
+                  },
+                },
+                Config.pluginOptions(load.item) ?? null,
+                load.init,
+              )
+            }
+          }
+        } finally {
+          await PluginMeta.persist().catch((error) => {
+            log.warn("failed to persist tui plugin metadata", { error })
+          })
+        }
+      },
+    }).catch((error) => {
+      log.error("failed to load tui plugins", { directory: dir, error })
+    })
+  }
+}

packages/opencode/src/cli/cmd/tui/routes/home.tsx

@@ -15,6 +15,7 @@ import { Installation } from "@/installation"
 import { useKV } from "../context/kv"
 import { useCommandDialog } from "../component/dialog-command"
 import { useLocal } from "../context/local"
+import { TuiPlugin } from "../plugin"
 
 // TODO: what is the best way to do this?
 let once = false
@@ -57,8 +58,8 @@ export function Home() {
   ])
 
   const Hint = (
-    <Show when={connectedMcpCount() > 0}>
-      <box flexShrink={0} flexDirection="row" gap={1}>
+    <box flexShrink={0} flexDirection="row" gap={1}>
+      <Show when={connectedMcpCount() > 0}>
         <text fg={theme.text}>
           <Switch>
             <Match when={mcpError()}>
@@ -71,8 +72,8 @@ export function Home() {
             </Match>
           </Switch>
         </text>
-      </box>
-    </Show>
+      </Show>
+    </box>
   )
 
   let prompt: PromptRef
@@ -111,7 +112,9 @@ export function Home() {
         <box flexGrow={1} minHeight={0} />
         <box height={4} minHeight={0} flexShrink={1} />
         <box flexShrink={0}>
-          <Logo />
+          <TuiPlugin.Slot name="home_logo" mode="replace">
+            <Logo />
+          </TuiPlugin.Slot>
         </box>
         <box height={1} minHeight={0} flexShrink={1} />
         <box width="100%" maxWidth={75} zIndex={1000} paddingTop={1} flexShrink={0}>

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -70,7 +70,6 @@ import { Toast, useToast } from "../../ui/toast"
 import { useKV } from "../../context/kv.tsx"
 import { Editor } from "../../util/editor"
 import stripAnsi from "strip-ansi"
-import { Footer } from "./footer.tsx"
 import { usePromptRef } from "../../context/prompt"
 import { useExit } from "../../context/exit"
 import { Filesystem } from "@/util/filesystem"
@@ -383,12 +382,7 @@ export function Session() {
             sessionID: route.sessionID,
           })
           .then((res) => copy(res.data!.share!.url))
-          .catch((error) => {
-            toast.show({
-              message: error instanceof Error ? error.message : "Failed to share session",
-              variant: "error",
-            })
-          })
+          .catch(() => toast.show({ message: "Failed to share session", variant: "error" }))
         dialog.clear()
       },
     },
@@ -491,12 +485,7 @@ export function Session() {
             sessionID: route.sessionID,
           })
           .then(() => toast.show({ message: "Session unshared successfully", variant: "success" }))
-          .catch((error) => {
-            toast.show({
-              message: error instanceof Error ? error.message : "Failed to unshare session",
-              variant: "error",
-            })
-          })
+          .catch(() => toast.show({ message: "Failed to unshare session", variant: "error" }))
         dialog.clear()
       },
     },

packages/opencode/src/cli/cmd/tui/routes/session/sidebar.tsx

@@ -11,6 +11,7 @@ import { useKeybind } from "../../context/keybind"
 import { useDirectory } from "../../context/directory"
 import { useKV } from "../../context/kv"
 import { TodoItem } from "../../component/todo-item"
+import { TuiPlugin } from "../../plugin"
 
 export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
   const sync = useSync()
@@ -90,6 +91,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
           }}
         >
           <box flexShrink={0} gap={1} paddingRight={1}>
+            <TuiPlugin.Slot name="sidebar_top" session_id={props.sessionID} />
             <box paddingRight={1}>
               <text fg={theme.text}>
                 <b>{session().title}</b>

packages/opencode/src/cli/cmd/tui/ui/dialog.tsx

@@ -35,6 +35,7 @@ export function Dialog(
       height={dimensions().height}
       alignItems="center"
       position="absolute"
+      zIndex={3000}
       paddingTop={dimensions().height / 4}
       left={0}
       top={0}
@@ -70,8 +71,10 @@ function init() {
   useKeyboard((evt) => {
     if (store.stack.length === 0) return
     if (evt.defaultPrevented) return
-    if ((evt.name === "escape" || (evt.ctrl && evt.name === "c")) && renderer.getSelection()) return
     if (evt.name === "escape" || (evt.ctrl && evt.name === "c")) {
+      if (renderer.getSelection()) {
+        renderer.clearSelection()
+      }
       const current = store.stack.at(-1)!
       current.onClose?.()
       setStore("stack", store.stack.slice(0, -1))
@@ -151,6 +154,7 @@ export function DialogProvider(props: ParentProps) {
       {props.children}
       <box
         position="absolute"
+        zIndex={3000}
         onMouseDown={(evt) => {
           if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) return
           if (evt.button !== MouseButton.RIGHT) return

packages/opencode/src/cli/effect/prompt.ts

@@ -1,25 +0,0 @@
-import * as prompts from "@clack/prompts"
-import { Effect, Option } from "effect"
-
-export const intro = (msg: string) => Effect.sync(() => prompts.intro(msg))
-export const outro = (msg: string) => Effect.sync(() => prompts.outro(msg))
-
-export const log = {
-  info: (msg: string) => Effect.sync(() => prompts.log.info(msg)),
-}
-
-export const select = <Value>(opts: Parameters<typeof prompts.select<Value>>[0]) =>
-  Effect.tryPromise(() => prompts.select(opts)).pipe(
-    Effect.map((result) => {
-      if (prompts.isCancel(result)) return Option.none<Value>()
-      return Option.some(result)
-    }),
-  )
-
-export const spinner = () => {
-  const s = prompts.spinner()
-  return {
-    start: (msg: string) => Effect.sync(() => s.start(msg)),
-    stop: (msg: string, code?: number) => Effect.sync(() => s.stop(msg, code)),
-  }
-}

packages/opencode/src/config/config.ts

@@ -1,6 +1,6 @@
 import { Log } from "../util/log"
 import path from "path"
-import { pathToFileURL, fileURLToPath } from "url"
+import { pathToFileURL } from "url"
 import { createRequire } from "module"
 import os from "os"
 import z from "zod"
@@ -12,7 +12,6 @@ import { lazy } from "../util/lazy"
 import { NamedError } from "@opencode-ai/util/error"
 import { Flag } from "../flag/flag"
 import { Auth } from "../auth"
-import { Env } from "../env"
 import {
   type ParseError as JsoncParseError,
   applyEdits,
@@ -33,12 +32,18 @@ import { Glob } from "../util/glob"
 import { PackageRegistry } from "@/bun/registry"
 import { proxied } from "@/util/proxied"
 import { iife } from "@/util/iife"
-import { Account } from "@/account"
+import { isRecord } from "@/util/record"
+import { Control } from "@/control"
 import { ConfigPaths } from "./paths"
 import { Filesystem } from "@/util/filesystem"
 
 export namespace Config {
   const ModelId = z.string().meta({ $ref: "https://models.dev/model-schema.json#/$defs/Model" })
+  const PluginOptions = z.record(z.string(), z.unknown())
+  export const PluginSpec = z.union([z.string(), z.tuple([z.string(), PluginOptions])])
+
+  export type PluginOptions = z.infer<typeof PluginOptions>
+  export type PluginSpec = z.infer<typeof PluginSpec>
 
   const log = Log.create({ service: "config" })
 
@@ -109,6 +114,10 @@ export namespace Config {
       }
     }
 
+    const token = await Control.token()
+    if (token) {
+    }
+
     // Global user config overrides remote config.
     result = mergeConfigConcatArrays(result, await global())
 
@@ -175,26 +184,6 @@ export namespace Config {
       log.debug("loaded custom config from OPENCODE_CONFIG_CONTENT")
     }
 
-    const active = Account.active()
-    if (active?.active_org_id) {
-      const config = await Account.config(active.id, active.active_org_id)
-      const token = await Account.token(active.id)
-      if (token) {
-        process.env["OPENCODE_CONSOLE_TOKEN"] = token
-        Env.set("OPENCODE_CONSOLE_TOKEN", token)
-      }
-
-      if (config) {
-        result = mergeConfigConcatArrays(
-          result,
-          await load(JSON.stringify(config), {
-            dir: path.dirname(`${active.url}/api/config`),
-            source: `${active.url}/api/config`,
-          }),
-        )
-      }
-    }
-
     // Load managed config files last (highest priority) - enterprise admin-controlled
     // Kept separate from directories array to avoid write operations when installing plugins
     // which would fail on system directories requiring elevated permissions
@@ -326,8 +315,9 @@ export namespace Config {
 
     const targetVersion = Installation.isLocal() ? "latest" : Installation.VERSION
     if (targetVersion === "latest") {
-      const isOutdated = await PackageRegistry.isOutdated("@opencode-ai/plugin", depVersion, dir)
-      if (!isOutdated) return false
+      if (!PackageRegistry.online()) return false
+      const stale = await PackageRegistry.isOutdated("@opencode-ai/plugin", depVersion, dir)
+      if (!stale) return false
       log.info("Cached version is outdated, proceeding with install", {
         pkg: "@opencode-ai/plugin",
         cachedVersion: depVersion,
@@ -466,7 +456,7 @@ export namespace Config {
   }
 
   async function loadPlugin(dir: string) {
-    const plugins: string[] = []
+    const plugins: PluginSpec[] = []
 
     for (const item of await Glob.scan("{plugin,plugins}/*.{ts,js}", {
       cwd: dir,
@@ -479,6 +469,32 @@ export namespace Config {
     return plugins
   }
 
+  export function pluginSpecifier(plugin: PluginSpec): string {
+    return Array.isArray(plugin) ? plugin[0] : plugin
+  }
+
+  export function pluginOptions(plugin: PluginSpec): PluginOptions | undefined {
+    return Array.isArray(plugin) ? plugin[1] : undefined
+  }
+
+  export function resolvePluginSpec(plugin: PluginSpec, configFilepath: string): PluginSpec {
+    const spec = pluginSpecifier(plugin)
+    try {
+      const resolved = import.meta.resolve!(spec, configFilepath)
+      if (Array.isArray(plugin)) return [resolved, plugin[1]]
+      return resolved
+    } catch {
+      try {
+        const require = createRequire(configFilepath)
+        const resolved = pathToFileURL(require.resolve(spec)).href
+        if (Array.isArray(plugin)) return [resolved, plugin[1]]
+        return resolved
+      } catch {
+        return plugin
+      }
+    }
+  }
+
   /**
    * Extracts a canonical plugin name from a plugin specifier.
    * - For file:// URLs: extracts filename without extension
@@ -489,15 +505,16 @@ export namespace Config {
    * getPluginName("oh-my-opencode@2.4.3") // "oh-my-opencode"
    * getPluginName("@scope/pkg@1.0.0") // "@scope/pkg"
    */
-  export function getPluginName(plugin: string): string {
-    if (plugin.startsWith("file://")) {
-      return path.parse(new URL(plugin).pathname).name
+  export function getPluginName(plugin: PluginSpec): string {
+    const spec = pluginSpecifier(plugin)
+    if (spec.startsWith("file://")) {
+      return path.parse(new URL(spec).pathname).name
     }
-    const lastAt = plugin.lastIndexOf("@")
+    const lastAt = spec.lastIndexOf("@")
     if (lastAt > 0) {
-      return plugin.substring(0, lastAt)
+      return spec.substring(0, lastAt)
     }
-    return plugin
+    return spec
   }
 
   /**
@@ -511,14 +528,14 @@ export namespace Config {
    * Since plugins are added in low-to-high priority order,
    * we reverse, deduplicate (keeping first occurrence), then restore order.
    */
-  export function deduplicatePlugins(plugins: string[]): string[] {
+  export function deduplicatePlugins(plugins: PluginSpec[]): PluginSpec[] {
     // seenNames: canonical plugin names for duplicate detection
     // e.g., "oh-my-opencode", "@scope/pkg"
     const seenNames = new Set<string>()
 
     // uniqueSpecifiers: full plugin specifiers to return
-    // e.g., "oh-my-opencode@2.4.3", "file:///path/to/plugin.js"
-    const uniqueSpecifiers: string[] = []
+    // e.g., "oh-my-opencode@2.4.3", ["file:///path/to/plugin.js", { ... }]
+    const uniqueSpecifiers: PluginSpec[] = []
 
     for (const specifier of plugins.toReversed()) {
       const name = getPluginName(specifier)
@@ -1014,7 +1031,7 @@ export namespace Config {
           ignore: z.array(z.string()).optional(),
         })
         .optional(),
-      plugin: z.string().array().optional(),
+      plugin: PluginSpec.array().optional(),
       snapshot: z.boolean().optional(),
       share: z
         .enum(["manual", "auto", "disabled"])
@@ -1262,19 +1279,7 @@ export namespace Config {
       const data = parsed.data
       if (data.plugin && isFile) {
         for (let i = 0; i < data.plugin.length; i++) {
-          const plugin = data.plugin[i]
-          try {
-            data.plugin[i] = import.meta.resolve!(plugin, options.path)
-          } catch (e) {
-            try {
-              // import.meta.resolve sometimes fails with newly created node_modules
-              const require = createRequire(options.path)
-              const resolvedPath = require.resolve(plugin)
-              data.plugin[i] = pathToFileURL(resolvedPath).href
-            } catch {
-              // Ignore, plugin might be a generic string identifier like "mcp-server"
-            }
-          }
+          data.plugin[i] = resolvePluginSpec(data.plugin[i], options.path)
         }
       }
       return data
@@ -1321,10 +1326,6 @@ export namespace Config {
     return candidates[0]
   }
 
-  function isRecord(value: unknown): value is Record<string, unknown> {
-    return !!value && typeof value === "object" && !Array.isArray(value)
-  }
-
   function patchJsonc(input: string, patch: unknown, path: string[] = []): string {
     if (!isRecord(patch)) {
       const edits = modify(input, path, patch, {
@@ -1418,5 +1419,3 @@ export namespace Config {
     return state().then((x) => x.directories)
   }
 }
-Filesystem.write
-Filesystem.write

packages/opencode/src/config/tui-schema.ts

@@ -29,6 +29,7 @@ export const TuiInfo = z
     $schema: z.string().optional(),
     theme: z.string().optional(),
     keybinds: KeybindOverride.optional(),
+    plugin: Config.PluginSpec.array().optional(),
   })
   .extend(TuiOptions.shape)
   .strict()

packages/opencode/src/config/tui.ts

@@ -8,6 +8,7 @@ import { TuiInfo } from "./tui-schema"
 import { Instance } from "@/project/instance"
 import { Flag } from "@/flag/flag"
 import { Log } from "@/util/log"
+import { isRecord } from "@/util/record"
 import { Global } from "@/global"
 
 export namespace TuiConfig {
@@ -15,10 +16,43 @@ export namespace TuiConfig {
 
   export const Info = TuiInfo
 
-  export type Info = z.output<typeof Info>
+  export type PluginMeta = {
+    scope: "global" | "local"
+    source: string
+  }
+
+  type PluginEntry = {
+    item: Config.PluginSpec
+    meta: PluginMeta
+  }
+
+  export type Info = z.output<typeof Info> & {
+    plugin_meta?: Record<string, PluginMeta>
+  }
+
+  function pluginScope(file: string): PluginMeta["scope"] {
+    if (Instance.containsPath(file)) return "local"
+    return "global"
+  }
+
+  function dedupePlugins(list: PluginEntry[]) {
+    const seen = new Set<string>()
+    const result: PluginEntry[] = []
+    for (const item of list.toReversed()) {
+      const name = Config.getPluginName(item.item)
+      if (seen.has(name)) continue
+      seen.add(name)
+      result.push(item)
+    }
+    return result.toReversed()
+  }
 
   function mergeInfo(target: Info, source: Info): Info {
-    return mergeDeep(target, source)
+    const merged = mergeDeep(target, source)
+    if (target.plugin && source.plugin) {
+      merged.plugin = [...target.plugin, ...source.plugin]
+    }
+    return merged
   }
 
   function customPath() {
@@ -39,37 +73,74 @@ export namespace TuiConfig {
       : await ConfigPaths.projectFiles("tui", Instance.directory, Instance.worktree)
 
     let result: Info = {}
+    const pluginEntries: PluginEntry[] = []
+
+    const mergeFile = async (file: string) => {
+      const data = await loadFile(file)
+      result = mergeInfo(result, data)
+      if (!data.plugin?.length) return
+      const sourceScope = pluginScope(file)
+      for (const item of data.plugin) {
+        pluginEntries.push({
+          item,
+          meta: {
+            scope: sourceScope,
+            source: file,
+          },
+        })
+      }
+    }
 
     for (const file of ConfigPaths.fileInDirectory(Global.Path.config, "tui")) {
-      result = mergeInfo(result, await loadFile(file))
+      await mergeFile(file)
     }
 
     if (custom) {
-      result = mergeInfo(result, await loadFile(custom))
+      await mergeFile(custom)
       log.debug("loaded custom tui config", { path: custom })
     }
 
     for (const file of projectFiles) {
-      result = mergeInfo(result, await loadFile(file))
+      await mergeFile(file)
     }
 
     for (const dir of unique(directories)) {
       if (!dir.endsWith(".opencode") && dir !== Flag.OPENCODE_CONFIG_DIR) continue
       for (const file of ConfigPaths.fileInDirectory(dir, "tui")) {
-        result = mergeInfo(result, await loadFile(file))
+        await mergeFile(file)
       }
     }
 
     if (existsSync(managed)) {
       for (const file of ConfigPaths.fileInDirectory(managed, "tui")) {
-        result = mergeInfo(result, await loadFile(file))
+        await mergeFile(file)
       }
     }
 
+    const merged = dedupePlugins(pluginEntries)
     result.keybinds = Config.Keybinds.parse(result.keybinds ?? {})
+    result.plugin = merged.map((item) => item.item)
+    result.plugin_meta = merged.length
+      ? Object.fromEntries(merged.map((item) => [Config.getPluginName(item.item), item.meta]))
+      : undefined
+
+    const deps: Promise<void>[] = []
+    if (result.plugin?.length) {
+      for (const dir of unique(directories)) {
+        if (!dir.endsWith(".opencode") && dir !== Flag.OPENCODE_CONFIG_DIR) continue
+        deps.push(
+          (async () => {
+            const shouldInstall = await Config.needsInstall(dir)
+            if (!shouldInstall) return
+            await Config.installDependencies(dir)
+          })(),
+        )
+      }
+    }
 
     return {
       config: result,
+      deps,
     }
   })
 
@@ -77,6 +148,11 @@ export namespace TuiConfig {
     return state().then((x) => x.config)
   }
 
+  export async function waitForDependencies() {
+    const deps = await state().then((x) => x.deps)
+    await Promise.all(deps)
+  }
+
   async function loadFile(filepath: string): Promise<Info> {
     const text = await ConfigPaths.readFile(filepath)
     if (!text) return {}
@@ -87,19 +163,19 @@ export namespace TuiConfig {
   }
 
   async function load(text: string, configFilepath: string): Promise<Info> {
-    const data = await ConfigPaths.parseText(text, configFilepath, "empty")
-    if (!data || typeof data !== "object" || Array.isArray(data)) return {}
+    const raw = await ConfigPaths.parseText(text, configFilepath, "empty")
+    if (!isRecord(raw)) return {}
 
     // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
     // (mirroring the old opencode.json shape) still get their settings applied.
     const normalized = (() => {
-      const copy = { ...(data as Record<string, unknown>) }
+      const copy = { ...raw }
       if (!("tui" in copy)) return copy
-      if (!copy.tui || typeof copy.tui !== "object" || Array.isArray(copy.tui)) {
+      if (!isRecord(copy.tui)) {
         delete copy.tui
         return copy
       }
-      const tui = copy.tui as Record<string, unknown>
+      const tui = copy.tui
       delete copy.tui
       return {
         ...tui,
@@ -113,6 +189,13 @@ export namespace TuiConfig {
       return {}
     }
 
-    return parsed.data
+    const data = parsed.data
+    if (data.plugin) {
+      for (let i = 0; i < data.plugin.length; i++) {
+        data.plugin[i] = Config.resolvePluginSpec(data.plugin[i], configFilepath)
+      }
+    }
+
+    return data
   }
 }

packages/opencode/src/control/control.sql.ts

@@ -1,23 +1,7 @@
-import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
+import { sqliteTable, text, integer, primaryKey, uniqueIndex } from "drizzle-orm/sqlite-core"
+import { eq } from "drizzle-orm"
 import { Timestamps } from "@/storage/schema.sql"
 
-export const AccountTable = sqliteTable("account", {
-  id: text().primaryKey(),
-  email: text().notNull(),
-  url: text().notNull(),
-  access_token: text().notNull(),
-  refresh_token: text().notNull(),
-  token_expiry: integer(),
-  ...Timestamps,
-})
-
-export const AccountStateTable = sqliteTable("account_state", {
-  id: integer().primaryKey(),
-  active_account_id: text().references(() => AccountTable.id, { onDelete: "set null" }),
-  active_org_id: text(),
-})
-
-// LEGACY
 export const ControlAccountTable = sqliteTable(
   "control_account",
   {

packages/opencode/src/control/index.ts

@@ -0,0 +1,67 @@
+import { eq, and } from "drizzle-orm"
+import { Database } from "@/storage/db"
+import { ControlAccountTable } from "./control.sql"
+import z from "zod"
+
+export * from "./control.sql"
+
+export namespace Control {
+  export const Account = z.object({
+    email: z.string(),
+    url: z.string(),
+  })
+  export type Account = z.infer<typeof Account>
+
+  function fromRow(row: (typeof ControlAccountTable)["$inferSelect"]): Account {
+    return {
+      email: row.email,
+      url: row.url,
+    }
+  }
+
+  export function account(): Account | undefined {
+    const row = Database.use((db) =>
+      db.select().from(ControlAccountTable).where(eq(ControlAccountTable.active, true)).get(),
+    )
+    return row ? fromRow(row) : undefined
+  }
+
+  export async function token(): Promise<string | undefined> {
+    const row = Database.use((db) =>
+      db.select().from(ControlAccountTable).where(eq(ControlAccountTable.active, true)).get(),
+    )
+    if (!row) return undefined
+    if (row.token_expiry && row.token_expiry > Date.now()) return row.access_token
+
+    const res = await fetch(`${row.url}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: row.refresh_token,
+      }).toString(),
+    })
+
+    if (!res.ok) return
+
+    const json = (await res.json()) as {
+      access_token: string
+      refresh_token?: string
+      expires_in?: number
+    }
+
+    Database.use((db) =>
+      db
+        .update(ControlAccountTable)
+        .set({
+          access_token: json.access_token,
+          refresh_token: json.refresh_token ?? row.refresh_token,
+          token_expiry: json.expires_in ? Date.now() + json.expires_in * 1000 : undefined,
+        })
+        .where(and(eq(ControlAccountTable.email, row.email), eq(ControlAccountTable.url, row.url)))
+        .run(),
+    )
+
+    return json.access_token
+  }
+}

packages/opencode/src/effect/runtime.ts

@@ -1,4 +0,0 @@
-import { ManagedRuntime } from "effect"
-import { AccountService } from "@/account/service"
-
-export const runtime = ManagedRuntime.make(AccountService.defaultLayer)

packages/opencode/src/flag/flag.ts

@@ -14,10 +14,12 @@ export namespace Flag {
   export const OPENCODE_CONFIG = process.env["OPENCODE_CONFIG"]
   export declare const OPENCODE_TUI_CONFIG: string | undefined
   export declare const OPENCODE_CONFIG_DIR: string | undefined
+  export declare const OPENCODE_PLUGIN_META_FILE: string | undefined
   export const OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"]
   export const OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE")
   export const OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE")
   export const OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE")
+  export const OPENCODE_SHOW_TTFD = truthy("OPENCODE_SHOW_TTFD")
   export const OPENCODE_PERMISSION = process.env["OPENCODE_PERMISSION"]
   export const OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS")
   export const OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD")
@@ -105,6 +107,17 @@ Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
   configurable: false,
 })
 
+// Dynamic getter for OPENCODE_PLUGIN_META_FILE
+// This must be evaluated at access time, not module load time,
+// because tests and external tooling may set this env var at runtime
+Object.defineProperty(Flag, "OPENCODE_PLUGIN_META_FILE", {
+  get() {
+    return process.env["OPENCODE_PLUGIN_META_FILE"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
 // Dynamic getter for OPENCODE_CLIENT
 // This must be evaluated at access time, not module load time,
 // because some commands override the client at runtime

packages/opencode/src/index.ts

@@ -3,8 +3,7 @@ import { hideBin } from "yargs/helpers"
 import { RunCommand } from "./cli/cmd/run"
 import { GenerateCommand } from "./cli/cmd/generate"
 import { Log } from "./util/log"
-import { LoginCommand, LogoutCommand, SwitchCommand, OrgsCommand } from "./cli/cmd/account"
-import { ProvidersCommand } from "./cli/cmd/providers"
+import { AuthCommand } from "./cli/cmd/auth"
 import { AgentCommand } from "./cli/cmd/agent"
 import { UpgradeCommand } from "./cli/cmd/upgrade"
 import { UninstallCommand } from "./cli/cmd/uninstall"
@@ -135,11 +134,7 @@ let cli = yargs(hideBin(process.argv))
   .command(RunCommand)
   .command(GenerateCommand)
   .command(DebugCommand)
-  .command(LoginCommand)
-  .command(LogoutCommand)
-  .command(SwitchCommand)
-  .command(OrgsCommand)
-  .command(ProvidersCommand)
+  .command(AuthCommand)
   .command(AgentCommand)
   .command(UpgradeCommand)
   .command(UninstallCommand)

packages/opencode/src/plugin/index.ts

@@ -4,13 +4,13 @@ import { Bus } from "../bus"
 import { Log } from "../util/log"
 import { createOpencodeClient } from "@opencode-ai/sdk"
 import { Server } from "../server/server"
-import { BunProc } from "../bun"
 import { Instance } from "../project/instance"
 import { Flag } from "../flag/flag"
 import { CodexAuthPlugin } from "./codex"
 import { Session } from "../session"
 import { NamedError } from "@opencode-ai/util/error"
 import { CopilotAuthPlugin } from "./copilot"
+import { parsePluginSpecifier, resolvePluginTarget, uniqueModuleEntries } from "./shared"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "@gitlab/opencode-gitlab-auth"
 
 export namespace Plugin {
@@ -54,48 +54,83 @@ export namespace Plugin {
       plugins = [...BUILTIN, ...plugins]
     }
 
-    for (let plugin of plugins) {
-      // ignore old codex plugin since it is supported first party now
-      if (plugin.includes("opencode-openai-codex-auth") || plugin.includes("opencode-copilot-auth")) continue
-      log.info("loading plugin", { path: plugin })
-      if (!plugin.startsWith("file://")) {
-        const lastAtIndex = plugin.lastIndexOf("@")
-        const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
-        const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
-        plugin = await BunProc.install(pkg, version).catch((err) => {
-          const cause = err instanceof Error ? err.cause : err
-          const detail = cause instanceof Error ? cause.message : String(cause ?? err)
-          log.error("failed to install plugin", { pkg, version, error: detail })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to install plugin ${pkg}@${version}: ${detail}`,
-            }).toObject(),
-          })
-          return ""
+    async function resolvePlugin(spec: string) {
+      const parsed = parsePluginSpecifier(spec)
+      const target = await resolvePluginTarget(spec, parsed).catch((err) => {
+        const cause = err instanceof Error ? err.cause : err
+        const detail = cause instanceof Error ? cause.message : String(cause ?? err)
+        log.error("failed to install plugin", { pkg: parsed.pkg, version: parsed.version, error: detail })
+        Bus.publish(Session.Event.Error, {
+          error: new NamedError.Unknown({
+            message: `Failed to install plugin ${parsed.pkg}@${parsed.version}: ${detail}`,
+          }).toObject(),
         })
-        if (!plugin) continue
+        return ""
+      })
+      if (!target) return
+      return target
+    }
+
+    function isServerPlugin(value: unknown): value is PluginInstance {
+      return typeof value === "function"
+    }
+
+    function getServerPlugin(value: unknown) {
+      if (isServerPlugin(value)) return value
+      if (!value || typeof value !== "object" || !("server" in value)) return
+      if (!isServerPlugin(value.server)) return
+      return value.server
+    }
+
+    const prep = async (item: (typeof plugins)[number]) => {
+      const spec = Config.pluginSpecifier(item)
+      // ignore old codex plugin since it is supported first party now
+      if (spec.includes("opencode-openai-codex-auth") || spec.includes("opencode-copilot-auth")) return
+      log.info("loading plugin", { path: spec })
+      const target = await resolvePlugin(spec)
+      if (!target) return
+      const mod = await import(target).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err)
+        log.error("failed to load plugin", { path: spec, error: message })
+        Bus.publish(Session.Event.Error, {
+          error: new NamedError.Unknown({
+            message: `Failed to load plugin ${spec}: ${message}`,
+          }).toObject(),
+        })
+        return
+      })
+      if (!mod) return
+      return {
+        item,
+        spec,
+        mod,
       }
+    }
+
+    const loaded = await Promise.all(plugins.map((item) => prep(item)))
+    for (const load of loaded) {
+      if (!load) continue
+
+      // Keep plugin execution sequential so hook registration and execution
+      // order remains deterministic across plugin runs.
       // Prevent duplicate initialization when plugins export the same function
       // as both a named export and default export (e.g., `export const X` and `export default X`).
-      // Object.entries(mod) would return both entries pointing to the same function reference.
-      await import(plugin)
-        .then(async (mod) => {
-          const seen = new Set<PluginInstance>()
-          for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-            if (seen.has(fn)) continue
-            seen.add(fn)
-            hooks.push(await fn(input))
-          }
-        })
-        .catch((err) => {
-          const message = err instanceof Error ? err.message : String(err)
-          log.error("failed to load plugin", { path: plugin, error: message })
-          Bus.publish(Session.Event.Error, {
-            error: new NamedError.Unknown({
-              message: `Failed to load plugin ${plugin}: ${message}`,
-            }).toObject(),
-          })
+      // uniqueModuleEntries keeps only the first export for each shared value reference.
+      await (async () => {
+        for (const [, entry] of uniqueModuleEntries(load.mod)) {
+          const server = getServerPlugin(entry)
+          if (!server) throw new TypeError("Plugin export is not a function")
+          hooks.push(await server(input, Config.pluginOptions(load.item)))
+        }
+      })().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err)
+        log.error("failed to load plugin", { path: load.spec, error: message })
+        Bus.publish(Session.Event.Error, {
+          error: new NamedError.Unknown({
+            message: `Failed to load plugin ${load.spec}: ${message}`,
+          }).toObject(),
         })
+      })
     }
 
     return {

packages/opencode/src/plugin/meta.ts

@@ -0,0 +1,160 @@
+import path from "path"
+import { fileURLToPath } from "url"
+
+import { Flag } from "@/flag/flag"
+import { Global } from "@/global"
+import { Filesystem } from "@/util/filesystem"
+
+import { parsePluginSpecifier } from "./shared"
+
+export namespace PluginMeta {
+  type Source = "file" | "npm"
+
+  export type Entry = {
+    name: string
+    source: Source
+    spec: string
+    target: string
+    requested?: string
+    version?: string
+    modified?: number
+    first_time: number
+    last_time: number
+    time_changed: number
+    load_count: number
+    fingerprint: string
+  }
+
+  export type State = "first" | "updated" | "same"
+
+  type Store = Record<string, Entry>
+  type Core = Omit<Entry, "first_time" | "last_time" | "time_changed" | "load_count" | "fingerprint">
+
+  const cache = {
+    ready: false,
+    path: "",
+    store: {} as Store,
+    dirty: false,
+  }
+
+  function storePath() {
+    return Flag.OPENCODE_PLUGIN_META_FILE ?? path.join(Global.Path.state, "plugin-meta.json")
+  }
+
+  function sourceKind(spec: string): Source {
+    if (spec.startsWith("file://")) return "file"
+    return "npm"
+  }
+
+  function entryKey(spec: string) {
+    if (spec.startsWith("file://")) return `file:${fileURLToPath(spec)}`
+    return `npm:${parsePluginSpecifier(spec).pkg}`
+  }
+
+  function entryName(spec: string) {
+    if (spec.startsWith("file://")) return path.parse(fileURLToPath(spec)).name
+    return parsePluginSpecifier(spec).pkg
+  }
+
+  function fileTarget(spec: string, target: string) {
+    if (spec.startsWith("file://")) return fileURLToPath(spec)
+    if (target.startsWith("file://")) return fileURLToPath(target)
+    return
+  }
+
+  function modifiedAt(file: string) {
+    const stat = Filesystem.stat(file)
+    if (!stat) return
+    const value = stat.mtimeMs
+    return Math.floor(typeof value === "bigint" ? Number(value) : value)
+  }
+
+  function resolvedTarget(target: string) {
+    if (target.startsWith("file://")) return fileURLToPath(target)
+    return target
+  }
+
+  async function npmVersion(target: string) {
+    const resolved = resolvedTarget(target)
+    const stat = Filesystem.stat(resolved)
+    const dir = stat?.isDirectory() ? resolved : path.dirname(resolved)
+    return Filesystem.readJson<{ version?: string }>(path.join(dir, "package.json"))
+      .then((item) => item.version)
+      .catch(() => undefined)
+  }
+
+  async function entryCore(spec: string, target: string): Promise<Core> {
+    const source = sourceKind(spec)
+    if (source === "file") {
+      const file = fileTarget(spec, target)
+      return {
+        name: entryName(spec),
+        source,
+        spec,
+        target,
+        modified: file ? modifiedAt(file) : undefined,
+      }
+    }
+
+    return {
+      name: entryName(spec),
+      source,
+      spec,
+      target,
+      requested: parsePluginSpecifier(spec).version,
+      version: await npmVersion(target),
+    }
+  }
+
+  function fingerprint(value: Core) {
+    if (value.source === "file") return [value.target, value.modified ?? ""].join("|")
+    return [value.target, value.requested ?? "", value.version ?? ""].join("|")
+  }
+
+  async function load() {
+    const next = storePath()
+    if (cache.ready && cache.path === next) return
+    cache.path = next
+    cache.store = await Filesystem.readJson<Store>(next).catch(() => ({}) as Store)
+    cache.dirty = false
+    cache.ready = true
+  }
+
+  export async function touch(spec: string, target: string): Promise<{ state: State; entry: Entry }> {
+    await load()
+    const now = Date.now()
+    const id = entryKey(spec)
+    const prev = cache.store[id]
+    const core = await entryCore(spec, target)
+    const entry: Entry = {
+      ...core,
+      first_time: prev?.first_time ?? now,
+      last_time: now,
+      time_changed: prev?.time_changed ?? now,
+      load_count: (prev?.load_count ?? 0) + 1,
+      fingerprint: fingerprint(core),
+    }
+
+    const state: State = !prev ? "first" : prev.fingerprint === entry.fingerprint ? "same" : "updated"
+    if (state === "updated") entry.time_changed = now
+
+    cache.store[id] = entry
+    cache.dirty = true
+    return {
+      state,
+      entry,
+    }
+  }
+
+  export async function persist() {
+    await load()
+    if (!cache.dirty) return
+    await Filesystem.writeJson(cache.path, cache.store)
+    cache.dirty = false
+  }
+
+  export async function list(): Promise<Store> {
+    await load()
+    return { ...cache.store }
+  }
+}

packages/opencode/src/plugin/shared.ts

@@ -0,0 +1,26 @@
+import { BunProc } from "@/bun"
+
+export function parsePluginSpecifier(spec: string) {
+  const lastAt = spec.lastIndexOf("@")
+  const pkg = lastAt > 0 ? spec.substring(0, lastAt) : spec
+  const version = lastAt > 0 ? spec.substring(lastAt + 1) : "latest"
+  return { pkg, version }
+}
+
+export async function resolvePluginTarget(spec: string, parsed = parsePluginSpecifier(spec)) {
+  if (spec.startsWith("file://")) return spec
+  return BunProc.install(parsed.pkg, parsed.version)
+}
+
+export function uniqueModuleEntries(mod: Record<string, unknown>) {
+  const seen = new Set<unknown>()
+  const entries: [string, unknown][] = []
+
+  for (const [name, entry] of Object.entries(mod)) {
+    if (seen.has(entry)) continue
+    seen.add(entry)
+    entries.push([name, entry])
+  }
+
+  return entries
+}

packages/opencode/src/share/share-next.ts

@@ -1,5 +1,4 @@
 import { Bus } from "@/bus"
-import { Account } from "@/account"
 import { Config } from "@/config/config"
 import { Provider } from "@/provider/provider"
 import { Session } from "@/session"
@@ -12,51 +11,8 @@ import type * as SDK from "@opencode-ai/sdk/v2"
 export namespace ShareNext {
   const log = Log.create({ service: "share-next" })
 
-  type ApiEndpoints = {
-    create: string
-    sync: (shareId: string) => string
-    remove: (shareId: string) => string
-    data: (shareId: string) => string
-  }
-
-  function apiEndpoints(resource: string): ApiEndpoints {
-    return {
-      create: `/api/${resource}`,
-      sync: (shareId) => `/api/${resource}/${shareId}/sync`,
-      remove: (shareId) => `/api/${resource}/${shareId}`,
-      data: (shareId) => `/api/${resource}/${shareId}/data`,
-    }
-  }
-
-  const legacyApi = apiEndpoints("share")
-  const controlApi = apiEndpoints("shares")
-
   export async function url() {
-    const req = await request()
-    return req.baseUrl
-  }
-
-  export async function request(): Promise<{
-    headers: Record<string, string>
-    api: ApiEndpoints
-    baseUrl: string
-  }> {
-    const headers: Record<string, string> = {}
-
-    const active = Account.active()
-    if (!active?.active_org_id) {
-      const baseUrl = await Config.get().then((x) => x.enterprise?.url ?? "https://opncd.ai")
-      return { headers, api: legacyApi, baseUrl }
-    }
-
-    const token = await Account.token(active.id)
-    if (!token) {
-      throw new Error("No active OpenControl token available for sharing")
-    }
-
-    headers["authorization"] = `Bearer ${token}`
-    headers["x-org-id"] = active.active_org_id
-    return { headers, api: controlApi, baseUrl: active.url }
+    return Config.get().then((x) => x.enterprise?.url ?? "https://opncd.ai")
   }
 
   const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
@@ -112,20 +68,15 @@ export namespace ShareNext {
   export async function create(sessionID: string) {
     if (disabled) return { id: "", url: "", secret: "" }
     log.info("creating share", { sessionID })
-    const req = await request()
-    const response = await fetch(`${req.baseUrl}${req.api.create}`, {
+    const result = await fetch(`${await url()}/api/share`, {
       method: "POST",
-      headers: { ...req.headers, "Content-Type": "application/json" },
+      headers: {
+        "Content-Type": "application/json",
+      },
       body: JSON.stringify({ sessionID: sessionID }),
     })
-
-    if (!response.ok) {
-      const message = await response.text().catch(() => response.statusText)
-      throw new Error(`Failed to create share (${response.status}): ${message || response.statusText}`)
-    }
-
-    const result = (await response.json()) as { id: string; url: string; secret: string }
-
+      .then((x) => x.json())
+      .then((x) => x as { id: string; url: string; secret: string })
     Database.use((db) =>
       db
         .insert(SessionShareTable)
@@ -208,19 +159,16 @@ export namespace ShareNext {
       const share = get(sessionID)
       if (!share) return
 
-      const req = await request()
-      const response = await fetch(`${req.baseUrl}${req.api.sync(share.id)}`, {
+      await fetch(`${await url()}/api/share/${share.id}/sync`, {
         method: "POST",
-        headers: { ...req.headers, "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+        },
         body: JSON.stringify({
           secret: share.secret,
           data: Array.from(queued.data.values()),
         }),
       })
-
-      if (!response.ok) {
-        log.warn("failed to sync share", { sessionID, shareID: share.id, status: response.status })
-      }
     }, 1000)
     queue.set(sessionID, { timeout, data: dataMap })
   }
@@ -230,21 +178,15 @@ export namespace ShareNext {
     log.info("removing share", { sessionID })
     const share = get(sessionID)
     if (!share) return
-
-    const req = await request()
-    const response = await fetch(`${req.baseUrl}${req.api.remove(share.id)}`, {
+    await fetch(`${await url()}/api/share/${share.id}`, {
       method: "DELETE",
-      headers: { ...req.headers, "Content-Type": "application/json" },
+      headers: {
+        "Content-Type": "application/json",
+      },
       body: JSON.stringify({
         secret: share.secret,
       }),
     })
-
-    if (!response.ok) {
-      const message = await response.text().catch(() => response.statusText)
-      throw new Error(`Failed to remove share (${response.status}): ${message || response.statusText}`)
-    }
-
     Database.use((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())
   }
 

packages/opencode/src/storage/db.ts

@@ -39,7 +39,7 @@ export namespace Database {
   type Schema = typeof schema
   export type Transaction = SQLiteTransaction<"sync", void, Schema>
 
-  type Client = SQLiteBunDatabase
+  type Client = SQLiteBunDatabase<Schema>
 
   type Journal = { sql: string; timestamp: number; name: string }[]
 
@@ -93,7 +93,7 @@ export namespace Database {
     sqlite.run("PRAGMA foreign_keys = ON")
     sqlite.run("PRAGMA wal_checkpoint(PASSIVE)")
 
-    const db = drizzle({ client: sqlite })
+    const db = drizzle({ client: sqlite, schema })
 
     // Apply schema migrations
     const entries =
@@ -124,7 +124,7 @@ export namespace Database {
     Client.reset()
   }
 
-  export type TxOrDb = SQLiteTransaction<"sync", void, any, any> | Client
+  export type TxOrDb = Transaction | Client
 
   const ctx = Context.create<{
     tx: TxOrDb

packages/opencode/src/storage/schema.ts

@@ -1,5 +1,5 @@
-export { AccountTable, AccountStateTable, ControlAccountTable } from "../account/account.sql"
-export { ProjectTable } from "../project/project.sql"
+export { ControlAccountTable } from "../control/control.sql"
 export { SessionTable, MessageTable, PartTable, TodoTable, PermissionTable } from "../session/session.sql"
 export { SessionShareTable } from "../share/share.sql"
+export { ProjectTable } from "../project/project.sql"
 export { WorkspaceTable } from "../control-plane/workspace.sql"

packages/opencode/src/util/effect-http-client.ts

@@ -1,11 +0,0 @@
-import { Schedule } from "effect"
-import { HttpClient } from "effect/unstable/http"
-
-export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
-  client.pipe(
-    HttpClient.retryTransient({
-      retryOn: "errors-and-responses",
-      times: 2,
-      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
-    }),
-  )

packages/opencode/src/util/record.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}

packages/opencode/src/util/schema.ts

@@ -1,17 +0,0 @@
-import { Schema } from "effect"
-
-/**
- * Attach static methods to a schema object. Designed to be used with `.pipe()`:
- *
- * @example
- *   export const Foo = fooSchema.pipe(
- *     withStatics((schema) => ({
- *       zero: schema.makeUnsafe(0),
- *       from: Schema.decodeUnknownOption(schema),
- *     }))
- *   )
- */
-export const withStatics =
-  <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) =>
-  (schema: S): S & M =>
-    Object.assign(schema, methods(schema))

packages/opencode/test/account/repo.test.ts

@@ -1,332 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Layer, Option } from "effect"
-
-import { AccountRepo } from "../../src/account/repo"
-import { AccountID, OrgID } from "../../src/account/schema"
-import { resetDatabase } from "../fixture/db"
-import { testEffect } from "../fixture/effect"
-
-const reset = Layer.effectDiscard(Effect.promise(() => resetDatabase()))
-
-const it = testEffect(Layer.merge(AccountRepo.layer, reset))
-
-it.effect(
-  "list returns empty when no accounts exist",
-  Effect.gen(function* () {
-    const accounts = yield* AccountRepo.use((r) => r.list())
-    expect(accounts).toEqual([])
-  }),
-)
-
-it.effect(
-  "active returns none when no accounts exist",
-  Effect.gen(function* () {
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.isNone(active)).toBe(true)
-  }),
-)
-
-it.effect(
-  "persistAccount inserts and getRow retrieves",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_123",
-        refreshToken: "rt_456",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.some(OrgID.make("org-1")),
-      }),
-    )
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    expect(Option.isSome(row)).toBe(true)
-    const value = Option.getOrThrow(row)
-    expect(value.id).toBe("user-1")
-    expect(value.email).toBe("test@example.com")
-
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.getOrThrow(active).active_org_id).toBe(OrgID.make("org-1"))
-  }),
-)
-
-it.effect(
-  "persistAccount sets the active account and org",
-  Effect.gen(function* () {
-    const id1 = AccountID.make("user-1")
-    const id2 = AccountID.make("user-2")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id1,
-        email: "first@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.some(OrgID.make("org-1")),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id2,
-        email: "second@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_2",
-        refreshToken: "rt_2",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.some(OrgID.make("org-2")),
-      }),
-    )
-
-    // Last persisted account is active with its org
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.isSome(active)).toBe(true)
-    expect(Option.getOrThrow(active).id).toBe(AccountID.make("user-2"))
-    expect(Option.getOrThrow(active).active_org_id).toBe(OrgID.make("org-2"))
-  }),
-)
-
-it.effect(
-  "list returns all accounts",
-  Effect.gen(function* () {
-    const id1 = AccountID.make("user-1")
-    const id2 = AccountID.make("user-2")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id1,
-        email: "a@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id2,
-        email: "b@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_2",
-        refreshToken: "rt_2",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.some(OrgID.make("org-1")),
-      }),
-    )
-
-    const accounts = yield* AccountRepo.use((r) => r.list())
-    expect(accounts.length).toBe(2)
-    expect(accounts.map((a) => a.email).sort()).toEqual(["a@example.com", "b@example.com"])
-  }),
-)
-
-it.effect(
-  "remove deletes an account",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) => r.remove(id))
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    expect(Option.isNone(row)).toBe(true)
-  }),
-)
-
-it.effect(
-  "use stores the selected org and marks the account active",
-  Effect.gen(function* () {
-    const id1 = AccountID.make("user-1")
-    const id2 = AccountID.make("user-2")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id1,
-        email: "first@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: id2,
-        email: "second@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_2",
-        refreshToken: "rt_2",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) => r.use(id1, Option.some(OrgID.make("org-99"))))
-    const active1 = yield* AccountRepo.use((r) => r.active())
-    expect(Option.getOrThrow(active1).id).toBe(id1)
-    expect(Option.getOrThrow(active1).active_org_id).toBe(OrgID.make("org-99"))
-
-    yield* AccountRepo.use((r) => r.use(id1, Option.none()))
-    const active2 = yield* AccountRepo.use((r) => r.active())
-    expect(Option.getOrThrow(active2).active_org_id).toBeNull()
-  }),
-)
-
-it.effect(
-  "persistToken updates token fields",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "old_token",
-        refreshToken: "old_refresh",
-        expiry: 1000,
-        orgID: Option.none(),
-      }),
-    )
-
-    const expiry = Date.now() + 7200_000
-    yield* AccountRepo.use((r) =>
-      r.persistToken({
-        accountID: id,
-        accessToken: "new_token",
-        refreshToken: "new_refresh",
-        expiry: Option.some(expiry),
-      }),
-    )
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe("new_token")
-    expect(value.refresh_token).toBe("new_refresh")
-    expect(value.token_expiry).toBe(expiry)
-  }),
-)
-
-it.effect(
-  "persistToken with no expiry sets token_expiry to null",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "old_token",
-        refreshToken: "old_refresh",
-        expiry: 1000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistToken({
-        accountID: id,
-        accessToken: "new_token",
-        refreshToken: "new_refresh",
-        expiry: Option.none(),
-      }),
-    )
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    expect(Option.getOrThrow(row).token_expiry).toBeNull()
-  }),
-)
-
-it.effect(
-  "persistAccount upserts on conflict",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_v1",
-        refreshToken: "rt_v1",
-        expiry: 1000,
-        orgID: Option.some(OrgID.make("org-1")),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_v2",
-        refreshToken: "rt_v2",
-        expiry: 2000,
-        orgID: Option.some(OrgID.make("org-2")),
-      }),
-    )
-
-    const accounts = yield* AccountRepo.use((r) => r.list())
-    expect(accounts.length).toBe(1)
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe("at_v2")
-
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.getOrThrow(active).active_org_id).toBe(OrgID.make("org-2"))
-  }),
-)
-
-it.effect(
-  "remove clears active state when deleting the active account",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "test@example.com",
-        url: "https://control.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 3600_000,
-        orgID: Option.some(OrgID.make("org-1")),
-      }),
-    )
-
-    yield* AccountRepo.use((r) => r.remove(id))
-
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.isNone(active)).toBe(true)
-  }),
-)
-
-it.effect(
-  "getRow returns none for nonexistent account",
-  Effect.gen(function* () {
-    const row = yield* AccountRepo.use((r) => r.getRow(AccountID.make("nope")))
-    expect(Option.isNone(row)).toBe(true)
-  }),
-)

packages/opencode/test/account/service.test.ts

@@ -1,217 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Layer, Option, Ref, Schema } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-
-import { AccountRepo } from "../../src/account/repo"
-import { AccountService } from "../../src/account/service"
-import { AccountID, Login, Org, OrgID } from "../../src/account/schema"
-import { resetDatabase } from "../fixture/db"
-import { testEffect } from "../fixture/effect"
-
-const reset = Layer.effectDiscard(Effect.promise(() => resetDatabase()))
-
-const it = testEffect(Layer.merge(AccountRepo.layer, reset))
-
-const live = (client: HttpClient.HttpClient) =>
-  AccountService.layer.pipe(Layer.provide(Layer.succeed(HttpClient.HttpClient, client)))
-
-const json = (req: Parameters<typeof HttpClientResponse.fromWeb>[0], body: unknown, status = 200) =>
-  HttpClientResponse.fromWeb(
-    req,
-    new Response(JSON.stringify(body), {
-      status,
-      headers: { "content-type": "application/json" },
-    }),
-  )
-
-const encodeOrg = Schema.encodeSync(Org)
-
-const org = (id: string, name: string) => encodeOrg(new Org({ id: OrgID.make(id), name }))
-
-it.effect(
-  "orgsByAccount groups orgs per account",
-  Effect.gen(function* () {
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: AccountID.make("user-1"),
-        email: "one@example.com",
-        url: "https://one.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 60_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id: AccountID.make("user-2"),
-        email: "two@example.com",
-        url: "https://two.example.com",
-        accessToken: "at_2",
-        refreshToken: "rt_2",
-        expiry: Date.now() + 60_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    const seen = yield* Ref.make<string[]>([])
-    const client = HttpClient.make((req) =>
-      Effect.gen(function* () {
-        yield* Ref.update(seen, (xs) => [...xs, `${req.method} ${req.url}`])
-
-        if (req.url === "https://one.example.com/api/orgs") {
-          return json(req, [org("org-1", "One")])
-        }
-
-        if (req.url === "https://two.example.com/api/orgs") {
-          return json(req, [org("org-2", "Two A"), org("org-3", "Two B")])
-        }
-
-        return json(req, [], 404)
-      }),
-    )
-
-    const rows = yield* AccountService.use((s) => s.orgsByAccount()).pipe(Effect.provide(live(client)))
-
-    expect(rows.map((row) => [row.account.id, row.orgs.map((org) => org.id)]).map(([id, orgs]) => [id, orgs])).toEqual([
-      [AccountID.make("user-1"), [OrgID.make("org-1")]],
-      [AccountID.make("user-2"), [OrgID.make("org-2"), OrgID.make("org-3")]],
-    ])
-    expect(yield* Ref.get(seen)).toEqual([
-      "GET https://one.example.com/api/orgs",
-      "GET https://two.example.com/api/orgs",
-    ])
-  }),
-)
-
-it.effect(
-  "token refresh persists the new token",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: "at_old",
-        refreshToken: "rt_old",
-        expiry: Date.now() - 1_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    const client = HttpClient.make((req) =>
-      Effect.succeed(
-        req.url === "https://one.example.com/oauth/token"
-          ? json(req, {
-              access_token: "at_new",
-              refresh_token: "rt_new",
-              expires_in: 60,
-            })
-          : json(req, {}, 404),
-      ),
-    )
-
-    const token = yield* AccountService.use((s) => s.token(id)).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(token)).toBeDefined()
-    expect(String(Option.getOrThrow(token))).toBe("at_new")
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe("at_new")
-    expect(value.refresh_token).toBe("rt_new")
-    expect(value.token_expiry).toBeGreaterThan(Date.now())
-  }),
-)
-
-it.effect(
-  "config sends the selected org header",
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: "at_1",
-        refreshToken: "rt_1",
-        expiry: Date.now() + 60_000,
-        orgID: Option.none(),
-      }),
-    )
-
-    const seen = yield* Ref.make<{ auth?: string; org?: string }>({})
-    const client = HttpClient.make((req) =>
-      Effect.gen(function* () {
-        yield* Ref.set(seen, {
-          auth: req.headers.authorization,
-          org: req.headers["x-org-id"],
-        })
-
-        if (req.url === "https://one.example.com/api/config") {
-          return json(req, { config: { theme: "light", seats: 5 } })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const cfg = yield* AccountService.use((s) => s.config(id, OrgID.make("org-9"))).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(cfg)).toEqual({ theme: "light", seats: 5 })
-    expect(yield* Ref.get(seen)).toEqual({
-      auth: "Bearer at_1",
-      org: "org-9",
-    })
-  }),
-)
-
-it.effect(
-  "poll stores the account and first org on success",
-  Effect.gen(function* () {
-    const login = new Login({
-      code: "device-code",
-      user: "user-code",
-      url: "https://one.example.com/verify",
-      server: "https://one.example.com",
-      expiry: 600,
-      interval: 5,
-    })
-
-    const client = HttpClient.make((req) =>
-      Effect.succeed(
-        req.url === "https://one.example.com/auth/device/token"
-          ? json(req, {
-              access_token: "at_1",
-              refresh_token: "rt_1",
-              expires_in: 60,
-            })
-          : req.url === "https://one.example.com/api/user"
-            ? json(req, { id: "user-1", email: "user@example.com" })
-            : req.url === "https://one.example.com/api/orgs"
-              ? json(req, [org("org-1", "One")])
-              : json(req, {}, 404),
-      ),
-    )
-
-    const res = yield* AccountService.use((s) => s.poll(login)).pipe(Effect.provide(live(client)))
-
-    expect(res._tag).toBe("PollSuccess")
-    if (res._tag === "PollSuccess") {
-      expect(res.email).toBe("user@example.com")
-    }
-
-    const active = yield* AccountRepo.use((r) => r.active())
-    expect(Option.getOrThrow(active)).toEqual(
-      expect.objectContaining({
-        id: "user-1",
-        email: "user@example.com",
-        active_org_id: "org-1",
-      }),
-    )
-  }),
-)

packages/opencode/test/cli/import.test.ts

@@ -1,10 +1,5 @@
 import { test, expect } from "bun:test"
-import {
-  parseShareUrl,
-  shouldAttachShareAuthHeaders,
-  transformShareData,
-  type ShareData,
-} from "../../src/cli/cmd/import"
+import { parseShareUrl, transformShareData, type ShareData } from "../../src/cli/cmd/import"
 
 // parseShareUrl tests
 test("parses valid share URLs", () => {
@@ -20,19 +15,6 @@ test("rejects invalid URLs", () => {
   expect(parseShareUrl("not-a-url")).toBeNull()
 })
 
-test("only attaches share auth headers for same-origin URLs", () => {
-  expect(shouldAttachShareAuthHeaders("https://control.example.com/share/abc", "https://control.example.com")).toBe(
-    true,
-  )
-  expect(
-    shouldAttachShareAuthHeaders("https://other.example.com/share/abc", "https://control.example.com"),
-  ).toBe(false)
-  expect(shouldAttachShareAuthHeaders("https://control.example.com:443/share/abc", "https://control.example.com")).toBe(
-    true,
-  )
-  expect(shouldAttachShareAuthHeaders("not-a-url", "https://control.example.com")).toBe(false)
-})
-
 // transformShareData tests
 test("transforms share data to storage format", () => {
   const data: ShareData[] = [

packages/opencode/test/cli/plugin-auth-picker.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe } from "bun:test"
-import { resolvePluginProviders } from "../../src/cli/cmd/providers"
+import { resolvePluginProviders } from "../../src/cli/cmd/auth"
 import type { Hooks } from "@opencode-ai/plugin"
 
 function hookWithAuth(provider: string): Hooks {

packages/opencode/test/cli/tui/keybind-plugin.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test"
+import type { ParsedKey } from "@opentui/core"
+import { createPluginKeybind } from "../../../src/cli/cmd/tui/context/keybind-plugin"
+
+describe("createPluginKeybind", () => {
+  const defaults = {
+    open: "ctrl+o",
+    close: "escape",
+  }
+
+  test("uses defaults when overrides are missing", () => {
+    const api = {
+      parse: () => "parsed",
+      match: () => false,
+      print: (key: string) => key,
+    }
+    const bind = createPluginKeybind(api, defaults)
+
+    expect(bind.all).toEqual(defaults)
+    expect(bind.get("open")).toBe("ctrl+o")
+    expect(bind.get("close")).toBe("escape")
+  })
+
+  test("applies valid overrides", () => {
+    const api = {
+      parse: () => "parsed",
+      match: () => false,
+      print: (key: string) => key,
+    }
+    const bind = createPluginKeybind(api, defaults, {
+      open: "ctrl+alt+o",
+      close: "q",
+    })
+
+    expect(bind.all).toEqual({
+      open: "ctrl+alt+o",
+      close: "q",
+    })
+  })
+
+  test("ignores invalid overrides", () => {
+    const api = {
+      parse: () => "parsed",
+      match: () => false,
+      print: (key: string) => key,
+    }
+    const bind = createPluginKeybind(api, defaults, {
+      open: "   ",
+      close: 1,
+      extra: "ctrl+x",
+    })
+
+    expect(bind.all).toEqual(defaults)
+    expect(bind.get("extra")).toBe("extra")
+  })
+
+  test("delegates parse", () => {
+    const evt = { name: "x" } as ParsedKey
+    const api = {
+      parse: (value: ParsedKey) => value,
+      match: () => false,
+      print: (key: string) => key,
+    }
+    const bind = createPluginKeybind(api, defaults)
+
+    expect(bind.parse(evt)).toBe(evt)
+  })
+
+  test("resolves names for match", () => {
+    const list: string[] = []
+    const api = {
+      parse: () => "parsed",
+      match: (key: string) => {
+        list.push(key)
+        return true
+      },
+      print: (key: string) => key,
+    }
+    const bind = createPluginKeybind(api, defaults, {
+      open: "ctrl+shift+o",
+    })
+
+    bind.match("open", { name: "x" } as ParsedKey)
+    bind.match("ctrl+k", { name: "x" } as ParsedKey)
+
+    expect(list).toEqual(["ctrl+shift+o", "ctrl+k"])
+  })
+
+  test("resolves names for print", () => {
+    const list: string[] = []
+    const api = {
+      parse: () => "parsed",
+      match: () => false,
+      print: (key: string) => {
+        list.push(key)
+        return `print:${key}`
+      },
+    }
+    const bind = createPluginKeybind(api, defaults, {
+      close: "q",
+    })
+
+    expect(bind.print("close")).toBe("print:q")
+    expect(bind.print("ctrl+p")).toBe("print:ctrl+p")
+    expect(list).toEqual(["q", "ctrl+p"])
+  })
+})

packages/opencode/test/cli/tui/plugin-loader.test.ts

@@ -0,0 +1,482 @@
+import { expect, mock, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
+import type { CliRenderer } from "@opentui/core"
+import { tmpdir } from "../../fixture/fixture"
+import { Log } from "../../../src/util/log"
+import { Global } from "../../../src/global"
+import { createPluginKeybind } from "../../../src/cli/cmd/tui/context/keybind-plugin"
+
+mock.module("@opentui/solid/preload", () => ({}))
+mock.module("@opentui/solid", () => ({
+  createSolidSlotRegistry: () => ({
+    register: () => () => {},
+  }),
+  createSlot: () => () => null,
+  useRenderer: () => ({
+    getPalette: async () => ({ palette: [] as string[] }),
+    clearPaletteCache: () => {},
+  }),
+}))
+mock.module("@opentui/solid/jsx-runtime", () => ({
+  Fragment: Symbol.for("Fragment"),
+  jsx: () => null,
+  jsxs: () => null,
+  jsxDEV: () => null,
+}))
+const { allThemes, addTheme } = await import("../../../src/cli/cmd/tui/context/theme")
+const { TuiPlugin } = await import("../../../src/cli/cmd/tui/plugin")
+const { PluginMeta } = await import("../../../src/plugin/meta")
+
+async function waitForLog(text: string, timeout = 1000) {
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    const file = Log.file()
+    if (file) {
+      const content = await Bun.file(file)
+        .text()
+        .catch(() => "")
+      if (content.includes(text)) return content
+    }
+    await Bun.sleep(25)
+  }
+  return Bun.file(Log.file())
+    .text()
+    .catch(() => "")
+}
+
+test("loads plugin theme and keybind APIs with scoped theme installation", async () => {
+  const stamp = Date.now()
+  const globalConfigPath = path.join(Global.Path.config, "tui.json")
+  const backup = await Bun.file(globalConfigPath)
+    .text()
+    .catch(() => undefined)
+
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const localPluginPath = path.join(dir, "local-plugin.ts")
+      const preloadedPluginPath = path.join(dir, "preloaded-plugin.ts")
+      const globalPluginPath = path.join(dir, "global-plugin.ts")
+      const localSpec = pathToFileURL(localPluginPath).href
+      const preloadedSpec = pathToFileURL(preloadedPluginPath).href
+      const globalSpec = pathToFileURL(globalPluginPath).href
+      const localThemeFile = `local-theme-${stamp}.json`
+      const globalThemeFile = `global-theme-${stamp}.json`
+      const preloadedThemeFile = `preloaded-theme-${stamp}.json`
+      const localThemeName = localThemeFile.replace(/\.json$/, "")
+      const globalThemeName = globalThemeFile.replace(/\.json$/, "")
+      const preloadedThemeName = preloadedThemeFile.replace(/\.json$/, "")
+      const localThemePath = path.join(dir, localThemeFile)
+      const globalThemePath = path.join(dir, globalThemeFile)
+      const preloadedThemePath = path.join(dir, preloadedThemeFile)
+      const localDest = path.join(dir, ".opencode", "themes", localThemeFile)
+      const globalDest = path.join(Global.Path.config, "themes", globalThemeFile)
+      const preloadedDest = path.join(dir, ".opencode", "themes", preloadedThemeFile)
+      const fnMarker = path.join(dir, "function-called.txt")
+      const localMarker = path.join(dir, "local-called.json")
+      const globalMarker = path.join(dir, "global-called.json")
+      const preloadedMarker = path.join(dir, "preloaded-called.json")
+      const localConfigPath = path.join(dir, "tui.json")
+
+      await Bun.write(localThemePath, JSON.stringify({ theme: { primary: "#101010" } }, null, 2))
+      await Bun.write(globalThemePath, JSON.stringify({ theme: { primary: "#202020" } }, null, 2))
+      await Bun.write(preloadedThemePath, JSON.stringify({ theme: { primary: "#f0f0f0" } }, null, 2))
+      await Bun.write(preloadedDest, JSON.stringify({ theme: { primary: "#303030" } }, null, 2))
+
+      await Bun.write(
+        localPluginPath,
+        `export default async (_input, options) => {
+  if (!options?.fn_marker) return
+  await Bun.write(options.fn_marker, "called")
+}
+
+export const object_plugin = {
+  tui: async (input, options, init) => {
+    if (!options?.marker) return
+    const key = input.api.keybind.create(
+      { modal: "ctrl+shift+m", screen: "ctrl+shift+o", close: "escape" },
+      options.keybinds,
+    )
+    const depth_before = input.api.ui.dialog.depth
+    const open_before = input.api.ui.dialog.open
+    const size_before = input.api.ui.dialog.size
+    input.api.ui.dialog.setSize("large")
+    const size_after = input.api.ui.dialog.size
+    input.api.ui.dialog.replace(() => null)
+    const depth_after = input.api.ui.dialog.depth
+    const open_after = input.api.ui.dialog.open
+    input.api.ui.dialog.clear()
+    const open_clear = input.api.ui.dialog.open
+    const before = input.api.theme.has(options.theme_name)
+    const set_missing = input.api.theme.set(options.theme_name)
+    await input.api.theme.install(options.theme_path)
+    const after = input.api.theme.has(options.theme_name)
+    const set_installed = input.api.theme.set(options.theme_name)
+    const first = await Bun.file(options.dest).text()
+    await Bun.write(options.source, JSON.stringify({ theme: { primary: "#fefefe" } }, null, 2))
+    await input.api.theme.install(options.theme_path)
+    const second = await Bun.file(options.dest).text()
+    const init_state = init.state
+    const init_source = init.entry.source
+    const init_load_count = init.entry.load_count
+    await Bun.write(
+      options.marker,
+      JSON.stringify({
+        before,
+        set_missing,
+        after,
+        set_installed,
+        selected: input.api.theme.selected,
+        same: first === second,
+        key_modal: key.get("modal"),
+        key_close: key.get("close"),
+        key_unknown: key.get("ctrl+k"),
+        key_print: key.print("modal"),
+        depth_before,
+        open_before,
+        size_before,
+        size_after,
+        depth_after,
+        open_after,
+        open_clear,
+        init_state,
+        init_source,
+        init_load_count,
+      }),
+    )
+  },
+}
+`,
+      )
+
+      await Bun.write(
+        preloadedPluginPath,
+        `export default {
+  tui: async (input, options, init) => {
+    if (!options?.marker) return
+    const before = input.api.theme.has(options.theme_name)
+    await input.api.theme.install(options.theme_path)
+    const after = input.api.theme.has(options.theme_name)
+    const text = await Bun.file(options.dest).text()
+    await Bun.write(
+      options.marker,
+      JSON.stringify({
+        before,
+        after,
+        text,
+        init_state: init.state,
+        init_source: init.entry.source,
+        init_load_count: init.entry.load_count,
+      }),
+    )
+  },
+}
+`,
+      )
+
+      await Bun.write(
+        globalPluginPath,
+        `export default {
+  tui: async (input, options, init) => {
+    if (!options?.marker) return
+    await input.api.theme.install(options.theme_path)
+    const has = input.api.theme.has(options.theme_name)
+    const set_installed = input.api.theme.set(options.theme_name)
+    await Bun.write(
+      options.marker,
+      JSON.stringify({
+        has,
+        set_installed,
+        selected: input.api.theme.selected,
+        init_state: init.state,
+        init_source: init.entry.source,
+        init_load_count: init.entry.load_count,
+      }),
+    )
+  },
+}
+`,
+      )
+
+      await Bun.write(
+        globalConfigPath,
+        JSON.stringify(
+          {
+            plugin: [
+              [globalSpec, { marker: globalMarker, theme_path: `./${globalThemeFile}`, theme_name: globalThemeName }],
+            ],
+          },
+          null,
+          2,
+        ),
+      )
+
+      await Bun.write(
+        localConfigPath,
+        JSON.stringify(
+          {
+            plugin: [
+              [
+                localSpec,
+                {
+                  fn_marker: fnMarker,
+                  marker: localMarker,
+                  source: localThemePath,
+                  dest: localDest,
+                  theme_path: `./${localThemeFile}`,
+                  theme_name: localThemeName,
+                  keybinds: {
+                    modal: "ctrl+alt+m",
+                    close: "q",
+                  },
+                },
+              ],
+              [
+                preloadedSpec,
+                {
+                  marker: preloadedMarker,
+                  dest: preloadedDest,
+                  theme_path: `./${preloadedThemeFile}`,
+                  theme_name: preloadedThemeName,
+                },
+              ],
+            ],
+          },
+          null,
+          2,
+        ),
+      )
+
+      return {
+        localThemeFile,
+        globalThemeFile,
+        preloadedThemeFile,
+        localThemeName,
+        globalThemeName,
+        preloadedThemeName,
+        localDest,
+        globalDest,
+        preloadedDest,
+        localPluginPath,
+        globalPluginPath,
+        preloadedPluginPath,
+        localSpec,
+        globalSpec,
+        preloadedSpec,
+        fnMarker,
+        localMarker,
+        globalMarker,
+        preloadedMarker,
+      }
+    },
+  })
+  process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  if (!process.env.OPENCODE_PLUGIN_META_FILE) throw new Error("missing meta file")
+  await PluginMeta.touch(tmp.extra.localSpec, tmp.extra.localSpec)
+  await PluginMeta.touch(tmp.extra.globalSpec, tmp.extra.globalSpec)
+  await PluginMeta.persist()
+  await Bun.sleep(20)
+  const text = await Bun.file(tmp.extra.globalPluginPath).text()
+  await Bun.write(tmp.extra.globalPluginPath, `${text}\n`)
+
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+  let selected = "opencode"
+  let depth = 0
+  let size: "medium" | "large" = "medium"
+
+  const renderer = {
+    ...Object.create(null),
+    once(this: CliRenderer) {
+      return this
+    },
+  } satisfies CliRenderer
+  const keybind = {
+    parse: (evt: { name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean; super?: boolean }) => ({
+      name: evt.name ?? "",
+      ctrl: evt.ctrl ?? false,
+      meta: evt.meta ?? false,
+      shift: evt.shift ?? false,
+      super: evt.super,
+      leader: false,
+    }),
+    match: () => false,
+    print: (key: string) => `print:${key}`,
+  }
+
+  try {
+    expect(addTheme(tmp.extra.preloadedThemeName, { theme: { primary: "#303030" } })).toBe(true)
+
+    await TuiPlugin.init({
+      client: createOpencodeClient({
+        baseUrl: "http://localhost:4096",
+      }),
+      event: {
+        on: () => () => {},
+      },
+      renderer,
+      api: {
+        command: {
+          register: () => {},
+          trigger: () => {},
+        },
+        route: {
+          register: () => () => {},
+          navigate: () => {},
+          get current() {
+            return { name: "home" as const }
+          },
+        },
+        ui: {
+          Dialog: () => null,
+          DialogAlert: () => null,
+          DialogConfirm: () => null,
+          DialogPrompt: () => null,
+          DialogSelect: () => null,
+          toast: () => {},
+          dialog: {
+            replace: () => {
+              depth = 1
+            },
+            clear: () => {
+              depth = 0
+              size = "medium"
+            },
+            setSize: (next) => {
+              size = next
+            },
+            get size() {
+              return size
+            },
+            get depth() {
+              return depth
+            },
+            get open() {
+              return depth > 0
+            },
+          },
+        },
+        keybind: {
+          ...keybind,
+          create(defaults, overrides) {
+            return createPluginKeybind(keybind, defaults, overrides)
+          },
+        },
+        theme: {
+          get current() {
+            return {}
+          },
+          get selected() {
+            return selected
+          },
+          has(name) {
+            return allThemes()[name] !== undefined
+          },
+          set(name) {
+            if (!allThemes()[name]) return false
+            selected = name
+            return true
+          },
+          async install() {
+            throw new Error("base theme.install should not run")
+          },
+          mode() {
+            return "dark" as const
+          },
+          get ready() {
+            return true
+          },
+        },
+      },
+    })
+
+    const local = JSON.parse(await fs.readFile(tmp.extra.localMarker, "utf8"))
+    expect(local.before).toBe(false)
+    expect(local.set_missing).toBe(false)
+    expect(local.after).toBe(true)
+    expect(local.set_installed).toBe(true)
+    expect(local.selected).toBe(tmp.extra.localThemeName)
+    expect(local.same).toBe(true)
+    expect(local.key_modal).toBe("ctrl+alt+m")
+    expect(local.key_close).toBe("q")
+    expect(local.key_unknown).toBe("ctrl+k")
+    expect(local.key_print).toBe("print:ctrl+alt+m")
+    expect(local.depth_before).toBe(0)
+    expect(local.open_before).toBe(false)
+    expect(local.size_before).toBe("medium")
+    expect(local.size_after).toBe("large")
+    expect(local.depth_after).toBe(1)
+    expect(local.open_after).toBe(true)
+    expect(local.open_clear).toBe(false)
+    expect(local.init_state).toBe("same")
+    expect(local.init_source).toBe("file")
+    expect(local.init_load_count).toBe(2)
+
+    const global = JSON.parse(await fs.readFile(tmp.extra.globalMarker, "utf8"))
+    expect(global.has).toBe(true)
+    expect(global.set_installed).toBe(true)
+    expect(global.selected).toBe(tmp.extra.globalThemeName)
+    expect(global.init_state).toBe("updated")
+    expect(global.init_source).toBe("file")
+    expect(global.init_load_count).toBe(2)
+
+    const preloaded = JSON.parse(await fs.readFile(tmp.extra.preloadedMarker, "utf8"))
+    expect(preloaded.before).toBe(true)
+    expect(preloaded.after).toBe(true)
+    expect(preloaded.text).toContain("#303030")
+    expect(preloaded.text).not.toContain("#f0f0f0")
+    expect(preloaded.init_state).toBe("first")
+    expect(preloaded.init_source).toBe("file")
+    expect(preloaded.init_load_count).toBe(1)
+
+    await expect(fs.readFile(tmp.extra.fnMarker, "utf8")).rejects.toThrow()
+
+    const localInstalled = await fs.readFile(tmp.extra.localDest, "utf8")
+    expect(localInstalled).toContain("#101010")
+    expect(localInstalled).not.toContain("#fefefe")
+
+    const globalInstalled = await fs.readFile(tmp.extra.globalDest, "utf8")
+    expect(globalInstalled).toContain("#202020")
+
+    const preloadedInstalled = await fs.readFile(tmp.extra.preloadedDest, "utf8")
+    expect(preloadedInstalled).toContain("#303030")
+    expect(preloadedInstalled).not.toContain("#f0f0f0")
+
+    expect(
+      await fs
+        .stat(path.join(Global.Path.config, "themes", tmp.extra.localThemeFile))
+        .then(() => true)
+        .catch(() => false),
+    ).toBe(false)
+    expect(
+      await fs
+        .stat(path.join(tmp.path, ".opencode", "themes", tmp.extra.globalThemeFile))
+        .then(() => true)
+        .catch(() => false),
+    ).toBe(false)
+
+    const log = await waitForLog("ignoring non-object tui plugin export")
+    expect(log).toContain("ignoring non-object tui plugin export")
+    expect(log).toContain("name=default")
+    expect(log).toContain("type=function")
+
+    const meta = JSON.parse(await fs.readFile(path.join(tmp.path, "plugin-meta.json"), "utf8")) as Record<
+      string,
+      { name: string; load_count: number }
+    >
+    const rows = Object.values(meta)
+    expect(rows.find((item) => item.name === "local-plugin")?.load_count).toBe(2)
+    expect(rows.find((item) => item.name === "global-plugin")?.load_count).toBe(2)
+    expect(rows.find((item) => item.name === "preloaded-plugin")?.load_count).toBe(1)
+  } finally {
+    cwd.mockRestore()
+    if (backup === undefined) {
+      await fs.rm(globalConfigPath, { force: true })
+    } else {
+      await Bun.write(globalConfigPath, backup)
+    }
+    await fs.rm(tmp.extra.globalDest, { force: true }).catch(() => {})
+    delete process.env.OPENCODE_PLUGIN_META_FILE
+  }
+})

packages/opencode/test/cli/tui/theme-store.test.ts

@@ -0,0 +1,44 @@
+import { expect, mock, test } from "bun:test"
+
+mock.module("@opentui/solid/jsx-runtime", () => ({
+  Fragment: Symbol.for("Fragment"),
+  jsx: () => null,
+  jsxs: () => null,
+  jsxDEV: () => null,
+}))
+
+const { DEFAULT_THEMES, allThemes, addTheme, hasTheme } = await import("../../../src/cli/cmd/tui/context/theme")
+
+test("addTheme writes into module theme store", () => {
+  const name = `plugin-theme-${Date.now()}`
+  expect(addTheme(name, DEFAULT_THEMES.opencode)).toBe(true)
+
+  expect(allThemes()[name]).toBeDefined()
+})
+
+test("addTheme keeps first theme for duplicate names", () => {
+  const name = `plugin-theme-keep-${Date.now()}`
+  const one = structuredClone(DEFAULT_THEMES.opencode)
+  const two = structuredClone(DEFAULT_THEMES.opencode)
+  ;(one.theme as Record<string, unknown>).primary = "#101010"
+  ;(two.theme as Record<string, unknown>).primary = "#fefefe"
+
+  expect(addTheme(name, one)).toBe(true)
+  expect(addTheme(name, two)).toBe(false)
+
+  expect(allThemes()[name]).toBeDefined()
+  expect(allThemes()[name]!.theme.primary).toBe("#101010")
+})
+
+test("addTheme ignores entries without a theme object", () => {
+  const name = `plugin-theme-invalid-${Date.now()}`
+  expect(addTheme(name, { defs: { a: "#ffffff" } })).toBe(false)
+  expect(allThemes()[name]).toBeUndefined()
+})
+
+test("hasTheme checks theme presence", () => {
+  const name = `plugin-theme-has-${Date.now()}`
+  expect(hasTheme(name)).toBe(false)
+  expect(addTheme(name, DEFAULT_THEMES.opencode)).toBe(true)
+  expect(hasTheme(name)).toBe(true)
+})

packages/opencode/test/config/config.test.ts

@@ -2,7 +2,6 @@ import { test, expect, describe, mock, afterEach } from "bun:test"
 import { Config } from "../../src/config/config"
 import { Instance } from "../../src/project/instance"
 import { Auth } from "../../src/auth"
-import { AccessToken, Account, AccountID, OrgID } from "../../src/account"
 import { tmpdir } from "../fixture/fixture"
 import path from "path"
 import fs from "fs/promises"
@@ -243,52 +242,6 @@ test("preserves env variables when adding $schema to config", async () => {
   }
 })
 
-test("resolves env templates in account config with account token", async () => {
-  const originalActive = Account.active
-  const originalConfig = Account.config
-  const originalToken = Account.token
-  const originalControlToken = process.env["OPENCODE_CONSOLE_TOKEN"]
-
-  Account.active = mock(() => ({
-    id: AccountID.make("account-1"),
-    email: "user@example.com",
-    url: "https://control.example.com",
-    active_org_id: OrgID.make("org-1"),
-  }))
-
-  Account.config = mock(async () => ({
-    provider: {
-      opencode: {
-        options: {
-          apiKey: "{env:OPENCODE_CONSOLE_TOKEN}",
-        },
-      },
-    },
-  }))
-
-  Account.token = mock(async () => AccessToken.make("st_test_token"))
-
-  try {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const config = await Config.get()
-        expect(config.provider?.["opencode"]?.options?.apiKey).toBe("st_test_token")
-      },
-    })
-  } finally {
-    Account.active = originalActive
-    Account.config = originalConfig
-    Account.token = originalToken
-    if (originalControlToken !== undefined) {
-      process.env["OPENCODE_CONSOLE_TOKEN"] = originalControlToken
-    } else {
-      delete process.env["OPENCODE_CONSOLE_TOKEN"]
-    }
-  }
-})
-
 test("handles file inclusion substitution", async () => {
   await using tmp = await tmpdir({
     init: async (dir) => {
@@ -1774,7 +1727,7 @@ describe("deduplicatePlugins", () => {
 
         const myPlugins = plugins.filter((p) => Config.getPluginName(p) === "my-plugin")
         expect(myPlugins.length).toBe(1)
-        expect(myPlugins[0].startsWith("file://")).toBe(true)
+        expect(Config.pluginSpecifier(myPlugins[0]).startsWith("file://")).toBe(true)
       },
     })
   })

packages/opencode/test/config/tui.test.ts

@@ -458,9 +458,15 @@ test("applies file substitutions when first identical token is in a commented li
 test("loads managed tui config and gives it highest precedence", async () => {
   await using tmp = await tmpdir({
     init: async (dir) => {
-      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ theme: "project-theme" }, null, 2))
+      await Bun.write(
+        path.join(dir, "tui.json"),
+        JSON.stringify({ theme: "project-theme", plugin: ["shared-plugin@1.0.0"] }, null, 2),
+      )
       await fs.mkdir(managedConfigDir, { recursive: true })
-      await Bun.write(path.join(managedConfigDir, "tui.json"), JSON.stringify({ theme: "managed-theme" }, null, 2))
+      await Bun.write(
+        path.join(managedConfigDir, "tui.json"),
+        JSON.stringify({ theme: "managed-theme", plugin: ["shared-plugin@2.0.0"] }, null, 2),
+      )
     },
   })
 
@@ -469,6 +475,13 @@ test("loads managed tui config and gives it highest precedence", async () => {
     fn: async () => {
       const config = await TuiConfig.get()
       expect(config.theme).toBe("managed-theme")
+      expect(config.plugin).toEqual(["shared-plugin@2.0.0"])
+      expect(config.plugin_meta).toEqual({
+        "shared-plugin": {
+          scope: "global",
+          source: path.join(managedConfigDir, "tui.json"),
+        },
+      })
     },
   })
 })
@@ -508,3 +521,110 @@ test("gracefully falls back when tui.json has invalid JSON", async () => {
     },
   })
 })
+
+test("supports tuple plugin specs with options in tui.json", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "tui.json"),
+        JSON.stringify({
+          plugin: [["acme-plugin@1.2.3", { enabled: true, label: "demo" }]],
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await TuiConfig.get()
+      expect(config.plugin).toEqual([["acme-plugin@1.2.3", { enabled: true, label: "demo" }]])
+      expect(config.plugin_meta).toEqual({
+        "acme-plugin": {
+          scope: "local",
+          source: path.join(tmp.path, "tui.json"),
+        },
+      })
+    },
+  })
+})
+
+test("deduplicates tuple plugin specs by name with higher precedence winning", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(Global.Path.config, "tui.json"),
+        JSON.stringify({
+          plugin: [["acme-plugin@1.0.0", { source: "global" }]],
+        }),
+      )
+      await Bun.write(
+        path.join(dir, "tui.json"),
+        JSON.stringify({
+          plugin: [
+            ["acme-plugin@2.0.0", { source: "project" }],
+            ["second-plugin@3.0.0", { source: "project" }],
+          ],
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await TuiConfig.get()
+      expect(config.plugin).toEqual([
+        ["acme-plugin@2.0.0", { source: "project" }],
+        ["second-plugin@3.0.0", { source: "project" }],
+      ])
+      expect(config.plugin_meta).toEqual({
+        "acme-plugin": {
+          scope: "local",
+          source: path.join(tmp.path, "tui.json"),
+        },
+        "second-plugin": {
+          scope: "local",
+          source: path.join(tmp.path, "tui.json"),
+        },
+      })
+    },
+  })
+})
+
+test("tracks global and local plugin metadata in merged tui config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(Global.Path.config, "tui.json"),
+        JSON.stringify({
+          plugin: ["global-plugin@1.0.0"],
+        }),
+      )
+      await Bun.write(
+        path.join(dir, "tui.json"),
+        JSON.stringify({
+          plugin: ["local-plugin@2.0.0"],
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const config = await TuiConfig.get()
+      expect(config.plugin).toEqual(["global-plugin@1.0.0", "local-plugin@2.0.0"])
+      expect(config.plugin_meta).toEqual({
+        "global-plugin": {
+          scope: "global",
+          source: path.join(Global.Path.config, "tui.json"),
+        },
+        "local-plugin": {
+          scope: "local",
+          source: path.join(tmp.path, "tui.json"),
+        },
+      })
+    },
+  })
+})

packages/opencode/test/fixture/effect.ts

@@ -1,7 +0,0 @@
-import { test } from "bun:test"
-import { Effect, Layer } from "effect"
-
-export const testEffect = <R, E>(layer: Layer.Layer<R, E, never>) => ({
-  effect: <A, E2>(name: string, value: Effect.Effect<A, E2, R>) =>
-    test(name, () => Effect.runPromise(value.pipe(Effect.provide(layer)))),
-})

packages/opencode/test/plugin/loader-shared.test.ts

@@ -0,0 +1,306 @@
+import { afterAll, afterEach, describe, expect, mock, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../fixture/fixture"
+
+const disableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
+process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "1"
+
+const { Plugin } = await import("../../src/plugin/index")
+const { Instance } = await import("../../src/project/instance")
+const { BunProc } = await import("../../src/bun")
+const { Bus } = await import("../../src/bus")
+const { Session } = await import("../../src/session")
+
+afterAll(() => {
+  if (disableDefault === undefined) {
+    delete process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
+    return
+  }
+  process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = disableDefault
+})
+
+afterEach(async () => {
+  mock.restore()
+  await Instance.disposeAll()
+})
+
+async function load(dir: string) {
+  return Instance.provide({
+    directory: dir,
+    fn: async () => {
+      await Plugin.list()
+    },
+  })
+}
+
+async function errs(dir: string) {
+  return Instance.provide({
+    directory: dir,
+    fn: async () => {
+      const errors: string[] = []
+      const off = Bus.subscribe(Session.Event.Error, (evt) => {
+        const error = evt.properties.error
+        if (!error || typeof error !== "object") return
+        if (!("data" in error)) return
+        if (!error.data || typeof error.data !== "object") return
+        if (!("message" in error.data)) return
+        if (typeof error.data.message !== "string") return
+        errors.push(error.data.message)
+      })
+      await Plugin.list()
+      off()
+      return errors
+    },
+  })
+}
+
+describe("plugin.loader.shared", () => {
+  test("loads a file:// plugin function export", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "plugin.ts")
+        const mark = path.join(dir, "called.txt")
+        await Bun.write(
+          file,
+          [
+            "export default async () => {",
+            `  await Bun.write(${JSON.stringify(mark)}, \"called\")`,
+            "  return {}",
+            "}",
+            "",
+          ].join("\n"),
+        )
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({ plugin: [pathToFileURL(file).href] }, null, 2),
+        )
+
+        return { mark }
+      },
+    })
+
+    await load(tmp.path)
+    expect(await fs.readFile(tmp.extra.mark, "utf8")).toBe("called")
+  })
+
+  test("deduplicates same function exported as default and named", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "plugin.ts")
+        const mark = path.join(dir, "count.txt")
+        await Bun.write(
+          file,
+          [
+            "const run = async () => {",
+            `  const text = await Bun.file(${JSON.stringify(mark)}).text().catch(() => \"\")`,
+            `  await Bun.write(${JSON.stringify(mark)}, text + \"1\")`,
+            "  return {}",
+            "}",
+            "export default run",
+            "export const named = run",
+            "",
+          ].join("\n"),
+        )
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({ plugin: [pathToFileURL(file).href] }, null, 2),
+        )
+
+        return { mark }
+      },
+    })
+
+    await load(tmp.path)
+    expect(await fs.readFile(tmp.extra.mark, "utf8")).toBe("1")
+  })
+
+  test("resolves npm plugin specs with explicit and default versions", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "plugin.ts")
+        await Bun.write(file, ["export default async () => {", "  return {}", "}", ""].join("\n"))
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({ plugin: ["acme-plugin", "scope-plugin@2.3.4"] }, null, 2),
+        )
+
+        return { file }
+      },
+    })
+
+    const install = spyOn(BunProc, "install").mockImplementation(async () => pathToFileURL(tmp.extra.file).href)
+
+    await load(tmp.path)
+
+    expect(install.mock.calls).toContainEqual(["acme-plugin", "latest"])
+    expect(install.mock.calls).toContainEqual(["scope-plugin", "2.3.4"])
+  })
+
+  test("skips legacy codex and copilot auth plugin specs", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify(
+            {
+              plugin: ["opencode-openai-codex-auth@1.0.0", "opencode-copilot-auth@1.0.0", "regular-plugin@1.0.0"],
+            },
+            null,
+            2,
+          ),
+        )
+      },
+    })
+
+    const install = spyOn(BunProc, "install").mockResolvedValue("")
+
+    await load(tmp.path)
+
+    const pkgs = install.mock.calls.map((call) => call[0])
+    expect(pkgs).toContain("regular-plugin")
+    expect(pkgs).not.toContain("opencode-openai-codex-auth")
+    expect(pkgs).not.toContain("opencode-copilot-auth")
+  })
+
+  test("publishes session.error when install fails", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ plugin: ["broken-plugin@9.9.9"] }, null, 2))
+      },
+    })
+
+    spyOn(BunProc, "install").mockRejectedValue(new Error("boom"))
+
+    const errors = await errs(tmp.path)
+
+    expect(errors.some((x) => x.includes("Failed to install plugin broken-plugin@9.9.9") && x.includes("boom"))).toBe(
+      true,
+    )
+  })
+
+  test("publishes session.error when plugin init throws", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = pathToFileURL(path.join(dir, "throws.ts")).href
+        await Bun.write(
+          path.join(dir, "throws.ts"),
+          ["export default async () => {", '  throw new Error("explode")', "}", ""].join("\n"),
+        )
+
+        await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ plugin: [file] }, null, 2))
+
+        return { file }
+      },
+    })
+
+    const errors = await errs(tmp.path)
+
+    expect(errors.some((x) => x.includes(`Failed to load plugin ${tmp.extra.file}: explode`))).toBe(true)
+  })
+
+  test("publishes session.error when plugin module has invalid export", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = pathToFileURL(path.join(dir, "invalid.ts")).href
+        await Bun.write(
+          path.join(dir, "invalid.ts"),
+          ["export default async () => {", "  return {}", "}", 'export const meta = { name: "invalid" }', ""].join(
+            "\n",
+          ),
+        )
+
+        await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ plugin: [file] }, null, 2))
+
+        return { file }
+      },
+    })
+
+    const errors = await errs(tmp.path)
+
+    expect(errors.some((x) => x.includes(`Failed to load plugin ${tmp.extra.file}`))).toBe(true)
+  })
+
+  test("publishes session.error when plugin import fails", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const missing = pathToFileURL(path.join(dir, "missing-plugin.ts")).href
+        await Bun.write(path.join(dir, "opencode.json"), JSON.stringify({ plugin: [missing] }, null, 2))
+
+        return { missing }
+      },
+    })
+
+    const errors = await errs(tmp.path)
+
+    expect(errors.some((x) => x.includes(`Failed to load plugin ${tmp.extra.missing}`))).toBe(true)
+  })
+
+  test("loads object plugin via plugin.server", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "object-plugin.ts")
+        const mark = path.join(dir, "object-called.txt")
+        await Bun.write(
+          file,
+          [
+            "const plugin = {",
+            "  server: async () => {",
+            `    await Bun.write(${JSON.stringify(mark)}, \"called\")`,
+            "    return {}",
+            "  },",
+            "}",
+            "export default plugin",
+            "",
+          ].join("\n"),
+        )
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({ plugin: [pathToFileURL(file).href] }, null, 2),
+        )
+
+        return { mark }
+      },
+    })
+
+    await load(tmp.path)
+    expect(await fs.readFile(tmp.extra.mark, "utf8")).toBe("called")
+  })
+
+  test("passes tuple plugin options into server plugin", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const file = path.join(dir, "options-plugin.ts")
+        const mark = path.join(dir, "options.json")
+        await Bun.write(
+          file,
+          [
+            "const plugin = {",
+            "  server: async (_input, options) => {",
+            `    await Bun.write(${JSON.stringify(mark)}, JSON.stringify(options ?? null))`,
+            "    return {}",
+            "  },",
+            "}",
+            "export default plugin",
+            "",
+          ].join("\n"),
+        )
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({ plugin: [[pathToFileURL(file).href, { source: "tuple", enabled: true }]] }, null, 2),
+        )
+
+        return { mark }
+      },
+    })
+
+    await load(tmp.path)
+    expect(JSON.parse(await fs.readFile(tmp.extra.mark, "utf8"))).toEqual({ source: "tuple", enabled: true })
+  })
+})

packages/opencode/test/plugin/meta.test.ts

@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+
+import { tmpdir } from "../fixture/fixture"
+
+const { PluginMeta } = await import("../../src/plugin/meta")
+
+afterEach(() => {
+  delete process.env.OPENCODE_PLUGIN_META_FILE
+})
+
+describe("plugin.meta", () => {
+  test("tracks file plugin loads and changes", async () => {
+    await using tmp = await tmpdir<{ file: string }>({
+      init: async (dir) => {
+        const file = path.join(dir, "plugin.ts")
+        await Bun.write(file, "export default async () => ({})\n")
+        return { file }
+      },
+    })
+
+    process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "state", "plugin-meta.json")
+    const file = process.env.OPENCODE_PLUGIN_META_FILE!
+    const spec = pathToFileURL(tmp.extra.file).href
+
+    const one = await PluginMeta.touch(spec, spec)
+    expect(one.state).toBe("first")
+    expect(one.entry.source).toBe("file")
+    expect(one.entry.modified).toBeDefined()
+
+    const two = await PluginMeta.touch(spec, spec)
+    expect(two.state).toBe("same")
+    expect(two.entry.load_count).toBe(2)
+
+    await Bun.sleep(20)
+    await Bun.write(tmp.extra.file, "export default async () => ({ ok: true })\n")
+
+    const three = await PluginMeta.touch(spec, spec)
+    expect(three.state).toBe("updated")
+    expect(three.entry.load_count).toBe(3)
+    expect((three.entry.modified ?? 0) >= (one.entry.modified ?? 0)).toBe(true)
+
+    await expect(fs.readFile(file, "utf8")).rejects.toThrow()
+    await PluginMeta.persist()
+
+    const all = await PluginMeta.list()
+    expect(Object.values(all).some((item) => item.spec === spec && item.source === "file")).toBe(true)
+    const saved = JSON.parse(await fs.readFile(file, "utf8")) as Record<string, { spec: string; load_count: number }>
+    expect(Object.values(saved).some((item) => item.spec === spec && item.load_count === 3)).toBe(true)
+  })
+
+  test("tracks npm plugin versions", async () => {
+    await using tmp = await tmpdir<{ mod: string; pkg: string }>({
+      init: async (dir) => {
+        const mod = path.join(dir, "node_modules", "acme-plugin")
+        const pkg = path.join(mod, "package.json")
+        await fs.mkdir(mod, { recursive: true })
+        await Bun.write(pkg, JSON.stringify({ name: "acme-plugin", version: "1.0.0" }, null, 2))
+        return { mod, pkg }
+      },
+    })
+
+    process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "state", "plugin-meta.json")
+    const file = process.env.OPENCODE_PLUGIN_META_FILE!
+
+    const one = await PluginMeta.touch("acme-plugin@latest", tmp.extra.mod)
+    expect(one.state).toBe("first")
+    expect(one.entry.source).toBe("npm")
+    expect(one.entry.requested).toBe("latest")
+    expect(one.entry.version).toBe("1.0.0")
+
+    await Bun.write(tmp.extra.pkg, JSON.stringify({ name: "acme-plugin", version: "1.1.0" }, null, 2))
+
+    const two = await PluginMeta.touch("acme-plugin@latest", tmp.extra.mod)
+    expect(two.state).toBe("updated")
+    expect(two.entry.version).toBe("1.1.0")
+    expect(two.entry.load_count).toBe(2)
+    await PluginMeta.persist()
+
+    const all = await PluginMeta.list()
+    expect(Object.values(all).some((item) => item.name === "acme-plugin" && item.version === "1.1.0")).toBe(true)
+    const saved = JSON.parse(await fs.readFile(file, "utf8")) as Record<string, { name: string; version?: string }>
+    expect(Object.values(saved).some((item) => item.name === "acme-plugin" && item.version === "1.1.0")).toBe(true)
+  })
+})

packages/opencode/test/share/share-next.test.ts

@@ -1,76 +0,0 @@
-import { test, expect, mock } from "bun:test"
-import { ShareNext } from "../../src/share/share-next"
-import { AccessToken, Account, AccountID, OrgID } from "../../src/account"
-import { Config } from "../../src/config/config"
-
-test("ShareNext.request uses legacy share API without active org account", async () => {
-  const originalActive = Account.active
-  const originalConfigGet = Config.get
-
-  Account.active = mock(() => undefined)
-  Config.get = mock(async () => ({ enterprise: { url: "https://legacy-share.example.com" } }))
-
-  try {
-    const req = await ShareNext.request()
-
-    expect(req.api.create).toBe("/api/share")
-    expect(req.api.sync("shr_123")).toBe("/api/share/shr_123/sync")
-    expect(req.api.remove("shr_123")).toBe("/api/share/shr_123")
-    expect(req.api.data("shr_123")).toBe("/api/share/shr_123/data")
-    expect(req.baseUrl).toBe("https://legacy-share.example.com")
-    expect(req.headers).toEqual({})
-  } finally {
-    Account.active = originalActive
-    Config.get = originalConfigGet
-  }
-})
-
-test("ShareNext.request uses org share API with auth headers when account is active", async () => {
-  const originalActive = Account.active
-  const originalToken = Account.token
-
-  Account.active = mock(() => ({
-    id: AccountID.make("account-1"),
-    email: "user@example.com",
-    url: "https://control.example.com",
-    active_org_id: OrgID.make("org-1"),
-  }))
-  Account.token = mock(async () => AccessToken.make("st_test_token"))
-
-  try {
-    const req = await ShareNext.request()
-
-    expect(req.api.create).toBe("/api/shares")
-    expect(req.api.sync("shr_123")).toBe("/api/shares/shr_123/sync")
-    expect(req.api.remove("shr_123")).toBe("/api/shares/shr_123")
-    expect(req.api.data("shr_123")).toBe("/api/shares/shr_123/data")
-    expect(req.baseUrl).toBe("https://control.example.com")
-    expect(req.headers).toEqual({
-      authorization: "Bearer st_test_token",
-      "x-org-id": "org-1",
-    })
-  } finally {
-    Account.active = originalActive
-    Account.token = originalToken
-  }
-})
-
-test("ShareNext.request fails when org account has no token", async () => {
-  const originalActive = Account.active
-  const originalToken = Account.token
-
-  Account.active = mock(() => ({
-    id: AccountID.make("account-1"),
-    email: "user@example.com",
-    url: "https://control.example.com",
-    active_org_id: OrgID.make("org-1"),
-  }))
-  Account.token = mock(async () => undefined)
-
-  try {
-    await expect(ShareNext.request()).rejects.toThrow("No active OpenControl token available for sharing")
-  } finally {
-    Account.active = originalActive
-    Account.token = originalToken
-  }
-})

packages/opencode/tsconfig.json

@@ -11,11 +11,6 @@
     "paths": {
       "@/*": ["./src/*"],
       "@tui/*": ["./src/cli/cmd/tui/*"]
-    },
-    "plugins": [{
-      "name": "@effect/language-service",
-      "transform": "@effect/language-service/transform",
-      "namespaceImportPackages": ["effect", "@effect/*"]
-    }]
+    }
   }
 }

packages/plugin/package.json

@@ -10,7 +10,8 @@
   },
   "exports": {
     ".": "./src/index.ts",
-    "./tool": "./src/tool.ts"
+    "./tool": "./src/tool.ts",
+    "./tui": "./src/tui.ts"
   },
   "files": [
     "dist"
@@ -19,7 +20,16 @@
     "@opencode-ai/sdk": "workspace:*",
     "zod": "catalog:"
   },
+  "peerDependencies": {
+    "@opentui/core": ">=0.1.87"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@opentui/core": "0.0.0-20260307-536c401b",
     "@tsconfig/node22": "catalog:",
     "@types/node": "catalog:",
     "typescript": "catalog:",

packages/plugin/src/index.ts

@@ -9,9 +9,8 @@ import type {
   Message,
   Part,
   Auth,
-  Config,
+  Config as SDKConfig,
 } from "@opencode-ai/sdk"
-
 import type { BunShell } from "./shell"
 import { type ToolDefinition } from "./tool"
 
@@ -32,7 +31,13 @@ export type PluginInput = {
   $: BunShell
 }
 
-export type Plugin = (input: PluginInput) => Promise<Hooks>
+export type PluginOptions = Record<string, unknown>
+
+export type Config = Omit<SDKConfig, "plugin"> & {
+  plugin?: Array<string | [string, PluginOptions]>
+}
+
+export type Plugin = (input: PluginInput, options?: PluginOptions) => Promise<Hooks>
 
 export type AuthHook = {
   provider: string

packages/plugin/src/tui.ts

@@ -0,0 +1,232 @@
+import type { createOpencodeClient as createOpencodeClientV2, Event as TuiEvent } from "@opencode-ai/sdk/v2"
+import type { CliRenderer, ParsedKey, Plugin as CorePlugin } from "@opentui/core"
+import type { Plugin as ServerPlugin, PluginOptions } from "./index"
+
+export type { CliRenderer, SlotMode } from "@opentui/core"
+
+export type TuiRouteCurrent =
+  | {
+      name: "home"
+    }
+  | {
+      name: "session"
+      params: {
+        sessionID: string
+        initialPrompt?: unknown
+      }
+    }
+  | {
+      name: string
+      params?: Record<string, unknown>
+    }
+
+export type TuiRouteDefinition<Node = unknown> = {
+  name: string
+  render: (input: { params?: Record<string, unknown> }) => Node
+}
+
+export type TuiCommand = {
+  title: string
+  value: string
+  description?: string
+  category?: string
+  keybind?: string
+  suggested?: boolean
+  hidden?: boolean
+  enabled?: boolean
+  slash?: {
+    name: string
+    aliases?: string[]
+  }
+  onSelect?: () => void
+}
+
+export type TuiKeybind = {
+  name: string
+  ctrl: boolean
+  meta: boolean
+  shift: boolean
+  super?: boolean
+  leader: boolean
+}
+
+export type TuiKeybindMap = Record<string, string>
+
+export type TuiKeybindSet = {
+  readonly all: TuiKeybindMap
+  get: (name: string) => string
+  parse: (evt: ParsedKey) => TuiKeybind
+  match: (name: string, evt: ParsedKey) => boolean
+  print: (name: string) => string
+}
+
+export type TuiDialogProps<Node = unknown> = {
+  size?: "medium" | "large"
+  onClose: () => void
+  children?: Node
+}
+
+export type TuiDialogStack<Node = unknown> = {
+  replace: (render: () => Node, onClose?: () => void) => void
+  clear: () => void
+  setSize: (size: "medium" | "large") => void
+  readonly size: "medium" | "large"
+  readonly depth: number
+  readonly open: boolean
+}
+
+export type TuiDialogAlertProps = {
+  title: string
+  message: string
+  onConfirm?: () => void
+}
+
+export type TuiDialogConfirmProps = {
+  title: string
+  message: string
+  onConfirm?: () => void
+  onCancel?: () => void
+}
+
+export type TuiDialogPromptProps<Node = unknown> = {
+  title: string
+  description?: () => Node
+  placeholder?: string
+  value?: string
+  onConfirm?: (value: string) => void
+  onCancel?: () => void
+}
+
+export type TuiDialogSelectOption<Value = unknown, Node = unknown> = {
+  title: string
+  value: Value
+  description?: string
+  footer?: Node | string
+  category?: string
+  disabled?: boolean
+  onSelect?: () => void
+}
+
+export type TuiDialogSelectProps<Value = unknown, Node = unknown> = {
+  title: string
+  placeholder?: string
+  options: TuiDialogSelectOption<Value, Node>[]
+  flat?: boolean
+  onMove?: (option: TuiDialogSelectOption<Value, Node>) => void
+  onFilter?: (query: string) => void
+  onSelect?: (option: TuiDialogSelectOption<Value, Node>) => void
+  skipFilter?: boolean
+  current?: Value
+}
+
+export type TuiToast = {
+  variant?: "info" | "success" | "warning" | "error"
+  title?: string
+  message: string
+  duration?: number
+}
+
+export type TuiTheme = {
+  readonly current: Record<string, unknown>
+  readonly selected: string
+  has: (name: string) => boolean
+  set: (name: string) => boolean
+  install: (jsonPath: string) => Promise<void>
+  mode: () => "dark" | "light"
+  readonly ready: boolean
+}
+
+export type TuiApi<Node = unknown> = {
+  command: {
+    register: (cb: () => TuiCommand[]) => void
+    trigger: (value: string) => void
+  }
+  route: {
+    register: (routes: TuiRouteDefinition<Node>[]) => () => void
+    navigate: (name: string, params?: Record<string, unknown>) => void
+    readonly current: TuiRouteCurrent
+  }
+  ui: {
+    Dialog: (props: TuiDialogProps<Node>) => Node
+    DialogAlert: (props: TuiDialogAlertProps) => Node
+    DialogConfirm: (props: TuiDialogConfirmProps) => Node
+    DialogPrompt: (props: TuiDialogPromptProps<Node>) => Node
+    DialogSelect: <Value = unknown>(props: TuiDialogSelectProps<Value, Node>) => Node
+    toast: (input: TuiToast) => void
+    dialog: TuiDialogStack<Node>
+  }
+  keybind: {
+    parse: (evt: ParsedKey) => TuiKeybind
+    match: (key: string, evt: ParsedKey) => boolean
+    print: (key: string) => string
+    create: (defaults: TuiKeybindMap, overrides?: Record<string, unknown>) => TuiKeybindSet
+  }
+  theme: TuiTheme
+}
+
+export type TuiSlotMap = {
+  app: {}
+  home_logo: {}
+  sidebar_top: {
+    session_id: string
+  }
+}
+
+export type TuiSlotContext = {
+  theme: TuiTheme
+}
+
+export type TuiSlotPlugin<Node = unknown> = CorePlugin<Node, TuiSlotMap, TuiSlotContext>
+
+export type TuiSlots = {
+  register: (plugin: TuiSlotPlugin) => () => void
+}
+
+export type TuiEventBus = {
+  on: <Type extends TuiEvent["type"]>(
+    type: Type,
+    handler: (event: Extract<TuiEvent, { type: Type }>) => void,
+  ) => () => void
+}
+
+export type TuiPluginState = "first" | "updated" | "same"
+
+export type TuiPluginMeta = {
+  name: string
+  source: "file" | "npm"
+  spec: string
+  target: string
+  requested?: string
+  version?: string
+  modified?: number
+  first_time: number
+  last_time: number
+  time_changed: number
+  load_count: number
+  fingerprint: string
+}
+
+export type TuiPluginInit = {
+  state: TuiPluginState
+  entry: TuiPluginMeta
+}
+
+export type TuiPluginInput<Renderer = CliRenderer, Node = unknown> = {
+  client: ReturnType<typeof createOpencodeClientV2>
+  event: TuiEventBus
+  renderer: Renderer
+  slots: TuiSlots
+  api: TuiApi<Node>
+}
+
+export type TuiPlugin<Renderer = CliRenderer, Node = unknown> = (
+  input: TuiPluginInput<Renderer, Node>,
+  options: PluginOptions | null,
+  init: TuiPluginInit,
+) => Promise<void>
+
+export type TuiPluginModule<Renderer = CliRenderer, Node = unknown> = {
+  server?: ServerPlugin
+  tui?: TuiPlugin<Renderer, Node>
+  slots?: TuiSlotPlugin
+}

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -1338,7 +1338,15 @@ export type Config = {
   watcher?: {
     ignore?: Array<string>
   }
-  plugin?: Array<string>
+  plugin?: Array<
+    | string
+    | [
+        string,
+        {
+          [key: string]: unknown
+        },
+      ]
+  >
   snapshot?: boolean
   /**
    * Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing