opencode-drive 0.1.2 → 0.1.3

package/src/experimental/flow-driver.ts

@@ -1,16 +1,31 @@
-import { connectBackendSimulation, connectSimulation, type OpenedExchange } from "../client/index.js"
-import { flowProperties, type FlowPropertyContext, type FlowResult, type FlowScenario, type TurnOutcome } from "./flows/index.js"
+import {
+  connectBackendSimulation,
+  connectSimulation,
+  type OpenedExchange,
+} from "../client/index.js"
+import {
+  flowProperties,
+  type FlowPropertyContext,
+  type FlowResult,
+  type FlowScenario,
+  type TurnOutcome,
+} from "./flows/index.js"
 
 const scenarioPath = process.argv[2]
 const resultPath = process.argv[3]
-if (scenarioPath === undefined) throw new Error("usage: flow-driver SCENARIO [RESULT]")
+if (scenarioPath === undefined)
+  throw new Error("usage: flow-driver SCENARIO [RESULT]")
 
 const scenario: FlowScenario = await Bun.file(scenarioPath).json()
 const stepDelay = Number(process.env.OPENCODE_PROBE_STEP_DELAY ?? "0")
 const chunkDelay = Number(process.env.OPENCODE_PROBE_CHUNK_DELAY ?? "30")
 const started = Date.now()
-const ui = await connectSimulation({ url: requiredEnv("OPENCODE_SIMULATION_UI_WS") })
-const backend = await connectBackendSimulation({ url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS") })
+const ui = await connectSimulation({
+  url: requiredEnv("OPENCODE_SIMULATION_UI_WS"),
+})
+const backend = await connectBackendSimulation({
+  url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS"),
+})
 const responses = scenario.turns.flatMap((turn) => turn.responses)
 let assistantExchanges = 0
 let responseCursor = 0
@@ -25,19 +40,27 @@ await backend.attach(async (request: OpenedExchange) => {
   try {
     if (isTitleRequest(request)) {
       titleExchanges++
-      await backend.chunk(request.id, [{ type: "textDelta", text: scenario.name }])
+      await backend.chunk(request.id, [
+        { type: "textDelta", text: scenario.name },
+      ])
       await backend.finish(request.id, "stop")
       return
     }
     if (isSubagentRequest(request)) {
       subagentExchanges++
-      await backend.chunk(request.id, [{ type: "textDelta", text: "The nested simulation fixture is consistent." }])
+      await backend.chunk(request.id, [
+        {
+          type: "textDelta",
+          text: "The nested simulation fixture is consistent.",
+        },
+      ])
       await backend.finish(request.id, "stop")
       return
     }
     const response = responses[responseCursor++]
     assistantExchanges++
-    if (response === undefined) throw new Error(`unexpected assistant exchange ${assistantExchanges}`)
+    if (response === undefined)
+      throw new Error(`unexpected assistant exchange ${assistantExchanges}`)
     active.add(request.id)
     for (const chunk of response.chunks) {
       await backend.chunk(request.id, chunk)
@@ -46,9 +69,11 @@ await backend.attach(async (request: OpenedExchange) => {
     }
     if (chunkDelay > 0) await Bun.sleep(Math.max(chunkDelay * 3, 100))
     if (response.terminal === "disconnect") await backend.disconnect(request.id)
-    else if (response.terminal !== "invalid-provider-event") await backend.finish(request.id, response.finish)
+    else if (response.terminal !== "invalid-provider-event")
+      await backend.finish(request.id, response.finish)
   } catch (error) {
-    if (!interrupted.has(request.id)) failure = error instanceof Error ? error : new Error(String(error))
+    if (!interrupted.has(request.id))
+      failure = error instanceof Error ? error : new Error(String(error))
   } finally {
     active.delete(request.id)
   }
@@ -59,7 +84,10 @@ try {
   let expectedExchanges = 0
   for (const turn of scenario.turns) {
     if (failure !== undefined) throw failure
-    await waitFor("prompt editor before submit", async () => (await ui.state()).focused.editor)
+    await waitFor(
+      "prompt editor before submit",
+      async () => (await ui.state()).focused.editor,
+    )
     expectedExchanges += turn.responses.length
     const beforeChunks = chunksSent
     await ui.typeText(turn.prompt)
@@ -67,26 +95,38 @@ try {
     await runProperties("afterSubmit", { turn, ui, backend, waitFor })
     if (turn.interaction === "double-submit") await ui.pressEnter()
     let outcome: TurnOutcome = "completed"
-    const hasTools = turn.responses.some((response) => (response.toolNames?.length ?? 0) > 0)
-    const settleTools = turn.interaction === "interrupt" || !hasTools
-      ? undefined
-      : settleBlockingUi(expectedExchanges)
+    const hasTools = turn.responses.some(
+      (response) => (response.toolNames?.length ?? 0) > 0,
+    )
+    const settleTools =
+      turn.interaction === "interrupt" || !hasTools
+        ? undefined
+        : settleBlockingUi(expectedExchanges)
     if (turn.interaction === "steer") {
-      await waitFor("active stream", async () => active.size > 0 && chunksSent > beforeChunks)
+      await waitFor(
+        "active stream",
+        async () => active.size > 0 && chunksSent > beforeChunks,
+      )
       await ui.typeText(turn.steerPrompt ?? "Also inspect the active boundary.")
       await ui.pressEnter()
     }
     if (turn.interaction === "interrupt") {
-      await waitFor("interruptible stream", async () => active.size > 0 && chunksSent > beforeChunks)
+      await waitFor(
+        "interruptible stream",
+        async () => active.size > 0 && chunksSent > beforeChunks,
+      )
       for (const id of active) interrupted.add(id)
       await ui.pressKey("escape")
       await ui.pressKey("escape")
-      await waitFor("interrupted provider drain", async () => active.size === 0 && (await backend.pendingExchanges()).exchanges.length === 0)
+      await waitFor("interrupted provider drain", async () => active.size === 0)
       responseCursor = expectedExchanges
       outcome = "interrupted"
     } else if (turn.interaction === "provider-drop") {
-      await waitFor("dropped provider exchange", async () => responseCursor >= expectedExchanges)
-      await waitFor("dropped provider drain", async () => active.size === 0 && (await backend.pendingExchanges()).exchanges.length === 0)
+      await waitFor(
+        "dropped provider exchange",
+        async () => responseCursor >= expectedExchanges,
+      )
+      await waitFor("dropped provider drain", async () => active.size === 0)
       outcome = "provider-error"
     } else {
       await settleTools
@@ -96,10 +136,16 @@ try {
         return responseCursor >= expectedExchanges
       })
     }
-    await runProperties("afterTerminal", { turn, ui, backend, outcome, waitFor })
+    await runProperties("afterTerminal", {
+      turn,
+      ui,
+      backend,
+      outcome,
+      waitFor,
+    })
     if (stepDelay > 0) await Bun.sleep(stepDelay)
   }
-  await waitFor("provider idle", async () => (await backend.pendingExchanges()).exchanges.length === 0)
+  await waitFor("provider idle", async () => active.size === 0)
   const result: FlowResult = {
     seed: scenario.seed,
     name: scenario.name,
@@ -110,18 +156,26 @@ try {
     durationMs: Date.now() - started,
     finalState: await ui.state(),
   }
-  if (resultPath !== undefined) await Bun.write(resultPath, `${JSON.stringify(result, undefined, 2)}\n`)
+  if (resultPath !== undefined)
+    await Bun.write(resultPath, `${JSON.stringify(result, undefined, 2)}\n`)
   console.log(JSON.stringify({ ...result, finalState: undefined }))
 } catch (error) {
   if (resultPath !== undefined) {
-    await Bun.write(`${resultPath}.failure.json`, `${JSON.stringify({
-      error: error instanceof Error ? error.message : String(error),
-      assistantExchanges,
-      subagentExchanges,
-      titleExchanges,
-      pendingExchanges: (await backend.pendingExchanges()).exchanges,
-      state: await ui.state(),
-    }, undefined, 2)}\n`)
+    await Bun.write(
+      `${resultPath}.failure.json`,
+      `${JSON.stringify(
+        {
+          error: error instanceof Error ? error.message : String(error),
+          assistantExchanges,
+          subagentExchanges,
+          titleExchanges,
+          activeExchanges: [...active],
+          state: await ui.state(),
+        },
+        undefined,
+        2,
+      )}\n`,
+    )
   }
   throw error
 } finally {
@@ -136,25 +190,51 @@ function requiredEnv(name: string) {
 }
 
 function isTitleRequest(request: OpenedExchange) {
-  if (typeof request.body !== "object" || request.body === null || !("messages" in request.body)) return false
+  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")
+  if (typeof first !== "object" || first === null || !("content" in first))
+    return false
+  return (
+    typeof first.content === "string" &&
+    first.content.includes("You are a title generator")
+  )
 }
 
 function isSubagentRequest(request: OpenedExchange) {
-  if (typeof request.body !== "object" || request.body === null || !("messages" in request.body)) return false
+  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
   return messages.some((message) => {
-    if (typeof message !== "object" || message === null || !("content" in message)) return false
-    return typeof message.content === "string" && message.content.includes("Inspect the simulation fixture.")
+    if (
+      typeof message !== "object" ||
+      message === null ||
+      !("content" in message)
+    )
+      return false
+    return (
+      typeof message.content === "string" &&
+      message.content.includes("Inspect the simulation fixture.")
+    )
   })
 }
 
-async function waitFor(label: string, check: () => Promise<boolean>, timeout = 30_000) {
+async function waitFor(
+  label: string,
+  check: () => Promise<boolean>,
+  timeout = 30_000,
+) {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     if (await check()) return
@@ -163,16 +243,22 @@ async function waitFor(label: string, check: () => Promise<boolean>, timeout = 3
   throw new Error(`timed out waiting for ${label}`)
 }
 
-async function runProperties(stage: "afterSubmit" | "afterTerminal", context: FlowPropertyContext) {
+async function runProperties(
+  stage: "afterSubmit" | "afterTerminal",
+  context: FlowPropertyContext,
+) {
   for (const property of flowProperties) {
     const check = property[stage]
     if (check === undefined) continue
     try {
       await check(context)
     } catch (error) {
-      throw new Error(`property ${property.name} failed for ${context.turn.marker}: ${error instanceof Error ? error.message : String(error)}`, {
-        cause: error,
-      })
+      throw new Error(
+        `property ${property.name} failed for ${context.turn.marker}: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          cause: error,
+        },
+      )
     }
   }
 }
@@ -183,5 +269,6 @@ async function settleBlockingUi(expectedExchanges: number) {
     await ui.pressEnter()
     await Bun.sleep(25)
   }
-  if (responseCursor < expectedExchanges) throw new Error("timed out settling blocking tool UI")
+  if (responseCursor < expectedExchanges)
+    throw new Error("timed out settling blocking tool UI")
 }

package/src/experimental/flows/properties.ts

@@ -1,4 +1,8 @@
-import type { BackendSimulationClient, SimulationClient, UiState } from "../../client/index.js"
+import type {
+  BackendSimulationClient,
+  SimulationClient,
+  UiState,
+} from "../../client/index.js"
 import type { FlowTurn } from "./types.js"
 
 export type TurnOutcome = "completed" | "interrupted" | "provider-error"
@@ -8,7 +12,10 @@ export interface FlowPropertyContext {
   readonly ui: SimulationClient
   readonly backend: BackendSimulationClient
   readonly outcome?: TurnOutcome
-  readonly waitFor: (label: string, check: () => Promise<boolean>) => Promise<void>
+  readonly waitFor: (
+    label: string,
+    check: () => Promise<boolean>,
+  ) => Promise<void>
 }
 
 export interface FlowProperty {
@@ -23,17 +30,16 @@ export const flowProperties: ReadonlyArray<FlowProperty> = [
   defineProperty({
     name: "submitted-turn-shows-running",
     afterSubmit: (context) => {
-      if (context.turn.responses.some((response) => response.terminal === "invalid-provider-event" || response.terminal === "disconnect")) return Promise.resolve()
-      return context.waitFor("submitted turn to show running", async () => isRunning(await context.ui.state()))
-    },
-  }),
-  defineProperty({
-    name: "turn-reaches-terminal-outcome",
-    afterTerminal: async (context) => {
-      if (context.outcome === undefined) throw new Error("turn has no terminal outcome")
-      await context.waitFor(
-        "terminal turn to have no provider exchange",
-        async () => (await context.backend.pendingExchanges()).exchanges.length === 0,
+      if (
+        context.turn.responses.some(
+          (response) =>
+            response.terminal === "invalid-provider-event" ||
+            response.terminal === "disconnect",
+        )
+      )
+        return Promise.resolve()
+      return context.waitFor("submitted turn to show running", async () =>
+        isRunning(await context.ui.state()),
       )
     },
   }),

package/src/experimental/hello-driver.ts

@@ -1,7 +1,15 @@
-import { connectBackendSimulation, connectSimulation, type OpenedExchange } from "../client/index.js"
+import {
+  connectBackendSimulation,
+  connectSimulation,
+  type OpenedExchange,
+} from "../client/index.js"
 
-const ui = await connectSimulation({ url: requiredEnv("OPENCODE_SIMULATION_UI_WS") })
-const backend = await connectBackendSimulation({ url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS") })
+const ui = await connectSimulation({
+  url: requiredEnv("OPENCODE_SIMULATION_UI_WS"),
+})
+const backend = await connectBackendSimulation({
+  url: requiredEnv("OPENCODE_SIMULATION_BACKEND_WS"),
+})
 let completed!: () => void
 const responseCompleted = new Promise<void>((resolve) => {
   completed = resolve
@@ -18,7 +26,6 @@ try {
   await ui.typeText("Say hello")
   await ui.pressEnter()
   await responseCompleted
-  await waitFor(async () => (await backend.pendingExchanges()).exchanges.length === 0)
   await ui.state()
   await Bun.sleep(Number(process.env.OPENCODE_PROBE_HOLD_MS ?? "10000"))
 } finally {

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

@@ -1,20 +1,35 @@
-import { connectBackendSimulation, connectSimulation, type OpenedExchange } from "../client/index.js"
+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 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.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 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()
@@ -22,19 +37,23 @@ await backend.attach(async (request: OpenedExchange) => {
 
 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.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 waitFor("provider drain", async () => (await backend.pendingExchanges()).exchanges.length === 0)
   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.")
+  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()
@@ -56,15 +75,28 @@ function requiredEnv(name: string) {
 }
 
 function isTitleRequest(request: OpenedExchange) {
-  if (typeof request.body !== "object" || request.body === null || !("messages" in request.body)) return false
+  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")
+  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) {
+async function waitFor(
+  label: string,
+  check: () => Promise<boolean>,
+  timeout = 30_000,
+) {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     if (await check()) return

package/src/index.ts

@@ -1 +1,3 @@
 export * from "./client/index.js"
+export { defineScript } from "./cli/script.js"
+export type { DriveScript, ScriptContext } from "./cli/script.js"

package/src/cli/driver-runner.ts

@@ -1,39 +0,0 @@
-import { resolve } from "node:path"
-import { pathToFileURL } from "node:url"
-import { connectDrive } from "../experimental/drive.js"
-import type { Driver } from "../experimental/drive.js"
-
-const driver = process.argv[2]
-if (!driver) throw new Error("driver file is required")
-const name = requiredArgument(3, "instance name")
-const ui = requiredArgument(4, "frontend WebSocket URL")
-const backend = requiredArgument(5, "backend WebSocket URL")
-const artifacts = requiredArgument(6, "artifacts directory")
-
-const module: { readonly default?: unknown } = await import(pathToFileURL(resolve(driver)).href)
-if (!isDriver(module.default)) throw new Error("driver must default-export defineDriver(...)")
-const controller = new AbortController()
-process.once("SIGINT", () => controller.abort())
-process.once("SIGTERM", () => controller.abort())
-const session = await connectDrive({ ui, backend })
-try {
-  await module.default({
-    name,
-    ui: session.ui,
-    backend: session.backend,
-    artifacts,
-    signal: controller.signal,
-  })
-} finally {
-  session.close()
-}
-
-function isDriver(value: unknown): value is Driver {
-  return typeof value === "function"
-}
-
-function requiredArgument(index: number, name: string) {
-  const value = process.argv[index]
-  if (!value) throw new Error(`${name} is required`)
-  return value
-}

package/src/cli/driver.ts

@@ -1,28 +0,0 @@
-import { mkdir } from "node:fs/promises"
-import { resolve } from "node:path"
-import type { InstanceManifest } from "./types.js"
-
-export async function runDriver(driver: string, manifest: InstanceManifest) {
-  await mkdir(manifest.artifacts, { recursive: true })
-  const child = Bun.spawn([
-    process.execPath,
-    resolve(import.meta.dir, "driver-runner.ts"),
-    resolve(driver),
-    manifest.name,
-    manifest.endpoints.ui,
-    manifest.endpoints.backend,
-    manifest.artifacts,
-  ], {
-    cwd: process.cwd(),
-    env: cleanEnv(process.env),
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  })
-  const status = await child.exited
-  if (status !== 0) throw new Error(`driver exited with status ${status}`)
-}
-
-function cleanEnv(env: Readonly<Record<string, string | undefined>>) {
-  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined))
-}