opencode-drive 0.2.0 → 0.2.1

package/README.md

@@ -2,14 +2,15 @@
 
 This project gives your agents control over OpenCode:
 
-* Run it during development and let your agents see and poke at the running instance
-* Allow your agents to run it in headless mode and drive it to test things
+- Run it during development and let your agents see and poke at the running instance
+- Allow your agents to run it in headless mode and drive it to test things
 
 ## Skill
 
 ```sh
 npx skills add jlongster/opencode-drive --agent opencode --skill opencode-drive
 ```
+
 ## OpenCode development
 
 Run this:
@@ -33,9 +34,20 @@ If you are doing UI development in OpenCode, you might want to run it in a simul
 Run it in visible mode:
 
 ```sh
-opencode-drive start --visible --dev ~/projects/opencode
+opencode-drive start --name demo --visible --dev ~/projects/opencode
+```
+
+Initialize first when you need to customize the isolated environment before OpenCode starts:
+
+```sh
+artifacts=$(opencode-drive init --name demo)
+cp -R ./fixtures/home/. "$artifacts/"
+cp -R ./fixtures/project/. "$artifacts/files/"
+opencode-drive start --name demo --visible --dev ~/projects/opencode
 ```
 
+`start` reuses the prepared artifacts for that name. If `init` was not run, `start` initializes them automatically.
+
 While developing, you can run `opencode-drive restart` to restart only the UI (the server will persist as a separate process). Do this with agents, and they will always restart and get the UI where you want it to be automatically.
 
 View the [skills file](https://github.com/jlongster/opencode-drive/blob/main/skills/opencode-drive/SKILL.md) for more details about the CLI.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-drive",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Drive real and simulated OpenCode instances",
   "license": "MIT",
   "type": "module",

package/src/cli/index.ts

@@ -4,6 +4,7 @@ import { Effect, Option } from "effect"
 import { Command, Flag } from "effect/unstable/cli"
 import packageJson from "../../package.json" with { type: "json" }
 import { extractCommands } from "./parse.js"
+import { init } from "./init.js"
 import { list } from "./list.js"
 import { logs } from "./logs.js"
 import { restart } from "./restart.js"
@@ -15,7 +16,6 @@ import type { DriveCommand, SendOptions, StartOptions } from "./types.js"
 
 const extracted = extract()
 const startName = Flag.string("name").pipe(
-  Flag.withDefault("default"),
   Flag.withDescription("Instance name"),
 )
 const name = Flag.string("name").pipe(
@@ -23,6 +23,18 @@ const name = Flag.string("name").pipe(
   Flag.withDescription("Instance name (inferred when exactly one is running)"),
 )
 
+const initCommand = Command.make("init", { name: startName }, (config) =>
+  execute(() => init(config.name)),
+).pipe(
+  Command.withDescription("Initialize an instance without launching OpenCode"),
+  Command.withExamples([
+    {
+      command: "opencode-drive init --name demo",
+      description: "Create an instance and print its artifact directory",
+    },
+  ]),
+)
+
 const startCommand = Command.make(
   "start",
   {
@@ -35,9 +47,7 @@ const startCommand = Command.make(
       Flag.optional,
       Flag.withDescription("JavaScript or TypeScript automation module"),
     ),
-    visible: Flag.boolean("visible").pipe(
-      Flag.withDescription("Show OpenCode in the terminal"),
-    ),
+    visible: Flag.boolean("visible").pipe(Flag.withDescription("Show OpenCode in the terminal")),
     record: Flag.boolean("record").pipe(
       Flag.withDescription("Record the complete headless session and export it on stop"),
     ),
@@ -46,23 +56,20 @@ const startCommand = Command.make(
       Flag.withDescription("Path to an OpenCode development checkout"),
     ),
   },
-  (config) =>
-    execute(() =>
-      start(toStartOptions(config, extracted.commands, extracted.app)),
-    ),
+  (config) => execute(() => start(toStartOptions(config, extracted.commands, extracted.app))),
 ).pipe(
   Command.withDescription("Launch a local simulated OpenCode instance"),
   Command.withExamples([
     {
-      command: "opencode-drive start",
+      command: "opencode-drive start --name demo",
       description: "Launch headless OpenCode on the default ports",
     },
     {
-      command: "opencode-drive start --visible",
+      command: "opencode-drive start --name demo --visible",
       description: "Launch visible OpenCode on the default ports",
     },
     {
-      command: "opencode-drive start --script ./drive.ts",
+      command: "opencode-drive start --name demo --script ./drive.ts",
       description: "Launch headless OpenCode and run a script",
     },
   ]),
@@ -70,20 +77,13 @@ const startCommand = Command.make(
 
 const sendCommand = Command.make("send", { name }, (config) =>
   execute(() =>
-    send(
-      toSendOptions(
-        Option.getOrUndefined(config.name),
-        extracted.commands,
-        extracted.app,
-      ),
-    ),
+    send(toSendOptions(Option.getOrUndefined(config.name), extracted.commands, extracted.app)),
   ),
 ).pipe(
   Command.withDescription("Send UI commands to OpenCode on the default port"),
   Command.withExamples([
     {
-      command:
-        'opencode-drive send --command.ui.type \'{"text":"hello"}\' --command.ui.state',
+      command: 'opencode-drive send --command.ui.type \'{"text":"hello"}\' --command.ui.state',
       description: "Execute an ordered UI command batch",
     },
   ]),
@@ -101,11 +101,7 @@ const screenshotCommand = Command.make("screenshot", { name }, (config) =>
 
 const restartCommand = Command.make("restart", { name }, (config) =>
   execute(() => restart(Option.getOrUndefined(config.name))),
-).pipe(
-  Command.withDescription(
-    "Restart a named OpenCode instance and rerun its script",
-  ),
-)
+).pipe(Command.withDescription("Restart a named OpenCode instance and rerun its script"))
 
 const stopCommand = Command.make("stop", { name }, (config) =>
   execute(() => stop(Option.getOrUndefined(config.name))),
@@ -145,6 +141,7 @@ const responsesCommand = Command.make(
 const root = Command.make("opencode-drive").pipe(
   Command.withDescription("Drive real and simulated OpenCode instances"),
   Command.withSubcommands([
+    initCommand,
     startCommand,
     sendCommand,
     screenshotCommand,
@@ -203,9 +200,7 @@ function execute(task: () => Promise<void>) {
   return Effect.tryPromise({ try: task, catch: (error) => error }).pipe(
     Effect.catch((error) =>
       Effect.sync(() => {
-        console.error(
-          `error: ${error instanceof Error ? error.message : String(error)}`,
-        )
+        console.error(`error: ${error instanceof Error ? error.message : String(error)}`)
         process.exitCode = 1
       }),
     ),
@@ -216,9 +211,7 @@ function extract() {
   try {
     return extractCommands(process.argv.slice(2))
   } catch (error) {
-    console.error(
-      `opencode-drive: ${error instanceof Error ? error.message : String(error)}`,
-    )
+    console.error(`opencode-drive: ${error instanceof Error ? error.message : String(error)}`)
     return process.exit(1)
   }
 }

package/src/cli/init.ts

@@ -0,0 +1,7 @@
+import { initializeInstance } from "./instance.js"
+import { initializeManifest } from "./registry.js"
+
+export async function init(name: string) {
+  const manifest = await initializeManifest(name, process.cwd(), initializeInstance)
+  console.log(manifest.artifacts)
+}

package/src/cli/instance.ts

@@ -5,6 +5,7 @@ import { ensureMediaDirectory } from "./media.js"
 import type { DriveScriptSetup } from "./script.js"
 
 export interface LaunchOptions {
+  readonly artifacts: string
   readonly name: string
   readonly command?: ReadonlyArray<string>
   readonly dev?: string
@@ -15,17 +16,12 @@ export interface LaunchOptions {
   readonly setup?: DriveScriptSetup
 }
 
-export async function launchInstance(options: LaunchOptions) {
+export async function initializeInstance() {
   const artifacts = resolve(
     join(tmpdir(), "opencode-drive", `run-${crypto.randomUUID().slice(0, 6)}`),
   )
   const logs = join(artifacts, "logs")
-  const endpoints = {
-    ui: `ws://127.0.0.1:${await freePort()}`,
-    backend: `ws://127.0.0.1:${await freePort()}`,
-  }
   const drive = join(artifacts, "drive")
-  const media = await ensureMediaDirectory()
   await Promise.all([
     mkdir(logs, { recursive: true }),
     mkdir(drive, { recursive: true }),
@@ -34,20 +30,6 @@ export async function launchInstance(options: LaunchOptions) {
     mkdir(join(artifacts, "home", ".local", "share"), { recursive: true }),
     mkdir(join(artifacts, "home", ".local", "state"), { recursive: true }),
   ])
-  let recording = options.record ? recordingPaths(media) : undefined
-  const writeDriveManifest = () =>
-    Bun.write(
-      join(drive, `${options.name}.json`),
-      `${JSON.stringify(
-        {
-          endpoints,
-          ...(recording ? { recording: { timeline: recording.timeline } } : {}),
-        },
-        undefined,
-        2,
-      )}\n`,
-    )
-  await writeDriveManifest()
   const files = join(artifacts, "files")
   await Promise.all([
     mkdir(join(files, ".git"), { recursive: true }),
@@ -87,9 +69,36 @@ export async function launchInstance(options: LaunchOptions) {
     ),
     Bun.write(
       join(files, "src", "garden.js"),
-      'export function greet(name) {\n  return `Hello, ${name}.`\n}\n',
+      "export function greet(name) {\n  return `Hello, ${name}.`\n}\n",
     ),
   ])
+  return artifacts
+}
+
+export async function launchInstance(options: LaunchOptions) {
+  const artifacts = resolve(options.artifacts)
+  const logs = join(artifacts, "logs")
+  const drive = join(artifacts, "drive")
+  const endpoints = {
+    ui: `ws://127.0.0.1:${await freePort()}`,
+    backend: `ws://127.0.0.1:${await freePort()}`,
+  }
+  const media = await ensureMediaDirectory()
+  const files = join(artifacts, "files")
+  let recording = options.record ? recordingPaths(media) : undefined
+  const writeDriveManifest = () =>
+    Bun.write(
+      join(drive, `${options.name}.json`),
+      `${JSON.stringify(
+        {
+          endpoints,
+          ...(recording ? { recording: { timeline: recording.timeline } } : {}),
+        },
+        undefined,
+        2,
+      )}\n`,
+    )
+  await writeDriveManifest()
   await options.setup?.({ directory: files })
   const environment = cleanEnv({
     ...process.env,
@@ -101,9 +110,7 @@ export async function launchInstance(options: LaunchOptions) {
     OPENCODE_DRIVE_MEDIA_DIR: media,
     OPENCODE_CONFIG_DIR: join(files, ".opencode"),
     OPENCODE_DB: ":memory:",
-    OPENCODE_LOG_LEVEL: !options.visible
-      ? "DEBUG"
-      : process.env.OPENCODE_LOG_LEVEL,
+    OPENCODE_LOG_LEVEL: !options.visible ? "DEBUG" : process.env.OPENCODE_LOG_LEVEL,
     OPENCODE_TEST_HOME: artifacts,
     XDG_CACHE_HOME: join(artifacts, "home", ".cache"),
     XDG_CONFIG_HOME: join(artifacts, "home", ".config"),
@@ -120,12 +127,8 @@ export async function launchInstance(options: LaunchOptions) {
       cwd: files,
       env: environment,
       stdin: options.visible ? "inherit" : "ignore",
-      stdout: !options.visible
-        ? Bun.file(join(logs, "opencode.stdout.log"))
-        : "inherit",
-      stderr: !options.visible
-        ? Bun.file(join(logs, "opencode.stderr.log"))
-        : "inherit",
+      stdout: !options.visible ? Bun.file(join(logs, "opencode.stdout.log")) : "inherit",
+      stderr: !options.visible ? Bun.file(join(logs, "opencode.stderr.log")) : "inherit",
     })
   let child = spawn()
   let stopping: Promise<void> | undefined
@@ -140,17 +143,10 @@ export async function launchInstance(options: LaunchOptions) {
     get child() {
       return child
     },
-    async waitForDrive(
-      requirement: "ui" | "backend" | "both" = "both",
-      timeout = 60_000,
-    ) {
+    async waitForDrive(requirement: "ui" | "backend" | "both" = "both", timeout = 60_000) {
       const urls =
-        requirement === "both"
-          ? [endpoints.ui, endpoints.backend]
-          : [endpoints[requirement]]
-      await Promise.all(
-        urls.map((url) => waitForWebSocket(url, child.exited, timeout)),
-      )
+        requirement === "both" ? [endpoints.ui, endpoints.backend] : [endpoints[requirement]]
+      await Promise.all(urls.map((url) => waitForWebSocket(url, child.exited, timeout)))
     },
     async restart() {
       if (restarting) return restarting
@@ -248,14 +244,8 @@ async function prepareDev(cwd: string, directory: string) {
     stderr: "ignore",
   })
   const status = await install.exited
-  if (status !== 0)
-    throw new Error(`bun install failed in ${cwd} with status ${status}`)
-  return [
-    process.execPath,
-    "--conditions=browser",
-    "--preload=@opentui/solid/preload",
-    entrypoint,
-  ]
+  if (status !== 0) throw new Error(`bun install failed in ${cwd} with status ${status}`)
+  return [process.execPath, "--conditions=browser", "--preload=@opentui/solid/preload", entrypoint]
 }
 
 async function freePort() {
@@ -298,10 +288,7 @@ async function stopService(state: string) {
 
 function isServiceInfo(value: unknown): value is { readonly pid: number } {
   return (
-    typeof value === "object" &&
-    value !== null &&
-    "pid" in value &&
-    typeof value.pid === "number"
+    typeof value === "object" && value !== null && "pid" in value && typeof value.pid === "number"
   )
 }
 
@@ -323,11 +310,7 @@ function isPackageInfo(value: unknown): value is { readonly version: string } {
   )
 }
 
-async function waitForWebSocket(
-  url: string,
-  exited: Promise<number>,
-  timeout: number,
-) {
+async function waitForWebSocket(url: string, exited: Promise<number>, timeout: number) {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     const connected = await Promise.race([
@@ -338,9 +321,7 @@ async function waitForWebSocket(
         })
         .catch(() => false),
       exited.then((code) => {
-        throw new Error(
-          `OpenCode exited with status ${code} before ${url} became ready`,
-        )
+        throw new Error(`OpenCode exited with status ${code} before ${url} became ready`)
       }),
     ])
     if (connected) return
@@ -355,18 +336,14 @@ function open(url: string) {
     socket.addEventListener("open", () => resolveSocket(socket), {
       once: true,
     })
-    socket.addEventListener(
-      "error",
-      () => reject(new Error(`cannot connect to ${url}`)),
-      { once: true },
-    )
+    socket.addEventListener("error", () => reject(new Error(`cannot connect to ${url}`)), {
+      once: true,
+    })
   })
 }
 
 function cleanEnv(env: Readonly<Record<string, string | undefined>>) {
   return Object.fromEntries(
-    Object.entries(env).filter(
-      (entry): entry is [string, string] => entry[1] !== undefined,
-    ),
+    Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined),
   )
 }

package/src/cli/list.ts

@@ -1,10 +1,8 @@
-import { listInstances, manifestPath } from "./registry.js"
+import { listManifests, manifestPath } from "./registry.js"
 
 export async function list() {
-  const instances = await listInstances()
+  const instances = await listManifests()
   console.log(
-    instances
-      .map((instance) => `${instance.name}: ${manifestPath(instance.name)}`)
-      .join("\n"),
+    instances.map((instance) => `${instance.name}: ${manifestPath(instance.name)}`).join("\n"),
   )
 }

package/src/cli/registry.ts

@@ -15,6 +15,17 @@ export interface InstanceManifest {
   readonly control: string
 }
 
+export interface InitializedManifest {
+  readonly version: 1
+  readonly name: string
+  readonly createdAt: string
+  readonly cwd: string
+  readonly artifacts: string
+  readonly status: "initialized"
+}
+
+export type Manifest = InstanceManifest | InitializedManifest
+
 export function registryDirectory() {
   return (
     process.env.DRIVE_REGISTRY_DIR ??
@@ -34,10 +45,38 @@ export function controlPath(name: string) {
   return join(registryDirectory(), `${validateName(name)}.sock`)
 }
 
+export async function initializeManifest(name: string, cwd: string, create: () => Promise<string>) {
+  let initialized: InitializedManifest | undefined
+  await withLock(name, false, async () => {
+    const existing = await read(manifestPath(name))
+    if (existing?.status === "initialized") {
+      initialized = existing
+      return
+    }
+    if (existing && alive(existing.pid))
+      throw new Error(`drive instance "${name}" is already running`)
+    initialized = {
+      version: 1,
+      name,
+      createdAt: new Date().toISOString(),
+      cwd,
+      artifacts: await create(),
+      status: "initialized",
+    }
+    await Promise.all([
+      rm(manifestPath(name), { force: true }),
+      rm(controlPath(name), { force: true }),
+    ])
+    await write(initialized)
+  })
+  if (!initialized) throw new Error(`failed to initialize drive instance "${name}"`)
+  return initialized
+}
+
 export async function register(manifest: InstanceManifest) {
   await withLock(manifest.name, false, async () => {
     const existing = await read(manifestPath(manifest.name))
-    if (existing && alive(existing.pid))
+    if (existing && existing.status !== "initialized" && alive(existing.pid))
       throw new Error(`drive instance "${manifest.name}" is already running`)
     await Promise.all([
       rm(manifestPath(manifest.name), { force: true }),
@@ -55,23 +94,16 @@ export async function markStarting(name: string, pid: number) {
   await markStatus(name, pid, "starting")
 }
 
-async function markStatus(
-  name: string,
-  pid: number,
-  status: InstanceManifest["status"],
-) {
+async function markStatus(name: string, pid: number, status: InstanceManifest["status"]) {
   await withLock(name, true, async () => {
     const manifest = await read(manifestPath(name))
-    if (!manifest || manifest.pid !== pid)
+    if (!manifest || manifest.status === "initialized" || manifest.pid !== pid)
       throw new Error(`drive instance "${name}" changed ownership`)
     await write({ ...manifest, status })
   })
 }
 
-export async function resolveInstance(
-  name?: string,
-  options: { readonly ready?: boolean } = {},
-) {
+export async function resolveInstance(name?: string, options: { readonly ready?: boolean } = {}) {
   const instances = await listInstances()
   const manifest = name
     ? instances.find((item) => item.name === name)
@@ -84,9 +116,7 @@ export async function resolveInstance(
         `multiple drive instances are running; pass --name (${instances.map((item) => item.name).join(", ")})`,
       )
     throw new Error(
-      name
-        ? `drive instance "${name}" was not found`
-        : "no drive instances are running",
+      name ? `drive instance "${name}" was not found` : "no drive instances are running",
     )
   }
   if (options.ready !== false && manifest.status !== "ready")
@@ -95,6 +125,12 @@ export async function resolveInstance(
 }
 
 export async function listInstances() {
+  return (await listManifests()).filter(
+    (manifest): manifest is InstanceManifest => manifest.status !== "initialized",
+  )
+}
+
+export async function listManifests() {
   await mkdir(registryDirectory(), { recursive: true })
   const files = await readdir(registryDirectory())
   const manifests = await Promise.all(
@@ -107,22 +143,21 @@ export async function listInstances() {
           return undefined
         }
         const manifest = await read(join(registryDirectory(), file))
-        if (manifest?.name === name && alive(manifest.pid)) return manifest
-        await prune(name, manifest?.pid)
+        if (manifest?.name === name) {
+          if (manifest.status === "initialized" || alive(manifest.pid)) return manifest
+        }
+        await prune(name, manifest?.status === "initialized" ? undefined : manifest?.pid)
         return undefined
       }),
   )
-  const active = manifests.filter(
-    (manifest): manifest is InstanceManifest => manifest !== undefined,
-  )
+  const active = manifests.filter((manifest): manifest is Manifest => manifest !== undefined)
   const names = new Set(active.map((manifest) => manifest.name))
   await Promise.all(
     files
       .filter((file) => file.endsWith(".sock"))
       .flatMap((file) => {
         const name = basename(file, ".sock")
-        if (!validName(name))
-          return [rm(join(registryDirectory(), file), { force: true })]
+        if (!validName(name)) return [rm(join(registryDirectory(), file), { force: true })]
         if (!names.has(name)) return [prune(name)]
         return []
       }),
@@ -133,7 +168,7 @@ export async function listInstances() {
 export async function unregister(name: string, pid: number) {
   await withLock(name, true, async () => {
     const manifest = await read(manifestPath(name))
-    if (manifest?.pid !== pid) return
+    if (!manifest || manifest.status === "initialized" || manifest.pid !== pid) return
     await Promise.all([
       rm(manifestPath(name), { force: true }),
       rm(controlPath(name), { force: true }),
@@ -144,6 +179,7 @@ export async function unregister(name: string, pid: number) {
 async function prune(name: string, pid?: number) {
   await withLock(name, true, async () => {
     const manifest = await read(manifestPath(name))
+    if (manifest?.status === "initialized") return
     if (manifest && (manifest.pid !== pid || alive(manifest.pid))) return
     await Promise.all([
       rm(manifestPath(name), { force: true }),
@@ -152,7 +188,7 @@ async function prune(name: string, pid?: number) {
   })
 }
 
-async function write(manifest: InstanceManifest) {
+async function write(manifest: Manifest) {
   const file = manifestPath(manifest.name)
   const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`
   try {
@@ -163,7 +199,7 @@ async function write(manifest: InstanceManifest) {
   }
 }
 
-async function read(file: string): Promise<InstanceManifest | undefined> {
+async function read(file: string): Promise<Manifest | undefined> {
   const value: unknown = await Bun.file(file)
     .json()
     .catch(() => undefined)
@@ -171,11 +207,7 @@ async function read(file: string): Promise<InstanceManifest | undefined> {
   return undefined
 }
 
-async function withLock(
-  name: string,
-  wait: boolean,
-  task: () => Promise<void>,
-) {
+async function withLock(name: string, wait: boolean, task: () => Promise<void>) {
   await mkdir(registryDirectory(), { recursive: true })
   const lock = `${manifestPath(name)}.lock`
   const deadline = Date.now() + 10_000
@@ -198,10 +230,8 @@ async function withLock(
       await rm(lock, { force: true })
       continue
     }
-    if (!wait)
-      throw new Error(`drive instance "${name}" is already starting`)
-    if (Date.now() >= deadline)
-      throw new Error(`timed out updating drive instance "${name}"`)
+    if (!wait) throw new Error(`drive instance "${name}" is already starting`)
+    if (Date.now() >= deadline) throw new Error(`timed out updating drive instance "${name}"`)
     await Bun.sleep(10)
   }
 }
@@ -216,28 +246,28 @@ async function staleLock(file: string) {
   return Number.isInteger(pid) && !alive(pid)
 }
 
-function isManifest(value: unknown): value is InstanceManifest {
+function isManifest(value: unknown): value is Manifest {
   if (typeof value !== "object" || value === null) return false
   if (!("version" in value) || value.version !== 1) return false
   if (!("name" in value) || typeof value.name !== "string") return false
+  if ("status" in value && value.status === "initialized")
+    return (
+      "createdAt" in value &&
+      typeof value.createdAt === "string" &&
+      "cwd" in value &&
+      typeof value.cwd === "string" &&
+      "artifacts" in value &&
+      typeof value.artifacts === "string"
+    )
   if (!("pid" in value) || typeof value.pid !== "number") return false
-  if (!("startedAt" in value) || typeof value.startedAt !== "string")
-    return false
+  if (!("startedAt" in value) || typeof value.startedAt !== "string") return false
   if (!("cwd" in value) || typeof value.cwd !== "string") return false
-  if (!("artifacts" in value) || typeof value.artifacts !== "string")
-    return false
+  if (!("artifacts" in value) || typeof value.artifacts !== "string") return false
   if (!("visible" in value) || typeof value.visible !== "boolean") return false
-  if (
-    !("status" in value) ||
-    (value.status !== "starting" && value.status !== "ready")
-  )
+  if (!("status" in value) || (value.status !== "starting" && value.status !== "ready"))
     return false
   if (!("control" in value) || typeof value.control !== "string") return false
-  if (
-    !("endpoints" in value) ||
-    typeof value.endpoints !== "object" ||
-    value.endpoints === null
-  )
+  if (!("endpoints" in value) || typeof value.endpoints !== "object" || value.endpoints === null)
     return false
   return (
     "ui" in value.endpoints &&

package/src/cli/start.ts

@@ -1,4 +1,4 @@
-import { launchInstance } from "./instance.js"
+import { initializeInstance, launchInstance } from "./instance.js"
 import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { connectSimulation } from "../client/index.js"
@@ -12,6 +12,7 @@ import {
   controlPath,
   markReady,
   markStarting,
+  initializeManifest,
   register,
   registryDirectory,
   resolveInstance,
@@ -20,11 +21,12 @@ import {
 import type { StartOptions } from "./types.js"
 
 export async function start(options: StartOptions) {
-  if (!options.visible && !options.script && !options.daemon)
-    return startDetached(options)
+  const initialized = await initializeManifest(options.name, process.cwd(), initializeInstance)
+  if (!options.visible && !options.script && !options.daemon) return startDetached(options)
   const script = options.script ? await loadScript(options.script) : undefined
   const responses = createResponseSettings()
   const instance = await launchInstance({
+    artifacts: initialized.artifacts,
     name: options.name,
     command: options.command,
     dev: options.dev,
@@ -56,8 +58,7 @@ export async function start(options: StartOptions) {
   let driveReady = false
   let recording: Promise<string | undefined> | undefined
   const finishCurrentRecording = (onProgress?: (percent: number) => void) => {
-    if (!options.record || options.visible || !driveReady)
-      return Promise.resolve(undefined)
+    if (!options.record || options.visible || !driveReady) return Promise.resolve(undefined)
     recording ??= finishRecording(instance, onProgress)
     return recording
   }
@@ -104,9 +105,7 @@ export async function start(options: StartOptions) {
           driveReady = false
           await instance.restart()
           recording = undefined
-          current = run(options, instance, responses, script?.run, (path) =>
-            screenshots.push(path),
-          )
+          current = run(options, instance, responses, script?.run, (path) => screenshots.push(path))
           await current.ready
           driveReady = true
           await markReady(options.name, process.pid)
@@ -123,9 +122,7 @@ export async function start(options: StartOptions) {
         return responses.update(input)
       },
     })
-    current = run(options, instance, responses, script?.run, (path) =>
-      screenshots.push(path),
-    )
+    current = run(options, instance, responses, script?.run, (path) => screenshots.push(path))
     await current.ready
     driveReady = true
     await markReady(options.name, process.pid)
@@ -170,10 +167,8 @@ export async function start(options: StartOptions) {
     await closeControl?.()
     await instance.stop()
     await unregister(options.name, process.pid)
-    if (options.script && !options.visible)
-      report(instance, completed ? "completed" : undefined)
-    if (options.script && recordingPath)
-      console.error(`opencode-drive: recording ${recordingPath}`)
+    if (options.script && !options.visible) report(instance, completed ? "completed" : undefined)
+    if (options.script && recordingPath) console.error(`opencode-drive: recording ${recordingPath}`)
   }
 }
 
@@ -187,7 +182,10 @@ async function finishRecording(
   if (instance.child.exitCode !== null) {
     timeline = expected.timeline
   } else {
-    const ui = await connectSimulation({ url: instance.endpoints.ui, timeout: 60_000 })
+    const ui = await connectSimulation({
+      url: instance.endpoints.ui,
+      timeout: 60_000,
+    })
     try {
       timeline = await ui.finishRecording()
     } finally {
@@ -204,8 +202,7 @@ async function finishRecording(
 
 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`)
+  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 })
@@ -242,15 +239,11 @@ async function startDetached(options: StartOptions) {
       return
     }
     if (child.exitCode !== null)
-      throw new Error(
-        `detached instance exited with status ${child.exitCode}; see ${ownerLog}`,
-      )
+      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}`,
-  )
+  throw new Error(`timed out starting drive instance "${options.name}"; see ${ownerLog}`)
 }
 
 async function terminateOwner(child: Bun.Subprocess) {
@@ -306,7 +299,9 @@ function run(
       }
       const mock = await connectMockBackend(instance.endpoints.backend, responses)
       ready()
-      abort.signal.addEventListener("abort", () => mock.close(), { once: true })
+      abort.signal.addEventListener("abort", () => mock.close(), {
+        once: true,
+      })
       const status = await Promise.race([
         child.exited,
         new Promise<number>((resolve) =>
@@ -321,10 +316,7 @@ function run(
   }
 }
 
-function report(
-  instance: { readonly artifacts: string; readonly logs: string },
-  status?: 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}`)
 }