orynacode-ai 1.16.2

package/src/cli/cmd/tui/ui/toast.tsx

@@ -0,0 +1,102 @@
+import { createContext, useContext, type ParentProps, Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useTheme } from "@tui/context/theme"
+import { useTerminalDimensions } from "@opentui/solid"
+import { SplitBorder } from "../component/border"
+import { TextAttributes } from "@opentui/core"
+import { Schema } from "effect"
+import { TuiEvent } from "../event"
+
+type ToastInput = Schema.Codec.Encoded<typeof TuiEvent.ToastShow.data>
+export type ToastOptions = Schema.Schema.Type<typeof TuiEvent.ToastShow.data>
+
+const decodeToastOptions = Schema.decodeUnknownSync(TuiEvent.ToastShow.data)
+
+export function Toast() {
+  const toast = useToast()
+  const { theme } = useTheme()
+  const dimensions = useTerminalDimensions()
+
+  return (
+    <Show when={toast.currentToast}>
+      {(current) => (
+        <box
+          position="absolute"
+          justifyContent="center"
+          alignItems="flex-start"
+          top={2}
+          right={2}
+          maxWidth={Math.min(60, dimensions().width - 6)}
+          paddingLeft={2}
+          paddingRight={2}
+          paddingTop={1}
+          paddingBottom={1}
+          backgroundColor={theme.backgroundPanel}
+          borderColor={theme[current().variant]}
+          border={["left", "right"]}
+          customBorderChars={SplitBorder.customBorderChars}
+        >
+          <Show when={current().title}>
+            <text attributes={TextAttributes.BOLD} marginBottom={1} fg={theme.text}>
+              {current().title}
+            </text>
+          </Show>
+          <text fg={theme.text} wrapMode="word" width="100%">
+            {current().message}
+          </text>
+        </box>
+      )}
+    </Show>
+  )
+}
+
+function init() {
+  const [store, setStore] = createStore({
+    currentToast: null as ToastOptions | null,
+  })
+
+  let timeoutHandle: NodeJS.Timeout | null = null
+
+  const toast = {
+    show(options: ToastInput) {
+      const toastOptions = decodeToastOptions(options)
+      setStore("currentToast", toastOptions)
+      if (timeoutHandle) clearTimeout(timeoutHandle)
+      timeoutHandle = setTimeout(() => {
+        setStore("currentToast", null)
+      }, toastOptions.duration).unref()
+    },
+    error: (err: any) => {
+      if (err instanceof Error)
+        return toast.show({
+          variant: "error",
+          message: err.message,
+        })
+      toast.show({
+        variant: "error",
+        message: "An unknown error has occurred",
+      })
+    },
+    get currentToast(): ToastOptions | null {
+      return store.currentToast
+    },
+  }
+  return toast
+}
+
+export type ToastContext = ReturnType<typeof init>
+
+const ctx = createContext<ToastContext>()
+
+export function ToastProvider(props: ParentProps) {
+  const value = init()
+  return <ctx.Provider value={value}>{props.children}</ctx.Provider>
+}
+
+export function useToast() {
+  const value = useContext(ctx)
+  if (!value) {
+    throw new Error("useToast must be used within a ToastProvider")
+  }
+  return value
+}

package/src/cli/cmd/tui/util/audio.ts

@@ -0,0 +1,58 @@
+import { Audio, type AudioErrorContext, type AudioPlayOptions, type AudioSound, type AudioVoice } from "@opentui/core"
+import * as Log from "@opencode-ai/core/util/log"
+
+const log = Log.create({ service: "tui.audio" })
+
+let audio: Audio | null | undefined
+const sounds = new Map<string, Promise<AudioSound | null>>()
+
+function getAudio() {
+  if (audio !== undefined) return audio
+  try {
+    const next = Audio.create({ autoStart: false })
+    next.on("error", (error: Error, context: AudioErrorContext) => {
+      log.debug("tui audio error", { error, context })
+    })
+    audio = next
+    return next
+  } catch (error) {
+    log.debug("failed to create tui audio", { error })
+    audio = null
+    return null
+  }
+}
+
+export function loadSoundFile(file: string) {
+  const current = getAudio()
+  if (!current) return Promise.resolve(null)
+  const cached = sounds.get(file)
+  if (cached) return cached
+  const task = Bun.file(file)
+    .bytes()
+    .then((bytes) => current.loadSound(bytes))
+    .catch((error) => {
+      log.debug("failed to load tui sound", { file, error })
+      return null
+    })
+  sounds.set(file, task)
+  return task
+}
+
+export function play(sound: AudioSound, options?: AudioPlayOptions) {
+  const current = getAudio()
+  if (!current) return null
+  if (!current.isStarted() && !current.start()) return null
+  return current.play(sound, options)
+}
+
+export function stopVoice(voice: AudioVoice) {
+  return audio?.stopVoice(voice) ?? false
+}
+
+export function dispose() {
+  audio?.dispose()
+  audio = undefined
+  sounds.clear()
+}
+
+export * as TuiAudio from "./audio"

package/src/cli/cmd/tui/util/clipboard.ts

@@ -0,0 +1,181 @@
+import { platform, release } from "os"
+import { lazy } from "../../../../util/lazy.js"
+import { tmpdir } from "os"
+import path from "path"
+import fs from "fs/promises"
+import { Effect } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import { AppProcess } from "@opencode-ai/core/process"
+import * as Filesystem from "../../../../util/filesystem"
+import * as Process from "../../../../util/process"
+
+const writeWithStdin = (cmd: string[], text: string): Promise<void> =>
+  Effect.runPromise(
+    AppProcess.Service.use((svc) => svc.run(ChildProcess.make(cmd[0]!, cmd.slice(1)), { stdin: text })).pipe(
+      Effect.provide(AppProcess.defaultLayer),
+      Effect.catch(() => Effect.void),
+      Effect.asVoid,
+    ),
+  ).catch(() => undefined)
+
+// Lazy load which and clipboardy to avoid expensive execa/which/isexe chain at startup
+const getWhich = lazy(async () => {
+  const { which } = await import("@opencode-ai/core/util/which")
+  return which
+})
+
+const getClipboardy = lazy(async () => {
+  const { default: clipboardy } = await import("clipboardy")
+  return clipboardy
+})
+
+/**
+ * Writes text to clipboard via OSC 52 escape sequence.
+ * This allows clipboard operations to work over SSH by having
+ * the terminal emulator handle the clipboard locally.
+ */
+function writeOsc52(text: string): void {
+  if (!process.stdout.isTTY) return
+  const base64 = Buffer.from(text).toString("base64")
+  const osc52 = `\x1b]52;c;${base64}\x07`
+  const passthrough = process.env["TMUX"] || process.env["STY"]
+  const sequence = passthrough ? `\x1bPtmux;\x1b${osc52}\x1b\\` : osc52
+  process.stdout.write(sequence)
+}
+
+export interface Content {
+  data: string
+  mime: string
+}
+
+// Checks clipboard for images first, then falls back to text.
+//
+// On Windows prompt/ can call this from multiple paste signals because
+// terminals surface image paste differently:
+//   1. A forwarded Ctrl+V keypress
+//   2. An empty bracketed-paste hint for image-only clipboard in Windows
+//      Terminal <1.25
+//   3. A kitty Ctrl+V key-release fallback for Windows Terminal 1.25+
+export async function read(): Promise<Content | undefined> {
+  const os = platform()
+
+  if (os === "darwin") {
+    const tmpfile = path.join(tmpdir(), "opencode-clipboard.png")
+    try {
+      await Process.run(
+        [
+          "osascript",
+          "-e",
+          'set imageData to the clipboard as "PNGf"',
+          "-e",
+          `set fileRef to open for access POSIX file "${tmpfile}" with write permission`,
+          "-e",
+          "set eof fileRef to 0",
+          "-e",
+          "write imageData to fileRef",
+          "-e",
+          "close access fileRef",
+        ],
+        { nothrow: true },
+      )
+      const buffer = await Filesystem.readBytes(tmpfile)
+      return { data: buffer.toString("base64"), mime: "image/png" }
+    } catch {
+    } finally {
+      await fs.rm(tmpfile, { force: true }).catch(() => {})
+    }
+  }
+
+  // Windows/WSL: probe clipboard for images via PowerShell.
+  // Bracketed paste can't carry image data so we read it directly.
+  if (os === "win32" || release().includes("WSL")) {
+    const script =
+      "Add-Type -AssemblyName System.Windows.Forms; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img) { $ms = New-Object System.IO.MemoryStream; $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); [System.Convert]::ToBase64String($ms.ToArray()) }"
+    const base64 = await Process.text(["powershell.exe", "-NonInteractive", "-NoProfile", "-command", script], {
+      nothrow: true,
+    })
+    if (base64.text) {
+      const imageBuffer = Buffer.from(base64.text.trim(), "base64")
+      if (imageBuffer.length > 0) {
+        return { data: imageBuffer.toString("base64"), mime: "image/png" }
+      }
+    }
+  }
+
+  if (os === "linux") {
+    const wayland = await Process.run(["wl-paste", "-t", "image/png"], { nothrow: true })
+    if (wayland.stdout.byteLength > 0) {
+      return { data: Buffer.from(wayland.stdout).toString("base64"), mime: "image/png" }
+    }
+    const x11 = await Process.run(["xclip", "-selection", "clipboard", "-t", "image/png", "-o"], {
+      nothrow: true,
+    })
+    if (x11.stdout.byteLength > 0) {
+      return { data: Buffer.from(x11.stdout).toString("base64"), mime: "image/png" }
+    }
+  }
+
+  const clipboardy = await getClipboardy()
+  const text = await clipboardy.read().catch(() => {})
+  if (text) {
+    return { data: text, mime: "text/plain" }
+  }
+}
+
+const getCopyMethod = lazy(async () => {
+  const os = platform()
+  const which = await getWhich()
+
+  if (os === "darwin" && which("osascript")) {
+    console.log("clipboard: using osascript")
+    return async (text: string) => {
+      const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+      await Process.run(["osascript", "-e", `set the clipboard to "${escaped}"`], { nothrow: true })
+    }
+  }
+
+  if (os === "linux") {
+    if (process.env["WAYLAND_DISPLAY"] && which("wl-copy")) {
+      console.log("clipboard: using wl-copy")
+      return (text: string) => writeWithStdin(["wl-copy"], text)
+    }
+    if (which("xclip")) {
+      console.log("clipboard: using xclip")
+      return (text: string) => writeWithStdin(["xclip", "-selection", "clipboard"], text)
+    }
+    if (which("xsel")) {
+      console.log("clipboard: using xsel")
+      return (text: string) => writeWithStdin(["xsel", "--clipboard", "--input"], text)
+    }
+  }
+
+  if (os === "win32") {
+    console.log("clipboard: using powershell")
+    return (text: string) =>
+      // Pipe via stdin to avoid PowerShell string interpolation ($env:FOO, $(), etc.)
+      writeWithStdin(
+        [
+          "powershell.exe",
+          "-NonInteractive",
+          "-NoProfile",
+          "-Command",
+          "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ],
+        text,
+      )
+  }
+
+  console.log("clipboard: no native support")
+  return async (text: string) => {
+    const clipboardy = await getClipboardy()
+    await clipboardy.write(text).catch(() => {})
+  }
+})
+
+export async function copy(text: string): Promise<void> {
+  writeOsc52(text)
+  const method = await getCopyMethod()
+  await method(text)
+}
+
+export * as Clipboard from "./clipboard"

package/src/cli/cmd/tui/util/collapse-tool-output.ts

@@ -0,0 +1,19 @@
+export function collapseToolOutput(output: string, maxLines: number, maxChars: number) {
+  const lines = output.split("\n")
+  if (lines.length <= maxLines && Array.from(output).length <= maxChars) {
+    return { output, overflow: false }
+  }
+
+  const preview = lines.slice(0, maxLines).join("\n")
+  if (Array.from(preview).length > maxChars) {
+    return {
+      output:
+        Array.from(preview)
+          .slice(0, Math.max(0, maxChars - 1))
+          .join("") + "…",
+      overflow: true,
+    }
+  }
+
+  return { output: [...lines.slice(0, maxLines), "…"].join("\n"), overflow: true }
+}

package/src/cli/cmd/tui/util/editor.ts

@@ -0,0 +1,43 @@
+import { defer } from "@/util/defer"
+import { existsSync } from "node:fs"
+import { rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { CliRenderer } from "@opentui/core"
+import { Filesystem } from "@/util/filesystem"
+import { Process } from "@/util/process"
+
+export async function open(opts: { value: string; renderer: CliRenderer; cwd?: string }): Promise<string | undefined> {
+  const editor = process.env["VISUAL"] || process.env["EDITOR"]
+  if (!editor) return
+
+  const filepath = join(tmpdir(), `${Date.now()}.md`)
+  await using _ = defer(async () => rm(filepath, { force: true }))
+
+  // In attach mode the server's project directory may not exist locally.
+  // Fall back to the local process cwd so the editor can still spawn.
+  const cwd = opts.cwd && existsSync(opts.cwd) ? opts.cwd : process.cwd()
+
+  await Filesystem.write(filepath, opts.value)
+  opts.renderer.suspend()
+  opts.renderer.currentRenderBuffer.clear()
+  try {
+    const parts = editor.split(" ")
+    const proc = Process.spawn([...parts, filepath], {
+      cwd,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      shell: process.platform === "win32",
+    })
+    await proc.exited
+    const content = await Filesystem.readText(filepath)
+    return content || undefined
+  } finally {
+    opts.renderer.currentRenderBuffer.clear()
+    opts.renderer.resume()
+    opts.renderer.requestRender()
+  }
+}
+
+export * as Editor from "./editor"

package/src/cli/cmd/tui/util/layout.ts

@@ -0,0 +1,25 @@
+import type { BaseRenderable, BoxRenderable } from "@opentui/core"
+
+const previousByParent = new WeakMap<
+  BaseRenderable,
+  { frameID: number; previous: WeakMap<BaseRenderable, BaseRenderable | undefined> }
+>()
+
+export function setPreLayoutSiblingMargin(el: BoxRenderable, margin: (previous?: BaseRenderable) => number) {
+  // Run before Yoga layout so scroll geometry matches the rendered frame.
+  el.onLifecyclePass = () => {
+    const parent = el.parent
+    if (!parent) return
+    const cached = previousByParent.get(parent)
+    const previous = cached?.frameID === el.ctx.frameId ? cached.previous : previousSiblings(parent, el.ctx.frameId)
+    const value = margin(previous.get(el))
+    if (el.marginTop !== value) el.marginTop = value
+  }
+}
+
+function previousSiblings(parent: BaseRenderable, frameID: number) {
+  const previous = new WeakMap<BaseRenderable, BaseRenderable | undefined>()
+  parent.getChildren().forEach((child, index, children) => previous.set(child, children[index - 1]))
+  previousByParent.set(parent, { frameID, previous })
+  return previous
+}

package/src/cli/cmd/tui/util/model.ts

@@ -0,0 +1,23 @@
+import type { Provider } from "@opencode-ai/sdk/v2"
+
+export function index(list: Provider[] | undefined) {
+  return new Map((list ?? []).map((item) => [item.id, item] as const))
+}
+
+export function get(list: Provider[] | ReadonlyMap<string, Provider> | undefined, providerID: string, modelID: string) {
+  const provider =
+    list instanceof Map
+      ? list.get(providerID)
+      : Array.isArray(list)
+        ? list.find((item) => item.id === providerID)
+        : undefined
+  return provider?.models[modelID]
+}
+
+export function name(
+  list: Provider[] | ReadonlyMap<string, Provider> | undefined,
+  providerID: string,
+  modelID: string,
+) {
+  return get(list, providerID, modelID)?.name ?? modelID
+}

package/src/cli/cmd/tui/util/provider-origin.ts

@@ -0,0 +1,7 @@
+const contains = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
+  Array.isArray(consoleManagedProviders)
+    ? consoleManagedProviders.includes(providerID)
+    : consoleManagedProviders.has(providerID)
+
+export const isConsoleManagedProvider = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
+  contains(consoleManagedProviders, providerID)

package/src/cli/cmd/tui/util/revert-diff.ts

@@ -0,0 +1,18 @@
+import { parsePatch } from "diff"
+
+export function getRevertDiffFiles(diffText: string) {
+  if (!diffText) return []
+
+  try {
+    return parsePatch(diffText).map((patch) => {
+      const filename = [patch.newFileName, patch.oldFileName].find((item) => item && item !== "/dev/null") ?? "unknown"
+      return {
+        filename: filename.replace(/^[ab]\//, ""),
+        additions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("+")).length, 0),
+        deletions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("-")).length, 0),
+      }
+    })
+  } catch {
+    return []
+  }
+}

package/src/cli/cmd/tui/util/scroll.ts

@@ -0,0 +1,25 @@
+import { MacOSScrollAccel, type ScrollAcceleration } from "@opentui/core"
+import type { TuiConfig } from "@/cli/cmd/tui/config/tui"
+
+export class CustomSpeedScroll implements ScrollAcceleration {
+  constructor(private speed: number) {}
+
+  tick(_now?: number): number {
+    return this.speed
+  }
+
+  reset(): void {}
+}
+
+export function getScrollAcceleration(
+  tuiConfig?: Pick<TuiConfig.Info, "scroll_acceleration" | "scroll_speed">,
+): ScrollAcceleration {
+  if (tuiConfig?.scroll_acceleration?.enabled) {
+    return new MacOSScrollAccel()
+  }
+  if (tuiConfig?.scroll_speed !== undefined) {
+    return new CustomSpeedScroll(tuiConfig.scroll_speed)
+  }
+
+  return new CustomSpeedScroll(3)
+}

package/src/cli/cmd/tui/util/selection.ts

@@ -0,0 +1,73 @@
+import * as Clipboard from "./clipboard"
+
+type Toast = {
+  show: (input: { message: string; variant: "info" | "success" | "warning" | "error" }) => void
+  error: (err: unknown) => void
+}
+
+type FocusableSelectionTarget = {
+  hasSelection: () => boolean
+  getClipboardText?: (text: string) => string
+}
+
+type Renderer = {
+  getSelection: () => { getSelectedText: () => string; selectedRenderables: FocusableSelectionTarget[] } | null
+  clearSelection: () => void
+  currentFocusedRenderable?: FocusableSelectionTarget | null
+}
+
+type SelectionKeyEvent = {
+  ctrl?: boolean
+  name: string
+  preventDefault: () => void
+  stopPropagation: () => void
+}
+
+export function copy(renderer: Renderer, toast: Toast): boolean {
+  const selection = renderer.getSelection()
+  if (!selection) return false
+
+  const text = selection.getSelectedText()
+  if (!text) return false
+
+  const focus = renderer.currentFocusedRenderable
+  const clipboardText =
+    focus?.getClipboardText && selection.selectedRenderables.includes(focus) ? focus.getClipboardText(text) : text
+
+  Clipboard.copy(clipboardText)
+    .then(() => toast.show({ message: "Copied to clipboard", variant: "info" }))
+    .catch(toast.error)
+
+  renderer.clearSelection()
+  return true
+}
+
+export function handleSelectionKey(renderer: Renderer, toast: Toast, event: SelectionKeyEvent) {
+  const selection = renderer.getSelection()
+  if (!selection) return
+
+  if (event.ctrl && event.name === "c") {
+    if (!copy(renderer, toast)) {
+      renderer.clearSelection()
+      return
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+    return
+  }
+
+  if (event.name === "escape") {
+    renderer.clearSelection()
+    event.preventDefault()
+    event.stopPropagation()
+    return
+  }
+
+  const focus = renderer.currentFocusedRenderable
+  if (focus?.hasSelection() && selection.selectedRenderables.includes(focus)) return
+
+  renderer.clearSelection()
+}
+
+export * as Selection from "./selection"

package/src/cli/cmd/tui/util/signal.ts

@@ -0,0 +1,41 @@
+import { createEffect, createSignal, on, onCleanup, type Accessor } from "solid-js"
+import { debounce, type Scheduled } from "@solid-primitives/scheduled"
+
+export function createDebouncedSignal<T>(value: T, ms: number): [Accessor<T>, Scheduled<[value: T]>] {
+  const [get, set] = createSignal(value)
+  return [get, debounce((v: T) => set(() => v), ms)]
+}
+
+export function createFadeIn(show: Accessor<boolean>, enabled: Accessor<boolean>) {
+  const [alpha, setAlpha] = createSignal(show() ? 1 : 0)
+  let revealed = show()
+
+  createEffect(
+    on([show, enabled], ([visible, animate]) => {
+      if (!visible) {
+        setAlpha(0)
+        return
+      }
+
+      if (!animate || revealed) {
+        revealed = true
+        setAlpha(1)
+        return
+      }
+
+      const start = performance.now()
+      revealed = true
+      setAlpha(0)
+
+      const timer = setInterval(() => {
+        const progress = Math.min((performance.now() - start) / 160, 1)
+        setAlpha(progress * progress * (3 - 2 * progress))
+        if (progress >= 1) clearInterval(timer)
+      }, 16)
+
+      onCleanup(() => clearInterval(timer))
+    }),
+  )
+
+  return alpha
+}