opencode-drive 0.1.2 → 0.1.3

package/src/client/backend.ts

@@ -1,16 +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 "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
@@ -45,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++) {
@@ -68,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")
   }
 
@@ -98,18 +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")
-  }
-
   close() {
+    this.closing = true
     this.socket.close()
   }
 
@@ -118,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
     }
@@ -127,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)
   }
 
@@ -140,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
@@ -175,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/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("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.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.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 }),
+    Schema.Struct({
+      type: Schema.Literal("ui.click"),
+      target: Schema.Number,
+      x: Schema.Number,
+      y: Schema.Number,
+    }),
   ])
   export type Action = Schema.Schema.Type<typeof Action>
 
@@ -103,24 +120,53 @@ export namespace Frontend {
   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 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 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 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.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.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([
@@ -134,47 +180,86 @@ export namespace Frontend {
   ])
   export type Request = Schema.Schema.Type<typeof Request>
   export const decodeRequest = Schema.decodeUnknownSync(Request)
-
 }
 
 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"]),
+      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,
@@ -182,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

@@ -1,6 +1,7 @@
 // CLI command contract for `opencode-drive send`.
 
-export type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
+export type Json =
+  null | boolean | number | string | Json[] | { [key: string]: Json }
 
 export type KeyModifiers = {
   ctrl?: boolean
@@ -31,36 +32,29 @@ export type State = {
   elements: Element[]
 }
 
-export type LlmItem =
-  | { type: "textDelta"; text: string }
-  | { type: "reasoningDelta"; text: string }
-  | { type: "toolCall"; id: string; name: string; input: Json }
-  | { type: "raw"; chunk: Json }
-
-export type FinishReason = "stop" | "tool-calls" | "length" | "content-filter"
-
-export type OpenedExchange = {
-  id: string
-  url: string
-  body: Json
-}
-
 export type Command =
   | { name: "ui.type"; params: { text: string }; result: State }
-  | { name: "ui.press"; params: { key: string; modifiers?: KeyModifiers }; 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.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.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 }
-  | { name: "llm.chunk"; params: { id: string; items: LlmItem[] }; result: { ok: true } }
-  | { name: "llm.finish"; params: { id: string; reason?: FinishReason }; result: { ok: true } }
-  | { name: "llm.disconnect"; params: { id: string }; result: { ok: true } }
-  | { name: "llm.attach"; result: { attached: true } }
-  | { name: "llm.pending"; result: { exchanges: OpenedExchange[] } }
 
 // Commands with `params` take one JSON argument:
 //   --command.ui.type '{"text":"hello"}'

package/src/experimental/driver.ts

@@ -1,18 +1,38 @@
-import { connectBackendSimulation, connectSimulation, type OpenedExchange } from "../client/index.js"
+import {
+  connectBackendSimulation,
+  connectSimulation,
+  type OpenedExchange,
+} from "../client/index.js"
 
 const uiUrl = process.env.OPENCODE_SIMULATION_UI_WS
 const backendUrl = process.env.OPENCODE_SIMULATION_BACKEND_WS
 
 const ui = await connectSimulation(uiUrl ? { url: uiUrl } : undefined)
-const backend = await connectBackendSimulation(backendUrl ? { url: backendUrl } : undefined)
+const backend = await connectBackendSimulation(
+  backendUrl ? { url: backendUrl } : undefined,
+)
 
 console.log("ui:", ui.url)
 console.log("backend:", backend.url)
 
+let completed!: () => void
+const responseCompleted = new Promise<void>((resolve) => {
+  completed = resolve
+})
+
 await backend.attach(async (request: OpenedExchange) => {
-  console.log("llm.request:", JSON.stringify({ id: request.id, model: (request.body as { model?: string }).model }))
-  await backend.chunk(request.id, [{ type: "textDelta", text: "Hello from opencode-probe." }])
+  console.log(
+    "llm.request:",
+    JSON.stringify({
+      id: request.id,
+      model: (request.body as { model?: string }).model,
+    }),
+  )
+  await backend.chunk(request.id, [
+    { type: "textDelta", text: "Hello from opencode-probe." },
+  ])
   await backend.finish(request.id, "stop")
+  completed()
 })
 
 for (let attempt = 0; attempt < 60; attempt++) {
@@ -22,20 +42,11 @@ for (let attempt = 0; attempt < 60; attempt++) {
   if (attempt === 59) throw new Error("prompt editor did not become ready")
 }
 
-await ui.typeText(process.argv.slice(2).join(" ") || "Hello from opencode-probe")
+await ui.typeText(
+  process.argv.slice(2).join(" ") || "Hello from opencode-probe",
+)
 await ui.pressEnter()
-
-for (let attempt = 0; attempt < 30; attempt++) {
-  await new Promise((resolve) => setTimeout(resolve, 500))
-  if ((await backend.pendingExchanges()).exchanges.length === 0) {
-    console.log("response complete")
-    ui.close()
-    backend.close()
-    process.exit(0)
-  }
-}
-
-console.log(await ui.state())
+await responseCompleted
+console.log("response complete")
 ui.close()
 backend.close()
-throw new Error("assistant reply did not render")