opencode-drive 0.1.1 → 0.1.3

package/src/cli/mock-backend.ts

@@ -0,0 +1,25 @@
+import { connectBackendSimulation } from "../client/index.js"
+
+const response = "This is a sample response from opencode-drive."
+
+export async function connectMockBackend(endpoint: string) {
+  const backend = await connectBackendSimulation({ url: endpoint })
+  let closing = false
+  await backend.attach((request) => {
+    void backend
+      .chunk(request.id, [{ type: "textDelta", text: response }])
+      .then(() => backend.finish(request.id))
+      .catch((error) => {
+        if (!closing)
+          console.error(
+            `error: ${error instanceof Error ? error.message : String(error)}`,
+          )
+      })
+  })
+  return {
+    close() {
+      closing = true
+      backend.close()
+    },
+  }
+}

package/src/cli/registry.ts

@@ -1,92 +1,54 @@
+import { mkdir, rm } from "node:fs/promises"
 import { homedir } from "node:os"
-import { basename, join } from "node:path"
-import { mkdir, open, readdir, rename, rm } from "node:fs/promises"
-import type { InstanceManifest } from "./types.js"
+import { join } from "node:path"
+
+export interface InstanceManifest {
+  readonly version: 1
+  readonly name: string
+  readonly pid: number
+  readonly artifacts: string
+  readonly visible: boolean
+  readonly endpoints: { readonly ui: string; readonly backend: string }
+  readonly control: string
+}
 
 export function registryDirectory() {
-  if (process.env.DRIVE_REGISTRY_DIR) return process.env.DRIVE_REGISTRY_DIR
-  return join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "opencode-drive", "instances")
+  return process.env.DRIVE_REGISTRY_DIR ?? join(homedir(), ".local", "state", "opencode-drive", "instances")
 }
 
 export function manifestPath(name: string) {
   return join(registryDirectory(), `${validateName(name)}.json`)
 }
 
-export async function registerInstance(manifest: InstanceManifest) {
-  await mkdir(registryDirectory(), { recursive: true })
-  const file = manifestPath(manifest.name)
-  const lock = `${file}.lock`
-  const existing = await readManifest(file)
-  if (existing && processAlive(existing.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
-  if (existing) await rm(file, { force: true })
-  const handle = await open(lock, "wx").catch(() => undefined)
-  if (!handle) throw new Error(`drive instance "${manifest.name}" is already starting`)
-  try {
-    const current = await readManifest(file)
-    if (current && processAlive(current.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
-    const temporary = `${file}.${process.pid}.tmp`
-    await Bun.write(temporary, `${JSON.stringify(manifest, undefined, 2)}\n`)
-    await rename(temporary, file)
-    return file
-  } finally {
-    await handle.close()
-    await rm(lock, { force: true })
-  }
+export function controlPath(name: string) {
+  return join(registryDirectory(), `${validateName(name)}.sock`)
 }
 
-export async function unregisterInstance(name: string, pid: number) {
-  const file = manifestPath(name)
-  const manifest = await readManifest(file)
-  if (manifest?.pid !== pid) return
-  await rm(file, { force: true })
-}
-
-export async function transferInstance(manifest: InstanceManifest, pid: number) {
-  const file = manifestPath(manifest.name)
-  const current = await readManifest(file)
-  if (current?.pid !== manifest.pid) throw new Error(`drive instance "${manifest.name}" changed ownership`)
-  const temporary = `${file}.${process.pid}.tmp`
-  await Bun.write(temporary, `${JSON.stringify({ ...manifest, pid }, undefined, 2)}\n`)
-  await rename(temporary, file)
+export async function register(manifest: InstanceManifest) {
+  await mkdir(registryDirectory(), { recursive: true })
+  const existing = await read(manifest.name).catch(() => undefined)
+  if (existing && alive(existing.pid)) throw new Error(`drive instance "${manifest.name}" is already running`)
+  await rm(manifest.control, { force: true })
+  await Bun.write(manifestPath(manifest.name), `${JSON.stringify(manifest, undefined, 2)}\n`)
 }
 
-export async function resolveInstance(name?: string) {
-  const instances = await listInstances()
-  if (name) {
-    const instance = instances.find((item) => item.name === name)
-    if (!instance) throw new Error(`drive instance "${name}" was not found`)
-    return instance
+export async function resolveInstance(name = "default") {
+  const manifest = await read(name)
+  if (!alive(manifest.pid)) {
+    await unregister(name)
+    throw new Error(`drive instance "${name}" is not running`)
   }
-  if (instances.length === 1) return instances[0]!
-  if (instances.length === 0) throw new Error("no drive instances are running")
-  throw new Error(`multiple drive instances are running; pass --name (${instances.map((item) => item.name).join(", ")})`)
+  return manifest
 }
 
-export async function listInstances() {
-  await mkdir(registryDirectory(), { recursive: true })
-  const directory = registryDirectory()
-  const files = (await readdir(directory)).filter((file) => file.endsWith(".json"))
-  const entries = await Promise.all(files.map((file) => readManifest(join(directory, file))))
-  const active = entries.filter((entry): entry is InstanceManifest => entry !== undefined && processAlive(entry.pid))
-  const activeNames = new Set(active.map((entry) => entry.name))
-  await Promise.all(
-    files
-      .filter((file) => !activeNames.has(basename(file, ".json")))
-      .map((file) => rm(join(directory, file), { force: true })),
-  )
-  return active.sort((a, b) => a.name.localeCompare(b.name))
+export async function unregister(name: string) {
+  await Promise.all([rm(manifestPath(name), { force: true }), rm(controlPath(name), { force: true })])
 }
 
-async function readManifest(file: string): Promise<InstanceManifest | undefined> {
-  if (!(await Bun.file(file).exists())) return undefined
-  try {
-    const value = await Bun.file(file).json()
-    if (!isManifest(value)) return undefined
-    return value
-  } catch {
-    await rm(file, { force: true })
-    return undefined
-  }
+async function read(name: string): Promise<InstanceManifest> {
+  const value: unknown = await Bun.file(manifestPath(name)).json().catch(() => undefined)
+  if (!isManifest(value)) throw new Error(`drive instance "${name}" was not found`)
+  return value
 }
 
 function isManifest(value: unknown): value is InstanceManifest {
@@ -94,16 +56,19 @@ function isManifest(value: unknown): value is InstanceManifest {
   if (!("version" in value) || value.version !== 1) return false
   if (!("name" in value) || typeof value.name !== "string") return false
   if (!("pid" in value) || typeof value.pid !== "number") return false
-  if (!("startedAt" in value) || typeof value.startedAt !== "string") return false
-  if (!("mode" in value) || (value.mode !== "simulated" && value.mode !== "real")) return false
-  if (!("headless" in value) || typeof value.headless !== "boolean") return false
-  if (!("cwd" in value) || typeof value.cwd !== "string") return false
   if (!("artifacts" in value) || typeof value.artifacts !== "string") return false
+  if (!("visible" in value) || typeof value.visible !== "boolean") return false
+  if (!("control" in value) || typeof value.control !== "string") return false
   if (!("endpoints" in value) || typeof value.endpoints !== "object" || value.endpoints === null) return false
   return "ui" in value.endpoints && typeof value.endpoints.ui === "string" && "backend" in value.endpoints && typeof value.endpoints.backend === "string"
 }
 
-function processAlive(pid: number) {
+function validateName(name: string) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(name)) throw new Error(`invalid instance name "${name}"`)
+  return name
+}
+
+function alive(pid: number) {
   try {
     process.kill(pid, 0)
     return true
@@ -111,10 +76,3 @@ function processAlive(pid: number) {
     return false
   }
 }
-
-function validateName(name: string) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(name)) {
-    throw new Error("instance names must contain 1-64 letters, numbers, dots, underscores, or dashes")
-  }
-  return name
-}

package/src/cli/restart.ts

@@ -0,0 +1,7 @@
+import { request } from "./control.js"
+import { resolveInstance } from "./registry.js"
+
+export async function restart(name: string) {
+  await request((await resolveInstance(name)).control, "restart")
+  console.log("success")
+}

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 && ["render", "end-record"].includes(options.commands[0]?.operation ?? "")) {
-      console.log(result.results[0]?.result)
-      return
-    }
-    if (options.commands.length === 1 && ["llm.pending", "state", "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,56 +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"
 
 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()
+  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 && ["render", "end-record"].includes(options.commands[0]?.operation ?? "")) {
-        console.log(result.results[0]?.result)
-        return
-      }
-      if (options.commands.length === 1 && ["llm.pending", "state", "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.child.exited
-    if (status !== 0) process.exitCode = status
   } finally {
     process.off("SIGINT", interrupt)
     process.off("SIGTERM", interrupt)
+    current?.abort.abort(new Error("opencode-drive stopped"))
+    await closeControl?.()
     await instance.stop()
+    if (options.script && !options.visible)
+      report(instance, completed ? "completed" : undefined)
   }
 }
+
+function run(
+  options: StartOptions,
+  instance: Awaited<ReturnType<typeof launchInstance>>,
+) {
+  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 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