opencode-drive 0.1.7 → 0.1.8

package/src/recording/terminal.ts

@@ -0,0 +1,124 @@
+import type { TerminalCore } from "@wterm/core"
+import { GhosttyCore } from "@wterm/ghostty"
+import type { CapturedFrame, CapturedSpan } from "./types.js"
+
+const DefaultForeground = 0xd8d8d8
+const DefaultBackground = 0x080808
+const SyncStart = Buffer.from("\x1b[?2026h")
+const SyncEnd = Buffer.from("\x1b[?2026l")
+
+export interface TerminalParser {
+  write(data: Uint8Array): void
+  finish(): void
+  resize(cols: number, rows: number): void
+  snapshot(): CapturedFrame
+}
+
+export type TerminalParserFactory = (cols: number, rows: number) => Promise<TerminalParser>
+
+function characterWidth(char: string) {
+  return Math.max(1, Bun.stringWidth(char))
+}
+
+function capture(core: TerminalCore): CapturedFrame {
+  const cols = core.getCols()
+  const rows = core.getRows()
+  const lines = Array.from({ length: rows }, (_, row) => {
+    const spans: CapturedSpan[] = []
+    for (let col = 0; col < cols; ) {
+      const cell = core.getCell(row, col)
+      const text = String.fromCodePoint(cell.char || 32)
+      const width = Math.min(characterWidth(text), cols - col)
+      const next = {
+        text,
+        width,
+        fg: cell.fgRgb ?? DefaultForeground,
+        bg: cell.bgRgb ?? DefaultBackground,
+        attributes: cell.flags,
+      }
+      const previous = spans.at(-1)
+      if (
+        previous &&
+        previous.fg === next.fg &&
+        previous.bg === next.bg &&
+        previous.attributes === next.attributes
+      ) {
+        previous.text += next.text
+        previous.width += width
+      } else {
+        spans.push(next)
+      }
+      col += width
+    }
+    return { spans }
+  })
+  return { cols, rows, cursor: core.getCursor(), lines }
+}
+
+class GhosttyTerminal implements TerminalParser {
+  private synchronized = false
+  private stable?: CapturedFrame
+  private pending = Buffer.alloc(0)
+
+  constructor(private readonly core: TerminalCore) {}
+
+  write(data: Uint8Array) {
+    const input = this.pending.length ? Buffer.concat([this.pending, data]) : Buffer.from(data)
+    this.pending = Buffer.alloc(0)
+    let offset = 0
+    while (offset < input.length) {
+      const start = input.indexOf(SyncStart, offset)
+      const end = input.indexOf(SyncEnd, offset)
+      const marker = start === -1 ? end : end === -1 ? start : Math.min(start, end)
+      if (marker === -1) {
+        const keep = partialMarkerLength(input.subarray(offset))
+        const boundary = input.length - keep
+        if (boundary > offset) this.core.writeRaw(input.subarray(offset, boundary))
+        if (keep) this.pending = input.subarray(boundary)
+        return
+      }
+      if (marker > offset) this.core.writeRaw(input.subarray(offset, marker))
+      if (marker === start) {
+        if (!this.synchronized) this.stable = capture(this.core)
+        this.synchronized = true
+        this.core.writeRaw(SyncStart)
+        offset = marker + SyncStart.length
+      } else {
+        this.core.writeRaw(SyncEnd)
+        this.synchronized = false
+        this.stable = undefined
+        offset = marker + SyncEnd.length
+      }
+    }
+  }
+
+  finish() {
+    if (!this.pending.length) return
+    this.core.writeRaw(this.pending)
+    this.pending = Buffer.alloc(0)
+  }
+
+  resize(cols: number, rows: number) {
+    this.core.resize(cols, rows)
+    if (this.synchronized) this.stable = capture(this.core)
+  }
+
+  snapshot() {
+    return this.synchronized && this.stable ? structuredClone(this.stable) : capture(this.core)
+  }
+}
+
+function partialMarkerLength(input: Uint8Array) {
+  const limit = Math.min(input.length, Math.max(SyncStart.length, SyncEnd.length) - 1)
+  for (let length = limit; length > 0; length--) {
+    const suffix = input.subarray(input.length - length)
+    if (SyncStart.subarray(0, length).equals(suffix) || SyncEnd.subarray(0, length).equals(suffix)) return length
+  }
+  return 0
+}
+
+export const createTerminalParser: TerminalParserFactory = async (cols, rows) => {
+  const core: TerminalCore = await GhosttyCore.load()
+  core.init(cols, rows)
+  return new GhosttyTerminal(core)
+}

package/src/recording/types.ts

@@ -0,0 +1,50 @@
+export const TextStyle = {
+  bold: 1,
+  dim: 2,
+  italic: 4,
+  underline: 8,
+  blink: 16,
+  inverse: 32,
+  invisible: 64,
+  strikethrough: 128,
+} as const
+
+export interface CapturedSpan {
+  text: string
+  width: number
+  fg: number
+  bg: number
+  attributes: number
+}
+
+export interface CapturedLine {
+  spans: CapturedSpan[]
+}
+
+export interface CapturedFrame {
+  cols: number
+  rows: number
+  cursor: { row: number; col: number; visible: boolean }
+  lines: CapturedLine[]
+}
+
+export interface SampledFrame {
+  atMs: number
+  frame: CapturedFrame
+}
+
+export interface TimelineHeader {
+  type: "header"
+  version: 1
+  cols: number
+  rows: number
+  encoding: "base64"
+}
+
+export interface TimelineOutput {
+  type: "output"
+  at_ms: number
+  data: string
+}
+
+export type TimelineRecord = TimelineHeader | TimelineOutput

package/src/experimental/reproduce-stale-running-visible.ts

@@ -1,60 +0,0 @@
-import path from "node:path"
-
-const root = "/tmp/opencode-probe-stale-running-visible"
-const state = path.join(root, "state", "files")
-await Bun.$`rm -rf ${root}`.quiet()
-await Bun.$`mkdir -p ${path.join(state, ".config/opencode")} ${path.join(state, "src")}`.quiet()
-
-const config = {
-  model: "simulation/sim-model",
-  permissions: [{ action: "*", resource: "*", effect: "allow" }],
-  providers: {
-    simulation: {
-      name: "Simulation",
-      request: { body: { apiKey: "sim-key" } },
-      models: {
-        "sim-model": {
-          name: "Simulated Model",
-          api: { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://api.openai.com/v1" },
-          capabilities: { tools: true, input: ["text"], output: ["text"] },
-          limit: { context: 128000, output: 16000 },
-        },
-      },
-    },
-  },
-}
-
-await Promise.all([
-  Bun.write(path.join(state, "opencode.json"), `${JSON.stringify(config, undefined, 2)}\n`),
-  Bun.write(path.join(state, ".config/opencode/opencode.json"), `${JSON.stringify(config, undefined, 2)}\n`),
-  Bun.write(path.join(state, "src/example.ts"), "export const example = true\n"),
-])
-
-const child = Bun.spawn([
-  path.resolve("bin/opencode-sim"),
-  "--state", path.join(root, "state"),
-  "--anchor", path.join(root, "anchor"),
-  "--renderer", "visible",
-  "--driver", `bun ${path.resolve("src/experimental/stale-running-driver.ts")}`,
-  "--",
-  "bun", "run", "--conditions=browser", "--preload=@opentui/solid/preload",
-  "/root/projects/opencode-latest/packages/cli/src/index.ts",
-], {
-  cwd: path.resolve("."),
-  env: {
-    ...processEnv(),
-    OPENCODE_SIMULATION_DRIVER_LOG: path.join(root, "driver.log"),
-    OPENCODE_SIMULATION_LOG: path.join(root, "simulation.log"),
-  },
-  stdin: "inherit",
-  stdout: "inherit",
-  stderr: "inherit",
-})
-
-const status = await child.exited
-if (status !== 0) throw new Error(`visible reproduction failed; see ${path.join(root, "driver.log")}`)
-console.log(`Reproduction artifacts: ${root}`)
-
-function processEnv(): Record<string, string> {
-  return Object.fromEntries(Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined))
-}

package/src/experimental/reproduce-stale-running.ts

@@ -1,26 +0,0 @@
-const child = Bun.spawn([
-  "bun",
-  "test",
-  "test/cli/tui/data.test.tsx",
-  "--test-name-pattern",
-  "clears stale running status after reconnect",
-], {
-  cwd: "/root/projects/opencode-latest/packages/tui",
-  stdout: "pipe",
-  stderr: "pipe",
-})
-
-const [status, stdout, stderr] = await Promise.all([
-  child.exited,
-  new Response(child.stdout).text(),
-  new Response(child.stderr).text(),
-])
-const output = `${stdout}${stderr}`
-process.stdout.write(output)
-
-if (status !== 0 && output.includes('Expected: "idle"') && output.includes('Received: "running"')) {
-  console.log("\nREPRODUCED: reconnect left an inactive session stuck in the running UI state.")
-  process.exit(0)
-}
-
-throw new Error(`reproduction did not produce the expected stale-running failure (test exit ${status})`)

package/src/experimental/stale-running-driver.ts

@@ -1,106 +0,0 @@
-import {
-  connectBackendSimulation,
-  connectSimulation,
-  type OpenedExchange,
-} from "../client/index.js"
-import { isRunning } from "./flows/index.js"
-
-const ui = await connectSimulation({
-  url: requiredEnv("OPENCODE_SIMULATION_UI_WS"),
-})
-const backend = await connectBackendSimulation({
-  url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS"),
-})
-const requestOpened = deferred()
-const releaseResponse = deferred()
-const responseFinished = deferred()
-
-await backend.attach(async (request: OpenedExchange) => {
-  if (isTitleRequest(request)) {
-    await backend.chunk(request.id, [
-      { type: "textDelta", text: "Stale running reproduction" },
-    ])
-    await backend.finish(request.id, "stop")
-    return
-  }
-  requestOpened.resolve()
-  await backend.chunk(request.id, [
-    {
-      type: "textDelta",
-      text: "The provider turn is finishing while events are disconnected.",
-    },
-  ])
-  await releaseResponse.promise
-  await backend.finish(request.id, "stop")
-  responseFinished.resolve()
-})
-
-try {
-  await waitFor("prompt editor", async () => (await ui.state()).focused.editor)
-  await ui.typeText(
-    "Reproduce stale running status across an event-stream reconnect",
-  )
-  await ui.pressEnter()
-  await requestOpened.promise
-  await waitFor("running TUI", async () => isRunning(await ui.state()))
-
-  releaseResponse.resolve()
-  await responseFinished.promise
-  await Bun.sleep(1_000)
-
-  const state = await ui.state()
-  if (!isRunning(state))
-    throw new Error("stale running status was not reproduced")
-  console.log(
-    "REPRODUCED: backend provider work is idle while the TUI still displays running.",
-  )
-  await Bun.sleep(Number(process.env.OPENCODE_PROBE_HOLD_MS ?? "10000"))
-} finally {
-  ui.close()
-  backend.close()
-}
-
-function deferred() {
-  let resolve!: () => void
-  const promise = new Promise<void>((done) => {
-    resolve = done
-  })
-  return { promise, resolve }
-}
-
-function requiredEnv(name: string) {
-  const value = process.env[name]
-  if (value === undefined) throw new Error(`${name} is required`)
-  return value
-}
-
-function isTitleRequest(request: OpenedExchange) {
-  if (
-    typeof request.body !== "object" ||
-    request.body === null ||
-    !("messages" in request.body)
-  )
-    return false
-  const messages = request.body.messages
-  if (!Array.isArray(messages)) return false
-  const first = messages[0]
-  if (typeof first !== "object" || first === null || !("content" in first))
-    return false
-  return (
-    typeof first.content === "string" &&
-    first.content.includes("You are a title generator")
-  )
-}
-
-async function waitFor(
-  label: string,
-  check: () => Promise<boolean>,
-  timeout = 30_000,
-) {
-  const deadline = Date.now() + timeout
-  while (Date.now() < deadline) {
-    if (await check()) return
-    await Bun.sleep(50)
-  }
-  throw new Error(`timed out waiting for ${label}`)
-}