opencode-drive 0.1.8 → 0.1.9

package/package.json

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

package/src/cli/index.ts

@@ -45,10 +45,6 @@ const startCommand = Command.make(
       Flag.optional,
       Flag.withDescription("Path to an OpenCode development checkout"),
     ),
-    state: Flag.string("state").pipe(
-      Flag.optional,
-      Flag.withDescription("Simulation snapshot containing files/"),
-    ),
   },
   (config) =>
     execute(() =>
@@ -173,7 +169,6 @@ function toStartOptions(
     readonly visible: boolean
     readonly record: boolean
     readonly dev: Option.Option<string>
-    readonly state: Option.Option<string>
   },
   commands: ReadonlyArray<DriveCommand>,
   app: ReadonlyArray<string>,
@@ -188,7 +183,6 @@ function toStartOptions(
     visible: config.visible,
     record: config.record,
     dev: Option.getOrUndefined(config.dev),
-    state: Option.getOrUndefined(config.state),
     command: app,
   }
   if (options.dev !== undefined && app.length > 0)

package/src/cli/instance.ts

@@ -1,17 +1,18 @@
-import { mkdir, rm } from "node:fs/promises"
+import { mkdir } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join, resolve } from "node:path"
 import { ensureMediaDirectory } from "./media.js"
+import type { DriveScriptSetup } from "./script.js"
 
 export interface LaunchOptions {
   readonly name: string
   readonly command?: ReadonlyArray<string>
   readonly dev?: string
-  readonly state?: string
   readonly scripted?: boolean
   readonly visible?: boolean
   readonly record?: boolean
   readonly env?: Readonly<Record<string, string>>
+  readonly setup?: DriveScriptSetup
 }
 
 export async function launchInstance(options: LaunchOptions) {
@@ -47,62 +48,57 @@ export async function launchInstance(options: LaunchOptions) {
       )}\n`,
     )
   await writeDriveManifest()
-  const state = options.state
-    ? resolve(options.state)
-    : join(artifacts, "state")
-  if (!options.state) {
-    await rm(state, { recursive: true, force: true })
-    await Promise.all([
-      mkdir(join(state, "files", ".git"), { recursive: true }),
-      mkdir(join(state, "files", ".opencode"), { recursive: true }),
-      mkdir(join(state, "files", "src"), { recursive: true }),
-    ])
-    await Promise.all([
-      Bun.write(
-        join(state, "files", ".opencode", "opencode.jsonc"),
-        `${JSON.stringify(
-          {
-            model: "simulation/gpt-sim-model",
-            permissions: [{ action: "*", resource: "*", effect: "allow" }],
-            providers: {
-              simulation: {
-                name: "Simulation",
-                package: "aisdk:@ai-sdk/openai-compatible",
-                settings: { baseURL: "https://api.openai.com/v1" },
-                request: { body: { apiKey: "sim-key" } },
-                models: {
-                  "gpt-sim-model": {
-                    name: "Simulated Model",
-                    capabilities: {
-                      tools: true,
-                      input: ["text"],
-                      output: ["text"],
-                    },
-                    limit: { context: 128000, output: 16000 },
+  const files = join(artifacts, "files")
+  await Promise.all([
+    mkdir(join(files, ".git"), { recursive: true }),
+    mkdir(join(files, ".opencode"), { recursive: true }),
+    mkdir(join(files, "src"), { recursive: true }),
+  ])
+  await Promise.all([
+    Bun.write(
+      join(files, ".opencode", "opencode.jsonc"),
+      `${JSON.stringify(
+        {
+          model: "simulation/gpt-sim-model",
+          permissions: [{ action: "*", resource: "*", effect: "allow" }],
+          providers: {
+            simulation: {
+              name: "Simulation",
+              package: "aisdk:@ai-sdk/openai-compatible",
+              settings: { baseURL: "https://api.openai.com/v1" },
+              request: { body: { apiKey: "sim-key" } },
+              models: {
+                "gpt-sim-model": {
+                  name: "Simulated Model",
+                  capabilities: {
+                    tools: true,
+                    input: ["text"],
+                    output: ["text"],
                   },
+                  limit: { context: 128000, output: 16000 },
                 },
               },
             },
           },
-          undefined,
-          2,
-        )}\n`,
-      ),
-      Bun.write(
-        join(state, "files", "src", "garden.js"),
-        'export function greet(name) {\n  return `Hello, ${name}.`\n}\n',
-      ),
-    ])
-  }
+        },
+        undefined,
+        2,
+      )}\n`,
+    ),
+    Bun.write(
+      join(files, "src", "garden.js"),
+      'export function greet(name) {\n  return `Hello, ${name}.`\n}\n',
+    ),
+  ])
+  await options.setup?.({ directory: files })
   const environment = cleanEnv({
     ...process.env,
     ...options.env,
     OPENCODE_SIMULATE: "1",
-    OPENCODE_SIMULATE_STATE: state,
     DRIVE_REGISTRY_DIR: drive,
     OPENCODE_DRIVE: options.name,
     OPENCODE_DRIVE_RENDERER: options.visible ? "visible" : "headless",
-    OPENCODE_CONFIG_DIR: join(artifacts, ".opencode"),
+    OPENCODE_CONFIG_DIR: join(files, ".opencode"),
     OPENCODE_DB: ":memory:",
     OPENCODE_LOG_LEVEL: !options.visible
       ? "INFO"
@@ -114,13 +110,13 @@ export async function launchInstance(options: LaunchOptions) {
     XDG_STATE_HOME: join(artifacts, "home", ".local", "state"),
   })
   const command = options.dev
-    ? await prepareDev(artifacts, options.dev)
+    ? await prepareDev(files, options.dev)
     : options.command?.length
       ? [...options.command]
       : ["opencode2"]
   const spawn = () =>
     Bun.spawn(command, {
-      cwd: artifacts,
+      cwd: files,
       env: environment,
       stdin: options.visible ? "inherit" : "ignore",
       stdout: !options.visible

package/src/cli/script.ts

@@ -15,23 +15,43 @@ export interface ScriptContext {
 
 export type DriveScript = (context: ScriptContext) => void | Promise<void>
 
+export interface ScriptSetupContext {
+  readonly directory: string
+}
+
+export type DriveScriptSetup = (
+  context: ScriptSetupContext,
+) => void | Promise<void>
+
+export interface LoadedDriveScript {
+  readonly run: DriveScript
+  readonly setup?: DriveScriptSetup
+}
+
 export function defineScript(script: DriveScript) {
   return script
 }
 
+export async function loadScript(file: string): Promise<LoadedDriveScript> {
+  const module: { readonly default?: unknown; readonly setup?: unknown } =
+    await import(pathToFileURL(resolve(file)).href)
+  if (!isDriveScript(module.default))
+    throw new Error("script must default-export a function")
+  if (module.setup !== undefined && !isDriveScriptSetup(module.setup))
+    throw new Error("script setup export must be a function")
+  return {
+    run: module.default,
+    ...(module.setup === undefined ? {} : { setup: module.setup }),
+  }
+}
+
 export async function runScript(
-  file: string,
+  script: DriveScript,
   artifacts: string,
   endpoints: { readonly ui: string; readonly backend: string },
   signal: AbortSignal,
   onScreenshot?: (path: string) => void,
 ) {
-  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, onScreenshot })
   const backend = await connectBackendSimulation({
     url: endpoints.backend,
@@ -76,3 +96,7 @@ async function waitForEditor(ui: SimulationClient, signal: AbortSignal) {
 function isDriveScript(value: unknown): value is DriveScript {
   return typeof value === "function"
 }
+
+function isDriveScriptSetup(value: unknown): value is DriveScriptSetup {
+  return typeof value === "function"
+}

package/src/cli/start.ts

@@ -5,7 +5,8 @@ import { connectSimulation } from "../client/index.js"
 import { exportRecording } from "../recording/index.js"
 import { connectMockBackend } from "./mock-backend.js"
 import { createResponseSettings } from "./response-generator.js"
-import { runScript } from "./script.js"
+import { loadScript, runScript } from "./script.js"
+import type { DriveScript } from "./script.js"
 import { listenControl } from "./control.js"
 import {
   controlPath,
@@ -21,15 +22,16 @@ import type { StartOptions } from "./types.js"
 export async function start(options: StartOptions) {
   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({
     name: options.name,
     command: options.command,
     dev: options.dev,
-    state: options.state,
     scripted: options.script !== undefined,
     visible: options.visible,
     record: options.record,
+    setup: script?.setup,
   })
   await register({
     version: 1,
@@ -102,7 +104,9 @@ export async function start(options: StartOptions) {
           driveReady = false
           await instance.restart()
           recording = undefined
-          current = run(options, instance, responses, (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)
@@ -119,7 +123,9 @@ export async function start(options: StartOptions) {
         return responses.update(input)
       },
     })
-    current = run(options, instance, responses, (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)
@@ -213,7 +219,6 @@ async function startDetached(options: StartOptions) {
       options.name,
       ...(options.script ? ["--script", options.script] : []),
       ...(options.dev ? ["--dev", options.dev] : []),
-      ...(options.state ? ["--state", options.state] : []),
       ...(options.record ? ["--record"] : []),
       ...(options.command.length ? ["--", ...options.command] : []),
     ],
@@ -261,6 +266,7 @@ function run(
   options: StartOptions,
   instance: Awaited<ReturnType<typeof launchInstance>>,
   responses: ReturnType<typeof createResponseSettings>,
+  driveScript: DriveScript | undefined,
   onScreenshot: (path: string) => void,
 ) {
   const abort = new AbortController()
@@ -274,9 +280,9 @@ function run(
     ready: readiness,
     promise: (async () => {
       await instance.waitForDrive("both")
-      if (options.script) {
+      if (driveScript) {
         const script = runScript(
-          options.script,
+          driveScript,
           instance.artifacts,
           instance.endpoints,
           abort.signal,

package/src/cli/types.ts

@@ -11,7 +11,6 @@ export interface StartOptions {
   readonly visible: boolean
   readonly record: boolean
   readonly dev?: string
-  readonly state?: string
   readonly command: ReadonlyArray<string>
 }
 

package/src/experimental/reproduce-stale-exploring-empty.ts

@@ -19,7 +19,7 @@ export default defineScript(async ({ artifacts, backend, ui }) => {
           index: 0,
           id: "call_read",
           name: "read",
-          input: { filePath: join(artifacts, "state", "files", "src", "garden.js") },
+          input: { filePath: join(artifacts, "files", "src", "garden.js") },
         },
       ])
       await backend.finish(request.id, "tool-calls")

package/src/index.ts

@@ -1,3 +1,8 @@
 export * from "./client/index.js"
 export { defineScript } from "./cli/script.js"
-export type { DriveScript, ScriptContext } from "./cli/script.js"
+export type {
+  DriveScript,
+  DriveScriptSetup,
+  ScriptContext,
+  ScriptSetupContext,
+} from "./cli/script.js"