opencode-drive 0.1.2 → 0.1.4

package/src/cli/index.ts

@@ -2,82 +2,152 @@
 import { NodeRuntime, NodeServices } from "@effect/platform-node"
 import { Effect, Option } from "effect"
 import { Command, Flag } from "effect/unstable/cli"
-import { send } from "./send.js"
-import { describe } from "./describe.js"
+import { api } from "./api.js"
 import { extractCommands } from "./parse.js"
+import { list } from "./list.js"
+import { logs } from "./logs.js"
+import { restart } from "./restart.js"
+import { responses } from "./responses.js"
+import { send } from "./send.js"
 import { start } from "./start.js"
 import { stop } from "./stop.js"
-import { api } from "./api.js"
-import { restart } from "./restart.js"
 import type { DriveCommand, SendOptions, StartOptions } from "./types.js"
 
 const extracted = extract()
-const name = Flag.string("name").pipe(Flag.optional, Flag.withDescription("Instance name"))
-const driver = Flag.string("driver").pipe(Flag.optional, Flag.withDescription("TypeScript driver module"))
+const startName = Flag.string("name").pipe(
+  Flag.withDefault("default"),
+  Flag.withDescription("Instance name"),
+)
+const name = Flag.string("name").pipe(
+  Flag.optional,
+  Flag.withDescription("Instance name (inferred when exactly one is running)"),
+)
 
-const startCommand = Command.make("start", {
-  name,
-  driver,
-  campaign: Flag.string("campaign").pipe(Flag.optional, Flag.withDescription("Campaign module")),
-  seed: Flag.integer("seed").pipe(Flag.withDefault(Date.now() % 1_000_000)),
-  caseIndex: Flag.integer("case").pipe(
-    Flag.filter((value) => value >= 0, () => "Case must be non-negative"),
-    Flag.optional,
-  ),
-  count: Flag.integer("count").pipe(
-    Flag.filter((value) => value > 0, () => "Count must be greater than zero"),
-    Flag.optional,
-  ),
-  concurrency: Flag.integer("concurrency").pipe(
-    Flag.filter((value) => value > 0, () => "Concurrency must be greater than zero"),
-    Flag.withDefault(1),
+const startCommand = Command.make(
+  "start",
+  {
+    name: startName,
+    daemon: Flag.boolean("daemon").pipe(
+      Flag.withDescription("Run as detached instance owner"),
+    ),
+    script: Flag.string("script").pipe(
+      Flag.optional,
+      Flag.withDescription("JavaScript or TypeScript automation module"),
+    ),
+    visible: Flag.boolean("visible").pipe(
+      Flag.withDescription("Show OpenCode in the terminal"),
+    ),
+    dev: Flag.string("dev").pipe(
+      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(() =>
+      start(toStartOptions(config, extracted.commands, extracted.app)),
+    ),
+).pipe(
+  Command.withDescription("Launch a local simulated OpenCode instance"),
+  Command.withExamples([
+    {
+      command: "opencode-drive start",
+      description: "Launch headless OpenCode on the default ports",
+    },
+    {
+      command: "opencode-drive start --visible",
+      description: "Launch visible OpenCode on the default ports",
+    },
+    {
+      command: "opencode-drive start --script ./drive.ts",
+      description: "Launch headless OpenCode and run a script",
+    },
+  ]),
+)
+
+const sendCommand = Command.make("send", { name }, (config) =>
+  execute(() =>
+    send(
+      toSendOptions(
+        Option.getOrUndefined(config.name),
+        extracted.commands,
+        extracted.app,
+      ),
+    ),
   ),
-  visible: Flag.boolean("visible").pipe(Flag.withDescription("Show OpenCode in the terminal")),
-  detach: Flag.boolean("detach").pipe(Flag.withDescription("Keep OpenCode running in the background (default)")),
-  dev: Flag.string("dev").pipe(Flag.optional, Flag.withDescription("Path to an OpenCode development checkout")),
-  state: Flag.string("state").pipe(Flag.optional, Flag.withDescription("Simulation snapshot containing files/")),
-  anchor: Flag.string("anchor").pipe(Flag.optional),
-}, (config) => execute(() => start(toStartOptions(config, extracted.commands, extracted.app)))).pipe(
-  Command.withDescription("Launch and own a local simulated OpenCode instance"),
+).pipe(
+  Command.withDescription("Send UI commands to OpenCode on the default port"),
   Command.withExamples([
-    { command: "opencode-drive start --name demo --visible", description: "Launch a visible simulated instance" },
-    { command: "opencode-drive start --name demo --detach", description: "Launch a background simulated instance" },
+    {
+      command:
+        'opencode-drive send --command.ui.type \'{"text":"hello"}\' --command.ui.state',
+      description: "Execute an ordered UI command batch",
+    },
   ]),
 )
 
-const sendCommand = Command.make("send", { name, driver }, (config) =>
-  execute(() => send(toSendOptions(config, extracted.commands, extracted.app)))).pipe(
-    Command.withDescription("Connect to an existing drive-enabled OpenCode instance"),
-    Command.withExamples([
-      {
-        command: "opencode-drive send --name demo --command.ui.type '{\"text\":\"hello\"}' --command.ui.state",
-        description: "Execute an ordered command batch",
-      },
-    ]),
-  )
+const apiCommand = Command.make("api", {}, () => execute(api)).pipe(
+  Command.withDescription("Print the OpenCode drive UI protocol"),
+)
 
-const describeCommand = Command.make("describe", { name }, (config) =>
-  execute(() => describe(Option.getOrUndefined(config.name)))).pipe(
-    Command.withDescription("Describe a registered OpenCode instance"),
-  )
+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",
+  ),
+)
 
 const stopCommand = Command.make("stop", { name }, (config) =>
-  execute(() => stop(Option.getOrUndefined(config.name)))).pipe(
-    Command.withDescription("Stop a registered headless OpenCode instance"),
-  )
+  execute(() => stop(Option.getOrUndefined(config.name))),
+).pipe(Command.withDescription("Stop a named OpenCode instance"))
 
-const restartCommand = Command.make("restart", { name }, (config) =>
-  execute(() => restart(Option.getOrUndefined(config.name)))).pipe(
-    Command.withDescription("Restart a registered OpenCode client"),
-  )
+const logsCommand = Command.make("logs", { name }, (config) =>
+  execute(() => logs(Option.getOrUndefined(config.name))),
+).pipe(Command.withDescription("List log files for a named OpenCode instance"))
 
-const apiCommand = Command.make("api", {}, () => execute(api)).pipe(
-  Command.withDescription("Print the OpenCode drive protocol"),
+const listCommand = Command.make("list", {}, () => execute(list)).pipe(
+  Command.withDescription("List active OpenCode instances"),
 )
 
+const responsesCommand = Command.make(
+  "responses",
+  {
+    name,
+    types: Flag.string("types").pipe(
+      Flag.optional,
+      Flag.withDescription("Comma-delimited response types"),
+    ),
+    tools: Flag.string("tools").pipe(
+      Flag.optional,
+      Flag.withDescription("Comma-delimited tool names, or * for all tools"),
+    ),
+  },
+  (config) =>
+    execute(() =>
+      responses({
+        name: Option.getOrUndefined(config.name),
+        types: Option.getOrUndefined(config.types),
+        tools: Option.getOrUndefined(config.tools),
+      }),
+    ),
+).pipe(Command.withDescription("Configure simulated LLM response generation"))
+
 const root = Command.make("opencode-drive").pipe(
   Command.withDescription("Drive real and simulated OpenCode instances"),
-  Command.withSubcommands([startCommand, sendCommand, describeCommand, stopCommand, restartCommand, apiCommand]),
+  Command.withSubcommands([
+    startCommand,
+    sendCommand,
+    listCommand,
+    responsesCommand,
+    logsCommand,
+    restartCommand,
+    stopCommand,
+    apiCommand,
+  ]),
 )
 
 Command.runWith(root, { version: "0.1.0" })(extracted.args).pipe(
@@ -87,81 +157,52 @@ Command.runWith(root, { version: "0.1.0" })(extracted.args).pipe(
 
 function toStartOptions(
   config: {
-    readonly name: Option.Option<string>
-    readonly driver: Option.Option<string>
-    readonly campaign: Option.Option<string>
-    readonly seed: number
-    readonly caseIndex: Option.Option<number>
-    readonly count: Option.Option<number>
-    readonly concurrency: number
+    readonly script: Option.Option<string>
+    readonly name: string
+    readonly daemon: boolean
     readonly visible: boolean
-    readonly detach: boolean
     readonly dev: Option.Option<string>
     readonly state: Option.Option<string>
-    readonly anchor: Option.Option<string>
   },
   commands: ReadonlyArray<DriveCommand>,
   app: ReadonlyArray<string>,
 ): StartOptions {
-  const driver = Option.getOrUndefined(config.driver)
-  const campaign = Option.getOrUndefined(config.campaign)
-  const visible = config.visible
+  if (commands.length > 0)
+    throw new Error("start does not accept command flags; use send or --script")
   const options = {
     kind: "start" as const,
-    name: Option.getOrUndefined(config.name),
-    driver,
-    campaign,
-    seed: config.seed,
-    caseIndex: Option.getOrUndefined(config.caseIndex),
-    count: Option.getOrUndefined(config.count),
-    concurrency: config.concurrency,
-    visible,
-    detach: !visible && (config.detach || (driver === undefined && campaign === undefined && commands.length === 0)),
+    name: config.name,
+    daemon: config.daemon,
+    script: Option.getOrUndefined(config.script),
+    visible: config.visible,
     dev: Option.getOrUndefined(config.dev),
     state: Option.getOrUndefined(config.state),
-    anchor: Option.getOrUndefined(config.anchor),
     command: app,
-    commands,
-  }
-  assertExecutionMode(options.driver, options.campaign, commands)
-  if (options.dev !== undefined && app.length > 0) throw new Error("--dev cannot be combined with a command after --")
-  if (options.caseIndex !== undefined && options.campaign === undefined) throw new Error("--case requires --campaign")
-  if (options.visible && options.campaign !== undefined && options.caseIndex === undefined) {
-    throw new Error("visible campaign runs require --case")
-  }
-  if (config.detach && (options.driver !== undefined || options.campaign !== undefined || commands.length > 0)) {
-    throw new Error("--detach cannot be combined with --driver, --campaign, or command flags")
   }
+  if (options.dev !== undefined && app.length > 0)
+    throw new Error("--dev cannot be combined with a command after --")
   return options
 }
 
 function toSendOptions(
-  config: { readonly name: Option.Option<string>; readonly driver: Option.Option<string> },
+  name: string | undefined,
   commands: ReadonlyArray<DriveCommand>,
   app: ReadonlyArray<string>,
 ): SendOptions {
   if (app.length > 0) throw new Error("send does not accept a command after --")
-  const options = {
-    kind: "send" as const,
-    name: Option.getOrUndefined(config.name),
-    driver: Option.getOrUndefined(config.driver),
-    commands,
-  }
-  assertExecutionMode(options.driver, undefined, commands)
-  return options
-}
-
-function assertExecutionMode(driver: string | undefined, campaign: string | undefined, commands: ReadonlyArray<DriveCommand>) {
-  const count = Number(driver !== undefined) + Number(campaign !== undefined) + Number(commands.length > 0)
-  if (count > 1) throw new Error("command flags, --driver, and --campaign are mutually exclusive")
+  return { kind: "send", name, commands }
 }
 
 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)}`)
-      process.exitCode = 1
-    })),
+    Effect.catch((error) =>
+      Effect.sync(() => {
+        console.error(
+          `error: ${error instanceof Error ? error.message : String(error)}`,
+        )
+        process.exitCode = 1
+      }),
+    ),
   )
 }
 
@@ -169,7 +210,9 @@ 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)
   }
 }