@mirrowel/opencode-openshare 0.0.0-stage → 0.1.1

package/src/sidebar.tsx

@@ -0,0 +1,187 @@
+/** @jsxImportSource @opentui/solid */
+
+// OpenShare sidebar chip: rendered into the `sidebar_title` slot
+// (single_winner mode — our render replaces the default title block, so it
+// re-renders the session title and appends the share state). The share
+// state reads the live session store, so the chip updates the moment the
+// server plugin writes the binding.
+//
+// v1-only: the v2 TUI plugin context has no slot registry. The v2 adapter
+// simply skips this module.
+//
+// SLOT CONTRACT (live-caught 2x): (1) @opentui/core SlotRenderer is called
+// as (ctx, props) — CONTEXT FIRST. (2) The payload MUST be box-rooted:
+// a text root with text children is not hostable through the slot
+// machinery ("TextNodeRenderable only accepts strings…" on embed). Every
+// proven consumer returns box-rooted trees (opencode's own default
+// children, magic-context's sidebar, the host's slot self-test); text
+// nodes stay LEAVES here — string content only.
+//
+// TEMPORARY crash-hunt instrumentation (owner-approved 2026-10-19): every
+// render logs its inputs (with TYPES), the computed locals, and a dump of
+// the returned element tree to %TEMP%/openshare-tui-debug.log via
+// synchronous appends, so a crash mid-render still leaves evidence. Any
+// throw inside the renderer is logged with its stack, then rethrown.
+// Remove once the live crash is cornered.
+
+import type { JSX } from "@opentui/solid"
+import { bindingsOf, bindingOf, verifyShare } from "./share-flow.js"
+import type { TuiPluginApi, TuiSlotContext } from "@opencode-ai/plugin/tui"
+import type { Session } from "@opencode-ai/sdk/v2"
+import { appendFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+const DBG_FILE = join(tmpdir(), "openshare-tui-debug.log")
+
+/** value -> `kind:preview` so the log shows TYPES (the crash was a type bug) */
+export function dbg(v: unknown, depth = 0): string {
+  const t = typeof v
+  if (v === null) return "null"
+  if (t === "string") return `str(${(v as string).length}):${JSON.stringify((v as string).slice(0, 60))}`
+  if (t === "number" || t === "boolean" || t === "bigint") return `${t}:${String(v)}`
+  if (t === "undefined") return "undef"
+  if (t === "function") return `fn:${(v as { name?: string }).name || "anon"}`
+  if (Array.isArray(v)) return `arr[${v.length}]:[${v.slice(0, 6).map((x) => dbg(x, depth + 1)).join(",")}]`
+  if (depth >= 3) return "obj:…"
+  try {
+    const keys = Object.keys(v as object)
+    return `obj{${keys.slice(0, 8).join(",")}}` + (depth < 2 ? `{${keys.slice(0, 8).map((k) => `${k}=${dbg((v as Record<string, unknown>)[k], depth + 1)}`).join(",")}}` : "")
+  } catch {
+    return "obj:?}"
+  }
+}
+
+/** shallow structural dump of a rendered element tree (type names, children kinds) */
+function dbgEl(el: unknown, depth = 0): string {
+  if (el === null || el === undefined || typeof el === "string" || typeof el === "number" || typeof el === "boolean") return dbg(el)
+  if (Array.isArray(el)) return `[${el.map((x) => dbgEl(x, depth)).join(",")}]`
+  if (typeof el === "function") return "fn-node"
+  if (depth >= 4) return "…"
+  try {
+    const rec = el as Record<string, unknown>
+    const t = dbg(rec.t ?? rec.type, 2)
+    const kids = rec.children
+    const props = Object.keys(rec).filter((k) => !["t", "type", "children"].includes(k))
+    return `<${t} ${props.join(" ")}>${kids === undefined ? "" : dbgEl(kids, depth + 1)}</${t}>`
+  } catch (e) {
+    return `el?-${dbg(e)}`
+  }
+}
+
+export function dbgLog(line: string): void {
+  try {
+    appendFileSync(DBG_FILE, `${new Date().toISOString()} ${line}\n`)
+  } catch {}
+}
+
+let renderSeq = 0
+
+/** Share liveness cache for the chip: a binding can claim "shared" long
+ * after the page died server-side (purge/TTL/delete with no event ever
+ * reaching this host). One credential-free probe per (session, server)
+ * per minute; the chip picks the verdict up on the next render. */
+type GoneVerdict = { status: "live" | "gone" | "unknown"; at: number }
+const GONE_TTL_MS = 60_000
+const goneCache = new Map<string, GoneVerdict>()
+
+function goneVerdict(sid: string, server: string, shareId: string): GoneVerdict | undefined {
+  const key = `${sid}|${server}`
+  const cached = goneCache.get(key)
+  if (cached && Date.now() - cached.at < GONE_TTL_MS) return cached
+  void verifyShare(server, shareId).then((status) => {
+    goneCache.set(key, { status, at: Date.now() })
+  })
+  return cached
+}
+
+type SidebarTitleProps = {
+  session_id: string
+  title: string
+  share_url?: string
+}
+
+export function createSidebarSlot(api: TuiPluginApi, opts?: { onShareCommand?: () => void }) {
+  dbgLog(`createSidebarSlot called; api.state=${!!api.state} api.theme=${!!api.theme} api.version=${dbg(api.app?.version)}`)
+  return {
+    slots: {
+      sidebar_title: (ctx: TuiSlotContext, props: SidebarTitleProps): JSX.Element => {
+        const seq = ++renderSeq
+        try {
+          dbgLog(`render#${seq} ctx=${dbg(ctx)} props=${dbg(props)}`)
+          const sid = typeof props?.session_id === "string" ? props.session_id : ""
+          const title = String(props?.title ?? "") || "Session"
+          const session = sid ? api.state.session.get(sid) : undefined
+          const binding = bindingOf(session as never)
+          const allBindings = bindingsOf(session as never)
+          const liveCount = allBindings.filter((b) => b.url && b.enabled !== false).length
+          const status = session?.time?.archived ? undefined : binding?.url ? (binding.enabled === false ? "attached" : "live") : undefined
+          // gone detection: any live-bound server whose page died server-side
+          const checked = allBindings.filter((b) => b.url && b.enabled !== false && b.id && b.server)
+          const verdicts = checked.map((b) => goneVerdict(sid, b.server, b.id))
+          const anyGone = verdicts.some((v) => v?.status === "gone")
+          const multi = liveCount > 1 ? `·${liveCount} ` : ""
+          const theme = ctx?.theme?.current ?? api.theme.current
+          dbgLog(
+            `render#${seq} sid=${dbg(sid)} title=${dbg(title)} session=${session ? "found" : "MISSING"} binding=${binding ? `id=${dbg(binding.id)} enabled=${dbg(binding.enabled)}` : "none"} status=${dbg(status)} theme=${dbg(theme)}`,
+          )
+          // chip on its own line under the title (takes the blank line that
+          // separated the title block from the context blocks); clicking it
+          // copies the share link — proven pattern: onMouseDown on a box.
+          // A verified-gone share renders dim (⊘) and clicking opens the
+          // share manager (verify + gone modal) instead of a dead copy.
+          const copyLink = () => {
+            if (anyGone) {
+              opts?.onShareCommand?.()
+              return
+            }
+            const url = binding?.url
+            if (!url) return
+            // navigator first (no-op-resolves in the TUI runtime are
+            // possible), then ALWAYS OSC52 — the empirically working path
+            let copied = false
+            try {
+              const clip = (navigator as unknown as { clipboard?: { writeText?: (t: string) => Promise<void> } }).clipboard
+              if (typeof clip?.writeText === "function") {
+                void clip.writeText(url).then(
+                  () => {},
+                  () => {},
+                )
+                copied = true
+              }
+            } catch {}
+            try {
+              // OSC52 escape (most modern terminals, incl. Windows Terminal)
+              process.stdout.write(`\x1b]52;c;${Buffer.from(url, "utf8").toString("base64")}\x07`)
+              copied = true
+            } catch {}
+            try {
+              api.ui.toast({ variant: copied ? "success" : "info", title: "OpenShare", message: copied ? `Share link copied: ${url}` : `Share link: ${url}`, duration: 6000 })
+            } catch {}
+          }
+          const el = (
+            <box flexDirection="column" paddingRight={1}>
+              <text fg={theme.text}>{title}</text>
+              {status ? (
+                <box onMouseDown={copyLink}>
+                  <text fg={anyGone ? theme.error : binding?.enabled === false ? theme.warning : theme.success}>
+                    {anyGone
+                      ? `⊘ re:share — gone (removed/expired) — click to fix`
+                      : status === "live"
+                        ? `◉ re:share ${multi}— click to copy link`
+                        : "◉ re:share (dormant)"}
+                  </text>
+                </box>
+              ) : null}
+            </box>
+          )
+          dbgLog(`render#${seq} RETURNS ${dbgEl(el)}`)
+          return el
+        } catch (error) {
+          dbgLog(`render#${seq} THREW ${(error as Error)?.stack ?? dbg(error)} — rethrowing`)
+          throw error
+        }
+      },
+    },
+  }
+}

package/src/tui-host.ts

@@ -0,0 +1,134 @@
+// Host-agnostic TUI API surface for OpenShare. The exact bounded subset of
+// the OpenCode v1 `TuiPluginApi` the share flows and settings dialog use;
+// a v1 api instance satisfies it structurally, and v2-tui.ts implements it
+// over the OpenCode v2 TUI plugin context. Flows never touch anything
+// outside this interface — one compiled bundle runs on both hosts.
+
+import type { ClientApi, SessionInfo, SessionOpts } from "./core.js"
+
+export type ShareDialogSelectOption<Value = string> = {
+  title: string
+  value: Value
+  description?: string
+  category?: string
+  disabled?: boolean
+  /** long-form detail shown in the [i] pane (v1 menus; other hosts ignore).
+   * "## Header" lines split paged sections. */
+  help?: string
+  /** destructive action — renders red (v1 menus) */
+  danger?: boolean
+  /** pending/edited — renders green (v1 menus) */
+  edited?: boolean
+  /** non-interactive separator row (v1 menus) */
+  divider?: boolean
+}
+
+export type ShareHostKeyContext = {
+  event?: {
+    preventDefault?: () => void
+    stopPropagation?: () => void
+  }
+}
+
+export type ShareHostLayerCommand = {
+  name: string
+  title?: string
+  desc?: string
+  slashName?: string
+  slashAliases?: string[]
+  suggested?: boolean
+  hidden?: boolean
+  enabled?: boolean | (() => boolean)
+  category?: string
+  group?: string
+  run: (ctx: ShareHostKeyContext) => void | Promise<void>
+}
+
+export type ShareHostKeymapLayer = {
+  /** v2 adapter only (v2 keymap layers are natively mode-scoped "global").
+   * The v1 registration deliberately ignores this: a v1 plugin layer with
+   * a declared mode is gated on the mode stack and never reachable. */
+  mode?: string
+  priority?: number
+  commands: readonly ShareHostLayerCommand[]
+  bindings: readonly { key: string; cmd: string; desc?: string }[]
+}
+
+export type ShareHostApi = {
+  /** Host version marker (v2 adapter sets 2; v1 leaves undefined). */
+  hostVersion?: 1 | 2
+  app?: { version?: string }
+  /** Raw SDK client; metadata PATCH/GET go through it. */
+  client?: ClientApi
+  kv: {
+    get<Value = unknown>(key: string, fallback?: Value): Value
+    set(key: string, value: unknown): void
+  }
+  lifecycle: {
+    onDispose(fn: () => void): void
+  }
+  theme: {
+    current: {
+      success: unknown
+      info: unknown
+      error: unknown
+      warning: unknown
+      textMuted: unknown
+    }
+  }
+  ui: {
+    toast(input: { variant?: "info" | "success" | "warning" | "error"; title?: string; message: string; duration?: number }): void
+    dialog: {
+      replace(renderer: unknown, onClose?: () => void): void
+      clear(): void
+      setSize(size: string): void
+    }
+    /** Promise menus (the family showMenuOnce pattern). Preferred UI on v1. */
+    showMenu<Value = string>(props: { title: string; options: ShareDialogSelectOption<Value>[]; current?: Value; hint?: string }): Promise<Value | undefined>
+    showConfirm(props: { title: string; message: string; confirmLabel?: string; danger?: boolean }): Promise<boolean>
+    showAlert(props: { title: string; message: string }): Promise<void>
+    showPrompt(props: { title: string; placeholder?: string; value?: string }): Promise<string | undefined>
+    /** Combined menu-size picker (v1 facade only; feature-detected). */
+    showSizePicker?(current: { width: string; heightPercent: number }): Promise<{ width: string; heightPercent: number } | undefined>
+    /** Non-cancelable busy dialog; returns the done() that clears it. */
+    showBusy?(title: string): (() => void) | undefined
+    // Callback dialogs (v2 adapter bridge only — host ui.DialogX under
+    // plugin dialog.replace receives no keys on opencode 1.19.x).
+    DialogSelect<Value = string>(props: {
+      title: string
+      placeholder?: string
+      options: ShareDialogSelectOption<Value>[]
+      current?: Value
+      flat?: boolean
+      onSelect: (option: ShareDialogSelectOption<Value>) => void
+    }): unknown
+    DialogPrompt(props: {
+      title: string
+      placeholder?: string
+      value?: string
+      onConfirm: (value: string) => void
+      onCancel?: () => void
+    }): unknown
+    DialogConfirm(props: {
+      title: string
+      message: string
+      confirmLabel?: string
+      onConfirm: () => void
+      onCancel?: () => void
+    }): unknown
+    DialogAlert(props: { title: string; message: string; onConfirm?: () => void }): unknown
+  }
+  keymap: {
+    registerLayer(layer: ShareHostKeymapLayer): () => void
+  }
+  /** Live session lookup (v1: reactive state store; v2: client GET). */
+  sessionInfo(sessionID: string): SessionInfo | undefined
+  /** Currently focused/open session id, when the host can tell. */
+  currentSessionID?: () => string | undefined
+  /** Clipboard write; resolves false when unavailable. */
+  clipboard: {
+    write(text: string): Promise<boolean>
+  }
+}
+
+export type { ClientApi, SessionInfo, SessionOpts }

package/src/tui.tsx

@@ -0,0 +1,318 @@
+/** @jsxImportSource @opentui/solid */
+
+// OpenShare TUI plugin entry (OpenCode v1).
+//
+// Registers the /share (toggle + manager, shadowing the deprecated opncd.ai
+// built-ins via a priority keymap layer) and /openshare commands, plus the
+// sidebar_title slot chip. The flows run against the ShareHostApi facade
+// (tui-host.ts); v2 hosts run the same flows through the v2-tui adapter.
+
+import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
+import type { ClientApi } from "./core.js"
+import { registerCommands, buildShareCommand } from "./commands.js"
+import { createSidebarSlot, dbgLog, dbg } from "./sidebar.js"
+import { showAlertMenu, showConfirmMenu, showMenuOnce, showPromptOnce, showSizePickerOnce, toMenuOptions } from "./dialogs.js"
+import { clampHeightPercent, kvHeightPercentOf, kvWidthOf } from "./ui-prefs.js"
+import type { ShareHostApi } from "./tui-host.js"
+import { createV2TuiSetup } from "./v2-tui.js"
+
+/** Builds the host facade over the v1 TuiPluginApi. */
+
+/** Combined size-picker flow (config-studio showSizeSlider shape): picker →
+ * optional custom-percent prompt → saved result. Undefined = cancelled. */
+async function showSizePickerFlow(api: TuiPluginApi, current: { width: string; heightPercent: number }): Promise<{ width: string; heightPercent: number } | undefined> {
+  let heightPercent = clampHeightPercent(current.heightPercent)
+  while (true) {
+    const choice = await showSizePickerOnce(api, { width: kvWidthOf(api.kv), heightPercent })
+    if (!choice) return undefined
+    if (choice.heightPercent >= 0) return { width: kvWidthOf(api.kv), heightPercent: clampHeightPercent(choice.heightPercent) }
+    const input = await showPromptOnce(api, { title: "Menu height percent", placeholder: "25-100", value: String(heightPercent) })
+    if (input === undefined) continue
+    const parsed = Number(input)
+    if (!Number.isFinite(parsed)) {
+      await showAlertMenu(api, { title: "Invalid height", message: "Enter a number from 25 to 100." })
+      continue
+    }
+    heightPercent = clampHeightPercent(parsed)
+  }
+}
+
+export function buildV1HostApi(api: TuiPluginApi): ShareHostApi {
+  return {
+    hostVersion: 1,
+    app: { version: api.app?.version },
+    // 1.19.x hands plugins the v2 SDK client — a LAZY PROXY (methods
+    // materialize on property access; spreading it destroys them, which
+    // broke session.update: live-caught "no client.session.update" after
+    // the adapter was added). Wrap with passthrough Proxies instead:
+    //  - path args are translated id -> sessionID (the v2 SDK's URL
+    //    builder left "{sessionID}" literally in the URL for {path:{id}}
+    //    calls — server log: "Expected a string starting with ses, got
+    //    %7BsessionID%7D" — so every session.get/update failed silently),
+    //  - session.get fills metadata from the state store when the v2
+    //    response lacks it,
+    //  - everything else reaches the original proxy untouched.
+    client: (() => {
+      const raw = api.client as unknown as Record<string, unknown> & { session?: Record<string, unknown> }
+      const rawSession = raw?.session
+      if (!rawSession) return raw as unknown as ClientApi
+      const translateArgs = (args: unknown): unknown => {
+        if (!args || typeof args !== "object") return args
+        const a = args as { path?: Record<string, unknown>; body?: Record<string, unknown> }
+        if (a.path && "id" in a.path && !("sessionID" in a.path)) {
+          const { id, ...rest } = a.path
+          return { ...a, path: { ...rest, sessionID: id } }
+        }
+        return args
+      }
+      // v2 arg-shape probing: hey-api left "{sessionID}" literally in the
+      // URL for {path:{id}} calls (server: "Expected a string starting
+      // with ses, got %7BsessionID%7D"), and {path:{sessionID}} fared no
+      // better — the v2 convention is FLAT args ({sessionID, ...body},
+      // matching the beta client's SessionUpdateInput). Failed calls are
+      // side-effect-free (URL 500s), so probe: path-shape first, then
+      // flat. The winning shape is cached and logged once.
+      let argShape: "path" | "flat" | undefined
+      const callV2 = async (method: string, args: unknown): Promise<Record<string, unknown> | undefined> => {
+        const orig = rawSession[method] as ((a: unknown) => Promise<unknown>) | undefined
+        if (!orig) return undefined
+        const a = args as { path?: Record<string, unknown>; body?: Record<string, unknown> }
+        const flat = { sessionID: a.path?.id ?? a.path?.sessionID, ...(a.body ?? {}) }
+        const attempts: Array<["path" | "flat", unknown]> =
+          argShape === "flat"
+            ? [["flat", flat]]
+            : argShape === "path"
+              ? [["path", translateArgs(args)]]
+              : [
+                  ["path", translateArgs(args)],
+                  ["flat", flat],
+                ]
+        let last: Record<string, unknown> | undefined
+        for (const [shape, callArgs] of attempts) {
+          try {
+            last = (await orig.call(rawSession, callArgs)) as Record<string, unknown> | undefined
+          } catch (e) {
+            last = { error: e } as Record<string, unknown>
+          }
+          const failed = !last || (typeof last === "object" && "error" in last && (last as { error?: unknown }).error)
+          if (!failed) {
+            if (!argShape) {
+              argShape = shape
+              dbgLog(`client.${method} arg shape = ${shape}`)
+            }
+            return last
+          }
+        }
+        return last
+      }
+      const adaptedGet = async (args: { path: { id: string } }) => {
+        const res = (await callV2("get", args)) as Record<string, unknown> | undefined
+        const info = (res && typeof res === "object" && "data" in (res as object) ? (res as { data?: Record<string, unknown> }).data : (res as Record<string, unknown> | undefined)) ?? undefined
+        if (info && typeof info === "object" && !info.metadata) {
+          const stateInfo = api.state.session.get(args.path.id) as { metadata?: Record<string, unknown> } | undefined
+          if (stateInfo?.metadata) {
+            dbgLog(`client.get metadata fallback: client keys=${Object.keys(info).slice(0, 12).join("|")} -> state metadata used`)
+            if (res && typeof res === "object" && "data" in res) return { ...res, data: { ...info, metadata: stateInfo.metadata } }
+            return { ...info, metadata: stateInfo.metadata }
+          }
+        }
+        return res
+      }
+      const adaptedSession = new Proxy(rawSession, {
+        get(target, key: string) {
+          if (key === "get") return adaptedGet
+          if (key === "update") return (args: unknown) => callV2("update", args)
+          const value = Reflect.get(target, key, target)
+          return typeof value === "function" ? (value as (...a: unknown[]) => unknown).bind(target) : value
+        },
+      })
+      return new Proxy(raw, {
+        get(target, key: string) {
+          if (key === "session") return adaptedSession
+          const value = Reflect.get(target, key, target)
+          return typeof value === "function" ? (value as (...a: unknown[]) => unknown).bind(target) : value
+        },
+      }) as unknown as ClientApi
+    })(),
+    kv: api.kv,
+    lifecycle: api.lifecycle,
+    theme: api.theme,
+    ui: {
+      toast: (input) => api.ui.toast(input),
+      // dialog.clear() THROWS on an already-empty stack on 1.19.x — and
+      // flows legitimately clear after my components already settled+cleared
+      // (the throw killed confirmShare before it started, live-caught via
+      // the debug log). Idempotent wrapper for every call site.
+      dialog: new Proxy({} as ShareHostApi["ui"]["dialog"], {
+        get: (_t, key: string) => {
+          if (key === "clear")
+            return () => {
+              try {
+                api.ui.dialog.clear()
+              } catch {}
+            }
+          if (key === "replace")
+            return (render: () => unknown, onClose?: () => void) => {
+              try {
+                api.ui.dialog.replace(render as never, onClose)
+              } catch (e) {
+                dbgLog(`dialog.replace THREW: ${(e as Error)?.message ?? e}`)
+              }
+            }
+          const value = (api.ui.dialog as unknown as Record<string, unknown>)[key]
+          return typeof value === "function" ? (value as (...a: unknown[]) => unknown).bind(api.ui.dialog) : value
+        },
+      }),
+      // Promise menus — the family showMenuOnce pattern, ported verbatim.
+      showMenu: (props) => showMenuOnce(api, { ...props, options: toMenuOptions(props.options) }),
+      showConfirm: (props) => showConfirmMenu(api, props),
+      showAlert: (props) => showAlertMenu(api, props),
+      showPrompt: (props) => showPromptOnce(api, props),
+      showSizePicker: (current) => showSizePickerFlow(api, current),
+      showBusy: (title: string) => {
+        const theme = () => api.theme.current
+        api.ui.dialog.replace(() => (
+          <box flexDirection="column" width="100%" paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1}>
+            <text fg={theme().accent}><b>{title}</b></text>
+            <text fg={theme().textMuted}>working… (esc does not cancel)</text>
+          </box>
+        ))
+        return () => {
+          try {
+            api.ui.dialog.clear()
+          } catch {}
+        }
+      },
+      // CUSTOM interactive dialogs (family MenuDialog pattern: own
+      // priority-10000 key layer + mode push + input shield). The host's
+      // ui.DialogX components under plugin dialog.replace render but
+      // receive no keys on opencode 1.19.x (live-caught + pty-reproduced).
+      // These are component functions: flows invoke them inside their own
+      // dialog.replace(() => ...) render thunk (the host renders the thunk
+      // in a proper Solid root, so the hooks inside run with an owner).
+      // DialogX bridge shims (v2 adapter / legacy call sites): route to the
+      // ported promise menus. Nothing on v1 renders these through
+      // dialog.replace anymore — flows use showMenu/showConfirm directly.
+      DialogSelect: (props) => {
+        void showMenuOnce(api, { title: props.title, options: toMenuOptions(props.options), current: props.current, hint: props.placeholder }).then((value) => {
+          if (value === undefined) (props as { onCancel?: () => void }).onCancel?.()
+          else {
+            const option = props.options.find((o) => o.value === value)
+            if (option) (props as { onSelect: (o: unknown) => void }).onSelect(option)
+          }
+        })
+        return undefined as never
+      },
+      DialogPrompt: (props) => {
+        void showPromptOnce(api, { title: props.title, placeholder: props.placeholder, value: props.value }).then((value) => {
+          if (value === undefined) (props as { onCancel?: () => void }).onCancel?.()
+          else (props as { onConfirm: (v: string) => void }).onConfirm(value)
+        })
+        return undefined as never
+      },
+      DialogConfirm: (props) => {
+        void showConfirmMenu(api, { title: props.title, message: props.message, confirmLabel: props.confirmLabel }).then((yes) => (yes ? props.onConfirm() : (props as { onCancel?: () => void }).onCancel?.()))
+        return undefined as never
+      },
+      DialogAlert: (props) => {
+        void showAlertMenu(api, { title: props.title, message: props.message }).then(() => (props as { onConfirm?: () => void }).onConfirm?.())
+        return undefined as never
+      },
+    },
+    keymap: {
+      registerLayer(layer) {
+        // Host layer shape = exactly what the proven family plugins pass:
+        // {commands, bindings}. NO mode (a declared mode gates the layer on
+        // the mode stack; resting mode is "base" — the layer would never be
+        // reachable), no priority, and command objects carry ONLY defined
+        // fields (undefined-valued keys are not part of the working shape).
+        const commands = layer.commands.map((command) => {
+          const host: Record<string, unknown> = {
+            namespace: "palette",
+            name: command.name,
+            title: command.title,
+            run: (ctx: unknown) => command.run((ctx ?? {}) as never),
+          }
+          if (command.desc !== undefined) host.desc = command.desc
+          if (command.category !== undefined) host.category = command.category
+          if (command.slashName !== undefined) host.slashName = command.slashName
+          if (command.slashAliases?.length) host.slashAliases = command.slashAliases
+          if (command.suggested !== undefined) host.suggested = command.suggested
+          if (command.hidden !== undefined) host.hidden = command.hidden
+          if (command.enabled !== undefined) host.enabled = command.enabled
+          return host
+        })
+        return api.keymap.registerLayer({ commands, bindings: layer.bindings as never[] })
+      },
+    },
+    sessionInfo: (sid) => api.state.session.get(sid) as never,
+    currentSessionID: () => {
+      const route = api.route.current
+      return route.name === "session" ? (route.params?.sessionID as string | undefined) : undefined
+    },
+    clipboard: {
+      // navigator.clipboard.writeText resolves as a silent no-op in the
+      // TUI runtime (live-caught: the menu copy said "copied" but nothing
+      // landed; the sidebar chip worked because it falls back to OSC52).
+      // Belt-and-braces: try navigator, then ALWAYS emit the OSC52 escape
+      // — harmless when the terminal ignores it, correct when it honors it.
+      async write(text) {
+        let ok = false
+        try {
+          const clip = (navigator as unknown as { clipboard?: { writeText?: (t: string) => Promise<void> } }).clipboard
+          if (typeof clip?.writeText === "function") {
+            await clip.writeText(text).then(
+              () => {
+                ok = true
+              },
+              () => {},
+            )
+          }
+        } catch {}
+        try {
+          process.stdout.write(`\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`)
+          ok = true
+        } catch {}
+        return ok
+      },
+    },
+  }
+}
+
+const tui: TuiPlugin = async (api) => {
+  dbgLog(`tui entry running; host v=${dbg(api.app?.version)} slots=${!!api.slots} keymap=${!!api.keymap} state=${!!api.state}`)
+  const host = buildV1HostApi(api)
+
+  const sessionID = () => host.currentSessionID?.() ?? undefined
+  const unregister = registerCommands(host, sessionID)
+
+  // sidebar chip (v1 slots; the v2 context has no slot registry). The
+  // slots registry has no unregister API — registration lives for the
+  // process lifetime. The chip gets the live /share command instance so a
+  // click on a gone/dead share opens the share manager (verify + modal)
+  // instead of copying a dead link.
+  try {
+    const shareCommand = buildShareCommand(host, sessionID)
+    const slot = createSidebarSlot(api, { onShareCommand: () => void shareCommand.run({}) })
+    dbgLog(`registering sidebar slot: ${Object.keys(slot?.slots ?? {}).join(", ") || "NO SLOTS"}`)
+    const reg = api.slots.register(slot as never)
+    dbgLog(`sidebar slot registered -> ${dbg(reg)}`)
+  } catch (error) {
+    dbgLog(`sidebar slot REGISTRATION THREW ${(error as Error)?.stack ?? String(error)}`)
+  }
+
+  api.lifecycle.onDispose(() => {
+    try {
+      unregister()
+    } catch {}
+  })
+}
+
+/**
+ * Dual-target TUI entry.
+ *
+ * - OpenCode v1 (strict loader) requires `default.tui` to be a function;
+ *   excess keys are ignored.
+ * - OpenCode v2 requires `default` to be `{ id, setup }`.
+ */
+export default { id: "openshare", tui, setup: createV2TuiSetup() }

package/src/ui-prefs.ts

@@ -0,0 +1,36 @@
+// Host-agnostic dialog size preferences (owner decision 2026-10-19: host
+// kv, not the config file — UI settings are per-host and synced by
+// opencode itself). dialog width maps to the host's fixed dialog widths;
+// height is a percent of terminal rows. v1 dialogs apply these directly
+// (dialogs.tsx); the settings dialog edits them through this module so the
+// flows stay host-agnostic.
+
+export const UI_WIDTH_KV = "openshare.ui-width"
+export const UI_HEIGHT_PERCENT_KV = "openshare.ui-height-percent"
+
+export type DialogWidth = "medium" | "large" | "xlarge"
+
+export const HEIGHT_PERCENT_MIN = 25
+export const HEIGHT_PERCENT_MAX = 100
+
+/** what each width means in columns (opencode's fixed dialog widths) */
+export const DIALOG_WIDTH_COLUMNS: Record<DialogWidth, number> = { medium: 60, large: 88, xlarge: 116 }
+
+export function clampHeightPercent(value: number) {
+  return Math.max(HEIGHT_PERCENT_MIN, Math.min(HEIGHT_PERCENT_MAX, Math.round(value)))
+}
+
+export function nextDialogWidth(width: DialogWidth): DialogWidth {
+  return width === "medium" ? "large" : width === "large" ? "xlarge" : "medium"
+}
+
+/** kv read with validation; falls back to the default on garbage. */
+export function kvWidthOf(kv: { get<Value = unknown>(key: string, fallback?: Value): Value }): DialogWidth {
+  const value = kv.get<DialogWidth>(UI_WIDTH_KV, "large")
+  return value === "medium" || value === "large" || value === "xlarge" ? value : "large"
+}
+
+export function kvHeightPercentOf(kv: { get<Value = unknown>(key: string, fallback?: Value): Value }): number {
+  const value = kv.get<number>(UI_HEIGHT_PERCENT_KV, 50)
+  return typeof value === "number" && Number.isFinite(value) ? clampHeightPercent(value) : 50
+}