opencode-drive 0.1.0

package/src/cli/instance.ts

@@ -0,0 +1,218 @@
+import { mkdir, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join, resolve } from "node:path"
+import { registerInstance, registryDirectory, transferInstance, unregisterInstance } from "./registry.js"
+import type { InstanceManifest } from "./types.js"
+
+export interface LaunchOptions {
+  readonly name?: string
+  readonly command?: ReadonlyArray<string>
+  readonly dev?: string
+  readonly state?: string
+  readonly visible?: boolean
+  readonly env?: Readonly<Record<string, string>>
+}
+
+export async function launchInstance(options: LaunchOptions = {}) {
+  const name = options.name ?? "default"
+  const artifacts = resolve(join(tmpdir(), "opencode-drive", `${name}-${randomSuffix()}`))
+  const cwd = artifacts
+  const [uiPort, backendPort] = await Promise.all([freePort(), freePort()])
+  const endpoints = {
+    ui: `ws://127.0.0.1:${uiPort}`,
+    backend: `ws://127.0.0.1:${backendPort}`,
+  }
+  const manifest: InstanceManifest = {
+    version: 1,
+    name,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    mode: "simulated",
+    headless: options.visible !== true,
+    cwd,
+    artifacts,
+    endpoints,
+  }
+  await Promise.all([
+    mkdir(artifacts, { recursive: true }),
+    mkdir(cwd, { recursive: true }),
+    mkdir(join(artifacts, "home", ".cache"), { recursive: true }),
+    mkdir(join(artifacts, "home", ".config"), { recursive: true }),
+    mkdir(join(artifacts, "home", ".local", "share"), { recursive: true }),
+    mkdir(join(artifacts, "home", ".local", "state"), { recursive: true }),
+  ])
+  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 }),
+    ])
+    await Bun.write(
+      join(state, "files", ".opencode", "opencode.jsonc"),
+      `${JSON.stringify(
+        {
+          model: "simulation/sim-model",
+          permissions: [{ action: "*", resource: "*", effect: "allow" }],
+          providers: {
+            simulation: {
+              name: "Simulation",
+              request: { body: { apiKey: "sim-key" } },
+              models: {
+                "sim-model": {
+                  name: "Simulated Model",
+                  api: {
+                    type: "aisdk",
+                    package: "@ai-sdk/openai-compatible",
+                    url: "https://api.openai.com/v1",
+                  },
+                  capabilities: { tools: true, input: ["text"], output: ["text"] },
+                  limit: { context: 128000, output: 16000 },
+                },
+              },
+            },
+          },
+        },
+        undefined,
+        2,
+      )}\n`,
+    )
+  }
+  await registerInstance(manifest)
+  const environment = cleanEnv({
+    ...process.env,
+    ...options.env,
+    DRIVE_REGISTRY_DIR: registryDirectory(),
+    OPENCODE_SIMULATE: "1",
+    OPENCODE_SIMULATE_STATE: state,
+    OPENCODE_DRIVE: name,
+    OPENCODE_DRIVE_RENDERER: options.visible ? "visible" : "headless",
+    OPENCODE_CONFIG_DIR: join(cwd, ".opencode"),
+    OPENCODE_DB: ":memory:",
+    XDG_CACHE_HOME: join(artifacts, "home", ".cache"),
+    XDG_CONFIG_HOME: join(artifacts, "home", ".config"),
+    XDG_DATA_HOME: join(artifacts, "home", ".local", "share"),
+    XDG_STATE_HOME: join(artifacts, "home", ".local", "state"),
+  })
+  const command = options.dev
+    ? await prepareDev(cwd, options.dev)
+    : options.command?.length
+      ? [...options.command]
+      : ["opencode2", "--standalone"]
+  const visible = options.visible === true
+  const child = Bun.spawn(command, {
+    cwd,
+    env: environment,
+    stdin: visible ? "inherit" : "ignore",
+    stdout: visible ? "inherit" : Bun.file(join(artifacts, "opencode.stdout.log")),
+    stderr: visible ? "inherit" : Bun.file(join(artifacts, "opencode.stderr.log")),
+  })
+  const lifecycle = { detached: false, stopping: undefined as Promise<void> | undefined }
+  return {
+    manifest,
+    child,
+    async waitForDrive(requirement: "ui" | "backend" | "both" = "both", timeout = 60_000) {
+      const urls = requirement === "both"
+        ? [endpoints.ui, endpoints.backend]
+        : [requirement === "ui" ? endpoints.ui : endpoints.backend]
+      await Promise.all(urls.map((url) => waitForWebSocket(url, child.exited, timeout)))
+    },
+    async detach() {
+      await transferInstance(manifest, child.pid)
+      child.unref()
+      lifecycle.detached = true
+    },
+    stop(force = false) {
+      if (lifecycle.detached) return Promise.resolve()
+      if (lifecycle.stopping) return lifecycle.stopping
+      lifecycle.stopping = (async () => {
+        if (force) {
+          if (child.exitCode === null) child.kill("SIGKILL")
+        } else if (child.exitCode === null) {
+          child.kill("SIGTERM")
+          await Promise.race([child.exited, Bun.sleep(1_000)])
+        }
+        if (child.exitCode === null) child.kill("SIGKILL")
+        await child.exited
+        await unregisterInstance(name, process.pid)
+      })()
+      return lifecycle.stopping
+    },
+  }
+}
+
+async function prepareDev(cwd: string, directory: string) {
+  const root = resolve(directory)
+  const entrypoint = join(root, "packages", "cli", "src", "index.ts")
+  if (!(await Bun.file(entrypoint).exists())) throw new Error(`OpenCode development entrypoint not found: ${entrypoint}`)
+  const solidPackage = join(root, "packages", "tui", "node_modules", "@opentui", "solid", "package.json")
+  if (!(await Bun.file(solidPackage).exists())) {
+    throw new Error(`OpenCode development dependency not found: ${solidPackage}; run bun install in ${root}`)
+  }
+  const info: unknown = await Bun.file(solidPackage).json()
+  if (!isPackageInfo(info)) throw new Error(`Invalid @opentui/solid package metadata: ${solidPackage}`)
+  await Bun.write(join(cwd, "package.json"), `${JSON.stringify({
+    private: true,
+    dependencies: { "@opentui/solid": info.version },
+  }, undefined, 2)}\n`)
+  const install = Bun.spawn([process.execPath, "install"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  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,
+    "--standalone",
+  ]
+}
+
+function isPackageInfo(value: unknown): value is { readonly version: string } {
+  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string"
+}
+
+async function freePort() {
+  const server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response() })
+  const port = server.port
+  await server.stop(true)
+  return port
+}
+
+async function waitForWebSocket(url: string, exited: Promise<number>, timeout: number) {
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const connected = await Promise.race([
+      open(url).then((socket) => {
+        socket.close()
+        return true
+      }).catch(() => false),
+      exited.then((code) => {
+        throw new Error(`OpenCode exited with status ${code} before ${url} became ready`)
+      }),
+    ])
+    if (connected) return
+    await Bun.sleep(50)
+  }
+  throw new Error(`timed out waiting for drive endpoint ${url}`)
+}
+
+function open(url: string) {
+  return new Promise<WebSocket>((resolveSocket, reject) => {
+    const socket = new WebSocket(url)
+    socket.addEventListener("open", () => resolveSocket(socket), { once: true })
+    socket.addEventListener("error", () => reject(new Error(`cannot connect to ${url}`)), { once: true })
+  })
+}
+
+function randomSuffix() {
+  return crypto.randomUUID().slice(0, 6)
+}
+
+function cleanEnv(env: Readonly<Record<string, string | undefined>>) {
+  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined))
+}

package/src/cli/parse.ts

@@ -0,0 +1,24 @@
+import { commandAcceptsValue } from "./commands.js"
+import type { DriveCommand } from "./types.js"
+
+export function extractCommands(args: ReadonlyArray<string>) {
+  const commands: DriveCommand[] = []
+  const remaining: string[] = []
+  const separator = args.indexOf("--")
+  const cli = separator === -1 ? args : args.slice(0, separator)
+  const app = separator === -1 ? [] : args.slice(separator + 1)
+
+  for (let index = 0; index < cli.length; index++) {
+    const flag = cli[index]!
+    if (!flag.startsWith("--command.")) {
+      remaining.push(flag)
+      continue
+    }
+    const operation = flag.slice("--command.".length)
+    const acceptsValue = commandAcceptsValue(operation)
+    const value = acceptsValue ? cli[++index] : undefined
+    if (acceptsValue && (value === undefined || value.startsWith("--"))) throw new Error(`${flag} requires a value`)
+    commands.push({ operation, ...(value === undefined ? {} : { value }) })
+  }
+  return { args: remaining, app, commands }
+}

package/src/cli/registry.ts

@@ -0,0 +1,120 @@
+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"
+
+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")
+}
+
+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 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 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
+  }
+  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(", ")})`)
+}
+
+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))
+}
+
+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
+  }
+}
+
+function isManifest(value: unknown): value is InstanceManifest {
+  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 (!("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 (!("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) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    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/send.ts

@@ -0,0 +1,48 @@
+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"
+
+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")
+    return
+  }
+  if (options.driver) {
+    await runDriver(resolve(options.driver), manifest)
+    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}`,
+    },
+  }
+}

package/src/cli/start.ts

@@ -0,0 +1,56 @@
+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"
+
+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,
+    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()
+  process.once("SIGINT", interrupt)
+  process.once("SIGTERM", interrupt)
+  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")
+      return
+    }
+    if (options.driver) {
+      await instance.waitForDrive("both")
+      await runDriver(resolve(options.driver), instance.manifest)
+      return
+    }
+    const status = await instance.child.exited
+    if (status !== 0) process.exitCode = status
+  } finally {
+    process.off("SIGINT", interrupt)
+    process.off("SIGTERM", interrupt)
+    await instance.stop()
+  }
+}

package/src/cli/types.ts

@@ -0,0 +1,46 @@
+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 {
+  readonly kind: "start"
+  readonly detach: boolean
+  readonly campaign?: string
+  readonly seed: number
+  readonly caseIndex?: number
+  readonly count?: number
+  readonly concurrency: number
+  readonly visible: boolean
+  readonly dev?: string
+  readonly state?: string
+  readonly anchor?: string
+  readonly command: ReadonlyArray<string>
+}
+
+export interface SendOptions extends CommonOptions {
+  readonly kind: "send"
+}
+
+export type CliOptions = StartOptions | SendOptions