jonsoc 1.1.49 → 1.1.50

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

@@ -1,255 +0,0 @@
-import { $ } from "bun"
-import { platform, release } from "os"
-import clipboardy from "clipboardy"
-import { lazy } from "../../../../util/lazy.js"
-import { tmpdir } from "os"
-import path from "path"
-
-/**
- * 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`
-  // tmux and screen require DCS passthrough wrapping
-  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
-  }
-
-  export function parseImageDataUrl(text: string): Content | undefined {
-    const normalized = text.trim()
-    const match = normalized.match(/^data:(image\/[a-z0-9.+-]+);base64,([\s\S]+)$/i)
-    if (!match) return
-    const data = match[2]?.replace(/\s+/g, "")
-    if (!data) return
-    return { data, mime: match[1].toLowerCase() }
-  }
-
-  export async function read(): Promise<Content | undefined> {
-    const os = platform()
-
-    if (os === "darwin") {
-      const tmpfile = path.join(tmpdir(), "jonsoc-clipboard.png")
-      try {
-        await $`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()
-          .quiet()
-        const file = Bun.file(tmpfile)
-        const buffer = await file.arrayBuffer()
-        if (buffer.byteLength === 0) return
-        return { data: Buffer.from(buffer).toString("base64"), mime: "image/png" }
-      } catch {
-      } finally {
-        await $`rm -f "${tmpfile}"`.nothrow().quiet()
-      }
-    }
-
-    if (os === "win32" || release().includes("WSL")) {
-      // Terminal paste does not provide image bytes, so we must read the OS clipboard.
-      // On Windows, clipboard access can fail depending on apartment state and API used.
-      // Try WPF first (PresentationCore), then WinForms, then Get-Clipboard.
-      const script =
-        "$ErrorActionPreference='SilentlyContinue';" +
-        "$OutputEncoding=[System.Text.Encoding]::UTF8;" +
-        "[Console]::OutputEncoding=$OutputEncoding;" +
-        "$result=$null;" +
-        "$paths=Get-Clipboard -Format FileDropList;" +
-        "if($paths -and $paths.Count -gt 0){$path=$paths[0];" +
-        "if(Test-Path $path){$result='FILE:'+ $path}}" +
-        "$tmp=$null;" +
-        "if(-not $result){$tmp=Join-Path $env:TEMP ('jonsoc-clipboard-' + [guid]::NewGuid().ToString() + '.png')}" +
-        // WPF path
-        "if(-not $result){Add-Type -AssemblyName PresentationCore;" +
-        "$src=[System.Windows.Clipboard]::GetImage();" +
-        "if($src){$enc=New-Object System.Windows.Media.Imaging.PngBitmapEncoder;" +
-        "$enc.Frames.Add([System.Windows.Media.Imaging.BitmapFrame]::Create($src));" +
-        "$file=New-Object System.IO.FileStream($tmp,[System.IO.FileMode]::Create);" +
-        "$enc.Save($file); $file.Close(); $result='TMPFILE:'+ $tmp}}" +
-        // WinForms path
-        "if(-not $result){Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing;" +
-        "$img=[System.Windows.Forms.Clipboard]::GetImage();" +
-        "if(-not $img){$img=Get-Clipboard -Format Image}" +
-        "if($img){$img.Save($tmp,[System.Drawing.Imaging.ImageFormat]::Png); $result='TMPFILE:'+ $tmp}}" +
-        "if($result){$result}"
-
-      const base64 = await $`powershell.exe -NoProfile -NonInteractive -STA -command ${script}`.nothrow().text()
-      const trimmed = base64.trim().replace(/\s+/g, "").replace(/\0/g, "")
-      if (!trimmed) return
-
-      const readFile = async (filepath: string) => {
-        const file = Bun.file(filepath)
-        if (!file.type.startsWith("image/")) return
-        const buffer = await file.arrayBuffer()
-        if (buffer.byteLength === 0) return
-        return { data: Buffer.from(buffer).toString("base64"), mime: file.type }
-      }
-
-      if (trimmed.startsWith("FILE:")) {
-        return readFile(trimmed.slice("FILE:".length))
-      }
-
-      if (trimmed.startsWith("TMPFILE:")) {
-        const filepath = trimmed.slice("TMPFILE:".length)
-        const result = await readFile(filepath)
-        await $`rm -f "${filepath}"`.nothrow().quiet()
-        return result
-      }
-    }
-
-    if (os === "linux") {
-      const wayland = await $`wl-paste -t image/png`.nothrow().arrayBuffer()
-      if (wayland && wayland.byteLength > 0) {
-        return { data: Buffer.from(wayland).toString("base64"), mime: "image/png" }
-      }
-      const x11 = await $`xclip -selection clipboard -t image/png -o`.nothrow().arrayBuffer()
-      if (x11 && x11.byteLength > 0) {
-        return { data: Buffer.from(x11).toString("base64"), mime: "image/png" }
-      }
-    }
-
-    const text = await clipboardy.read().catch(() => {})
-    if (text) {
-      const image = parseImageDataUrl(text)
-      if (image) return image
-      return { data: text, mime: "text/plain" }
-    }
-  }
-
-  export async function readText(): Promise<string | undefined> {
-    const os = platform()
-
-    if (os === "win32" || release().includes("WSL")) {
-      const script =
-        "$ErrorActionPreference='SilentlyContinue';" +
-        "$OutputEncoding=[System.Text.Encoding]::UTF8;" +
-        "[Console]::OutputEncoding=$OutputEncoding;" +
-        "$txt=Get-Clipboard -Format Text -Raw;" +
-        "if($txt){[Console]::Write($txt)}"
-      const text = await $`powershell.exe -NoProfile -NonInteractive -STA -command ${script}`.nothrow().text()
-      const trimmed = text.trim().replace(/\0/g, "")
-      if (trimmed) return trimmed
-    }
-
-    if (os === "darwin" && Bun.which("pbpaste")) {
-      const text = await $`pbpaste`.nothrow().text()
-      const trimmed = text.trim().replace(/\0/g, "")
-      if (trimmed) return trimmed
-    }
-
-    if (os === "linux") {
-      if (process.env["WAYLAND_DISPLAY"] && Bun.which("wl-paste")) {
-        const text = await $`wl-paste -n`.nothrow().text()
-        const trimmed = text.trim().replace(/\0/g, "")
-        if (trimmed) return trimmed
-      }
-      if (Bun.which("xclip")) {
-        const text = await $`xclip -selection clipboard -o`.nothrow().text()
-        const trimmed = text.trim().replace(/\0/g, "")
-        if (trimmed) return trimmed
-      }
-      if (Bun.which("xsel")) {
-        const text = await $`xsel --clipboard --output`.nothrow().text()
-        const trimmed = text.trim().replace(/\0/g, "")
-        if (trimmed) return trimmed
-      }
-    }
-
-    const text = await clipboardy.read().catch(() => {})
-    if (text) return text
-  }
-
-  const getCopyMethod = lazy(() => {
-    const os = platform()
-
-    if (os === "darwin" && Bun.which("osascript")) {
-      console.log("clipboard: using osascript")
-      return async (text: string) => {
-        const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
-        await $`osascript -e 'set the clipboard to "${escaped}"'`.nothrow().quiet()
-      }
-    }
-
-    if (os === "linux") {
-      if (process.env["WAYLAND_DISPLAY"] && Bun.which("wl-copy")) {
-        console.log("clipboard: using wl-copy")
-        return async (text: string) => {
-          const proc = Bun.spawn(["wl-copy"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" })
-          proc.stdin.write(text)
-          proc.stdin.end()
-          await proc.exited.catch(() => {})
-        }
-      }
-      if (Bun.which("xclip")) {
-        console.log("clipboard: using xclip")
-        return async (text: string) => {
-          const proc = Bun.spawn(["xclip", "-selection", "clipboard"], {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          })
-          proc.stdin.write(text)
-          proc.stdin.end()
-          await proc.exited.catch(() => {})
-        }
-      }
-      if (Bun.which("xsel")) {
-        console.log("clipboard: using xsel")
-        return async (text: string) => {
-          const proc = Bun.spawn(["xsel", "--clipboard", "--input"], {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          })
-          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 = Bun.spawn(
-          [
-            "powershell.exe",
-            "-NonInteractive",
-            "-NoProfile",
-            "-Command",
-            "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())",
-          ],
-          {
-            stdin: "pipe",
-            stdout: "ignore",
-            stderr: "ignore",
-          },
-        )
-
-        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,32 +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"
-
-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 Bun.write(filepath, opts.value)
-    opts.renderer.suspend()
-    opts.renderer.currentRenderBuffer.clear()
-    const parts = editor.split(" ")
-    const proc = Bun.spawn({
-      cmd: [...parts, filepath],
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-    })
-    await proc.exited
-    const content = await Bun.file(filepath).text()
-    opts.renderer.currentRenderBuffer.clear()
-    opts.renderer.resume()
-    opts.renderer.requestRender()
-    return content || undefined
-  }
-}

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,98 +0,0 @@
-import type { AssistantMessage, Part, UserMessage } from "@jonsoc/sdk/v2"
-import { Locale } from "@/util/locale"
-
-export type TranscriptOptions = {
-  thinking: boolean
-  toolDetails: boolean
-  assistantMetadata: boolean
-}
-
-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 {
-  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)
-    transcript += `---\n\n`
-  }
-
-  return transcript
-}
-
-export function formatMessage(msg: UserMessage | AssistantMessage, parts: Part[], options: TranscriptOptions): string {
-  let result = ""
-
-  if (msg.role === "user") {
-    result += `## User\n\n`
-  } else {
-    result += formatAssistantHeader(msg, options.assistantMetadata)
-  }
-
-  for (const part of parts) {
-    result += formatPart(part, options)
-  }
-
-  return result
-}
-
-export function formatAssistantHeader(msg: AssistantMessage, includeMetadata: boolean): 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" : ""
-
-  return `## Assistant (${Locale.titlecase(msg.agent)} · ${msg.modelID}${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 = `\`\`\`\nTool: ${part.tool}\n`
-    if (options.toolDetails && part.state.input) {
-      result += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\``
-    }
-    if (options.toolDetails && part.state.status === "completed" && part.state.output) {
-      result += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\``
-    }
-    if (options.toolDetails && part.state.status === "error" && part.state.error) {
-      result += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\``
-    }
-    result += `\n\`\`\`\n\n`
-    return result
-  }
-
-  return ""
-}

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

@@ -1,152 +0,0 @@
-import { Installation } from "@/installation"
-import { Server } from "@/server/server"
-import { Log } from "@/util/log"
-import { Instance } from "@/project/instance"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { Rpc } from "@/util/rpc"
-import { upgrade } from "@/cli/upgrade"
-import { Config } from "@/config/config"
-import { GlobalBus } from "@/bus/global"
-import { createOpencodeClient, type Event } from "@jonsoc/sdk/v2"
-import type { BunWebSocketData } from "hono/bun"
-import { Flag } from "@/flag/flag"
-
-await Log.init({
-  print: process.argv.includes("--print-logs") || process.env.PRINT_LOGS === "1",
-  dev: Installation.isLocal(),
-  level: (() => {
-    if (Installation.isLocal()) return "DEBUG"
-    return "INFO"
-  })(),
-})
-
-process.on("unhandledRejection", (e) => {
-  Log.Default.error("rejection", {
-    e: e instanceof Error ? e.message : e,
-  })
-})
-
-process.on("uncaughtException", (e) => {
-  Log.Default.error("exception", {
-    e: e instanceof Error ? e.message : e,
-  })
-})
-
-// Subscribe to global events and forward them via RPC
-GlobalBus.on("event", (event) => {
-  Rpc.emit("global.event", event)
-})
-
-let server: Bun.Server<BunWebSocketData> | undefined
-
-const eventStream = {
-  abort: undefined as AbortController | undefined,
-}
-
-const startEventStream = (directory: string) => {
-  if (eventStream.abort) eventStream.abort.abort()
-  const abort = new AbortController()
-  eventStream.abort = abort
-  const signal = abort.signal
-
-  const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
-    const request = new Request(input, init)
-    const auth = getAuthorizationHeader()
-    if (auth) request.headers.set("Authorization", auth)
-    return Server.App().fetch(request)
-  }) as typeof globalThis.fetch
-
-  const sdk = createOpencodeClient({
-    baseUrl: "http://jonsoc.internal",
-    directory,
-    fetch: fetchFn,
-    signal,
-  })
-
-  ;(async () => {
-    while (!signal.aborted) {
-      const events = await Promise.resolve(
-        sdk.event.subscribe(
-          {},
-          {
-            signal,
-          },
-        ),
-      ).catch(() => undefined)
-
-      if (!events) {
-        await Bun.sleep(250)
-        continue
-      }
-
-      for await (const event of events.stream) {
-        Rpc.emit("event", event as Event)
-      }
-
-      if (!signal.aborted) {
-        await Bun.sleep(250)
-      }
-    }
-  })().catch((error) => {
-    Log.Default.error("event stream error", {
-      error: error instanceof Error ? error.message : error,
-    })
-  })
-}
-
-startEventStream(process.cwd())
-
-export const rpc = {
-  async fetch(input: { url: string; method: string; headers: Record<string, string>; body?: string }) {
-    const headers = { ...input.headers }
-    const auth = getAuthorizationHeader()
-    if (auth && !headers["authorization"] && !headers["Authorization"]) {
-      headers["Authorization"] = auth
-    }
-    const request = new Request(input.url, {
-      method: input.method,
-      headers,
-      body: input.body,
-    })
-    const response = await Server.App().fetch(request)
-    const body = await response.text()
-    return {
-      status: response.status,
-      headers: Object.fromEntries(response.headers.entries()),
-      body,
-    }
-  },
-  async server(input: { port: number; hostname: string; mdns?: boolean; cors?: string[] }) {
-    if (server) await server.stop(true)
-    server = Server.listen(input)
-    return { url: server.url.toString() }
-  },
-  async checkUpgrade(input: { directory: string }) {
-    await Instance.provide({
-      directory: input.directory,
-      init: InstanceBootstrap,
-      fn: async () => {
-        await upgrade().catch(() => {})
-      },
-    })
-  },
-  async reload() {
-    Config.global.reset()
-    await Instance.disposeAll()
-  },
-  async shutdown() {
-    Log.Default.info("worker shutting down")
-    if (eventStream.abort) eventStream.abort.abort()
-    await Instance.disposeAll()
-    if (server) server.stop(true)
-  },
-}
-
-Rpc.listen(rpc)
-
-function getAuthorizationHeader(): string | undefined {
-  const password = Flag.OPENCODE_SERVER_PASSWORD
-  if (!password) return undefined
-  const username = Flag.OPENCODE_SERVER_USERNAME ?? "jonsoc"
-  return `Basic ${btoa(`${username}:${password}`)}`
-}