@epoch-ai/cli 2.2.4 → 2.2.5

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

@@ -1,192 +0,0 @@
-import { platform, release } from "os"
-import clipboardy from "clipboardy"
-import { lazy } from "../../../../util/lazy.js"
-import { tmpdir } from "os"
-import path from "path"
-import fs from "fs/promises"
-import { Filesystem } from "../../../../util/filesystem"
-import { Process } from "../../../../util/process"
-import { which } from "../../../../util/which"
-
-/**
- * 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 namespace Clipboard {
-  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(), "epochcli-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 text = await clipboardy.read().catch(() => {})
-    if (text) {
-      return { data: text, mime: "text/plain" }
-    }
-  }
-
-  const getCopyMethod = lazy(() => {
-    const os = platform()
-
-    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 async (text: string) => {
-          const proc = Process.spawn(["wl-copy"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" })
-          if (!proc.stdin) return
-          proc.stdin.write(text)
-          proc.stdin.end()
-          await proc.exited.catch(() => {})
-        }
-      }
-      if (which("xclip")) {
-        console.log("clipboard: using xclip")
-        return async (text: string) => {
-          const proc = Process.spawn(["xclip", "-selection", "clipboard"], {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          })
-          if (!proc.stdin) return
-          proc.stdin.write(text)
-          proc.stdin.end()
-          await proc.exited.catch(() => {})
-        }
-      }
-      if (which("xsel")) {
-        console.log("clipboard: using xsel")
-        return async (text: string) => {
-          const proc = Process.spawn(["xsel", "--clipboard", "--input"], {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          })
-          if (!proc.stdin) return
-          proc.stdin.write(text)
-          proc.stdin.end()
-          await proc.exited.catch(() => {})
-        }
-      }
-    }
-
-    if (os === "win32") {
-      console.log("clipboard: using powershell")
-      return async (text: string) => {
-        // Pipe via stdin to avoid PowerShell string interpolation ($env:FOO, $(), etc.)
-        const proc = Process.spawn(
-          [
-            "powershell.exe",
-            "-NonInteractive",
-            "-NoProfile",
-            "-Command",
-            "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())",
-          ],
-          {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          },
-        )
-
-        if (!proc.stdin) return
-        proc.stdin.write(text)
-        proc.stdin.end()
-        await proc.exited.catch(() => {})
-      }
-    }
-
-    console.log("clipboard: no native support")
-    return async (text: string) => {
-      await clipboardy.write(text).catch(() => {})
-    }
-  })
-
-  export async function copy(text: string): Promise<void> {
-    writeOsc52(text)
-    await getCopyMethod()(text)
-  }
-}

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

@@ -1,37 +0,0 @@
-import { defer } from "@/util/defer"
-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 namespace Editor {
-  export async function open(opts: { value: string; renderer: CliRenderer }): 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 }))
-
-    await Filesystem.write(filepath, opts.value)
-    opts.renderer.suspend()
-    opts.renderer.currentRenderBuffer.clear()
-    try {
-      const parts = editor.split(" ")
-      const proc = Process.spawn([...parts, filepath], {
-        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()
-    }
-  }
-}

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

@@ -1,23 +0,0 @@
-import type { Provider } from "@epoch-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

@@ -1,20 +0,0 @@
-export const CONSOLE_MANAGED_ICON = "⌂"
-
-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)
-
-export const consoleManagedProviderSuffix = (
-  consoleManagedProviders: string[] | ReadonlySet<string>,
-  providerID: string,
-) => (contains(consoleManagedProviders, providerID) ? ` ${CONSOLE_MANAGED_ICON}` : "")
-
-export const consoleManagedProviderLabel = (
-  consoleManagedProviders: string[] | ReadonlySet<string>,
-  providerID: string,
-  providerName: string,
-) => `${providerName}${consoleManagedProviderSuffix(consoleManagedProviders, providerID)}`

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

@@ -1,23 +0,0 @@
-import { MacOSScrollAccel, type ScrollAcceleration } from "@opentui/core"
-import type { TuiConfig } from "@/config/tui"
-
-export class CustomSpeedScroll implements ScrollAcceleration {
-  constructor(private speed: number) {}
-
-  tick(_now?: number): number {
-    return this.speed
-  }
-
-  reset(): void {}
-}
-
-export function getScrollAcceleration(tuiConfig?: TuiConfig.Info): 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

@@ -1,25 +0,0 @@
-import { Clipboard } from "./clipboard"
-
-type Toast = {
-  show: (input: { message: string; variant: "info" | "success" | "warning" | "error" }) => void
-  error: (err: unknown) => void
-}
-
-type Renderer = {
-  getSelection: () => { getSelectedText: () => string } | null
-  clearSelection: () => void
-}
-
-export namespace Selection {
-  export function copy(renderer: Renderer, toast: Toast): boolean {
-    const text = renderer.getSelection()?.getSelectedText()
-    if (!text) return false
-
-    Clipboard.copy(text)
-      .then(() => toast.show({ message: "Copied to clipboard", variant: "info" }))
-      .catch(toast.error)
-
-    renderer.clearSelection()
-    return true
-  }
-}

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

@@ -1,7 +0,0 @@
-import { createSignal, 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)]
-}

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

@@ -1,114 +0,0 @@
-import { RGBA } from "@opentui/core"
-
-export namespace Terminal {
-  export type Colors = Awaited<ReturnType<typeof colors>>
-  /**
-   * Query terminal colors including background, foreground, and palette (0-15).
-   * Uses OSC escape sequences to retrieve actual terminal color values.
-   *
-   * Note: OSC 4 (palette) queries may not work through tmux as responses are filtered.
-   * OSC 10/11 (foreground/background) typically work in most environments.
-   *
-   * Returns an object with background, foreground, and colors array.
-   * Any query that fails will be null/empty.
-   */
-  export async function colors(): Promise<{
-    background: RGBA | null
-    foreground: RGBA | null
-    colors: RGBA[]
-  }> {
-    if (!process.stdin.isTTY) return { background: null, foreground: null, colors: [] }
-
-    return new Promise((resolve) => {
-      let background: RGBA | null = null
-      let foreground: RGBA | null = null
-      const paletteColors: RGBA[] = []
-      let timeout: NodeJS.Timeout
-
-      const cleanup = () => {
-        process.stdin.setRawMode(false)
-        process.stdin.removeListener("data", handler)
-        clearTimeout(timeout)
-      }
-
-      const parseColor = (colorStr: string): RGBA | null => {
-        if (colorStr.startsWith("rgb:")) {
-          const parts = colorStr.substring(4).split("/")
-          return RGBA.fromInts(
-            parseInt(parts[0], 16) >> 8, // Convert 16-bit to 8-bit
-            parseInt(parts[1], 16) >> 8,
-            parseInt(parts[2], 16) >> 8,
-            255,
-          )
-        }
-        if (colorStr.startsWith("#")) {
-          return RGBA.fromHex(colorStr)
-        }
-        if (colorStr.startsWith("rgb(")) {
-          const parts = colorStr.substring(4, colorStr.length - 1).split(",")
-          return RGBA.fromInts(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), 255)
-        }
-        return null
-      }
-
-      const handler = (data: Buffer) => {
-        const str = data.toString()
-
-        // Match OSC 11 (background color)
-        const bgMatch = str.match(/\x1b]11;([^\x07\x1b]+)/)
-        if (bgMatch) {
-          background = parseColor(bgMatch[1])
-        }
-
-        // Match OSC 10 (foreground color)
-        const fgMatch = str.match(/\x1b]10;([^\x07\x1b]+)/)
-        if (fgMatch) {
-          foreground = parseColor(fgMatch[1])
-        }
-
-        // Match OSC 4 (palette colors)
-        const paletteMatches = str.matchAll(/\x1b]4;(\d+);([^\x07\x1b]+)/g)
-        for (const match of paletteMatches) {
-          const index = parseInt(match[1])
-          const color = parseColor(match[2])
-          if (color) paletteColors[index] = color
-        }
-
-        // Return immediately if we have all 16 palette colors
-        if (paletteColors.filter((c) => c !== undefined).length === 16) {
-          cleanup()
-          resolve({ background, foreground, colors: paletteColors })
-        }
-      }
-
-      process.stdin.setRawMode(true)
-      process.stdin.on("data", handler)
-
-      // Query background (OSC 11)
-      process.stdout.write("\x1b]11;?\x07")
-      // Query foreground (OSC 10)
-      process.stdout.write("\x1b]10;?\x07")
-      // Query palette colors 0-15 (OSC 4)
-      for (let i = 0; i < 16; i++) {
-        process.stdout.write(`\x1b]4;${i};?\x07`)
-      }
-
-      timeout = setTimeout(() => {
-        cleanup()
-        resolve({ background, foreground, colors: paletteColors })
-      }, 1000)
-    })
-  }
-
-  export async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
-    const result = await colors()
-    if (!result.background) return "dark"
-
-    const { r, g, b } = result.background
-    // Calculate luminance using relative luminance formula
-    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
-
-    // Determine if dark or light based on luminance threshold
-    return luminance > 0.5 ? "light" : "dark"
-  }
-}

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

@@ -1,112 +0,0 @@
-import type { AssistantMessage, Part, Provider, UserMessage } from "@epoch-ai/sdk/v2"
-import { Locale } from "@/util/locale"
-import * as Model from "./model"
-
-export type TranscriptOptions = {
-  thinking: boolean
-  toolDetails: boolean
-  assistantMetadata: boolean
-  providers?: Provider[]
-}
-
-export type SessionInfo = {
-  id: string
-  title: string
-  time: {
-    created: number
-    updated: number
-  }
-}
-
-export type MessageWithParts = {
-  info: UserMessage | AssistantMessage
-  parts: Part[]
-}
-
-export function formatTranscript(
-  session: SessionInfo,
-  messages: MessageWithParts[],
-  options: TranscriptOptions,
-): string {
-  const providers = Model.index(options.providers)
-  let transcript = `# ${session.title}\n\n`
-  transcript += `**Session ID:** ${session.id}\n`
-  transcript += `**Created:** ${new Date(session.time.created).toLocaleString()}\n`
-  transcript += `**Updated:** ${new Date(session.time.updated).toLocaleString()}\n\n`
-  transcript += `---\n\n`
-
-  for (const msg of messages) {
-    transcript += formatMessage(msg.info, msg.parts, options, providers)
-    transcript += `---\n\n`
-  }
-
-  return transcript
-}
-
-export function formatMessage(
-  msg: UserMessage | AssistantMessage,
-  parts: Part[],
-  options: TranscriptOptions,
-  providers?: Provider[] | ReadonlyMap<string, Provider>,
-): string {
-  let result = ""
-
-  if (msg.role === "user") {
-    result += `## User\n\n`
-  } else {
-    result += formatAssistantHeader(msg, options.assistantMetadata, providers ?? options.providers)
-  }
-
-  for (const part of parts) {
-    result += formatPart(part, options)
-  }
-
-  return result
-}
-
-export function formatAssistantHeader(
-  msg: AssistantMessage,
-  includeMetadata: boolean,
-  providers?: Provider[] | ReadonlyMap<string, Provider>,
-): string {
-  if (!includeMetadata) {
-    return `## Assistant\n\n`
-  }
-
-  const duration =
-    msg.time.completed && msg.time.created ? ((msg.time.completed - msg.time.created) / 1000).toFixed(1) + "s" : ""
-
-  const modelName = Model.name(providers, msg.providerID, msg.modelID)
-
-  return `## Assistant (${Locale.titlecase(msg.agent)} · ${modelName}${duration ? ` · ${duration}` : ""})\n\n`
-}
-
-export function formatPart(part: Part, options: TranscriptOptions): string {
-  if (part.type === "text" && !part.synthetic) {
-    return `${part.text}\n\n`
-  }
-
-  if (part.type === "reasoning") {
-    if (options.thinking) {
-      return `_Thinking:_\n\n${part.text}\n\n`
-    }
-    return ""
-  }
-
-  if (part.type === "tool") {
-    let result = `**Tool: ${part.tool}**\n`
-    if (options.toolDetails && part.state.input) {
-      result += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\`\n`
-    }
-    if (options.toolDetails && part.state.status === "completed" && part.state.output) {
-      result += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\`\n`
-    }
-    if (options.toolDetails && part.state.status === "error" && part.state.error) {
-      result += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\`\n`
-    }
-    result += `\n`
-    return result
-  }
-
-  return ""
-}

package/src/cli/cmd/tui/win32.ts

@@ -1,129 +0,0 @@
-import { dlopen, ptr } from "bun:ffi"
-
-const STD_INPUT_HANDLE = -10
-const ENABLE_PROCESSED_INPUT = 0x0001
-
-const kernel = () =>
-  dlopen("kernel32.dll", {
-    GetStdHandle: { args: ["i32"], returns: "ptr" },
-    GetConsoleMode: { args: ["ptr", "ptr"], returns: "i32" },
-    SetConsoleMode: { args: ["ptr", "u32"], returns: "i32" },
-    FlushConsoleInputBuffer: { args: ["ptr"], returns: "i32" },
-  })
-
-let k32: ReturnType<typeof kernel> | undefined
-
-function load() {
-  if (process.platform !== "win32") return false
-  try {
-    k32 ??= kernel()
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Clear ENABLE_PROCESSED_INPUT on the console stdin handle.
- */
-export function win32DisableProcessedInput() {
-  if (process.platform !== "win32") return
-  if (!process.stdin.isTTY) return
-  if (!load()) return
-
-  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
-  const buf = new Uint32Array(1)
-  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
-
-  const mode = buf[0]!
-  if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
-  k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
-}
-
-/**
- * Discard any queued console input (mouse events, key presses, etc.).
- */
-export function win32FlushInputBuffer() {
-  if (process.platform !== "win32") return
-  if (!process.stdin.isTTY) return
-  if (!load()) return
-
-  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
-  k32!.symbols.FlushConsoleInputBuffer(handle)
-}
-
-let unhook: (() => void) | undefined
-
-/**
- * Keep ENABLE_PROCESSED_INPUT disabled.
- *
- * On Windows, Ctrl+C becomes a CTRL_C_EVENT (instead of stdin input) when
- * ENABLE_PROCESSED_INPUT is set. Various runtimes can re-apply console modes
- * (sometimes on a later tick), and the flag is console-global, not per-process.
- *
- * We combine:
- * - A `setRawMode(...)` hook to re-clear after known raw-mode toggles.
- * - A low-frequency poll as a backstop for native/external mode changes.
- */
-export function win32InstallCtrlCGuard() {
-  if (process.platform !== "win32") return
-  if (!process.stdin.isTTY) return
-  if (!load()) return
-  if (unhook) return unhook
-
-  const stdin = process.stdin as any
-  const original = stdin.setRawMode
-
-  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
-  const buf = new Uint32Array(1)
-
-  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
-  const initial = buf[0]!
-
-  const enforce = () => {
-    if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
-    const mode = buf[0]!
-    if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
-    k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
-  }
-
-  // Some runtimes can re-apply console modes on the next tick; enforce twice.
-  const later = () => {
-    enforce()
-    setImmediate(enforce)
-  }
-
-  let wrapped: ((mode: boolean) => unknown) | undefined
-
-  if (typeof original === "function") {
-    wrapped = (mode: boolean) => {
-      const result = original.call(stdin, mode)
-      later()
-      return result
-    }
-
-    stdin.setRawMode = wrapped
-  }
-
-  // Ensure it's cleared immediately too (covers any earlier mode changes).
-  later()
-
-  const interval = setInterval(enforce, 100)
-  interval.unref()
-
-  let done = false
-  unhook = () => {
-    if (done) return
-    done = true
-
-    clearInterval(interval)
-    if (wrapped && stdin.setRawMode === wrapped) {
-      stdin.setRawMode = original
-    }
-
-    k32!.symbols.SetConsoleMode(handle, initial)
-    unhook = undefined
-  }
-
-  return unhook
-}