opencode-drive 0.1.2 → 0.1.4

package/src/cli/responses.ts

@@ -0,0 +1,20 @@
+import { requestResponses } from "./control.js"
+import { resolveInstance } from "./registry.js"
+
+export async function responses(options: {
+  readonly name?: string
+  readonly types?: string
+  readonly tools?: string
+}) {
+  const manifest = await resolveInstance(options.name)
+  const configuration = await requestResponses(manifest.control, {
+    ...(options.types === undefined ? {} : { types: split(options.types) }),
+    ...(options.tools === undefined ? {} : { tools: split(options.tools) }),
+  })
+  console.log(`Types: ${configuration.types.join(",")}`)
+  console.log(`Tools: ${configuration.tools.join(",")}`)
+}
+
+function split(value: string) {
+  return value.split(",").map((item) => item.trim())
+}

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)
+  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,77 @@
+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 waitForEditor(ui, signal)
+    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()
+  }
+}
+
+async function waitForEditor(ui: SimulationClient, signal: AbortSignal) {
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline) {
+    signal.throwIfAborted()
+    if ((await ui.state()).focused.editor) return
+    await Bun.sleep(50)
+  }
+  throw new Error("timed out waiting for the prompt editor")
+}
+
+function isDriveScript(value: unknown): value is DriveScript {
+  return typeof value === "function"
+}

package/src/cli/send.ts

@@ -1,48 +1,31 @@
-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,235 @@
-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 type { StartOptions } from "./types.js"
+import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
+import { connectMockBackend } from "./mock-backend.js"
+import { createResponseSettings } from "./response-generator.js"
+import { runScript } from "./script.js"
+import { listenControl } from "./control.js"
+import {
+  controlPath,
+  markReady,
+  markStarting,
+  register,
+  registryDirectory,
+  resolveInstance,
+  unregister,
+} from "./registry.js"
+import type { StartOptions } from "./types.js"
 
 export async function start(options: StartOptions) {
-  if (options.campaign) return runCampaign(options)
+  if (!options.visible && !options.script && !options.daemon)
+    return startDetached(options)
+  const responses = createResponseSettings()
   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
-  }
+  await register({
+    version: 1,
+    name: options.name,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    cwd: process.cwd(),
+    artifacts: instance.artifacts,
+    visible: options.visible,
+    status: "starting",
+    endpoints: instance.endpoints,
+    control: controlPath(options.name),
+  }).catch(async (error) => {
+    await instance.stop()
+    throw error
+  })
   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
+  let stopping = false
   process.once("SIGINT", interrupt)
   process.once("SIGTERM", interrupt)
+  let closeControl: (() => Promise<void>) | 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")
+    closeControl = await listenControl(controlPath(options.name), {
+      restart: () => {
+        if (restarting) return restarting
+        restarting = (async () => {
+          await markStarting(options.name, process.pid)
+          const previous = current
+          previous?.abort.abort(new Error("script restarted"))
+          await previous?.promise.catch(() => undefined)
+          await instance.restart()
+          current = run(options, instance, responses)
+          await current.ready
+          await markReady(options.name, process.pid)
+        })().finally(() => {
+          restarting = undefined
+        })
+        return restarting
+      },
+      stop: async () => {
+        stopping = true
+        current?.abort.abort(new Error("opencode-drive stopped"))
+        await instance.stop()
+      },
+      responses: async (input) => {
+        if (options.script)
+          throw new Error("responses are unavailable when --script owns the simulation backend")
+        return responses.update(input)
+      },
+    })
+    current = run(options, instance, responses)
+    await current.ready
+    await markReady(options.name, process.pid)
+    if (options.visible) {
+      const status = await instance.wait()
+      if (status !== 0 && !stopping) 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 (stopping) break
+      if (restarting) {
+        await restarting
+        continue
+      }
+      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()
+    await unregister(options.name, process.pid)
+    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 startDetached(options: StartOptions) {
+  const existing = await resolveInstance(options.name, { ready: false }).catch(() => undefined)
+  if (existing)
+    throw new Error(`drive instance "${options.name}" is already running`)
+  const ownerLog = join(registryDirectory(), `${options.name}.log`)
+  await mkdir(registryDirectory(), { recursive: true })
+  await rm(ownerLog, { force: true })
+  const child = Bun.spawn(
+    [
+      process.execPath,
+      process.argv[1]!,
+      "start",
+      "--daemon",
+      "--name",
+      options.name,
+      ...(options.script ? ["--script", options.script] : []),
+      ...(options.dev ? ["--dev", options.dev] : []),
+      ...(options.state ? ["--state", options.state] : []),
+      ...(options.command.length ? ["--", ...options.command] : []),
+    ],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: Bun.file(ownerLog),
+    },
+  )
+  child.unref()
+  const deadline = Date.now() + 60_000
+  while (Date.now() < deadline) {
+    const manifest = await resolveInstance(options.name).catch(() => undefined)
+    if (manifest?.pid === child.pid) {
+      report({
+        artifacts: manifest.artifacts,
+        logs: `${manifest.artifacts}/logs`,
+      })
+      return
+    }
+    if (child.exitCode !== null)
+      throw new Error(
+        `detached instance exited with status ${child.exitCode}; see ${ownerLog}`,
+      )
+    await Bun.sleep(50)
+  }
+  await terminateOwner(child)
+  throw new Error(
+    `timed out starting drive instance "${options.name}"; see ${ownerLog}`,
+  )
+}
+
+async function terminateOwner(child: Bun.Subprocess) {
+  if (child.exitCode !== null) return
+  child.kill("SIGTERM")
+  const deadline = Date.now() + 1_000
+  while (child.exitCode === null && Date.now() < deadline) await Bun.sleep(25)
+  if (child.exitCode === null) child.kill("SIGKILL")
+  await child.exited
 }
 
-async function handleVisibleRestart(
+function run(
+  options: StartOptions,
   instance: Awaited<ReturnType<typeof launchInstance>>,
-  request: string,
-  response: string,
-  state: { token: string | undefined },
+  responses: ReturnType<typeof createResponseSettings>,
 ) {
-  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, responses)
+      ready()
+      abort.signal.addEventListener("abort", () => mock.close(), { once: true })
+      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: { readonly artifacts: string; readonly logs: string },
+  status?: string,
+) {
+  if (status) console.error(`opencode-drive: ${status}`)
+  console.error(`opencode-drive: artifacts ${instance.artifacts}`)
 }

package/src/cli/stop.ts

@@ -1,31 +1,24 @@
-import { resolveInstance, unregisterInstance } from "./registry.js"
+import { request } from "./control.js"
+import { manifestPath, 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)
-  console.log("success")
-}
-
-function waitForExit(pid: number) {
-  return new Promise<void>((resolve) => {
-    const check = () => {
-      if (!alive(pid)) return resolve()
-      setTimeout(check, 25)
+  const manifest = await resolveInstance(name)
+  await request(manifest.control, "stop")
+  const deadline = Date.now() + 10_000
+  while (Date.now() < deadline) {
+    const current: unknown = await Bun.file(manifestPath(manifest.name))
+      .json()
+      .catch(() => undefined)
+    if (
+      typeof current !== "object" ||
+      current === null ||
+      !("pid" in current) ||
+      current.pid !== manifest.pid
+    ) {
+      console.log("success")
+      return
     }
-    check()
-  })
-}
-
-function alive(pid: number) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
+    await Bun.sleep(25)
   }
+  throw new Error(`timed out stopping drive instance "${manifest.name}"`)
 }

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