opencode-drive 0.1.2 → 0.1.3

package/src/cli/restart.ts

@@ -1,70 +1,7 @@
-import { randomUUID } from "node:crypto"
-import { join } from "node:path"
-import { restartInstance } from "./instance.js"
+import { request } from "./control.js"
 import { resolveInstance } from "./registry.js"
 
-export async function restart(name?: string) {
-  const manifest = await resolveInstance(name ?? "default")
-  if (!manifest.headless) {
-    await restartVisible(manifest)
-    console.log("success")
-    return
-  }
-  process.kill(manifest.pid, "SIGTERM")
-  await Promise.race([waitForExit(manifest.pid), Bun.sleep(1_000)])
-  if (alive(manifest.pid)) process.kill(manifest.pid, "SIGKILL")
-  await waitForExit(manifest.pid)
-  await restartInstance(manifest)
+export async function restart(name: string) {
+  await request((await resolveInstance(name)).control, "restart")
   console.log("success")
 }
-
-async function restartVisible(manifest: Awaited<ReturnType<typeof resolveInstance>>) {
-  if (!(await Bun.file(join(manifest.artifacts, "launch.json")).exists())) {
-    throw new Error(`drive instance "${manifest.name}" was started by a version that does not support restart`)
-  }
-  const token = randomUUID()
-  const request = join(manifest.artifacts, "restart-request.json")
-  const response = join(manifest.artifacts, "restart-response.json")
-  await Bun.file(response).delete().catch(() => undefined)
-  await Bun.write(request, `${JSON.stringify({ token })}\n`)
-  const deadline = Date.now() + 60_000
-  while (Date.now() < deadline) {
-    const value = await Bun.file(response).json().catch(() => undefined)
-    if (isRestartResponse(value) && value.token === token) {
-      if (!value.success) throw new Error(value.error ?? "visible restart failed")
-      return
-    }
-    if (!alive(manifest.pid)) throw new Error(`drive instance "${manifest.name}" exited while restarting`)
-    await Bun.sleep(25)
-  }
-  throw new Error(`timed out restarting drive instance "${manifest.name}"`)
-}
-
-function isRestartResponse(value: unknown): value is {
-  readonly token: string
-  readonly success: boolean
-  readonly error?: string
-} {
-  if (typeof value !== "object" || value === null) return false
-  if (!("token" in value) || typeof value.token !== "string") return false
-  return "success" in value && typeof value.success === "boolean"
-}
-
-function waitForExit(pid: number) {
-  return new Promise<void>((resolve) => {
-    const check = () => {
-      if (!alive(pid)) return resolve()
-      setTimeout(check, 25)
-    }
-    check()
-  })
-}
-
-function alive(pid: number) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}

package/src/cli/script.ts

@@ -0,0 +1,66 @@
+import { resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+import { connectBackendSimulation, connectSimulation } from "../client/index.js"
+import type {
+  BackendSimulationClient,
+  SimulationClient,
+} from "../client/index.js"
+
+export interface ScriptContext {
+  readonly ui: SimulationClient
+  readonly backend: BackendSimulationClient
+  readonly artifacts: string
+  readonly signal: AbortSignal
+}
+
+export type DriveScript = (context: ScriptContext) => void | Promise<void>
+
+export function defineScript(script: DriveScript) {
+  return script
+}
+
+export async function runScript(
+  file: string,
+  artifacts: string,
+  endpoints: { readonly ui: string; readonly backend: string },
+  signal: AbortSignal,
+) {
+  const module: { readonly default?: unknown } = await import(
+    pathToFileURL(resolve(file)).href
+  )
+  const script = module.default
+  if (!isDriveScript(script))
+    throw new Error("script must default-export a function")
+  const ui = await connectSimulation({ url: endpoints.ui })
+  const backend = await connectBackendSimulation({
+    url: endpoints.backend,
+  }).catch((error) => {
+    ui.close()
+    throw error
+  })
+  const abort = () => {
+    ui.close()
+    backend.close()
+  }
+  signal.addEventListener("abort", abort, { once: true })
+  try {
+    await Promise.race([
+      script({ ui, backend, artifacts, signal }),
+      new Promise<never>((_resolve, reject) => {
+        signal.addEventListener(
+          "abort",
+          () => reject(signal.reason ?? new Error("script restarted")),
+          { once: true },
+        )
+      }),
+    ])
+  } finally {
+    signal.removeEventListener("abort", abort)
+    ui.close()
+    backend.close()
+  }
+}
+
+function isDriveScript(value: unknown): value is DriveScript {
+  return typeof value === "function"
+}

package/src/cli/send.ts

@@ -1,48 +1,28 @@
-import { tmpdir } from "node:os"
-import { join, resolve } from "node:path"
-import { defaultBackendPort, defaultPort } from "../client/index.js"
 import { executeCommands } from "./commands.js"
-import { runDriver } from "./driver.js"
-import { resolveInstance } from "./registry.js"
 import type { SendOptions } from "./types.js"
+import { resolveInstance } from "./registry.js"
 
 export async function send(options: SendOptions) {
-  const manifest = options.name
-    ? await resolveInstance(options.name)
-    : await resolveInstance("default").catch(() => defaultManifest())
-  if (options.commands.length > 0) {
-    const result = await executeCommands(manifest, options.commands)
-    if (options.commands.length === 1 && ["ui.screenshot", "ui.end-record"].includes(options.commands[0]?.operation ?? "")) {
-      console.log(result.results[0]?.result)
-      return
-    }
-    if (options.commands.length === 1 && ["llm.pending", "ui.state", "ui.start-record"].includes(options.commands[0]?.operation ?? "")) {
-      console.log(JSON.stringify(result.results[0]?.result, undefined, 2))
-      return
-    }
-    console.log("success")
+  if (options.commands.length === 0)
+    throw new Error("send requires at least one --command.ui.* flag")
+  const result = await executeCommands((await resolveInstance(options.name)).endpoints.ui, options.commands)
+  if (
+    options.commands.length === 1 &&
+    ["ui.screenshot", "ui.end-record"].includes(
+      options.commands[0]?.operation ?? "",
+    )
+  ) {
+    console.log(result.results[0]?.result)
     return
   }
-  if (options.driver) {
-    await runDriver(resolve(options.driver), manifest)
+  if (
+    options.commands.length === 1 &&
+    ["ui.state", "ui.start-record"].includes(
+      options.commands[0]?.operation ?? "",
+    )
+  ) {
+    console.log(JSON.stringify(result.results[0]?.result, undefined, 2))
     return
   }
-  console.log(JSON.stringify(manifest, undefined, 2))
-}
-
-function defaultManifest() {
-  return {
-    version: 1 as const,
-    name: "default",
-    pid: 0,
-    startedAt: new Date().toISOString(),
-    mode: "real" as const,
-    headless: false,
-    cwd: process.cwd(),
-    artifacts: join(tmpdir(), "opencode-drive", "default"),
-    endpoints: {
-      ui: `ws://127.0.0.1:${defaultPort}`,
-      backend: `ws://127.0.0.1:${defaultBackendPort}`,
-    },
-  }
+  console.log("success")
 }

package/src/cli/start.ts

@@ -1,98 +1,123 @@
-import { resolve } from "node:path"
-import { executeCommands } from "./commands.js"
-import { runCampaign } from "../experimental/cli-campaign.js"
-import { runDriver } from "./driver.js"
 import { launchInstance } from "./instance.js"
+import { connectMockBackend } from "./mock-backend.js"
+import { runScript } from "./script.js"
+import { listenControl } from "./control.js"
 import type { StartOptions } from "./types.js"
-import { join } from "node:path"
 
 export async function start(options: StartOptions) {
-  if (options.campaign) return runCampaign(options)
   const instance = await launchInstance({
-    name: options.name,
     command: options.command,
     dev: options.dev,
     state: options.state,
+    scripted: options.script !== undefined,
     visible: options.visible,
   })
-  console.error(`opencode-drive: ${instance.manifest.name}`)
-  console.error(`opencode-drive: artifacts ${instance.manifest.artifacts}`)
-  console.error(`opencode-drive: send commands with opencode-drive send --name ${instance.manifest.name}`)
-  if (options.detach) {
-    await instance.waitForDrive("both")
-    await instance.detach()
-    return
-  }
   const interrupt = () => void instance.stop()
-  const stopRestart = options.visible ? watchVisibleRestarts(instance) : () => {}
+  let completed = false
+  let current: ReturnType<typeof run> | undefined
+  let restarting: Promise<void> | undefined
   process.once("SIGINT", interrupt)
   process.once("SIGTERM", interrupt)
+  const closeControl = options.visible
+    ? await listenControl(() => {
+        if (restarting) return restarting
+        restarting = (async () => {
+          const previous = current
+          previous?.abort.abort(new Error("script restarted"))
+          await previous?.promise.catch(() => undefined)
+          await instance.restart()
+          current = run(options, instance)
+          await current.ready
+        })().finally(() => {
+          restarting = undefined
+        })
+        return restarting
+      })
+    : undefined
   try {
-    if (options.commands.length > 0) {
-      await instance.waitForDrive("both")
-      const result = await executeCommands(instance.manifest, options.commands)
-      await instance.stop()
-      if (options.commands.length === 1 && ["ui.screenshot", "ui.end-record"].includes(options.commands[0]?.operation ?? "")) {
-        console.log(result.results[0]?.result)
-        return
-      }
-      if (options.commands.length === 1 && ["llm.pending", "ui.state", "ui.start-record"].includes(options.commands[0]?.operation ?? "")) {
-        console.log(JSON.stringify(result.results[0]?.result, undefined, 2))
-        return
-      }
-      console.log("success")
+    current = run(options, instance)
+    if (options.visible) {
+      const status = await instance.wait()
+      if (status !== 0) process.exitCode = status
       return
     }
-    if (options.driver) {
-      await instance.waitForDrive("both")
-      await runDriver(resolve(options.driver), instance.manifest)
-      return
+    while (true) {
+      const active: NonNullable<typeof current> = current
+      await active.promise
+      if (active !== current) continue
+      completed = true
+      break
     }
-    const status = await instance.wait()
-    if (status !== 0) process.exitCode = status
   } finally {
     process.off("SIGINT", interrupt)
     process.off("SIGTERM", interrupt)
-    stopRestart()
+    current?.abort.abort(new Error("opencode-drive stopped"))
+    await closeControl?.()
     await instance.stop()
+    if (options.script && !options.visible)
+      report(instance, completed ? "completed" : undefined)
   }
 }
 
-function watchVisibleRestarts(instance: Awaited<ReturnType<typeof launchInstance>>) {
-  const request = join(instance.manifest.artifacts, "restart-request.json")
-  const response = join(instance.manifest.artifacts, "restart-response.json")
-  const state = { token: undefined as string | undefined, busy: false }
-  const timer = setInterval(() => {
-    if (state.busy) return
-    state.busy = true
-    void handleVisibleRestart(instance, request, response, state).finally(() => {
-      state.busy = false
-    })
-  }, 50)
-  return () => clearInterval(timer)
-}
-
-async function handleVisibleRestart(
+function run(
+  options: StartOptions,
   instance: Awaited<ReturnType<typeof launchInstance>>,
-  request: string,
-  response: string,
-  state: { token: string | undefined },
 ) {
-  const value: unknown = await Bun.file(request).json().catch(() => undefined)
-  if (!isRestartRequest(value) || value.token === state.token) return
-  state.token = value.token
-  try {
-    await instance.restart()
-    await Bun.write(response, `${JSON.stringify({ token: value.token, success: true })}\n`)
-  } catch (error) {
-    await Bun.write(response, `${JSON.stringify({
-      token: value.token,
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    })}\n`)
+  const abort = new AbortController()
+  const child = instance.child
+  let ready!: () => void
+  const readiness = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+  return {
+    abort,
+    ready: readiness,
+    promise: (async () => {
+      await instance.waitForDrive("both")
+      if (options.script) {
+        const script = runScript(
+          options.script,
+          instance.artifacts,
+          instance.endpoints,
+          abort.signal,
+        )
+        ready()
+        await script
+        if (options.visible) {
+          await Promise.race([
+            child.exited,
+            new Promise<void>((resolve) => {
+              abort.signal.addEventListener("abort", () => resolve(), {
+                once: true,
+              })
+            }),
+          ])
+        }
+        return
+      }
+      const mock = await connectMockBackend(instance.endpoints.backend)
+      ready()
+      abort.signal.addEventListener("abort", () => mock.close(), { once: true })
+      if (!options.visible) report(instance)
+      const status = await Promise.race([
+        child.exited,
+        new Promise<number>((resolve) => {
+          abort.signal.addEventListener("abort", () => resolve(0), {
+            once: true,
+          })
+        }),
+      ])
+      mock.close()
+      if (status !== 0 && !abort.signal.aborted) process.exitCode = status
+    })(),
   }
 }
 
-function isRestartRequest(value: unknown): value is { readonly token: string } {
-  return typeof value === "object" && value !== null && "token" in value && typeof value.token === "string"
+function report(
+  instance: Awaited<ReturnType<typeof launchInstance>>,
+  status?: string,
+) {
+  if (status) console.error(`opencode-drive: ${status}`)
+  console.error(`opencode-drive: artifacts ${instance.artifacts}`)
+  console.error(`opencode-drive: logs ${instance.logs}`)
 }

package/src/cli/stop.ts

@@ -1,31 +1,7 @@
-import { resolveInstance, unregisterInstance } from "./registry.js"
+import { request } from "./control.js"
+import { resolveInstance } from "./registry.js"
 
-export async function stop(name?: string) {
-  const manifest = await resolveInstance(name ?? "default")
-  if (!manifest.headless) throw new Error(`drive instance "${manifest.name}" is visible`)
-  process.kill(manifest.pid, "SIGTERM")
-  await Promise.race([waitForExit(manifest.pid), Bun.sleep(1_000)])
-  if (alive(manifest.pid)) process.kill(manifest.pid, "SIGKILL")
-  await waitForExit(manifest.pid)
-  await unregisterInstance(manifest.name, manifest.pid)
+export async function stop(name: string) {
+  await request((await resolveInstance(name)).control, "stop")
   console.log("success")
 }
-
-function waitForExit(pid: number) {
-  return new Promise<void>((resolve) => {
-    const check = () => {
-      if (!alive(pid)) return resolve()
-      setTimeout(check, 25)
-    }
-    check()
-  })
-}
-
-function alive(pid: number) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}

package/src/cli/types.ts

@@ -1,46 +1,23 @@
-export interface InstanceManifest {
-  readonly version: 1
-  readonly name: string
-  readonly pid: number
-  readonly startedAt: string
-  readonly mode: "simulated" | "real"
-  readonly headless: boolean
-  readonly cwd: string
-  readonly artifacts: string
-  readonly endpoints: {
-    readonly ui: string
-    readonly backend: string
-  }
-}
-
 export interface DriveCommand {
   readonly operation: string
   readonly value?: string
 }
 
-export interface CommonOptions {
-  readonly name?: string
-  readonly driver?: string
-  readonly commands: ReadonlyArray<DriveCommand>
-}
-
-export interface StartOptions extends CommonOptions {
+export interface StartOptions {
   readonly kind: "start"
-  readonly detach: boolean
-  readonly campaign?: string
-  readonly seed: number
-  readonly caseIndex?: number
-  readonly count?: number
-  readonly concurrency: number
+  readonly name: string
+  readonly daemon: boolean
+  readonly script?: string
   readonly visible: boolean
   readonly dev?: string
   readonly state?: string
-  readonly anchor?: string
   readonly command: ReadonlyArray<string>
 }
 
-export interface SendOptions extends CommonOptions {
+export interface SendOptions {
   readonly kind: "send"
+  readonly name: string
+  readonly commands: ReadonlyArray<DriveCommand>
 }
 
 export type CliOptions = StartOptions | SendOptions