@agentprojectcontext/apx 1.15.6 → 1.17.0

package/src/tui/util/sound.ts

@@ -0,0 +1,156 @@
+import { Player } from "cli-sound"
+import { mkdirSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { basename, join } from "node:path"
+import { Process } from "@/util/process"
+import { which } from "@/util/which"
+import pulseA from "../asset/pulse-a.wav" with { type: "file" }
+import pulseB from "../asset/pulse-b.wav" with { type: "file" }
+import pulseC from "../asset/pulse-c.wav" with { type: "file" }
+import charge from "../asset/charge.wav" with { type: "file" }
+
+const FILE = [pulseA, pulseB, pulseC]
+
+const HUM = charge
+const DIR = join(tmpdir(), "opencode-sfx")
+
+const LIST = [
+  "ffplay",
+  "mpv",
+  "mpg123",
+  "mpg321",
+  "mplayer",
+  "afplay",
+  "play",
+  "omxplayer",
+  "aplay",
+  "cmdmp3",
+  "cvlc",
+  "powershell.exe",
+] as const
+
+type Kind = (typeof LIST)[number]
+
+function args(kind: Kind, file: string, volume: number) {
+  if (kind === "ffplay") return [kind, "-autoexit", "-nodisp", "-af", `volume=${volume}`, file]
+  if (kind === "mpv")
+    return [kind, "--no-video", "--audio-display=no", "--volume", String(Math.round(volume * 100)), file]
+  if (kind === "mpg123" || kind === "mpg321") return [kind, "-g", String(Math.round(volume * 100)), file]
+  if (kind === "mplayer") return [kind, "-vo", "null", "-volume", String(Math.round(volume * 100)), file]
+  if (kind === "afplay" || kind === "omxplayer" || kind === "aplay" || kind === "cmdmp3") return [kind, file]
+  if (kind === "play") return [kind, "-v", String(volume), file]
+  if (kind === "cvlc") return [kind, `--gain=${volume}`, "--play-and-exit", file]
+  return [kind, "-c", `(New-Object Media.SoundPlayer '${file.replace(/'/g, "''")}').PlaySync()`]
+}
+
+let item: Player | null | undefined
+let kind: Kind | null | undefined
+let proc: Process.Child | undefined
+let tail: ReturnType<typeof setTimeout> | undefined
+let cache: Promise<{ hum: string; pulse: string[] }> | undefined
+let seq = 0
+let shot = 0
+
+function load() {
+  if (item !== undefined) return item
+  try {
+    item = new Player({ volume: 0.35 })
+  } catch {
+    item = null
+  }
+  return item
+}
+
+async function file(path: string) {
+  mkdirSync(DIR, { recursive: true })
+  const next = join(DIR, basename(path))
+  const out = Bun.file(next)
+  if (await out.exists()) return next
+  await Bun.write(out, Bun.file(path))
+  return next
+}
+
+function asset() {
+  cache ??= Promise.all([file(HUM), Promise.all(FILE.map(file))]).then(([hum, pulse]) => ({ hum, pulse }))
+  return cache
+}
+
+function pick() {
+  if (kind !== undefined) return kind
+  kind = LIST.find((item) => which(item)) ?? null
+  return kind
+}
+
+function run(file: string, volume: number) {
+  const kind = pick()
+  if (!kind) return
+  return Process.spawn(args(kind, file, volume), {
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore",
+  })
+}
+
+function clear() {
+  if (!tail) return
+  clearTimeout(tail)
+  tail = undefined
+}
+
+function play(file: string, volume: number) {
+  const item = load()
+  if (!item) return run(file, volume)?.exited
+  return item.play(file, { volume }).catch(() => run(file, volume)?.exited)
+}
+
+export function start() {
+  stop()
+  const id = ++seq
+  void asset().then(({ hum }) => {
+    if (id !== seq) return
+    const next = run(hum, 0.24)
+    if (!next) return
+    proc = next
+    void next.exited.then(
+      () => {
+        if (id !== seq) return
+        if (proc === next) proc = undefined
+      },
+      () => {
+        if (id !== seq) return
+        if (proc === next) proc = undefined
+      },
+    )
+  })
+}
+
+export function stop(delay = 0) {
+  seq++
+  clear()
+  if (!proc) return
+  const next = proc
+  if (delay <= 0) {
+    proc = undefined
+    void Process.stop(next).catch(() => undefined)
+    return
+  }
+  tail = setTimeout(() => {
+    tail = undefined
+    if (proc === next) proc = undefined
+    void Process.stop(next).catch(() => undefined)
+  }, delay)
+}
+
+export function pulse(scale = 1) {
+  stop(140)
+  const index = shot++ % FILE.length
+  void asset()
+    .then(({ pulse }) => play(pulse[index], 0.26 + 0.14 * scale))
+    .catch(() => undefined)
+}
+
+export function dispose() {
+  stop()
+}
+
+export * as Sound from "./sound"

package/src/tui/util/transcript.ts

@@ -0,0 +1,112 @@
+import type { AssistantMessage, Part, Provider, UserMessage } from "@opencode-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/tui/validate-session.ts

@@ -0,0 +1,29 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
+import { SessionID } from "@/session/schema"
+import { Schema } from "effect"
+
+const decodeSessionID = Schema.decodeUnknownSync(SessionID)
+
+export async function validateSession(input: {
+  url: string
+  sessionID?: string
+  directory?: string
+  fetch?: typeof fetch
+  headers?: RequestInit["headers"]
+}) {
+  if (!input.sessionID) return
+
+  let sessionID: SessionID
+  try {
+    sessionID = decodeSessionID(input.sessionID)
+  } catch (error) {
+    throw new Error(`Invalid session ID: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error })
+  }
+
+  await createOpencodeClient({
+    baseUrl: input.url,
+    directory: input.directory,
+    fetch: input.fetch,
+    headers: input.headers,
+  }).session.get({ sessionID }, { throwOnError: true })
+}

package/src/tui/win32.ts

@@ -0,0 +1,130 @@
+import { dlopen, ptr } from "bun:ffi"
+import type { ReadStream } from "node:tty"
+
+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 ReadStream
+  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: ReadStream["setRawMode"] | 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/tui/worker.ts

@@ -0,0 +1,104 @@
+import { Installation } from "@/installation"
+import { Server } from "@/server/server"
+import * as Log from "@opencode-ai/core/util/log"
+import { InstanceRuntime } from "@/project/instance-runtime"
+import { WithInstance } from "@/project/with-instance"
+import { Rpc } from "@/util/rpc"
+import { upgrade } from "@/cli/upgrade"
+import { Config } from "@/config/config"
+import { GlobalBus } from "@/bus/global"
+import { ServerAuth } from "@/server/auth"
+import { writeHeapSnapshot } from "node:v8"
+import { Heap } from "@/cli/heap"
+import { AppRuntime } from "@/effect/app-runtime"
+import { ensureProcessMetadata } from "@opencode-ai/core/util/opencode-process"
+import { Effect } from "effect"
+import { disposeAllInstancesAndEmitGlobalDisposed } from "@/server/global-lifecycle"
+
+ensureProcessMetadata("worker")
+
+await Log.init({
+  print: process.argv.includes("--print-logs"),
+  dev: Installation.isLocal(),
+  level: (() => {
+    if (Installation.isLocal()) return "DEBUG"
+    return "INFO"
+  })(),
+})
+
+Heap.start()
+
+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
+
+export const rpc = {
+  async fetch(input: { url: string; method: string; headers: Record<string, string>; body?: string }) {
+    const headers = { ...input.headers }
+    const auth = ServerAuth.header()
+    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().app.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)
+    return { url: server.url.toString() }
+  },
+  async checkUpgrade(input: { directory: string }) {
+    await WithInstance.provide({
+      directory: input.directory,
+      fn: async () => {
+        await upgrade().catch(() => {})
+      },
+    })
+  },
+  async reload() {
+    await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const cfg = yield* Config.Service
+        yield* cfg.invalidate()
+        yield* disposeAllInstancesAndEmitGlobalDisposed({ swallowErrors: true })
+      }),
+    )
+  },
+  async shutdown() {
+    Log.Default.info("worker shutting down")
+
+    await InstanceRuntime.disposeAllInstances()
+    if (server) await server.stop(true)
+  },
+}
+
+Rpc.listen(rpc)