opencode-drive 0.1.6 → 0.1.8

package/src/cli/stop.ts

@@ -1,10 +1,12 @@
-import { request } from "./control.js"
+import { requestStop } from "./control.js"
 import { manifestPath, resolveInstance } from "./registry.js"
 
 export async function stop(name?: string) {
   const manifest = await resolveInstance(name)
-  await request(manifest.control, "stop")
-  const deadline = Date.now() + 10_000
+  const result = await requestStop(manifest.control, (percent) => {
+    console.error(`Rendering video: ${percent}%`)
+  })
+  const deadline = Date.now() + 5 * 60_000
   while (Date.now() < deadline) {
     const current: unknown = await Bun.file(manifestPath(manifest.name))
       .json()
@@ -15,7 +17,12 @@ export async function stop(name?: string) {
       !("pid" in current) ||
       current.pid !== manifest.pid
     ) {
-      console.log("success")
+      for (const screenshot of result.screenshots) console.log(screenshot)
+      if (result.recording) {
+        console.error(`Video successfully created: ${result.recording}`)
+      } else if (result.screenshots.length === 0) {
+        console.log("success")
+      }
       return
     }
     await Bun.sleep(25)

package/src/cli/types.ts

@@ -9,6 +9,7 @@ export interface StartOptions {
   readonly daemon: boolean
   readonly script?: string
   readonly visible: boolean
+  readonly record: boolean
   readonly dev?: string
   readonly state?: string
   readonly command: ReadonlyArray<string>

package/src/client/client.ts

@@ -4,20 +4,16 @@ const defaultPort = 40900
 
 type Methods = {
   readonly "ui.screenshot": {
-    readonly params: undefined
+    readonly params: Frontend.ScreenshotParams | undefined
     readonly result: Frontend.Screenshot
   }
   readonly "ui.state": {
     readonly params: undefined
     readonly result: Frontend.State
   }
-  readonly "ui.start-record": {
-    readonly params: undefined
-    readonly result: Frontend.StartRecord
-  }
-  readonly "ui.end-record": {
+  readonly "ui.recording.finish": {
     readonly params: undefined
-    readonly result: Frontend.EndRecord
+    readonly result: Frontend.RecordingFinish
   }
   readonly "ui.type": {
     readonly params: Frontend.TypeParams
@@ -69,6 +65,7 @@ export interface SimulationClientOptions {
   readonly portAttempts?: number
   /** Per-call timeout in milliseconds. Defaults to 30_000. */
   readonly timeout?: number
+  readonly onScreenshot?: (path: string) => void
 }
 
 export class SimulationError extends Error {
@@ -93,13 +90,20 @@ export class SimulationClient {
 
   private readonly socket: WebSocket
   private readonly timeout: number
+  private readonly onScreenshot?: (path: string) => void
   private nextId = 1
   private readonly pending = new Map<number, Waiter>()
 
-  private constructor(socket: WebSocket, url: string, timeout: number) {
+  private constructor(
+    socket: WebSocket,
+    url: string,
+    timeout: number,
+    onScreenshot?: (path: string) => void,
+  ) {
     this.socket = socket
     this.url = url
     this.timeout = timeout
+    this.onScreenshot = onScreenshot
     socket.addEventListener("message", (event) =>
       this.onMessage(String(event.data)),
     )
@@ -116,14 +120,24 @@ export class SimulationClient {
   ): Promise<SimulationClient> {
     const timeout = options?.timeout ?? 30_000
     if (options?.url !== undefined) {
-      return new SimulationClient(await open(options.url), options.url, timeout)
+      return new SimulationClient(
+        await open(options.url),
+        options.url,
+        timeout,
+        options.onScreenshot,
+      )
     }
     const first = options?.port ?? defaultPort
     const attempts = options?.portAttempts ?? 10
     for (let offset = 0; offset < attempts; offset++) {
       const url = `ws://127.0.0.1:${first + offset}`
       try {
-        return new SimulationClient(await open(url), url, timeout)
+        return new SimulationClient(
+          await open(url),
+          url,
+          timeout,
+          options?.onScreenshot,
+        )
       } catch {
         // occupied by something else or nothing listening; try the next port
       }
@@ -170,16 +184,17 @@ export class SimulationClient {
     return this.call("ui.state")
   }
 
-  screenshot(): Promise<Frontend.Screenshot> {
-    return this.call("ui.screenshot")
-  }
-
-  startRecord(): Promise<Frontend.StartRecord> {
-    return this.call("ui.start-record")
+  async screenshot(name?: string): Promise<Frontend.Screenshot> {
+    const path = await this.call(
+      "ui.screenshot",
+      name === undefined ? undefined : { name },
+    )
+    this.onScreenshot?.(path)
+    return path
   }
 
-  endRecord(): Promise<Frontend.EndRecord> {
-    return this.call("ui.end-record")
+  finishRecording(): Promise<Frontend.RecordingFinish> {
+    return this.call("ui.recording.finish")
   }
 
   /** Executes one user-level action and returns the post-action state. */

package/src/client/protocol.ts

@@ -111,11 +111,14 @@ export namespace Frontend {
   export const Screenshot = Schema.String
   export type Screenshot = Schema.Schema.Type<typeof Screenshot>
 
-  export const StartRecord = Schema.Struct({ recording: Schema.Literal(true) })
-  export interface StartRecord extends Schema.Schema.Type<typeof StartRecord> {}
+  export const RecordingFinish = Schema.String
+  export type RecordingFinish = Schema.Schema.Type<typeof RecordingFinish>
 
-  export const EndRecord = Schema.String
-  export type EndRecord = Schema.Schema.Type<typeof EndRecord>
+  export const ScreenshotParams = Schema.Struct({
+    name: Schema.optional(Schema.String),
+  })
+  export interface ScreenshotParams
+    extends Schema.Schema.Type<typeof ScreenshotParams> {}
 
   export const TypeParams = Schema.Struct({ text: Schema.String })
   export interface TypeParams extends Schema.Schema.Type<typeof TypeParams> {}
@@ -169,13 +172,12 @@ export namespace Frontend {
     }),
     Schema.Struct({
       ...JsonRpc.RequestFields,
-      method: Schema.Literals([
-        "ui.enter",
-        "ui.screenshot",
-        "ui.state",
-        "ui.start-record",
-        "ui.end-record",
-      ]),
+      method: Schema.Literal("ui.screenshot"),
+      params: Schema.optional(ScreenshotParams),
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literals(["ui.enter", "ui.state", "ui.recording.finish"]),
     }),
   ])
   export type Request = Schema.Schema.Type<typeof Request>

package/src/experimental/reproduce-stale-exploring-empty.ts

@@ -0,0 +1,102 @@
+import { join } from "node:path"
+import { defineScript } from "../index.js"
+
+export default defineScript(async ({ artifacts, backend, ui }) => {
+  const completed = Array.from({ length: 3 }, () => Promise.withResolvers<void>())
+  let turn = 0
+
+  await backend.attach(async (request) => {
+    if (isTitleRequest(request.body)) {
+      await backend.chunk(request.id, [{ type: "textDelta", text: "Stale exploring reproduction" }])
+      await backend.finish(request.id)
+      return
+    }
+    const current = turn++
+    if (current === 0) {
+      await backend.chunk(request.id, [
+        {
+          type: "toolCall",
+          index: 0,
+          id: "call_read",
+          name: "read",
+          input: { filePath: join(artifacts, "state", "files", "src", "garden.js") },
+        },
+      ])
+      await backend.finish(request.id, "tool-calls")
+      return
+    }
+    if (current === 1) {
+      await backend.finish(request.id, "tool-calls")
+      completed[0]?.resolve()
+      return
+    }
+    const response = current === 2 ? "The file exports a small greeting function." : "Confirmed again with no more tools."
+    await backend.chunk(request.id, [{ type: "textDelta", text: response }])
+    await backend.finish(request.id)
+    completed[current - 1]?.resolve()
+  })
+
+  const prompts = [
+    "Read src/garden.js, then tell me what it contains.",
+    "Now inspect that file one more time.",
+    "Finally, verify the same file again.",
+  ]
+  for (const [index, prompt] of prompts.entries()) {
+    if (index === 0) await ui.typeText(prompt)
+    else await typeSlowly(ui, prompt)
+    await ui.pressEnter()
+    await withTimeout(
+      completed[index]!.promise,
+      30_000,
+      `timed out waiting for empty continuation ${index + 1}`,
+    )
+    await waitForEditor(ui)
+    await Bun.sleep(500)
+    await ui.screenshot(`stale-exploring-${index + 1}`)
+  }
+})
+
+async function withTimeout(promise: Promise<void>, timeout: number, message: string) {
+  const expired = Promise.withResolvers<never>()
+  const timer = setTimeout(() => expired.reject(new Error(message)), timeout)
+  try {
+    await Promise.race([promise, expired.promise])
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+async function typeSlowly(
+  ui: Parameters<Parameters<typeof defineScript>[0]>[0]["ui"],
+  text: string,
+) {
+  for (const char of text) {
+    await ui.typeText(char)
+    await Bun.sleep(55)
+  }
+}
+
+async function waitForEditor(
+  ui: Parameters<Parameters<typeof defineScript>[0]>[0]["ui"],
+) {
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    if ((await ui.state()).focused.editor) return
+    await Bun.sleep(50)
+  }
+  throw new Error("timed out waiting for the session to become idle")
+}
+
+function isTitleRequest(body: unknown) {
+  if (typeof body !== "object" || body === null || !("messages" in body)) return false
+  const messages = body.messages
+  if (!Array.isArray(messages)) return false
+  return messages.some(
+    (message) =>
+      typeof message === "object" &&
+      message !== null &&
+      "content" in message &&
+      typeof message.content === "string" &&
+      message.content.includes("You are a title generator"),
+  )
+}

package/src/recording/decode.ts

@@ -0,0 +1,93 @@
+import { createReadStream } from "node:fs"
+import type { TimelineHeader, TimelineOutput, TimelineRecord } from "./types.js"
+
+function fail(line: number, message: string): never {
+  throw new Error(`Invalid recording timeline at line ${line}: ${message}`)
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function hasExactKeys(value: Record<string, unknown>, expected: string[]) {
+  const actual = Object.keys(value).sort()
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index])
+}
+
+function positiveInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+}
+
+function nonnegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+}
+
+function canonicalBase64(value: string) {
+  if (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+    return false
+  }
+  return Buffer.from(value, "base64").toString("base64") === value
+}
+
+function parseRecord(text: string, line: number, first: boolean, previousAt: number): TimelineRecord {
+  let value: unknown
+  try {
+    value = JSON.parse(text)
+  } catch {
+    fail(line, "line is not valid JSON")
+  }
+  if (!isObject(value)) fail(line, "record must be an object")
+
+  if (first) {
+    if (!hasExactKeys(value, ["cols", "encoding", "rows", "type", "version"])) fail(line, "invalid header fields")
+    if (value.type !== "header" || value.version !== 1 || value.encoding !== "base64") {
+      fail(line, "unsupported or missing header")
+    }
+    if (!positiveInteger(value.cols) || !positiveInteger(value.rows)) fail(line, "cols and rows must be positive integers")
+    return { type: "header", version: 1, cols: value.cols, rows: value.rows, encoding: "base64" } satisfies TimelineHeader
+  }
+
+  if (!hasExactKeys(value, ["at_ms", "data", "type"]) || value.type !== "output") fail(line, "invalid output fields")
+  if (!nonnegativeInteger(value.at_ms)) fail(line, "at_ms must be a nonnegative integer")
+  if (value.at_ms < previousAt) fail(line, "output timestamps must be nondecreasing")
+  if (typeof value.data !== "string" || !canonicalBase64(value.data)) fail(line, "data must be canonical base64")
+  return { type: "output", at_ms: value.at_ms, data: value.data } satisfies TimelineOutput
+}
+
+/** Decodes and validates a timeline without loading the complete file into memory. */
+export async function* decodeTimeline(path: string): AsyncGenerator<TimelineRecord> {
+  const decoder = new TextDecoder("utf-8", { fatal: true })
+  let buffered = ""
+  let line = 0
+  let records = 0
+  let previousAt = -1
+
+  const consume = (raw: string) => {
+    line++
+    const text = raw.endsWith("\r") ? raw.slice(0, -1) : raw
+    if (text.length === 0) fail(line, "empty lines are not allowed")
+    const record = parseRecord(text, line, records === 0, previousAt)
+    records++
+    if (record.type === "output") previousAt = record.at_ms
+    return record
+  }
+
+  try {
+    for await (const chunk of createReadStream(path)) {
+      buffered += decoder.decode(chunk, { stream: true })
+      let newline: number
+      while ((newline = buffered.indexOf("\n")) !== -1) {
+        const raw = buffered.slice(0, newline)
+        buffered = buffered.slice(newline + 1)
+        yield consume(raw)
+      }
+    }
+    buffered += decoder.decode()
+  } catch (error) {
+    if (error instanceof TypeError) fail(line + 1, "file is not valid UTF-8")
+    throw error
+  }
+
+  if (buffered.length > 0) yield consume(buffered)
+  if (records === 0) fail(1, "missing header")
+}

package/src/recording/export.ts

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process"
+import { createHash } from "node:crypto"
+import { copyFile, link, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { dirname, extname, join } from "node:path"
+import { replayRecording, type ReplayOptions } from "./replay.js"
+import { renderFrame } from "./render.js"
+
+export interface ExportRecordingOptions extends ReplayOptions {
+  ffmpegPath?: string
+  onProgress?: (percent: number) => void
+}
+
+export interface ExportRecordingResult {
+  frames: number
+  durationMs: number
+  width: number
+  height: number
+}
+
+function run(command: string, args: string[]) {
+  return new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] })
+    let stderr = ""
+    child.stderr.setEncoding("utf8")
+    child.stderr.on("data", (chunk: string) => (stderr += chunk))
+    child.on("error", reject)
+    child.on("close", (code) => {
+      if (code === 0) resolve()
+      else reject(new Error(`ffmpeg exited with code ${code}: ${stderr.trim()}`))
+    })
+  })
+}
+
+async function linkOrCopy(source: string, destination: string) {
+  try {
+    await link(source, destination)
+  } catch {
+    await copyFile(source, destination)
+  }
+}
+
+export async function exportRecording(
+  timelinePath: string,
+  outputPath: string,
+  options: ExportRecordingOptions = {},
+): Promise<ExportRecordingResult> {
+  const frames = await replayRecording(timelinePath, options)
+  const final = frames.at(-1)!
+  const extension = extname(outputPath).toLowerCase()
+  const progress = progressReporter(options.onProgress)
+  await mkdir(dirname(outputPath), { recursive: true })
+
+  if (extension === ".png") {
+    await writeFile(outputPath, renderFrame(final.frame))
+    progress(100)
+  } else if (extension === ".mp4") {
+    const directory = await mkdtemp(join(tmpdir(), "opencode-drive-recording-"))
+    try {
+      const unique = new Map<string, string>()
+      for (const [index, sample] of frames.entries()) {
+        const hash = createHash("sha256").update(JSON.stringify(sample.frame)).digest("hex")
+        let rendered = unique.get(hash)
+        if (!rendered) {
+          rendered = join(directory, `unique-${hash}.png`)
+          await writeFile(rendered, renderFrame(sample.frame))
+          unique.set(hash, rendered)
+        }
+        await linkOrCopy(rendered, join(directory, `frame-${String(index).padStart(8, "0")}.png`))
+        progress(((index + 1) / frames.length) * 90)
+      }
+      await run(options.ffmpegPath ?? "ffmpeg", [
+        "-y",
+        "-framerate",
+        String(options.fps ?? 20),
+        "-i",
+        join(directory, "frame-%08d.png"),
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        "-movflags",
+        "+faststart",
+        "-t",
+        String(Math.max(final.atMs, 1000 / (options.fps ?? 20)) / 1000),
+        outputPath,
+      ])
+      progress(100)
+    } finally {
+      await rm(directory, { recursive: true, force: true })
+    }
+  } else {
+    throw new Error(`Unsupported recording output extension: ${extension || "(none)"}`)
+  }
+
+  return {
+    frames: frames.length,
+    durationMs: final.atMs,
+    width: final.frame.cols * 10,
+    height: final.frame.rows * 20,
+  }
+}
+
+function progressReporter(onProgress?: (percent: number) => void) {
+  let reported = 0
+  return (percent: number) => {
+    const target = Math.min(100, Math.floor(percent / 10) * 10)
+    while (reported < target) {
+      reported += 10
+      onProgress?.(reported)
+    }
+  }
+}

package/src/recording/index.ts

@@ -0,0 +1,13 @@
+export { decodeTimeline } from "./decode.js"
+export { exportRecording, type ExportRecordingOptions, type ExportRecordingResult } from "./export.js"
+export { renderFrame } from "./render.js"
+export { replayRecording, type ReplayOptions } from "./replay.js"
+export type {
+  CapturedFrame,
+  CapturedLine,
+  CapturedSpan,
+  SampledFrame,
+  TimelineHeader,
+  TimelineOutput,
+  TimelineRecord,
+} from "./types.js"

package/src/recording/render.ts

@@ -0,0 +1,80 @@
+import { fileURLToPath } from "node:url"
+import { GlobalFonts, createCanvas } from "@napi-rs/canvas"
+import { TextStyle, type CapturedFrame } from "./types.js"
+
+const CellWidth = 10
+const CellHeight = 20
+const FontSize = 16
+const FontFamily = "OpenCode Mono"
+
+for (const file of [
+  "adwaita-mono-latin-400-normal.woff2",
+  "adwaita-mono-latin-700-normal.woff2",
+  "adwaita-mono-latin-400-italic.woff2",
+  "adwaita-mono-latin-700-italic.woff2",
+]) {
+  GlobalFonts.registerFromPath(
+    fileURLToPath(import.meta.resolve(`@fontsource/adwaita-mono/files/${file}`)),
+    FontFamily,
+  )
+}
+
+function color(rgb: number, alpha = 1) {
+  return `rgba(${(rgb >> 16) & 255}, ${(rgb >> 8) & 255}, ${rgb & 255}, ${alpha})`
+}
+
+export function renderFrame(frame: CapturedFrame): Buffer {
+  const canvas = createCanvas(frame.cols * CellWidth, frame.rows * CellHeight)
+  const context = canvas.getContext("2d")
+  context.fillStyle = "#080808"
+  context.fillRect(0, 0, canvas.width, canvas.height)
+  context.textBaseline = "top"
+
+  frame.lines.forEach((line, row) => {
+    let column = 0
+    for (const span of line.spans) {
+      const inverse = Boolean(span.attributes & TextStyle.inverse)
+      const hidden = Boolean(span.attributes & TextStyle.invisible)
+      const foreground = inverse ? span.bg : span.fg
+      const background = inverse ? span.fg : span.bg
+      let remaining = span.width
+      for (const char of span.text) {
+        const cells = Math.min(Math.max(1, Bun.stringWidth(char)), remaining)
+        context.fillStyle = color(background)
+        context.fillRect(column * CellWidth, row * CellHeight, cells * CellWidth, CellHeight)
+        if (!hidden) {
+          const italic = span.attributes & TextStyle.italic ? "italic " : ""
+          const weight = span.attributes & TextStyle.bold ? "700 " : "400 "
+          context.font = `${italic}${weight}${FontSize}px "${FontFamily}"`
+          context.fillStyle = color(foreground, span.attributes & TextStyle.dim ? 0.55 : 1)
+          context.fillText(char, column * CellWidth, row * CellHeight + 1)
+          if (span.attributes & TextStyle.underline) {
+            context.fillRect(column * CellWidth, row * CellHeight + 17, cells * CellWidth, 1)
+          }
+          if (span.attributes & TextStyle.strikethrough) {
+            context.fillRect(column * CellWidth, row * CellHeight + 10, cells * CellWidth, 1)
+          }
+        }
+        column += cells
+        remaining -= cells
+      }
+      if (remaining > 0) {
+        context.fillStyle = color(background)
+        context.fillRect(column * CellWidth, row * CellHeight, remaining * CellWidth, CellHeight)
+        column += remaining
+      }
+    }
+  })
+
+  if (frame.cursor.visible && frame.cursor.row >= 0 && frame.cursor.row < frame.rows) {
+    context.strokeStyle = "#d8d8d8"
+    context.lineWidth = 2
+    context.strokeRect(
+      frame.cursor.col * CellWidth + 1,
+      frame.cursor.row * CellHeight + 1,
+      CellWidth - 2,
+      CellHeight - 2,
+    )
+  }
+  return canvas.toBuffer("image/png")
+}

package/src/recording/replay.ts

@@ -0,0 +1,55 @@
+import { decodeTimeline } from "./decode.js"
+import { createTerminalParser, type TerminalParserFactory } from "./terminal.js"
+import type { SampledFrame, TimelineHeader } from "./types.js"
+
+export interface ReplayOptions {
+  fps?: number
+}
+
+interface InternalReplayOptions extends ReplayOptions {
+  terminalFactory?: TerminalParserFactory
+}
+
+function sampleInterval(fps: number) {
+  if (!Number.isFinite(fps) || fps <= 0) throw new Error("fps must be a positive finite number")
+  return 1000 / fps
+}
+
+export async function replayRecording(path: string, options: ReplayOptions = {}): Promise<SampledFrame[]> {
+  return replay(path, options)
+}
+
+export async function replay(path: string, options: InternalReplayOptions = {}): Promise<SampledFrame[]> {
+  const interval = sampleInterval(options.fps ?? 20)
+  const records = decodeTimeline(path)[Symbol.asyncIterator]()
+  const first = await records.next()
+  if (first.done || first.value.type !== "header") throw new Error("Recording timeline is missing its header")
+  const header: TimelineHeader = first.value
+  const terminal = await (options.terminalFactory ?? createTerminalParser)(header.cols, header.rows)
+  const frames: SampledFrame[] = []
+  let nextSample = 0
+  let finalAt = 0
+
+  for (;;) {
+    const next = await records.next()
+    if (next.done) break
+    const event = next.value
+    if (event.type !== "output") throw new Error("Recording timeline contains a second header")
+    while (nextSample < event.at_ms) {
+      frames.push({ atMs: nextSample, frame: terminal.snapshot() })
+      nextSample += interval
+    }
+    terminal.write(Buffer.from(event.data, "base64"))
+    finalAt = event.at_ms
+  }
+  terminal.finish()
+
+  while (nextSample <= finalAt) {
+    frames.push({ atMs: nextSample, frame: terminal.snapshot() })
+    nextSample += interval
+  }
+  if (frames.length === 0 || frames.at(-1)!.atMs !== finalAt) {
+    frames.push({ atMs: finalAt, frame: terminal.snapshot() })
+  }
+  return frames
+}