@mirrowel/opencode-openshare 0.0.0-stage → 0.1.1

package/src/v2-tui.ts

@@ -0,0 +1,315 @@
+/**
+ * OpenCode v2 TUI plugin implementation: builds a ShareHostApi adapter
+ * over the v2 TUI plugin context so the unchanged share flows and settings
+ * dialog run on both hosts, and registers the same commands (one reactive
+ * keymap layer).
+ *
+ * Dialog bridging (family pattern): the v1 api exposes dialog components
+ * that RETURN JSX rendered inside an enclosing `dialog.replace(render)`
+ * entry; the v2 api only offers promise-based dialogs that open their own
+ * host entry. The bridge reconciles the two — `replace()` invokes the
+ * render thunk synchronously; if it returned nothing (a DialogX bridge
+ * already opened the host's own dialog), the caller's onClose is parked
+ * and invoked when that nested dialog is dismissed without a result.
+ */
+
+import { createSignal } from "solid-js"
+import { registerCommands } from "./commands.js"
+import type { ClientApi } from "./core.js"
+import type { ShareDialogSelectOption, ShareHostApi, ShareHostKeymapLayer } from "./tui-host.js"
+import type { V2KeymapCommand, V2KeymapLayer, V2TuiContext, V2TuiSetup } from "./v2-types.js"
+
+function pickThemeToken(source: unknown, ...path: Array<string | number>): unknown {
+  let current: unknown = source
+  for (const key of path) {
+    if (!current || typeof current !== "object") return undefined
+    current = (current as Record<string, unknown>)[key]
+  }
+  return current
+}
+
+function buildV2Theme(context: V2TuiContext) {
+  // Read theme/mode live inside the getter so mid-session theme switches
+  // reach the flows.
+  return {
+    get current() {
+      const theme = context.theme
+      const dark = context.themeMode === "dark"
+      const text = pickThemeToken(theme, "text", "default")
+      return {
+        text,
+        textMuted: pickThemeToken(theme, "text", "subdued") ?? text,
+        background: pickThemeToken(theme, "background", "default"),
+        backgroundPanel: pickThemeToken(theme, "background", "surface", "offset") ?? pickThemeToken(theme, "background", "default"),
+        primary: pickThemeToken(theme, "text", "action", "primary", "selected") ?? text,
+        secondary: pickThemeToken(theme, "hue", dark ? "interactive" : "neutral", dark ? 300 : 700) ?? text,
+        accent: pickThemeToken(theme, "hue", "accent", dark ? 200 : 800) ?? text,
+        success: pickThemeToken(theme, "text", "feedback", "success", "default") ?? text,
+        warning: pickThemeToken(theme, "text", "feedback", "warning", "default") ?? text,
+        error: pickThemeToken(theme, "text", "feedback", "error", "default") ?? text,
+        info: pickThemeToken(theme, "text", "feedback", "info", "default") ?? text,
+      }
+    },
+  }
+}
+
+function convertKeymapLayer(layer: ShareHostKeymapLayer): V2KeymapLayer {
+  const bindingsByName = new Map<string, string[]>()
+  for (const binding of layer.bindings ?? []) {
+    if (!binding?.cmd) continue
+    const keys = bindingsByName.get(binding.cmd) ?? []
+    keys.push(binding.key)
+    bindingsByName.set(binding.cmd, keys)
+  }
+  const commands: V2KeymapCommand[] = (layer.commands ?? []).map((command) => ({
+    id: command.name,
+    title: command.title ?? command.name,
+    description: command.desc,
+    group: command.group ?? command.category,
+    palette: true as const,
+    ...(command.slashName ? { slash: { name: command.slashName, ...(command.slashAliases?.length ? { aliases: command.slashAliases } : {}) } } : {}),
+    ...(command.suggested !== undefined ? { suggested: command.suggested } : {}),
+    ...(command.enabled !== undefined ? { enabled: command.enabled } : {}),
+    ...(bindingsByName.get(command.name)?.length ? { bind: bindingsByName.get(command.name)!.join(",") } : {}),
+    run: (_input?: string, event?: { preventDefault?: () => void; stopPropagation?: () => void }) =>
+      command.run({
+        event: event
+          ? {
+              preventDefault: () => event.preventDefault?.(),
+              stopPropagation: () => event.stopPropagation?.(),
+            }
+          : undefined,
+      }),
+  }))
+  return { mode: layer.mode ?? "global", priority: layer.priority, commands }
+}
+
+/** Builds the v1-shaped ShareHostApi facade over a v2 TUI plugin context. */
+export function buildV2HostApi(context: V2TuiContext): ShareHostApi {
+  const disposeFns: Array<() => void> = []
+
+  // --- kv: synchronous read-your-writes mirror over the persistent store ---
+  const [kvStore, kvMutate] = context.storage.store("kv", { initial: {} as Record<string, unknown> })
+  const kvMirror: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(kvStore as Record<string, unknown>)) kvMirror[key] = value
+  const kv = {
+    get<Value = unknown>(key: string, fallback?: Value): Value {
+      const value = key in kvMirror ? kvMirror[key] : (kvStore as Record<string, unknown>)[key]
+      return (value === undefined ? fallback : value) as Value
+    },
+    set(key: string, value: unknown) {
+      kvMirror[key] = value
+      void kvMutate((draft) => {
+        draft[key] = value
+      }).catch(() => undefined)
+    },
+  }
+
+  // --- dialog bridging (see module doc comment) ---
+  const dialog = context.ui.dialog
+  let nestedOnClose: (() => void) | undefined
+  const settleNested = (dismissed: boolean) => {
+    const onClose = nestedOnClose
+    nestedOnClose = undefined
+    if (dismissed) onClose?.()
+  }
+
+  return {
+    hostVersion: 2,
+    app: { version: context.app?.version },
+    client: context.client as unknown as ClientApi,
+    kv,
+    lifecycle: {
+      onDispose(fn: () => void) {
+        disposeFns.push(fn)
+      },
+    },
+    theme: buildV2Theme(context),
+    ui: {
+      toast: (input) => {
+        try {
+          context.ui.toast.show({ title: input.title, message: input.message, variant: input.variant, duration: input.duration })
+        } catch {
+          /* toasts must never crash the flows */
+        }
+      },
+      dialog: {
+        replace(renderer: unknown, onClose?: () => void) {
+          nestedOnClose = undefined
+          let content: unknown
+          try {
+            content = typeof renderer === "function" ? (renderer as () => unknown)() : renderer
+          } catch {
+            content = undefined
+          }
+          if (content === undefined || content === null) {
+            nestedOnClose = onClose
+            return
+          }
+          dialog.show(() => content, onClose)
+        },
+        clear() {
+          nestedOnClose = undefined
+          dialog.clear()
+        },
+        setSize(size: string) {
+          try {
+            dialog.set({ size })
+          } catch {
+            /* size hints are best-effort */
+          }
+        },
+      },
+      // Promise menus (v2 host dialogs are host-native and fully keyed).
+      async showMenu<Value>(props: { title: string; options: ShareDialogSelectOption<Value>[]; current?: Value; hint?: string }): Promise<Value | undefined> {
+        const value = await dialog.select({
+          title: props.title,
+          placeholder: props.hint,
+          current: props.current,
+          options: props.options.map((option) => ({
+            title: option.title,
+            value: option.value,
+            description: option.description,
+            category: option.category,
+            disabled: option.disabled,
+          })),
+        })
+        return value as Value | undefined
+      },
+      async showConfirm(props: { title: string; message: string; confirmLabel?: string }) {
+        return (await dialog.confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } })) === true
+      },
+      async showAlert(props: { title: string; message: string }) {
+        await dialog.alert({ title: props.title, message: props.message })
+      },
+      async showPrompt(props: { title: string; placeholder?: string; value?: string }) {
+        return await dialog.prompt({ title: props.title, placeholder: props.placeholder, value: props.value })
+      },
+      DialogSelect(props) {
+        void dialog
+          .select({
+            title: props.title,
+            placeholder: props.placeholder,
+            current: props.current,
+            options: props.options.map((option) => ({
+              title: option.title,
+              value: option.value,
+              description: option.description,
+              category: option.category,
+              disabled: option.disabled,
+            })),
+          })
+          .then((value) => {
+            if (value === undefined) {
+              settleNested(true)
+              return
+            }
+            settleNested(false)
+            const option = props.options.find((item) => item.value === value)
+            if (option) props.onSelect(option)
+          })
+          .catch(() => settleNested(true))
+      },
+      DialogPrompt(props) {
+        void dialog
+          .prompt({ title: props.title, placeholder: props.placeholder, value: props.value })
+          .then((value) => {
+            settleNested(value === undefined)
+            if (value === undefined) props.onCancel?.()
+            else props.onConfirm(value)
+          })
+          .catch(() => {
+            settleNested(true)
+            props.onCancel?.()
+          })
+      },
+      DialogConfirm(props) {
+        void dialog
+          .confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } })
+          .then((result) => {
+            settleNested(result !== true)
+            if (result === true) props.onConfirm()
+            else props.onCancel?.()
+          })
+          .catch(() => {
+            settleNested(true)
+            props.onCancel?.()
+          })
+      },
+      DialogAlert(props) {
+        void dialog
+          .alert({ title: props.title, message: props.message })
+          .then(() => {
+            settleNested(false)
+            props.onConfirm?.()
+          })
+          .catch(() => {
+            settleNested(true)
+            props.onConfirm?.()
+          })
+      },
+    },
+    keymap: {
+      registerLayer(layer: ShareHostKeymapLayer) {
+        // v2 layers are reactive: the input function re-evaluates when the
+        // signal flips, so "unregistering" disables the layer.
+        const [active, setActive] = createSignal(true)
+        try {
+          context.keymap.layer(() =>
+            active()
+              ? convertKeymapLayer(layer)
+              : { mode: "global", enabled: false, commands: [], bindings: [] },
+          )
+        } catch {
+          return () => undefined
+        }
+        return () => {
+          setActive(false)
+        }
+      },
+    },
+    sessionInfo: () => undefined,
+    currentSessionID: undefined,
+    clipboard: {
+      // same belt-and-braces as the v1 facade: navigator may resolve as a
+      // silent no-op in the TUI runtime; OSC52 is the reliable path
+      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
+      },
+    },
+  }
+}
+
+/**
+ * v2 TUI plugin setup: registers the share commands (one reactive keymap
+ * layer). Session-context wiring (currentSessionID) finalizes in phase 4
+ * once the beta's session/route surface is verified.
+ */
+export function createV2TuiSetup(): V2TuiSetup {
+  return async (context: V2TuiContext) => {
+    const host = buildV2HostApi(context)
+    const sessionID = () => host.currentSessionID?.() ?? undefined
+    const unregister = registerCommands(host, sessionID)
+    return () => {
+      try {
+        unregister()
+      } catch {}
+    }
+  }
+}

package/src/v2-types.ts

@@ -0,0 +1,102 @@
+/**
+ * Minimal structural types for the OpenCode v2 TUI plugin context subset
+ * used by this plugin. Hand-written on purpose (same policy as the server
+ * side and the family plugins): the v2 SDK is still beta and a v2 plugin
+ * module must not import the plugin SDK at runtime anyway. Keep in sync
+ * with the beta repo (packages/plugin/src/tui) when the API settles.
+ */
+
+export type V2TuiKeyEvent = {
+  preventDefault?(): void
+  stopPropagation?(): void
+  [key: string]: unknown
+}
+
+export type V2KeymapCommand = {
+  id?: string
+  title?: string
+  description?: string
+  group?: string
+  enabled?: boolean | (() => boolean)
+  bind?: false | string
+  palette?: true
+  slash?: { name: string; aliases?: string[]; arguments?: true }
+  suggested?: boolean | (() => boolean)
+  run: (input?: string, event?: V2TuiKeyEvent) => void | false | Promise<void>
+}
+
+export type V2KeymapLayer = {
+  mode?: string
+  enabled?: boolean | (() => boolean)
+  priority?: number
+  commands?: readonly V2KeymapCommand[]
+  bindings?: readonly string[]
+}
+
+export type V2DialogSelectOption<Value> = {
+  title: string
+  value: Value
+  description?: string
+  category?: string
+  disabled?: boolean
+}
+
+export type V2LocationRef = { directory: string; workspaceID?: string }
+
+export type V2TuiContext = {
+  options: Readonly<Record<string, unknown>>
+  location?: unknown
+  app: { version?: string; channel?: string }
+  renderer: { root?: unknown }
+  client: any
+  keymap: {
+    layer(input: () => V2KeymapLayer): void
+    mode: { current(): string; push(mode: string): () => void }
+  }
+  storage: {
+    store<Value extends object>(
+      key: string,
+      options: { initial: Value },
+    ): readonly [Value, (mutation: (draft: Value) => void) => Promise<void>]
+  }
+  theme: V2ResolvedTheme
+  themeMode: "dark" | "light"
+  ui: {
+    dialog: {
+      show(render: () => unknown, onClose?: () => void): void
+      set(options: { size?: string; centered?: boolean }): void
+      clear(): void
+      alert(options: { title: string; message: string }): Promise<void>
+      confirm(options: {
+        title: string
+        message: string
+        label?: { confirm?: string; cancel?: string }
+      }): Promise<boolean | undefined>
+      prompt(options: { title: string; description?: string; placeholder?: string; value?: string }): Promise<string | undefined>
+      select<Value>(options: {
+        title: string
+        placeholder?: string
+        current?: Value
+        options: readonly V2DialogSelectOption<Value>[]
+      }): Promise<Value | undefined>
+    }
+    toast: { show(options: { title?: string; message: string; variant?: string; duration?: number }): void }
+  }
+}
+
+export type V2ResolvedTheme = {
+  text: {
+    default: unknown
+    subdued: unknown
+    feedback: Record<string, { default: unknown }>
+    action: Record<string, Record<string, unknown>>
+  }
+  background: {
+    default: unknown
+    surface: { offset: unknown; overlay: unknown }
+  }
+  hue: Record<string, Record<string | number, unknown>>
+  categorical?: ReadonlyArray<unknown>
+}
+
+export type V2TuiSetup = (context: V2TuiContext) => Promise<(() => void) | void> | (() => void) | void

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": false,
+    "noEmitOnError": true,
+    "declaration": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/solid",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"]
+}