@toolkit-cli/toolkode 1.3.7

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

@@ -0,0 +1,37 @@
+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/selection.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,98 @@
+import type { AssistantMessage, Part, UserMessage } from "@toolkit-cli/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 = `**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

@@ -0,0 +1,129 @@
+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
+}

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

@@ -0,0 +1,204 @@
+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 { Bus } from "@/bus"
+import { GlobalBus } from "@/bus/global"
+import type { Event } from "@toolkit-cli/sdk/v2"
+import { Flag } from "@/flag/flag"
+import { setTimeout as sleep } from "node:timers/promises"
+import { writeHeapSnapshot } from "node:v8"
+import { WorkspaceID } from "@/control-plane/schema"
+import { Cron } from "@/cron"
+
+await Log.init({
+  print: process.argv.includes("--print-logs"),
+  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: Awaited<ReturnType<typeof Server.listen>> | undefined
+
+const eventStream = {
+  abort: undefined as AbortController | undefined,
+}
+
+const startEventStream = (input: { directory: string; workspaceID?: string }) => {
+  if (eventStream.abort) eventStream.abort.abort()
+  const abort = new AbortController()
+  eventStream.abort = abort
+  const signal = abort.signal
+
+  ;(async () => {
+    while (!signal.aborted) {
+      const shouldReconnect = await Instance.provide({
+        directory: input.directory,
+        init: InstanceBootstrap,
+        fn: () =>
+          new Promise<boolean>((resolve) => {
+            Rpc.emit("event", {
+              type: "server.connected",
+              properties: {},
+            } satisfies Event)
+
+            let settled = false
+            const settle = (value: boolean) => {
+              if (settled) return
+              settled = true
+              signal.removeEventListener("abort", onAbort)
+              unsub()
+              resolve(value)
+            }
+
+            const unsub = Bus.subscribeAll((event) => {
+              Rpc.emit("event", event as Event)
+              if (event.type === Bus.InstanceDisposed.type) {
+                settle(true)
+              }
+            })
+
+            const onAbort = () => {
+              settle(false)
+            }
+
+            signal.addEventListener("abort", onAbort, { once: true })
+          }),
+      }).catch((error) => {
+        Log.Default.error("event stream subscribe error", {
+          error: error instanceof Error ? error.message : error,
+        })
+        return false
+      })
+
+      if (!shouldReconnect || signal.aborted) {
+        break
+      }
+
+      if (!signal.aborted) {
+        await sleep(250)
+      }
+    }
+  })().catch((error) => {
+    Log.Default.error("event stream error", {
+      error: error instanceof Error ? error.message : error,
+    })
+  })
+}
+
+startEventStream({ directory: 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.Default().fetch(request)
+    const body = await response.text()
+    return {
+      status: response.status,
+      headers: Object.fromEntries(response.headers.entries()),
+      body,
+    }
+  },
+  snapshot() {
+    const result = writeHeapSnapshot("server.heapsnapshot")
+    return result
+  },
+  async server(input: { port: number; hostname: string; mdns?: boolean; cors?: string[] }) {
+    if (server) await server.stop(true)
+    server = await Server.listen(input)
+
+    // Start the cron scheduler — fires prompts between turns via prompt_async
+    Cron.start((task) => {
+      if (!server) return
+      const url = new URL(server.url.toString())
+      // Find an active session to fire the prompt in
+      // Use the server's own API to submit the prompt
+      const authHeader = getAuthorizationHeader()
+      fetch(`${url.origin}/session`, {
+        headers: { ...(authHeader ? { Authorization: authHeader } : {}) },
+      })
+        .then((r) => r.json())
+        .then((sessions: any[]) => {
+          // Fire in the most recent session
+          const target = sessions?.[0]
+          if (!target?.id) return
+          return fetch(`${url.origin}/session/${target.id}/prompt_async`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...(authHeader ? { Authorization: authHeader } : {}),
+            },
+            body: JSON.stringify({
+              parts: [{ type: "text", text: `[Scheduled task ${task.id}]: ${task.prompt}` }],
+            }),
+          })
+        })
+        .catch((err) => Log.Default.error("cron fire failed", { taskId: task.id, error: err }))
+    })
+
+    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() {
+    await Config.invalidate(true)
+  },
+  async setWorkspace(input: { workspaceID?: string }) {
+    startEventStream({ directory: process.cwd(), workspaceID: input.workspaceID })
+  },
+  async shutdown() {
+    Log.Default.info("worker shutting down")
+    Cron.stop()
+    if (eventStream.abort) eventStream.abort.abort()
+    await Instance.disposeAll()
+    if (server) await 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 ?? "toolkode"
+  return `Basic ${btoa(`${username}:${password}`)}`
+}