opencode-drive 0.1.3 → 0.1.4

package/src/cli/send.ts

@@ -5,7 +5,10 @@ import { resolveInstance } from "./registry.js"
 export async function send(options: SendOptions) {
   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)
+  const result = await executeCommands(
+    (await resolveInstance(options.name)).endpoints.ui,
+    options.commands,
+  )
   if (
     options.commands.length === 1 &&
     ["ui.screenshot", "ui.end-record"].includes(

package/src/cli/start.ts

@@ -1,49 +1,101 @@
 import { launchInstance } from "./instance.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.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,
   })
+  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()
   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)
-  const closeControl = options.visible
-    ? await listenControl(() => {
+  let closeControl: (() => Promise<void>) | undefined
+  try {
+    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)
+          current = run(options, instance, responses)
           await current.ready
+          await markReady(options.name, process.pid)
         })().finally(() => {
           restarting = undefined
         })
         return restarting
-      })
-    : undefined
-  try {
-    current = run(options, instance)
+      },
+      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) process.exitCode = status
+      if (status !== 0 && !stopping) process.exitCode = status
       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
@@ -54,14 +106,76 @@ export async function start(options: StartOptions) {
     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)
   }
 }
 
+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
+}
+
 function run(
   options: StartOptions,
   instance: Awaited<ReturnType<typeof launchInstance>>,
+  responses: ReturnType<typeof createResponseSettings>,
 ) {
   const abort = new AbortController()
   const child = instance.child
@@ -86,26 +200,25 @@ function run(
         if (options.visible) {
           await Promise.race([
             child.exited,
-            new Promise<void>((resolve) => {
+            new Promise<void>((resolve) =>
               abort.signal.addEventListener("abort", () => resolve(), {
                 once: true,
-              })
-            }),
+              }),
+            ),
           ])
         }
         return
       }
-      const mock = await connectMockBackend(instance.endpoints.backend)
+      const mock = await connectMockBackend(instance.endpoints.backend, responses)
       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) => {
+        new Promise<number>((resolve) =>
           abort.signal.addEventListener("abort", () => resolve(0), {
             once: true,
-          })
-        }),
+          }),
+        ),
       ])
       mock.close()
       if (status !== 0 && !abort.signal.aborted) process.exitCode = status
@@ -114,10 +227,9 @@ function run(
 }
 
 function report(
-  instance: Awaited<ReturnType<typeof launchInstance>>,
+  instance: { readonly artifacts: string; readonly logs: string },
   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,7 +1,24 @@
 import { request } from "./control.js"
-import { resolveInstance } from "./registry.js"
+import { manifestPath, resolveInstance } from "./registry.js"
 
-export async function stop(name: string) {
-  await request((await resolveInstance(name)).control, "stop")
-  console.log("success")
+export async function stop(name?: string) {
+  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
+    }
+    await Bun.sleep(25)
+  }
+  throw new Error(`timed out stopping drive instance "${manifest.name}"`)
 }

package/src/cli/types.ts

@@ -16,7 +16,7 @@ export interface StartOptions {
 
 export interface SendOptions {
   readonly kind: "send"
-  readonly name: string
+  readonly name?: string
   readonly commands: ReadonlyArray<DriveCommand>
 }
 

package/src/client/backend.ts

@@ -159,7 +159,7 @@ export class BackendSimulationClient {
 
   close() {
     this.closing = true
-    this.socket.close()
+    this.socket.terminate()
   }
 
   private onMessage(data: string) {

package/src/client/client.ts

@@ -1,21 +1,48 @@
-import {
-  Frontend,
-  type JsonRpc,
-} from "./protocol.js"
+import { Frontend, type JsonRpc } from "./protocol.js"
 
 const defaultPort = 40900
 
 type Methods = {
-  readonly "ui.screenshot": { readonly params: undefined; readonly result: Frontend.Screenshot }
-  readonly "ui.state": { readonly params: undefined; readonly result: Frontend.State }
-  readonly "ui.start-record": { readonly params: undefined; readonly result: Frontend.StartRecord }
-  readonly "ui.end-record": { readonly params: undefined; readonly result: Frontend.EndRecord }
-  readonly "ui.type": { readonly params: Frontend.TypeParams; readonly result: Frontend.State }
-  readonly "ui.press": { readonly params: Frontend.PressParams; readonly result: Frontend.State }
-  readonly "ui.enter": { readonly params: undefined; readonly result: Frontend.State }
-  readonly "ui.arrow": { readonly params: Frontend.ArrowParams; readonly result: Frontend.State }
-  readonly "ui.focus": { readonly params: Frontend.FocusParams; readonly result: Frontend.State }
-  readonly "ui.click": { readonly params: Frontend.ClickParams; readonly result: Frontend.State }
+  readonly "ui.screenshot": {
+    readonly params: undefined
+    readonly result: Frontend.Screenshot
+  }
+  readonly "ui.state": {
+    readonly params: undefined
+    readonly result: Frontend.State
+  }
+  readonly "ui.start-record": {
+    readonly params: undefined
+    readonly result: Frontend.StartRecord
+  }
+  readonly "ui.end-record": {
+    readonly params: undefined
+    readonly result: Frontend.EndRecord
+  }
+  readonly "ui.type": {
+    readonly params: Frontend.TypeParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.press": {
+    readonly params: Frontend.PressParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.enter": {
+    readonly params: undefined
+    readonly result: Frontend.State
+  }
+  readonly "ui.arrow": {
+    readonly params: Frontend.ArrowParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.focus": {
+    readonly params: Frontend.FocusParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.click": {
+    readonly params: Frontend.ClickParams
+    readonly result: Frontend.State
+  }
 }
 
 type MethodName = keyof Methods
@@ -73,12 +100,20 @@ export class SimulationClient {
     this.socket = socket
     this.url = url
     this.timeout = timeout
-    socket.addEventListener("message", (event) => this.onMessage(String(event.data)))
-    socket.addEventListener("close", () => this.rejectAll(new SimulationError("connection closed")))
-    socket.addEventListener("error", () => this.rejectAll(new SimulationError("connection error")))
+    socket.addEventListener("message", (event) =>
+      this.onMessage(String(event.data)),
+    )
+    socket.addEventListener("close", () =>
+      this.rejectAll(new SimulationError("connection closed")),
+    )
+    socket.addEventListener("error", () =>
+      this.rejectAll(new SimulationError("connection error")),
+    )
   }
 
-  static async connect(options?: SimulationClientOptions): Promise<SimulationClient> {
+  static async connect(
+    options?: SimulationClientOptions,
+  ): Promise<SimulationClient> {
     const timeout = options?.timeout ?? 30_000
     if (options?.url !== undefined) {
       return new SimulationClient(await open(options.url), options.url, timeout)
@@ -100,7 +135,10 @@ export class SimulationClient {
   }
 
   /** Raw JSON-RPC call. Prefer the typed wrappers below. */
-  async call<M extends MethodName>(method: M, params?: Methods[M]["params"]): Promise<Methods[M]["result"]> {
+  async call<M extends MethodName>(
+    method: M,
+    params?: Methods[M]["params"],
+  ): Promise<Methods[M]["result"]> {
     if (this.socket.readyState !== WebSocket.OPEN) {
       throw new SimulationError("connection is not open", method)
     }
@@ -112,7 +150,14 @@ export class SimulationClient {
       }, 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 }),
+      }),
+    )
     // The server contract types each method's result; the cast happens once
     // here rather than at every call site.
     return (await promise) as Methods[M]["result"]
@@ -142,15 +187,23 @@ export class SimulationClient {
     return this.call("ui.type", { text })
   }
 
-  pressKey(key: string, modifiers?: Frontend.KeyModifiers): Promise<Frontend.State> {
-    return this.call("ui.press", { key: key === "escape" ? "\u001b" : key, ...(modifiers === undefined ? {} : { modifiers }) })
+  pressKey(
+    key: string,
+    modifiers?: Frontend.KeyModifiers,
+  ): Promise<Frontend.State> {
+    return this.call("ui.press", {
+      key: key === "escape" ? "\u001b" : key,
+      ...(modifiers === undefined ? {} : { modifiers }),
+    })
   }
 
   pressEnter(): Promise<Frontend.State> {
     return this.call("ui.enter")
   }
 
-  pressArrow(direction: "up" | "down" | "left" | "right"): Promise<Frontend.State> {
+  pressArrow(
+    direction: "up" | "down" | "left" | "right",
+  ): Promise<Frontend.State> {
     return this.call("ui.arrow", { direction })
   }
 
@@ -165,7 +218,7 @@ export class SimulationClient {
   // ── lifecycle ─────────────────────────────────────────────────────────
 
   close(): void {
-    this.socket.close()
+    this.socket.terminate()
   }
 
   private onMessage(data: string) {
@@ -175,7 +228,8 @@ export class SimulationClient {
     if (waiter === undefined) return
     this.pending.delete(message.id)
     clearTimeout(waiter.timer)
-    if (message.error) waiter.reject(new SimulationError(message.error.message, waiter.method))
+    if (message.error)
+      waiter.reject(new SimulationError(message.error.message, waiter.method))
     else waiter.resolve(message.result)
   }
 
@@ -199,14 +253,16 @@ function parseResponse(data: string): JsonRpc.Response | undefined {
   if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") return undefined
   if (!("id" in value)) return undefined
   const id = value.id
-  if (typeof id !== "number" && typeof id !== "string" && id !== null) return undefined
+  if (typeof id !== "number" && typeof id !== "string" && id !== null)
+    return undefined
   const result = "result" in value ? value.result : undefined
   const error = "error" in value ? value.error : undefined
   if (error !== undefined) {
     if (typeof error !== "object" || error === null) return undefined
     const code = "code" in error ? error.code : undefined
     const message = "message" in error ? error.message : undefined
-    if (typeof code !== "number" || typeof message !== "string") return undefined
+    if (typeof code !== "number" || typeof message !== "string")
+      return undefined
     return { jsonrpc: "2.0", id, error: { code, message } }
   }
   return { jsonrpc: "2.0", id, result: result as JsonRpc.Response["result"] }
@@ -232,5 +288,6 @@ function open(url: string): Promise<WebSocket> {
   })
 }
 
-export const connectSimulation = (options?: SimulationClientOptions): Promise<SimulationClient> =>
-  SimulationClient.connect(options)
+export const connectSimulation = (
+  options?: SimulationClientOptions,
+): Promise<SimulationClient> => SimulationClient.connect(options)

package/src/client/protocol.ts

@@ -191,6 +191,7 @@ export namespace Backend {
     }),
     Schema.Struct({
       type: Schema.Literal("toolCall"),
+      index: Schema.Number,
       id: Schema.String,
       name: Schema.String,
       input: Schema.Json,

package/src/cli/describe.ts

@@ -1,13 +0,0 @@
-import { resolveInstance } from "./registry.js"
-
-export async function describe(name: string) {
-  const manifest = await resolveInstance(name)
-  console.log([
-    `PID: ${manifest.pid}`,
-    `Visible: ${manifest.visible}`,
-    `Artifacts: ${manifest.artifacts}`,
-    `UI: ${manifest.endpoints.ui}`,
-    `Backend: ${manifest.endpoints.backend}`,
-    `Logs: ${manifest.artifacts}/logs`,
-  ].join("\n"))
-}