core: rename login param from url to server to remove pointless alias

drizzle-kit's jiti loader cannot resolve tsconfig @/ path aliases.
Switch all .sql.ts files to relative imports and add the missing
snapshot for the move_org_to_state custom migration.

.opencode/plugins/tui-smoke.tsx

@@ -1,912 +0,0 @@
-/** @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

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

.opencode/themes/mytheme.json

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

.opencode/tui.json

@@ -1,19 +0,0 @@
-{
-  "$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,3 +122,7 @@ 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,6 +43,7 @@
       "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,9 +185,7 @@ 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 ?? []).map((item) => (typeof item === "string" ? item : item[0])),
-  )
+  const plugins = createMemo(() => sync.data.config.plugin ?? [])
   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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,3 @@
+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,6 +27,7 @@
   },
   "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",
@@ -91,8 +92,8 @@
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/util": "workspace:*",
     "@openrouter/ai-sdk-provider": "1.5.4",
-    "@opentui/core": "0.0.0-20260307-536c401b",
-    "@opentui/solid": "0.0.0-20260307-536c401b",
+    "@opentui/core": "0.1.86",
+    "@opentui/solid": "0.1.86",
     "@parcel/watcher": "2.5.1",
     "@pierre/diffs": "catalog:",
     "@solid-primitives/event-bus": "1.1.2",
@@ -108,6 +109,7 @@
     "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 { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+import solidPlugin from "@opentui/solid/bun-plugin"
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -59,7 +59,6 @@ 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
@@ -174,7 +173,7 @@ for (const item of targets) {
   await Bun.build({
     conditions: ["browser"],
     tsconfig: "./tsconfig.json",
-    plugins: [plugin],
+    plugins: [solidPlugin],
     sourcemap: "external",
     compile: {
       autoloadBunfig: false,

packages/opencode/src/account/account.sql.ts

@@ -0,0 +1,35 @@
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core"
+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",
+  {
+    email: text().notNull(),
+    url: text().notNull(),
+    access_token: text().notNull(),
+    refresh_token: text().notNull(),
+    token_expiry: integer(),
+    active: integer({ mode: "boolean" })
+      .notNull()
+      .$default(() => false),
+    ...Timestamps,
+  },
+  (table) => [primaryKey({ columns: [table.email, table.url] })],
+)

packages/opencode/src/account/index.ts

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,384 @@
+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,
+  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 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* (server: string) {
+        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 ?? ""
+        if (!refresh) {
+          yield* Effect.logWarning("Server did not return a refresh token — session may expire without ability to refresh")
+        }
+
+        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,13 +72,12 @@ export namespace BunProc {
 
     if (!modExists || !cachedVersion) {
       // continue to install
-    } else if (version === "latest") {
-      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) {
+    } 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
+      log.info("Cached version is outdated, proceeding with install", { pkg, cachedVersion })
     }
 
     // Build command arguments

packages/opencode/src/bun/registry.ts

@@ -10,24 +10,11 @@ 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

@@ -0,0 +1,196 @@
+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
+  const accounts = yield* service.list()
+  if (accounts.length === 0) return yield* println("Not logged in")
+
+  if (email) {
+    const match = accounts.find((a) => a.email === email)
+    if (!match) return yield* println("Account not found: " + email)
+    yield* service.remove(match.id)
+    yield* Prompt.outro("Logged out from " + email)
+    return
+  }
+
+  const active = yield* service.active()
+  const activeID = Option.map(active, (a) => a.id)
+
+  yield* Prompt.intro("Log out")
+
+  const opts = accounts.map((a) => {
+    const isActive = Option.isSome(activeID) && activeID.value === a.id
+    const server = UI.Style.TEXT_DIM + a.url + UI.Style.TEXT_NORMAL
+    return {
+      value: a,
+      label: isActive
+        ? `${a.email} ${server}` + UI.Style.TEXT_DIM + " (active)"
+        : `${a.email} ${server}`,
+    }
+  })
+
+  const selected = yield* Prompt.select({ message: "Select account to log out", options: opts })
+  if (Option.isNone(selected)) return
+
+  yield* service.remove(selected.value.id)
+  yield* Prompt.outro("Logged out from " + selected.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: false,
+  builder: (yargs) =>
+    yargs.positional("url", {
+      describe: "server URL",
+      type: "string",
+      demandOption: true,
+    }),
+  async handler(args) {
+    UI.empty()
+    await runtime.runPromise(loginEffect(args.url))
+  },
+})
+
+export const LogoutCommand = cmd({
+  command: "logout [email]",
+  describe: false,
+  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: false,
+  async handler() {
+    UI.empty()
+    await runtime.runPromise(switchEffect())
+  },
+})
+
+export const OrgsCommand = cmd({
+  command: "orgs",
+  describe: false,
+  async handler() {
+    UI.empty()
+    await runtime.runPromise(orgsEffect())
+  },
+})

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/share/:id/data) */
+/** Discriminated union returned by the ShareNext API (GET /api/shares/:id/data) */
 export type ShareData =
   | { type: "session"; data: SDKSession }
   | { type: "message"; data: Message }
@@ -24,6 +24,14 @@ export function parseShareUrl(url: string): string | null {
   return match ? match[1] : null
 }
 
+export function shouldAttachShareAuthHeaders(shareUrl: string, accountBaseUrl: string): boolean {
+  try {
+    return new URL(shareUrl).origin === new URL(accountBaseUrl).origin
+  } catch {
+    return false
+  }
+}
+
 /**
  * Transform ShareNext API response (flat array) into the nested structure for local file storage.
  *
@@ -97,8 +105,21 @@ export const ImportCommand = cmd({
           return
         }
 
-        const baseUrl = await ShareNext.url()
-        const response = await fetch(`${baseUrl}/api/share/${slug}/data`)
+        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,
+          })
+        }
 
         if (!response.ok) {
           process.stdout.write(`Failed to fetch share data: ${response.statusText}`)

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

@@ -13,14 +13,9 @@ 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"]>
 
-/**
- * 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 (methodName) {
@@ -33,7 +28,7 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
     }
     index = match
   } else if (plugin.auth.methods.length > 1) {
-    const selected = await prompts.select({
+    const method = await prompts.select({
       message: "Login method",
       options: [
         ...plugin.auth.methods.map((x, index) => ({
@@ -42,13 +37,12 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
         })),
       ],
     })
-    if (prompts.isCancel(selected)) throw new UI.CancelledError()
-    index = parseInt(selected)
+    if (prompts.isCancel(method)) throw new UI.CancelledError()
+    index = parseInt(method)
   }
   const method = plugin.auth.methods[index]
 
-  // Handle prompts for all auth types
-  await sleep(10)
+  await new Promise((r) => setTimeout(r, 10))
   const inputs: Record<string, string> = {}
   if (method.prompts) {
     for (const prompt of method.prompts) {
@@ -171,11 +165,6 @@ 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>
@@ -203,19 +192,20 @@ export function resolvePluginProviders(input: {
   return result
 }
 
-export const AuthCommand = cmd({
-  command: "auth",
-  describe: "manage credentials",
+export const ProvidersCommand = cmd({
+  command: "providers",
+  aliases: ["auth"],
+  describe: "manage AI providers and credentials",
   builder: (yargs) =>
-    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
+    yargs.command(ProvidersListCommand).command(ProvidersLoginCommand).command(ProvidersLogoutCommand).demandCommand(),
   async handler() {},
 })
 
-export const AuthListCommand = cmd({
+export const ProvidersListCommand = cmd({
   command: "list",
   aliases: ["ls"],
-  describe: "list providers",
-  async handler() {
+  describe: "list providers and credentials",
+  async handler(_args) {
     UI.empty()
     const authPath = path.join(Global.Path.data, "auth.json")
     const homedir = os.homedir()
@@ -231,7 +221,6 @@ export const AuthListCommand = cmd({
 
     prompts.outro(`${results.length} credentials`)
 
-    // Environment variables section
     const activeEnvVars: Array<{ provider: string; envVar: string }> = []
 
     for (const [providerID, provider] of Object.entries(database)) {
@@ -258,7 +247,7 @@ export const AuthListCommand = cmd({
   },
 })
 
-export const AuthLoginCommand = cmd({
+export const ProvidersLoginCommand = cmd({
   command: "login [url]",
   describe: "log in to a provider",
   builder: (yargs) =>
@@ -356,7 +345,7 @@ export const AuthLoginCommand = cmd({
               value: x.id,
               hint: {
                 opencode: "recommended",
-                anthropic: "Claude Max or API key",
+                anthropic: "API key",
                 openai: "ChatGPT Plus/Pro or API key",
               }[x.id],
             })),
@@ -409,7 +398,6 @@ export const AuthLoginCommand = cmd({
           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, args.method)
@@ -461,10 +449,10 @@ export const AuthLoginCommand = cmd({
   },
 })
 
-export const AuthLogoutCommand = cmd({
+export const ProvidersLogoutCommand = cmd({
   command: "logout",
   describe: "log out from a configured provider",
-  async handler() {
+  async handler(_args) {
     UI.empty()
     const credentials = await Auth.all().then((x) => Object.entries(x))
     prompts.intro("Remove credential")

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

@@ -1,25 +1,13 @@
-import { render, TimeToFirstDraw, useKeyboard, useRenderer, useTerminalDimensions, type JSX } from "@opentui/solid"
+import { render, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/solid"
 import { Clipboard } from "@tui/util/clipboard"
 import { Selection } from "@tui/util/selection"
-import { createCliRenderer, MouseButton, TextAttributes, type CliRendererConfig, type ParsedKey } from "@opentui/core"
+import { MouseButton, TextAttributes } from "@opentui/core"
 import { RouteProvider, useRoute } from "@tui/context/route"
-import {
-  Switch,
-  Match,
-  createEffect,
-  createMemo,
-  untrack,
-  ErrorBoundary,
-  createSignal,
-  onMount,
-  batch,
-  Show,
-  on,
-} from "solid-js"
+import { Switch, Match, createEffect, 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 { Dialog as DialogUI, DialogProvider, useDialog } from "@tui/ui/dialog"
+import { 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"
@@ -33,7 +21,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, useKeybind } from "@tui/context/keybind"
+import { KeybindProvider } from "@tui/context/keybind"
 import { ThemeProvider, useTheme } from "@tui/context/theme"
 import { Home } from "@tui/routes/home"
 import { Session } from "@tui/routes/session"
@@ -41,9 +29,6 @@ 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"
@@ -56,8 +41,6 @@ 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
@@ -121,25 +104,6 @@ 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
@@ -165,57 +129,73 @@ export function tui(input: {
       resolve()
     }
 
-    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)
+    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}`)
+            })
+          },
+        },
+      },
+    )
   })
 }
 
@@ -228,226 +208,12 @@ function App() {
   const local = useLocal()
   const kv = useKV()
   const command = useCommandDialog()
-  const keybind = useKeybind()
   const sdk = useSDK()
   const toast = useToast()
-  const themeState = useTheme()
-  const { theme, mode, setMode } = themeState
+  const { theme, mode, setMode } = useTheme()
   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
@@ -490,6 +256,10 @@ 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
@@ -506,13 +276,9 @@ 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}`)
     }
   })
 
@@ -983,58 +749,29 @@ function App() {
     })
   })
 
-  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 })
-  })
-
   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
+    <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>
+        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>
     </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 { useKeybind } from "@tui/context/keybind"
+import { type KeybindKey, 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?: string
+  keybind?: KeybindKey
   suggested?: boolean
   slash?: Slash
   hidden?: boolean

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

@@ -36,7 +36,7 @@ export function createDialogProviderOptions() {
         value: provider.id,
         description: {
           opencode: "(Recommended)",
-          anthropic: "(Claude Max or API key)",
+          anthropic: "(API key)",
           openai: "(ChatGPT Plus/Pro or API key)",
           "opencode-go": "Low cost subscription for everyone",
         }[provider.id],

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

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

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

@@ -1,44 +0,0 @@
-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,7 +6,6 @@ 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
@@ -81,27 +80,21 @@ export const { use: useKeybind, provider: KeybindProvider } = createSimpleContex
         }
         return Keybind.fromParsedKey(evt, store.leader)
       },
-      match(key: string, evt: ParsedKey) {
-        const list = keybinds()[key] ?? Keybind.parse(key)
-        if (!list.length) return false
+      match(key: KeybindKey, evt: ParsedKey) {
+        const keybind = keybinds()[key]
+        if (!keybind) return false
         const parsed: Keybind.Info = result.parse(evt)
-        for (const item of list) {
-          if (Keybind.match(item, parsed)) {
+        for (const key of keybind) {
+          if (Keybind.match(key, parsed)) {
             return true
           }
         }
-        return false
       },
-      print(key: string) {
-        const first = keybinds()[key]?.at(0) ?? Keybind.parse(key).at(0)
+      print(key: KeybindKey) {
+        const first = keybinds()[key]?.at(0)
         if (!first) return ""
-        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)
+        const result = Keybind.toString(first)
+        return result.replace("<leader>", Keybind.toString(keybinds().leader![0]!))
       },
     }
     return result

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

@@ -13,13 +13,7 @@ export type SessionRoute = {
   initialPrompt?: PromptInfo
 }
 
-export type PluginRoute = {
-  type: "plugin"
-  id: string
-  data?: Record<string, unknown>
-}
-
-export type Route = HomeRoute | SessionRoute | PluginRoute
+export type Route = HomeRoute | SessionRoute
 
 export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
   name: "Route",
@@ -37,6 +31,7 @@ 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,7 +42,6 @@ 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
@@ -175,56 +174,6 @@ 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 {
@@ -333,14 +282,12 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
   init: (props: { mode: "dark" | "light" }) => {
     const config = useTuiConfig()
     const kv = useKV()
-
-    setStore(
-      produce((draft) => {
-        draft.mode = kv.get("theme_mode", props.mode)
-        draft.active = (config.theme ?? kv.get("theme", "opencode")) as string
-        draft.ready = false
-      }),
-    )
+    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,
+    })
 
     createEffect(() => {
       const theme = config.theme
@@ -348,49 +295,55 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
     })
 
     function init() {
-      Promise.allSettled([
-        resolveSystemTheme(),
-        getCustomThemes()
-          .then((custom) => {
-            setStore(
-              produce((draft) => {
-                Object.assign(draft.themes, custom)
-              }),
-            )
-          })
-          .catch(() => {
-            setStore("active", "opencode")
-          }),
-      ]).finally(() => {
-        setStore("ready", true)
-      })
+      resolveSystemTheme()
+      getCustomThemes()
+        .then((custom) => {
+          setStore(
+            produce((draft) => {
+              Object.assign(draft.themes, custom)
+            }),
+          )
+        })
+        .catch(() => {
+          setStore("active", "opencode")
+        })
+        .finally(() => {
+          if (store.active !== "system") {
+            setStore("ready", true)
+          }
+        })
     }
 
     onMount(init)
 
     function resolveSystemTheme() {
-      return renderer
+      console.log("resolveSystemTheme")
+      renderer
         .getPalette({
           size: 16,
         })
         .then((colors) => {
+          console.log(colors.palette)
           if (!colors.palette[0]) {
             if (store.active === "system") {
-              setStore("active", "opencode")
+              setStore(
+                produce((draft) => {
+                  draft.active = "opencode"
+                  draft.ready = true
+                }),
+              )
             }
             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()
@@ -417,10 +370,7 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
         return store.active
       },
       all() {
-        return allThemes()
-      },
-      has(name: string) {
-        return hasTheme(name)
+        return store.themes
       },
       syntax,
       subtleSyntax,
@@ -432,10 +382,8 @@ 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

@@ -1,323 +0,0 @@
-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,7 +15,6 @@ 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
@@ -58,8 +57,8 @@ export function Home() {
   ])
 
   const Hint = (
-    <box flexShrink={0} flexDirection="row" gap={1}>
-      <Show when={connectedMcpCount() > 0}>
+    <Show when={connectedMcpCount() > 0}>
+      <box flexShrink={0} flexDirection="row" gap={1}>
         <text fg={theme.text}>
           <Switch>
             <Match when={mcpError()}>
@@ -72,8 +71,8 @@ export function Home() {
             </Match>
           </Switch>
         </text>
-      </Show>
-    </box>
+      </box>
+    </Show>
   )
 
   let prompt: PromptRef
@@ -112,9 +111,7 @@ export function Home() {
         <box flexGrow={1} minHeight={0} />
         <box height={4} minHeight={0} flexShrink={1} />
         <box flexShrink={0}>
-          <TuiPlugin.Slot name="home_logo" mode="replace">
-            <Logo />
-          </TuiPlugin.Slot>
+          <Logo />
         </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,6 +70,7 @@ 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"
@@ -382,7 +383,12 @@ export function Session() {
             sessionID: route.sessionID,
           })
           .then((res) => copy(res.data!.share!.url))
-          .catch(() => toast.show({ message: "Failed to share session", variant: "error" }))
+          .catch((error) => {
+            toast.show({
+              message: error instanceof Error ? error.message : "Failed to share session",
+              variant: "error",
+            })
+          })
         dialog.clear()
       },
     },
@@ -485,7 +491,12 @@ export function Session() {
             sessionID: route.sessionID,
           })
           .then(() => toast.show({ message: "Session unshared successfully", variant: "success" }))
-          .catch(() => toast.show({ message: "Failed to unshare session", variant: "error" }))
+          .catch((error) => {
+            toast.show({
+              message: error instanceof Error ? error.message : "Failed to unshare session",
+              variant: "error",
+            })
+          })
         dialog.clear()
       },
     },

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

@@ -11,7 +11,6 @@ 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()
@@ -91,7 +90,6 @@ 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,7 +35,6 @@ export function Dialog(
       height={dimensions().height}
       alignItems="center"
       position="absolute"
-      zIndex={3000}
       paddingTop={dimensions().height / 4}
       left={0}
       top={0}
@@ -71,10 +70,8 @@ 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))
@@ -154,7 +151,6 @@ 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

@@ -0,0 +1,25 @@
+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 } from "url"
+import { pathToFileURL, fileURLToPath } from "url"
 import { createRequire } from "module"
 import os from "os"
 import z from "zod"
@@ -12,6 +12,7 @@ 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,
@@ -32,18 +33,12 @@ import { Glob } from "../util/glob"
 import { PackageRegistry } from "@/bun/registry"
 import { proxied } from "@/util/proxied"
 import { iife } from "@/util/iife"
-import { isRecord } from "@/util/record"
-import { Control } from "@/control"
+import { Account } from "@/account"
 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" })
 
@@ -114,10 +109,6 @@ export namespace Config {
       }
     }
 
-    const token = await Control.token()
-    if (token) {
-    }
-
     // Global user config overrides remote config.
     result = mergeConfigConcatArrays(result, await global())
 
@@ -184,6 +175,32 @@ export namespace Config {
       log.debug("loaded custom config from OPENCODE_CONFIG_CONTENT")
     }
 
+    const active = Account.active()
+    if (active?.active_org_id) {
+      try {
+        const [config, token] = await Promise.all([
+          Account.config(active.id, active.active_org_id),
+          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`,
+            }),
+          )
+        }
+      } catch (err: any) {
+        log.debug("failed to fetch remote account config", { error: err?.message ?? err })
+      }
+    }
+
     // 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
@@ -315,9 +332,8 @@ export namespace Config {
 
     const targetVersion = Installation.isLocal() ? "latest" : Installation.VERSION
     if (targetVersion === "latest") {
-      if (!PackageRegistry.online()) return false
-      const stale = await PackageRegistry.isOutdated("@opencode-ai/plugin", depVersion, dir)
-      if (!stale) return false
+      const isOutdated = await PackageRegistry.isOutdated("@opencode-ai/plugin", depVersion, dir)
+      if (!isOutdated) return false
       log.info("Cached version is outdated, proceeding with install", {
         pkg: "@opencode-ai/plugin",
         cachedVersion: depVersion,
@@ -456,7 +472,7 @@ export namespace Config {
   }
 
   async function loadPlugin(dir: string) {
-    const plugins: PluginSpec[] = []
+    const plugins: string[] = []
 
     for (const item of await Glob.scan("{plugin,plugins}/*.{ts,js}", {
       cwd: dir,
@@ -469,32 +485,6 @@ 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
@@ -505,16 +495,15 @@ 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: PluginSpec): string {
-    const spec = pluginSpecifier(plugin)
-    if (spec.startsWith("file://")) {
-      return path.parse(new URL(spec).pathname).name
+  export function getPluginName(plugin: string): string {
+    if (plugin.startsWith("file://")) {
+      return path.parse(new URL(plugin).pathname).name
     }
-    const lastAt = spec.lastIndexOf("@")
+    const lastAt = plugin.lastIndexOf("@")
     if (lastAt > 0) {
-      return spec.substring(0, lastAt)
+      return plugin.substring(0, lastAt)
     }
-    return spec
+    return plugin
   }
 
   /**
@@ -528,14 +517,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: PluginSpec[]): PluginSpec[] {
+  export function deduplicatePlugins(plugins: string[]): string[] {
     // 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: PluginSpec[] = []
+    // e.g., "oh-my-opencode@2.4.3", "file:///path/to/plugin.js"
+    const uniqueSpecifiers: string[] = []
 
     for (const specifier of plugins.toReversed()) {
       const name = getPluginName(specifier)
@@ -1031,7 +1020,7 @@ export namespace Config {
           ignore: z.array(z.string()).optional(),
         })
         .optional(),
-      plugin: PluginSpec.array().optional(),
+      plugin: z.string().array().optional(),
       snapshot: z.boolean().optional(),
       share: z
         .enum(["manual", "auto", "disabled"])
@@ -1279,7 +1268,19 @@ export namespace Config {
       const data = parsed.data
       if (data.plugin && isFile) {
         for (let i = 0; i < data.plugin.length; i++) {
-          data.plugin[i] = resolvePluginSpec(data.plugin[i], options.path)
+          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"
+            }
+          }
         }
       }
       return data
@@ -1326,6 +1327,10 @@ 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, {
@@ -1419,3 +1424,5 @@ export namespace Config {
     return state().then((x) => x.directories)
   }
 }
+Filesystem.write
+Filesystem.write

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

@@ -29,7 +29,6 @@ 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,7 +8,6 @@ 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 {
@@ -16,43 +15,10 @@ export namespace TuiConfig {
 
   export const Info = TuiInfo
 
-  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()
-  }
+  export type Info = z.output<typeof Info>
 
   function mergeInfo(target: Info, source: Info): Info {
-    const merged = mergeDeep(target, source)
-    if (target.plugin && source.plugin) {
-      merged.plugin = [...target.plugin, ...source.plugin]
-    }
-    return merged
+    return mergeDeep(target, source)
   }
 
   function customPath() {
@@ -73,74 +39,37 @@ 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")) {
-      await mergeFile(file)
+      result = mergeInfo(result, await loadFile(file))
     }
 
     if (custom) {
-      await mergeFile(custom)
+      result = mergeInfo(result, await loadFile(custom))
       log.debug("loaded custom tui config", { path: custom })
     }
 
     for (const file of projectFiles) {
-      await mergeFile(file)
+      result = mergeInfo(result, await loadFile(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")) {
-        await mergeFile(file)
+        result = mergeInfo(result, await loadFile(file))
       }
     }
 
     if (existsSync(managed)) {
       for (const file of ConfigPaths.fileInDirectory(managed, "tui")) {
-        await mergeFile(file)
+        result = mergeInfo(result, await loadFile(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,
     }
   })
 
@@ -148,11 +77,6 @@ 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 {}
@@ -163,19 +87,19 @@ export namespace TuiConfig {
   }
 
   async function load(text: string, configFilepath: string): Promise<Info> {
-    const raw = await ConfigPaths.parseText(text, configFilepath, "empty")
-    if (!isRecord(raw)) return {}
+    const data = await ConfigPaths.parseText(text, configFilepath, "empty")
+    if (!data || typeof data !== "object" || Array.isArray(data)) 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 = { ...raw }
+      const copy = { ...(data as Record<string, unknown>) }
       if (!("tui" in copy)) return copy
-      if (!isRecord(copy.tui)) {
+      if (!copy.tui || typeof copy.tui !== "object" || Array.isArray(copy.tui)) {
         delete copy.tui
         return copy
       }
-      const tui = copy.tui
+      const tui = copy.tui as Record<string, unknown>
       delete copy.tui
       return {
         ...tui,
@@ -189,13 +113,6 @@ export namespace TuiConfig {
       return {}
     }
 
-    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
+    return parsed.data
   }
 }

packages/opencode/src/control-plane/workspace.sql.ts

@@ -1,5 +1,5 @@
 import { sqliteTable, text } from "drizzle-orm/sqlite-core"
-import { ProjectTable } from "@/project/project.sql"
+import { ProjectTable } from "../project/project.sql"
 
 export const WorkspaceTable = sqliteTable("workspace", {
   id: text().primaryKey(),

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

@@ -1,22 +0,0 @@
-import { sqliteTable, text, integer, primaryKey, uniqueIndex } from "drizzle-orm/sqlite-core"
-import { eq } from "drizzle-orm"
-import { Timestamps } from "@/storage/schema.sql"
-
-export const ControlAccountTable = sqliteTable(
-  "control_account",
-  {
-    email: text().notNull(),
-    url: text().notNull(),
-    access_token: text().notNull(),
-    refresh_token: text().notNull(),
-    token_expiry: integer(),
-    active: integer({ mode: "boolean" })
-      .notNull()
-      .$default(() => false),
-    ...Timestamps,
-  },
-  (table) => [
-    primaryKey({ columns: [table.email, table.url] }),
-    // uniqueIndex("control_account_active_idx").on(table.email).where(eq(table.active, true)),
-  ],
-)

packages/opencode/src/control/index.ts

@@ -1,67 +0,0 @@
-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

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

packages/opencode/src/flag/flag.ts

@@ -14,12 +14,10 @@ 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")
@@ -107,17 +105,6 @@ 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,7 +3,8 @@ import { hideBin } from "yargs/helpers"
 import { RunCommand } from "./cli/cmd/run"
 import { GenerateCommand } from "./cli/cmd/generate"
 import { Log } from "./util/log"
-import { AuthCommand } from "./cli/cmd/auth"
+import { LoginCommand, LogoutCommand, SwitchCommand, OrgsCommand } from "./cli/cmd/account"
+import { ProvidersCommand } from "./cli/cmd/providers"
 import { AgentCommand } from "./cli/cmd/agent"
 import { UpgradeCommand } from "./cli/cmd/upgrade"
 import { UninstallCommand } from "./cli/cmd/uninstall"
@@ -134,7 +135,11 @@ let cli = yargs(hideBin(process.argv))
   .command(RunCommand)
   .command(GenerateCommand)
   .command(DebugCommand)
-  .command(AuthCommand)
+  .command(LoginCommand)
+  .command(LogoutCommand)
+  .command(SwitchCommand)
+  .command(OrgsCommand)
+  .command(ProvidersCommand)
   .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,83 +54,48 @@ export namespace Plugin {
       plugins = [...BUILTIN, ...plugins]
     }
 
-    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(),
-        })
-        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)
+    for (let plugin of plugins) {
       // 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(),
+      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 ""
         })
-        return
-      })
-      if (!mod) return
-      return {
-        item,
-        spec,
-        mod,
+        if (!plugin) continue
       }
-    }
-
-    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`).
-      // 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(),
+      // 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(),
+          })
         })
-      })
     }
 
     return {

packages/opencode/src/plugin/meta.ts

@@ -1,160 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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/project/project.sql.ts

@@ -1,5 +1,5 @@
 import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
-import { Timestamps } from "@/storage/schema.sql"
+import { Timestamps } from "../storage/schema.sql"
 
 export const ProjectTable = sqliteTable("project", {
   id: text().primaryKey(),

packages/opencode/src/session/session.sql.ts

@@ -1,9 +1,9 @@
 import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
 import { ProjectTable } from "../project/project.sql"
 import type { MessageV2 } from "./message-v2"
-import type { Snapshot } from "@/snapshot"
-import type { PermissionNext } from "@/permission/next"
-import { Timestamps } from "@/storage/schema.sql"
+import type { Snapshot } from "../snapshot"
+import type { PermissionNext } from "../permission/next"
+import { Timestamps } from "../storage/schema.sql"
 
 type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
 type InfoData = Omit<MessageV2.Info, "id" | "sessionID">

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

@@ -1,4 +1,5 @@
 import { Bus } from "@/bus"
+import { Account } from "@/account"
 import { Config } from "@/config/config"
 import { Provider } from "@/provider/provider"
 import { Session } from "@/session"
@@ -11,8 +12,51 @@ 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 consoleApi = apiEndpoints("shares")
+
   export async function url() {
-    return Config.get().then((x) => x.enterprise?.url ?? "https://opncd.ai")
+    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 account token available for sharing")
+    }
+
+    headers["authorization"] = `Bearer ${token}`
+    headers["x-org-id"] = active.active_org_id
+    return { headers, api: consoleApi, baseUrl: active.url }
   }
 
   const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
@@ -68,15 +112,20 @@ export namespace ShareNext {
   export async function create(sessionID: string) {
     if (disabled) return { id: "", url: "", secret: "" }
     log.info("creating share", { sessionID })
-    const result = await fetch(`${await url()}/api/share`, {
+    const req = await request()
+    const response = await fetch(`${req.baseUrl}${req.api.create}`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
+      headers: { ...req.headers, "Content-Type": "application/json" },
       body: JSON.stringify({ sessionID: sessionID }),
     })
-      .then((x) => x.json())
-      .then((x) => x as { id: string; url: string; secret: string })
+
+    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 }
+
     Database.use((db) =>
       db
         .insert(SessionShareTable)
@@ -159,16 +208,19 @@ export namespace ShareNext {
       const share = get(sessionID)
       if (!share) return
 
-      await fetch(`${await url()}/api/share/${share.id}/sync`, {
+      const req = await request()
+      const response = await fetch(`${req.baseUrl}${req.api.sync(share.id)}`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
+        headers: { ...req.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 })
   }
@@ -178,15 +230,21 @@ export namespace ShareNext {
     log.info("removing share", { sessionID })
     const share = get(sessionID)
     if (!share) return
-    await fetch(`${await url()}/api/share/${share.id}`, {
+
+    const req = await request()
+    const response = await fetch(`${req.baseUrl}${req.api.remove(share.id)}`, {
       method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
+      headers: { ...req.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/share/share.sql.ts

@@ -1,6 +1,6 @@
 import { sqliteTable, text } from "drizzle-orm/sqlite-core"
 import { SessionTable } from "../session/session.sql"
-import { Timestamps } from "@/storage/schema.sql"
+import { Timestamps } from "../storage/schema.sql"
 
 export const SessionShareTable = sqliteTable("session_share", {
   session_id: text()

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<Schema>
+  type Client = SQLiteBunDatabase
 
   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, schema })
+    const db = drizzle({ client: sqlite })
 
     // Apply schema migrations
     const entries =
@@ -124,7 +124,7 @@ export namespace Database {
     Client.reset()
   }
 
-  export type TxOrDb = Transaction | Client
+  export type TxOrDb = SQLiteTransaction<"sync", void, any, any> | Client
 
   const ctx = Context.create<{
     tx: TxOrDb

packages/opencode/src/storage/schema.ts

@@ -1,5 +1,5 @@
-export { ControlAccountTable } from "../control/control.sql"
+export { AccountTable, AccountStateTable, ControlAccountTable } from "../account/account.sql"
+export { ProjectTable } from "../project/project.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

@@ -0,0 +1,11 @@
+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

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

packages/opencode/src/util/schema.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,338 @@
+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 { Database } from "../../src/storage/db"
+import { testEffect } from "../fixture/effect"
+
+const truncate = Layer.effectDiscard(
+  Effect.sync(() => {
+    const db = Database.Client()
+    db.run(/*sql*/ `DELETE FROM account_state`)
+    db.run(/*sql*/ `DELETE FROM account`)
+  }),
+)
+
+const it = testEffect(Layer.merge(AccountRepo.layer, truncate))
+
+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

@@ -0,0 +1,223 @@
+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 { Database } from "../../src/storage/db"
+import { testEffect } from "../fixture/effect"
+
+const truncate = Layer.effectDiscard(
+  Effect.sync(() => {
+    const db = Database.Client()
+    db.run(/*sql*/ `DELETE FROM account_state`)
+    db.run(/*sql*/ `DELETE FROM account`)
+  }),
+)
+
+const it = testEffect(Layer.merge(AccountRepo.layer, truncate))
+
+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,5 +1,10 @@
 import { test, expect } from "bun:test"
-import { parseShareUrl, transformShareData, type ShareData } from "../../src/cli/cmd/import"
+import {
+  parseShareUrl,
+  shouldAttachShareAuthHeaders,
+  transformShareData,
+  type ShareData,
+} from "../../src/cli/cmd/import"
 
 // parseShareUrl tests
 test("parses valid share URLs", () => {
@@ -15,6 +20,19 @@ 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/auth"
+import { resolvePluginProviders } from "../../src/cli/cmd/providers"
 import type { Hooks } from "@opencode-ai/plugin"
 
 function hookWithAuth(provider: string): Hooks {

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

@@ -1,107 +0,0 @@
-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

@@ -1,482 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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,6 +2,7 @@ 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"
@@ -242,6 +243,52 @@ 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) => {
@@ -1727,7 +1774,7 @@ describe("deduplicatePlugins", () => {
 
         const myPlugins = plugins.filter((p) => Config.getPluginName(p) === "my-plugin")
         expect(myPlugins.length).toBe(1)
-        expect(Config.pluginSpecifier(myPlugins[0]).startsWith("file://")).toBe(true)
+        expect(myPlugins[0].startsWith("file://")).toBe(true)
       },
     })
   })

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

@@ -458,15 +458,9 @@ 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", plugin: ["shared-plugin@1.0.0"] }, null, 2),
-      )
+      await Bun.write(path.join(dir, "tui.json"), JSON.stringify({ theme: "project-theme" }, null, 2))
       await fs.mkdir(managedConfigDir, { recursive: true })
-      await Bun.write(
-        path.join(managedConfigDir, "tui.json"),
-        JSON.stringify({ theme: "managed-theme", plugin: ["shared-plugin@2.0.0"] }, null, 2),
-      )
+      await Bun.write(path.join(managedConfigDir, "tui.json"), JSON.stringify({ theme: "managed-theme" }, null, 2))
     },
   })
 
@@ -475,13 +469,6 @@ 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"),
-        },
-      })
     },
   })
 })
@@ -521,110 +508,3 @@ 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

@@ -0,0 +1,7 @@
+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

@@ -1,306 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -0,0 +1,76 @@
+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 account token available for sharing")
+  } finally {
+    Account.active = originalActive
+    Account.token = originalToken
+  }
+})

packages/opencode/tsconfig.json

@@ -11,6 +11,11 @@
     "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,8 +10,7 @@
   },
   "exports": {
     ".": "./src/index.ts",
-    "./tool": "./src/tool.ts",
-    "./tui": "./src/tui.ts"
+    "./tool": "./src/tool.ts"
   },
   "files": [
     "dist"
@@ -20,16 +19,7 @@
     "@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,8 +9,9 @@ import type {
   Message,
   Part,
   Auth,
-  Config as SDKConfig,
+  Config,
 } from "@opencode-ai/sdk"
+
 import type { BunShell } from "./shell"
 import { type ToolDefinition } from "./tool"
 
@@ -31,13 +32,7 @@ export type PluginInput = {
   $: BunShell
 }
 
-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 Plugin = (input: PluginInput) => Promise<Hooks>
 
 export type AuthHook = {
   provider: string

packages/plugin/src/tui.ts

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