opencode-drive 0.1.2 → 0.1.4

package/src/cli/instance.ts

@@ -1,173 +1,178 @@
-import { chmod, mkdir, rm } from "node:fs/promises"
+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 name: string
   readonly command?: ReadonlyArray<string>
   readonly dev?: string
   readonly state?: string
+  readonly scripted?: boolean
   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()])
+export async function launchInstance(options: LaunchOptions) {
+  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:${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,
+    ui: `ws://127.0.0.1:${await freePort()}`,
+    backend: `ws://127.0.0.1:${await freePort()}`,
   }
+  const drive = join(artifacts, "drive")
   await Promise.all([
-    mkdir(artifacts, { recursive: true }),
-    mkdir(cwd, { recursive: true }),
+    mkdir(logs, { recursive: true }),
+    mkdir(drive, { 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")
+  await Bun.write(
+    join(drive, `${options.name}.json`),
+    `${JSON.stringify({ endpoints }, undefined, 2)}\n`,
+  )
+  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 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",
+    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 },
                   },
-                  capabilities: { tools: true, input: ["text"], output: ["text"] },
-                  limit: { context: 128000, output: 16000 },
                 },
               },
             },
           },
-        },
-        undefined,
-        2,
-      )}\n`,
-    )
+          undefined,
+          2,
+        )}\n`,
+      ),
+      Bun.write(
+        join(state, "files", "src", "garden.js"),
+        'export function greet(name) {\n  return `Hello, ${name}.`\n}\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,
+    DRIVE_REGISTRY_DIR: drive,
+    OPENCODE_DRIVE: options.name,
     OPENCODE_DRIVE_RENDERER: options.visible ? "visible" : "headless",
-    OPENCODE_CONFIG_DIR: join(cwd, ".opencode"),
+    OPENCODE_CONFIG_DIR: join(artifacts, ".opencode"),
     OPENCODE_DB: ":memory:",
+    OPENCODE_LOG_LEVEL: !options.visible
+      ? "INFO"
+      : process.env.OPENCODE_LOG_LEVEL,
     OPENCODE_TEST_HOME: artifacts,
     XDG_CACHE_HOME: join(artifacts, "home", ".cache"),
     XDG_CONFIG_HOME: join(artifacts, "home", ".config"),
-    XDG_DATA_HOME: join(artifacts, "home", ".local", "share"),
+    XDG_DATA_HOME: logs,
     XDG_STATE_HOME: join(artifacts, "home", ".local", "state"),
   })
   const command = options.dev
-    ? await prepareDev(cwd, options.dev)
+    ? await prepareDev(artifacts, options.dev)
     : options.command?.length
       ? [...options.command]
       : ["opencode2"]
-  const launch = join(artifacts, "launch.json")
-  await Bun.write(launch, `${JSON.stringify({ command, environment }, undefined, 2)}\n`)
-  await chmod(launch, 0o600)
-  const visible = options.visible === true
-  let child = spawn(command, environment, manifest)
-  const lifecycle = {
-    detached: false,
-    stopping: undefined as Promise<void> | undefined,
-    restarting: undefined as Promise<void> | undefined,
-  }
+  const spawn = () =>
+    Bun.spawn(command, {
+      cwd: artifacts,
+      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",
+    })
+  let child = spawn()
+  let stopping: Promise<void> | undefined
+  let restarting: Promise<void> | undefined
   return {
-    manifest,
+    artifacts,
+    logs,
+    endpoints,
     get child() {
       return 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
+    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)),
+      )
     },
-    restart() {
-      if (lifecycle.restarting) return lifecycle.restarting
-      lifecycle.restarting = (async () => {
+    async restart() {
+      if (restarting) return restarting
+      restarting = (async () => {
         await terminate(child)
-        child = spawn(command, environment, manifest)
+        child = spawn()
         await Promise.all([
           waitForWebSocket(endpoints.ui, child.exited, 60_000),
           waitForWebSocket(endpoints.backend, child.exited, 60_000),
         ])
       })().finally(() => {
-        lifecycle.restarting = undefined
+        restarting = undefined
       })
-      return lifecycle.restarting
+      return restarting
     },
     async wait() {
       while (true) {
         const current = child
         const status = await current.exited
-        if (lifecycle.restarting) {
-          await lifecycle.restarting
+        if (restarting) {
+          await restarting
           continue
         }
-        if (child !== current) continue
+        if (current !== child) continue
         return status
       }
     },
-    stop(force = false) {
-      if (lifecycle.detached) return Promise.resolve()
-      if (lifecycle.stopping) return lifecycle.stopping
-      lifecycle.stopping = (async () => {
-        if (lifecycle.restarting) await lifecycle.restarting.catch(() => undefined)
-        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)
+    stop() {
+      if (stopping) return stopping
+      stopping = (async () => {
+        if (restarting) await restarting.catch(() => undefined)
+        await terminate(child)
+        await stopService(join(artifacts, "home", ".local", "state"))
       })()
-      return lifecycle.stopping
+      return stopping
     },
   }
 }
@@ -180,67 +185,48 @@ async function terminate(child: Bun.Subprocess) {
   await child.exited
 }
 
-export async function restartInstance(manifest: InstanceManifest) {
-  const value: unknown = await Bun.file(join(manifest.artifacts, "launch.json")).json()
-  if (!isLaunchInfo(value)) throw new Error(`drive instance "${manifest.name}" has no valid restart metadata`)
-  const child = spawn(value.command, value.environment, manifest)
-  await transferInstance(manifest, child.pid)
-  try {
-    await Promise.all([
-      waitForWebSocket(manifest.endpoints.ui, child.exited, 60_000),
-      waitForWebSocket(manifest.endpoints.backend, child.exited, 60_000),
-    ])
-    child.unref()
-    return child.pid
-  } catch (error) {
-    if (child.exitCode === null) child.kill("SIGKILL")
-    await child.exited
-    throw error
-  }
-}
-
-function spawn(command: ReadonlyArray<string>, environment: Readonly<Record<string, string>>, manifest: InstanceManifest) {
-  return Bun.spawn([...command], {
-    cwd: manifest.cwd,
-    env: environment,
-    stdin: manifest.headless ? "ignore" : "inherit",
-    stdout: manifest.headless ? Bun.file(join(manifest.artifacts, "opencode.stdout.log")) : "inherit",
-    stderr: manifest.headless ? Bun.file(join(manifest.artifacts, "opencode.stderr.log")) : "inherit",
-  })
-}
-
-function isLaunchInfo(value: unknown): value is {
-  readonly command: ReadonlyArray<string>
-  readonly environment: Readonly<Record<string, string>>
-} {
-  if (typeof value !== "object" || value === null) return false
-  if (!("command" in value) || !Array.isArray(value.command) || !value.command.every((item) => typeof item === "string")) return false
-  if (!("environment" in value) || typeof value.environment !== "object" || value.environment === null || Array.isArray(value.environment)) return false
-  return Object.values(value.environment).every((item) => typeof item === "string")
-}
-
 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(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}`)
+    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`)
+  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",
+    stdout: "ignore",
+    stderr: "ignore",
   })
   const status = await install.exited
-  if (status !== 0) throw new Error(`bun install failed in ${cwd} with status ${status}`)
+  if (status !== 0)
+    throw new Error(`bun install failed in ${cwd} with status ${status}`)
   return [
     process.execPath,
     "--conditions=browser",
@@ -249,27 +235,89 @@ async function prepareDev(cwd: string, directory: string) {
   ]
 }
 
-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 server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch: () => new Response(),
+  })
   const port = server.port
   await server.stop(true)
   return port
 }
 
-async function waitForWebSocket(url: string, exited: Promise<number>, timeout: number) {
+async function stopService(state: string) {
+  const files = [
+    join(state, "opencode", "service-local.json"),
+    join(state, "opencode", "service.json"),
+  ]
+  const info = await Promise.all(
+    files.map((file) =>
+      Bun.file(file)
+        .json()
+        .catch(() => undefined),
+    ),
+  )
+  await Promise.all(
+    info.map(async (value) => {
+      if (!isServiceInfo(value)) return
+      try {
+        process.kill(value.pid, "SIGTERM")
+      } catch {
+        return
+      }
+      const deadline = Date.now() + 1_000
+      while (Date.now() < deadline && alive(value.pid)) await Bun.sleep(25)
+      if (alive(value.pid)) process.kill(value.pid, "SIGKILL")
+    }),
+  )
+}
+
+function isServiceInfo(value: unknown): value is { readonly pid: number } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "pid" in value &&
+    typeof value.pid === "number"
+  )
+}
+
+function alive(pid: number) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isPackageInfo(value: unknown): value is { readonly version: string } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "version" in value &&
+    typeof value.version === "string"
+  )
+}
+
+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),
+      open(url)
+        .then((socket) => {
+          socket.terminate()
+          return true
+        })
+        .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
@@ -281,15 +329,21 @@ async function waitForWebSocket(url: string, exited: Promise<number>, timeout: n
 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 })
+    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))
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] => entry[1] !== undefined,
+    ),
+  )
 }

package/src/cli/list.ts

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

package/src/cli/logs.ts

@@ -0,0 +1,9 @@
+import { join } from "node:path"
+import { resolveInstance } from "./registry.js"
+
+export async function logs(name?: string) {
+  const manifest = await resolveInstance(name)
+  console.log(
+    join(manifest.artifacts, "logs", "opencode", "log", "opencode*.log"),
+  )
+}

package/src/cli/mock-backend.ts

@@ -0,0 +1,37 @@
+import { connectBackendSimulation } from "../client/index.js"
+import { generateResponse } from "./response-generator.js"
+import type { createResponseSettings } from "./response-generator.js"
+
+export async function connectMockBackend(
+  endpoint: string,
+  responses: ReturnType<typeof createResponseSettings>,
+) {
+  const backend = await connectBackendSimulation({ url: endpoint })
+  await backend.attach(async (request) => {
+    const response = generateResponse(responses.current(), request)
+    for (const item of response.items) {
+      if (item.type !== "textDelta" && item.type !== "reasoningDelta") {
+        await backend.chunk(request.id, [item])
+        continue
+      }
+      for (const text of splitText(item.text)) {
+        await backend.chunk(request.id, [{ ...item, text }])
+        await Bun.sleep(45 + Math.floor(Math.random() * 35))
+      }
+    }
+    await backend.finish(request.id, response.finish)
+  })
+  return {
+    close() {
+      backend.close()
+    },
+  }
+}
+
+export function splitText(text: string) {
+  const words = text.match(/\S+\s*/g) ?? [text]
+  return Array.from(
+    { length: Math.ceil(words.length / 3) },
+    (_, index) => words.slice(index * 3, index * 3 + 3).join(""),
+  )
+}