opencode-drive 0.1.1 → 0.1.3

package/src/client/backend.ts

@@ -1,17 +1,25 @@
-import {
-  Backend,
-  type JsonRpc,
-} from "./protocol.js"
+import { Backend, type JsonRpc } from "./protocol.js"
 
 const defaultBackendPort = 40950
 
 type BackendMethods = {
-  readonly "llm.attach": { readonly params: undefined; readonly result: { readonly attached: true } }
-  readonly "llm.chunk": { readonly params: Backend.ChunkParams; readonly result: { readonly ok: true } }
-  readonly "llm.finish": { readonly params: Partial<Backend.FinishParams> & Pick<Backend.FinishParams, "id">; readonly result: { readonly ok: true } }
-  readonly "llm.disconnect": { readonly params: Backend.DisconnectParams; readonly result: { readonly ok: true } }
-  readonly "llm.pending": { readonly params: undefined; readonly result: { readonly exchanges: ReadonlyArray<Backend.OpenedExchange> } }
-  readonly "network.log": { readonly params: undefined; readonly result: { readonly entries: ReadonlyArray<Backend.NetworkLogEntry> } }
+  readonly "llm.attach": {
+    readonly params: undefined
+    readonly result: { readonly attached: true }
+  }
+  readonly "llm.chunk": {
+    readonly params: Backend.ChunkParams
+    readonly result: { readonly ok: true }
+  }
+  readonly "llm.finish": {
+    readonly params: Partial<Backend.FinishParams> &
+      Pick<Backend.FinishParams, "id">
+    readonly result: { readonly ok: true }
+  }
+  readonly "llm.disconnect": {
+    readonly params: Backend.DisconnectParams
+    readonly result: { readonly ok: true }
+  }
 }
 
 type BackendMethodName = keyof BackendMethods
@@ -46,21 +54,37 @@ export class BackendSimulationClient {
   private readonly socket: WebSocket
   private readonly timeout: number
   private nextId = 1
+  private closing = false
   private readonly pending = new Map<number, Waiter>()
-  private readonly llmRequests = new Set<(request: Backend.OpenedExchange) => void>()
+  private readonly llmRequests = new Set<
+    (request: Backend.OpenedExchange) => void
+  >()
 
   private constructor(socket: WebSocket, url: string, timeout: number) {
     this.socket = socket
     this.url = url
     this.timeout = timeout
-    socket.addEventListener("message", (event) => this.onMessage(String(event.data)))
-    socket.addEventListener("close", () => this.rejectAll(new BackendSimulationError("connection closed")))
-    socket.addEventListener("error", () => this.rejectAll(new BackendSimulationError("connection error")))
+    socket.addEventListener("message", (event) =>
+      this.onMessage(String(event.data)),
+    )
+    socket.addEventListener("close", () =>
+      this.rejectAll(new BackendSimulationError("connection closed")),
+    )
+    socket.addEventListener("error", () =>
+      this.rejectAll(new BackendSimulationError("connection error")),
+    )
   }
 
-  static async connect(options?: BackendSimulationClientOptions): Promise<BackendSimulationClient> {
+  static async connect(
+    options?: BackendSimulationClientOptions,
+  ): Promise<BackendSimulationClient> {
     const timeout = options?.timeout ?? 30_000
-    if (options?.url !== undefined) return new BackendSimulationClient(await open(options.url), options.url, timeout)
+    if (options?.url !== undefined)
+      return new BackendSimulationClient(
+        await open(options.url),
+        options.url,
+        timeout,
+      )
     const first = options?.port ?? defaultBackendPort
     const attempts = options?.portAttempts ?? 10
     for (let offset = 0; offset < attempts; offset++) {
@@ -69,28 +93,52 @@ export class BackendSimulationClient {
         return new BackendSimulationClient(await open(url), url, timeout)
       } catch {}
     }
-    throw new BackendSimulationError(`no backend simulation server found on ports ${first}-${first + attempts - 1}`)
+    throw new BackendSimulationError(
+      `no backend simulation server found on ports ${first}-${first + attempts - 1}`,
+    )
   }
 
   async call<M extends BackendMethodName>(
     method: M,
     params?: BackendMethods[M]["params"],
   ): Promise<BackendMethods[M]["result"]> {
-    if (this.socket.readyState !== WebSocket.OPEN) throw new BackendSimulationError("connection is not open", method)
+    if (this.socket.readyState !== WebSocket.OPEN)
+      throw new BackendSimulationError("connection is not open", method)
     const id = this.nextId++
     const promise = new Promise<unknown>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id)
-        reject(new BackendSimulationError(`timed out after ${this.timeout}ms`, method))
+        reject(
+          new BackendSimulationError(
+            `timed out after ${this.timeout}ms`,
+            method,
+          ),
+        )
       }, this.timeout)
       this.pending.set(id, { method, resolve, reject, timer })
     })
-    this.socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, ...(params === undefined ? {} : { params }) }))
+    this.socket.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...(params === undefined ? {} : { params }),
+      }),
+    )
     return (await promise) as BackendMethods[M]["result"]
   }
 
-  async attach(onRequest: (request: Backend.OpenedExchange) => void | Promise<void>) {
-    this.llmRequests.add((request) => void onRequest(request))
+  async attach(
+    onRequest: (request: Backend.OpenedExchange) => void | Promise<void>,
+  ) {
+    this.llmRequests.add((request) => {
+      void Promise.resolve(onRequest(request)).catch((error) => {
+        if (!this.closing)
+          console.error(
+            `error: ${error instanceof Error ? error.message : String(error)}`,
+          )
+      })
+    })
     return await this.call("llm.attach")
   }
 
@@ -99,22 +147,18 @@ export class BackendSimulationClient {
   }
 
   finish(id: string, reason?: Backend.FinishReason) {
-    return this.call("llm.finish", { id, ...(reason === undefined ? {} : { reason }) })
+    return this.call("llm.finish", {
+      id,
+      ...(reason === undefined ? {} : { reason }),
+    })
   }
 
   disconnect(id: string) {
     return this.call("llm.disconnect", { id })
   }
 
-  pendingExchanges() {
-    return this.call("llm.pending")
-  }
-
-  networkLog(): Promise<{ readonly entries: ReadonlyArray<Backend.NetworkLogEntry> }> {
-    return this.call("network.log")
-  }
-
   close() {
+    this.closing = true
     this.socket.close()
   }
 
@@ -123,7 +167,8 @@ export class BackendSimulationClient {
     if (message === undefined) return
     if ("method" in message) {
       if (message.method === "llm.request") {
-        for (const listener of this.llmRequests) listener(message.params as Backend.OpenedExchange)
+        for (const listener of this.llmRequests)
+          listener(message.params as Backend.OpenedExchange)
       }
       return
     }
@@ -132,7 +177,10 @@ export class BackendSimulationClient {
     if (waiter === undefined) return
     this.pending.delete(message.id)
     clearTimeout(waiter.timer)
-    if (message.error) waiter.reject(new BackendSimulationError(message.error.message, waiter.method))
+    if (message.error)
+      waiter.reject(
+        new BackendSimulationError(message.error.message, waiter.method),
+      )
     else waiter.resolve(message.result)
   }
 
@@ -145,13 +193,21 @@ export class BackendSimulationClient {
   }
 }
 
-function parseResponse(data: string): JsonRpc.Response | { readonly method: string; readonly params: unknown } | undefined {
+function parseResponse(
+  data: string,
+):
+  | JsonRpc.Response
+  | { readonly method: string; readonly params: unknown }
+  | undefined {
   try {
     const value = JSON.parse(data) as unknown
     if (typeof value !== "object" || value === null) return undefined
     if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") return undefined
     if ("method" in value && typeof value.method === "string") {
-      return { method: value.method, params: "params" in value ? value.params : undefined }
+      return {
+        method: value.method,
+        params: "params" in value ? value.params : undefined,
+      }
     }
     if (!("id" in value)) return undefined
     return value as JsonRpc.Response
@@ -180,5 +236,6 @@ function open(url: string): Promise<WebSocket> {
   })
 }
 
-export const connectBackendSimulation = (options?: BackendSimulationClientOptions): Promise<BackendSimulationClient> =>
-  BackendSimulationClient.connect(options)
+export const connectBackendSimulation = (
+  options?: BackendSimulationClientOptions,
+): Promise<BackendSimulationClient> => BackendSimulationClient.connect(options)

package/src/client/client.ts

@@ -6,14 +6,16 @@ import {
 const defaultPort = 40900
 
 type Methods = {
-  readonly "ui.render": { readonly params: undefined; readonly result: Frontend.Render }
+  readonly "ui.screenshot": { readonly params: 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 params: undefined; readonly result: Frontend.EndRecord }
-  readonly "ui.action": { readonly params: Frontend.ActionParams; readonly result: Frontend.State }
-  readonly "trace.list": { readonly params: undefined; readonly result: Frontend.TraceList }
-  readonly "trace.clear": { readonly params: undefined; readonly result: { readonly cleared: true } }
-  readonly "trace.export": { readonly params: undefined; readonly result: Frontend.TraceList }
+  readonly "ui.type": { readonly params: Frontend.TypeParams; readonly result: Frontend.State }
+  readonly "ui.press": { readonly params: Frontend.PressParams; readonly result: Frontend.State }
+  readonly "ui.enter": { readonly params: undefined; readonly result: Frontend.State }
+  readonly "ui.arrow": { readonly params: Frontend.ArrowParams; readonly result: Frontend.State }
+  readonly "ui.focus": { readonly params: Frontend.FocusParams; readonly result: Frontend.State }
+  readonly "ui.click": { readonly params: Frontend.ClickParams; readonly result: Frontend.State }
 }
 
 type MethodName = keyof Methods
@@ -123,8 +125,8 @@ export class SimulationClient {
     return this.call("ui.state")
   }
 
-  render(): Promise<Frontend.Render> {
-    return this.call("ui.render")
+  screenshot(): Promise<Frontend.Screenshot> {
+    return this.call("ui.screenshot")
   }
 
   startRecord(): Promise<Frontend.StartRecord> {
@@ -136,46 +138,28 @@ export class SimulationClient {
   }
 
   /** Executes one user-level action and returns the post-action state. */
-  action(action: Frontend.Action): Promise<Frontend.State> {
-    return this.call("ui.action", { action })
-  }
-
   typeText(text: string): Promise<Frontend.State> {
-    return this.action({ type: "typeText", text })
+    return this.call("ui.type", { text })
   }
 
   pressKey(key: string, modifiers?: Frontend.KeyModifiers): Promise<Frontend.State> {
-    return this.action({ type: "pressKey", key: key === "escape" ? "\u001b" : key, ...(modifiers === undefined ? {} : { modifiers }) })
+    return this.call("ui.press", { key: key === "escape" ? "\u001b" : key, ...(modifiers === undefined ? {} : { modifiers }) })
   }
 
   pressEnter(): Promise<Frontend.State> {
-    return this.action({ type: "pressEnter" })
+    return this.call("ui.enter")
   }
 
   pressArrow(direction: "up" | "down" | "left" | "right"): Promise<Frontend.State> {
-    return this.action({ type: "pressArrow", direction })
+    return this.call("ui.arrow", { direction })
   }
 
   focus(target: number): Promise<Frontend.State> {
-    return this.action({ type: "focus", target })
+    return this.call("ui.focus", { target })
   }
 
   click(target: number, x: number, y: number): Promise<Frontend.State> {
-    return this.action({ type: "click", target, x, y })
-  }
-
-  // ── trace ─────────────────────────────────────────────────────────────
-
-  traceList(): Promise<Frontend.TraceList> {
-    return this.call("trace.list")
-  }
-
-  traceClear(): Promise<{ readonly cleared: true }> {
-    return this.call("trace.clear")
-  }
-
-  traceExport(): Promise<Frontend.TraceList> {
-    return this.call("trace.export")
+    return this.call("ui.click", { target, x, y })
   }
 
   // ── lifecycle ─────────────────────────────────────────────────────────

package/src/client/index.ts

@@ -7,11 +7,8 @@ export const defaultBackendPort = 40950
 export { Backend, Frontend, JsonRpc, SimulationProtocol } from "./protocol.js"
 export type BackendFinishReason = import("./protocol.js").Backend.FinishReason
 export type BackendItem = import("./protocol.js").Backend.Item
-export type NetworkLogEntry = import("./protocol.js").Backend.NetworkLogEntry
 export type OpenedExchange = import("./protocol.js").Backend.OpenedExchange
 export type KeyModifiers = import("./protocol.js").Frontend.KeyModifiers
-export type TraceList = import("./protocol.js").Frontend.TraceList
-export type TraceRecord = import("./protocol.js").Frontend.TraceRecord
 export type UiAction = import("./protocol.js").Frontend.Action
 export type UiElement = import("./protocol.js").Frontend.Element
 export type UiState = import("./protocol.js").Frontend.State

package/src/client/protocol.ts

@@ -31,7 +31,10 @@ export namespace JsonRpc {
 
   export const decodeRequest = Schema.decodeUnknownSync(Request)
 
-  export function success(id: Request["id"], result: unknown): Response | undefined {
+  export function success(
+    id: Request["id"],
+    result: unknown,
+  ): Response | undefined {
     if (id === undefined) return undefined
     return { jsonrpc: "2.0", id, result: result as Json }
   }
@@ -56,15 +59,29 @@ export namespace Frontend {
     super: Schema.optional(Schema.Boolean),
     hyper: Schema.optional(Schema.Boolean),
   })
-  export interface KeyModifiers extends Schema.Schema.Type<typeof KeyModifiers> {}
+  export interface KeyModifiers extends Schema.Schema.Type<
+    typeof KeyModifiers
+  > {}
 
   export const Action = Schema.Union([
-    Schema.Struct({ type: Schema.Literal("typeText"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("pressKey"), key: Schema.String, modifiers: Schema.optional(KeyModifiers) }),
-    Schema.Struct({ type: Schema.Literal("pressEnter") }),
-    Schema.Struct({ type: Schema.Literal("pressArrow"), direction: Schema.Literals(["up", "down", "left", "right"]) }),
-    Schema.Struct({ type: Schema.Literal("focus"), target: Schema.Number }),
-    Schema.Struct({ type: Schema.Literal("click"), target: Schema.Number, x: Schema.Number, y: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("ui.type"), text: Schema.String }),
+    Schema.Struct({
+      type: Schema.Literal("ui.press"),
+      key: Schema.String,
+      modifiers: Schema.optional(KeyModifiers),
+    }),
+    Schema.Struct({ type: Schema.Literal("ui.enter") }),
+    Schema.Struct({
+      type: Schema.Literal("ui.arrow"),
+      direction: Schema.Literals(["up", "down", "left", "right"]),
+    }),
+    Schema.Struct({ type: Schema.Literal("ui.focus"), target: Schema.Number }),
+    Schema.Struct({
+      type: Schema.Literal("ui.click"),
+      target: Schema.Number,
+      x: Schema.Number,
+      y: Schema.Number,
+    }),
   ])
   export type Action = Schema.Schema.Type<typeof Action>
 
@@ -88,12 +105,11 @@ export namespace Frontend {
       editor: Schema.Boolean,
     }),
     elements: Schema.Array(Element),
-    actions: Schema.Array(Action),
   })
   export interface State extends Schema.Schema.Type<typeof State> {}
 
-  export const Render = Schema.String
-  export type Render = Schema.Schema.Type<typeof Render>
+  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> {}
@@ -101,77 +117,149 @@ export namespace Frontend {
   export const EndRecord = Schema.String
   export type EndRecord = Schema.Schema.Type<typeof EndRecord>
 
-  export const ActionParams = Schema.Struct({ action: Action })
-  export interface ActionParams extends Schema.Schema.Type<typeof ActionParams> {}
+  export const TypeParams = Schema.Struct({ text: Schema.String })
+  export interface TypeParams extends Schema.Schema.Type<typeof TypeParams> {}
+
+  export const PressParams = Schema.Struct({
+    key: Schema.String,
+    modifiers: Schema.optional(KeyModifiers),
+  })
+  export interface PressParams extends Schema.Schema.Type<typeof PressParams> {}
+
+  export const ArrowParams = Schema.Struct({
+    direction: Schema.Literals(["up", "down", "left", "right"]),
+  })
+  export interface ArrowParams extends Schema.Schema.Type<typeof ArrowParams> {}
+
+  export const FocusParams = Schema.Struct({ target: Schema.Number })
+  export interface FocusParams extends Schema.Schema.Type<typeof FocusParams> {}
+
+  export const ClickParams = Schema.Struct({
+    target: Schema.Number,
+    x: Schema.Number,
+    y: Schema.Number,
+  })
+  export interface ClickParams extends Schema.Schema.Type<typeof ClickParams> {}
 
   export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.action"), params: ActionParams }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.type"),
+      params: TypeParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.press"),
+      params: PressParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.arrow"),
+      params: ArrowParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.focus"),
+      params: FocusParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.click"),
+      params: ClickParams,
+    }),
     Schema.Struct({
       ...JsonRpc.RequestFields,
       method: Schema.Literals([
-        "ui.render",
+        "ui.enter",
+        "ui.screenshot",
         "ui.state",
         "ui.start-record",
         "ui.end-record",
-        "trace.list",
-        "trace.clear",
-        "trace.export",
       ]),
     }),
   ])
   export type Request = Schema.Schema.Type<typeof Request>
   export const decodeRequest = Schema.decodeUnknownSync(Request)
-
-  export const TraceRecord = Schema.Struct({
-    id: Schema.Number,
-    time: Schema.String,
-    type: Schema.String,
-    data: Schema.optional(Schema.Json),
-  })
-  export interface TraceRecord extends Schema.Schema.Type<typeof TraceRecord> {}
-
-  export const TraceList = Schema.Struct({ records: Schema.Array(TraceRecord) })
-  export interface TraceList extends Schema.Schema.Type<typeof TraceList> {}
 }
 
 export namespace Backend {
   export const Item = Schema.Union([
     Schema.Struct({ type: Schema.Literal("textDelta"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("reasoningDelta"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("toolCall"), id: Schema.String, name: Schema.String, input: Schema.Json }),
+    Schema.Struct({
+      type: Schema.Literal("reasoningDelta"),
+      text: Schema.String,
+    }),
+    Schema.Struct({
+      type: Schema.Literal("toolCall"),
+      id: Schema.String,
+      name: Schema.String,
+      input: Schema.Json,
+    }),
     Schema.Struct({ type: Schema.Literal("raw"), chunk: Schema.Json }),
   ])
   export type Item = Schema.Schema.Type<typeof Item>
 
-  export const FinishReason = Schema.Literals(["stop", "tool-calls", "length", "content-filter"])
+  export const FinishReason = Schema.Literals([
+    "stop",
+    "tool-calls",
+    "length",
+    "content-filter",
+  ])
   export type FinishReason = Schema.Schema.Type<typeof FinishReason>
 
-  export const ChunkParams = Schema.Struct({ id: Schema.String, items: Schema.Array(Item) })
+  export const ChunkParams = Schema.Struct({
+    id: Schema.String,
+    items: Schema.Array(Item),
+  })
   export interface ChunkParams extends Schema.Schema.Type<typeof ChunkParams> {}
 
   export const FinishParams = Schema.Struct({
     id: Schema.String,
-    reason: FinishReason.pipe(Schema.withDecodingDefault(Effect.succeed("stop" as const))),
+    reason: FinishReason.pipe(
+      Schema.withDecodingDefault(Effect.succeed("stop" as const)),
+    ),
   })
-  export interface FinishParams extends Schema.Schema.Type<typeof FinishParams> {}
+  export interface FinishParams extends Schema.Schema.Type<
+    typeof FinishParams
+  > {}
 
   export const DisconnectParams = Schema.Struct({ id: Schema.String })
-  export interface DisconnectParams extends Schema.Schema.Type<typeof DisconnectParams> {}
+  export interface DisconnectParams extends Schema.Schema.Type<
+    typeof DisconnectParams
+  > {}
 
   export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.chunk"), params: ChunkParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.finish"), params: FinishParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.disconnect"), params: DisconnectParams }),
     Schema.Struct({
       ...JsonRpc.RequestFields,
-      method: Schema.Literals(["llm.attach", "llm.pending", "network.log"]),
+      method: Schema.Literal("llm.chunk"),
+      params: ChunkParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.finish"),
+      params: FinishParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.disconnect"),
+      params: DisconnectParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.attach"),
     }),
   ])
   export type Request = Schema.Schema.Type<typeof Request>
   export const decodeRequest = Schema.decodeUnknownSync(Request)
 
-  export const OpenedExchange = Schema.Struct({ id: Schema.String, url: Schema.String, body: Schema.Json })
-  export interface OpenedExchange extends Schema.Schema.Type<typeof OpenedExchange> {}
+  export const OpenedExchange = Schema.Struct({
+    id: Schema.String,
+    url: Schema.String,
+    body: Schema.Json,
+  })
+  export interface OpenedExchange extends Schema.Schema.Type<
+    typeof OpenedExchange
+  > {}
 
   export const NetworkLogEntry = Schema.Struct({
     time: Schema.Number,
@@ -179,8 +267,9 @@ export namespace Backend {
     url: Schema.String,
     matched: Schema.Boolean,
   })
-  export interface NetworkLogEntry extends Schema.Schema.Type<typeof NetworkLogEntry> {}
-
+  export interface NetworkLogEntry extends Schema.Schema.Type<
+    typeof NetworkLogEntry
+  > {}
 }
 
 export * as SimulationProtocol from "./index"

package/src/client/protocol.types.ts

@@ -0,0 +1,62 @@
+// CLI command contract for `opencode-drive send`.
+
+export type Json =
+  null | boolean | number | string | Json[] | { [key: string]: Json }
+
+export type KeyModifiers = {
+  ctrl?: boolean
+  shift?: boolean
+  meta?: boolean
+  super?: boolean
+  hyper?: boolean
+}
+
+export type Element = {
+  id: string
+  num: number
+  x: number
+  y: number
+  width: number
+  height: number
+  focusable: boolean
+  focused: boolean
+  clickable: boolean
+  editor: boolean
+}
+
+export type State = {
+  focused: {
+    renderable?: number
+    editor: boolean
+  }
+  elements: Element[]
+}
+
+export type Command =
+  | { name: "ui.type"; params: { text: string }; result: State }
+  | {
+      name: "ui.press"
+      params: { key: string; modifiers?: KeyModifiers }
+      result: State
+    }
+  | { name: "ui.enter"; result: State }
+  | {
+      name: "ui.arrow"
+      params: { direction: "up" | "down" | "left" | "right" }
+      result: State
+    }
+  | { name: "ui.focus"; params: { target: number }; result: State }
+  | {
+      name: "ui.click"
+      params: { target: number; x: number; y: number }
+      result: State
+    }
+  | { name: "ui.screenshot"; result: string }
+  | { name: "ui.state"; result: State }
+  | { name: "ui.start-record"; result: { recording: true } }
+  | { name: "ui.end-record"; result: string }
+
+// Commands with `params` take one JSON argument:
+//   --command.ui.type '{"text":"hello"}'
+// Commands without `params` are flags:
+//   --command.ui.enter

package/src/experimental/campaign.ts

@@ -83,7 +83,7 @@ for (let index = 0; index < options.count; index++) {
     "--driver", `bun ${path.resolve("src/experimental/flow-driver.ts")} ${path.join(directory, "scenario.json")} ${path.join(directory, "result.json")}`,
     "--",
     "bun", "run", "--conditions=browser", "--preload=@opentui/solid/preload",
-    "/root/projects/opencode-latest/packages/cli/src/index.ts", "--standalone",
+    "/root/projects/opencode-latest/packages/cli/src/index.ts",
   ], {
     cwd: path.resolve("."),
     env: {
@@ -107,7 +107,7 @@ for (let index = 0; index < options.count; index++) {
   }
   const result: FlowResult = await Bun.file(path.join(directory, "result.json")).json()
   results.push(result)
-  console.log(`  passed in ${result.durationMs}ms; trace=${result.traceRecords} title=${result.titleExchanges}`)
+  console.log(`  passed in ${result.durationMs}ms; title=${result.titleExchanges}`)
 }
 
 const summary = {
@@ -117,7 +117,6 @@ const summary = {
   assistantExchanges: results.reduce((total, result) => total + result.assistantExchanges, 0),
   subagentExchanges: results.reduce((total, result) => total + result.subagentExchanges, 0),
   titleExchanges: results.reduce((total, result) => total + result.titleExchanges, 0),
-  traceRecords: results.reduce((total, result) => total + result.traceRecords, 0),
   durationMs: results.reduce((total, result) => total + result.durationMs, 0),
   coverage: { ...coverage, streamChunkTypes: [...coverage.streamChunkTypes] },
 }