opendevbrowser 0.0.11 → 0.0.12

package/dist/cli/index.js

@@ -1,8 +1,52 @@
 #!/usr/bin/env node
 import {
+  createOpenDevBrowserCore,
   extractExtension,
-  generateSecureToken
-} from "../chunk-R5VUZEUU.js";
+  generateSecureToken,
+  loadGlobalConfig
+} from "../chunk-WTFSMBVH.js";
+
+// src/cli/errors.ts
+var EXIT_SUCCESS = 0;
+var EXIT_USAGE = 1;
+var EXIT_EXECUTION = 2;
+var EXIT_DISCONNECTED = 10;
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+};
+function createUsageError(message) {
+  return new CliError(message, EXIT_USAGE);
+}
+function createDisconnectedError(message) {
+  return new CliError(message, EXIT_DISCONNECTED);
+}
+function toCliError(error, fallbackExitCode = EXIT_EXECUTION) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new CliError(message, fallbackExitCode);
+}
+function formatErrorPayload(error) {
+  return {
+    success: false,
+    error: error.message,
+    exitCode: error.exitCode
+  };
+}
+function resolveExitCode(result) {
+  if (result.exitCode === null) {
+    return null;
+  }
+  if (typeof result.exitCode === "number") {
+    return result.exitCode;
+  }
+  return result.success ? EXIT_SUCCESS : EXIT_EXECUTION;
+}
 
 // src/cli/args.ts
 var SHORT_FLAGS = {
@@ -28,27 +72,99 @@ function parseSkillsMode(args) {
   }
   return "global";
 }
+function parseOutputFormat(args) {
+  const outputFlag = args.find((arg) => arg.startsWith("--output-format"));
+  if (!outputFlag) {
+    return "text";
+  }
+  let value;
+  if (outputFlag.includes("=")) {
+    value = outputFlag.split("=", 2)[1];
+  } else {
+    const index = args.indexOf(outputFlag);
+    value = index >= 0 ? args[index + 1] : void 0;
+  }
+  if (value === "text" || value === "json" || value === "stream-json") {
+    return value;
+  }
+  throw createUsageError(`Invalid --output-format: ${value ?? "missing"}`);
+}
 function parseArgs(argv) {
-  const args = expandShortFlags(argv.slice(2));
+  let args = expandShortFlags(argv.slice(2));
+  let commandOverride = null;
+  if (args[0] && !args[0].startsWith("-")) {
+    const candidate = args[0];
+    if (candidate === "install" || candidate === "update" || candidate === "uninstall" || candidate === "help" || candidate === "version" || candidate === "serve" || candidate === "run" || candidate === "launch" || candidate === "connect" || candidate === "disconnect" || candidate === "status" || candidate === "goto" || candidate === "wait" || candidate === "snapshot" || candidate === "click" || candidate === "type" || candidate === "select" || candidate === "scroll") {
+      commandOverride = candidate;
+      args = args.slice(1);
+    } else {
+      throw createUsageError(`Unknown command: ${candidate}`);
+    }
+  }
   const skillsMode = parseSkillsMode(args);
   const fullInstall = args.includes("--full");
-  if (args.includes("--help") || args.includes("-h")) {
-    return { command: "help", withConfig: false, noPrompt: false, skillsMode, fullInstall };
+  const outputFormat = parseOutputFormat(args);
+  if (commandOverride === "help" || args.includes("--help") || args.includes("-h")) {
+    return {
+      command: "help",
+      withConfig: false,
+      noPrompt: false,
+      noInteractive: false,
+      quiet: false,
+      outputFormat,
+      skillsMode,
+      fullInstall,
+      rawArgs: args
+    };
   }
-  if (args.includes("--version") || args.includes("-v")) {
-    return { command: "version", withConfig: false, noPrompt: false, skillsMode, fullInstall };
+  if (commandOverride === "version" || args.includes("--version") || args.includes("-v")) {
+    return {
+      command: "version",
+      withConfig: false,
+      noPrompt: false,
+      noInteractive: false,
+      quiet: false,
+      outputFormat,
+      skillsMode,
+      fullInstall,
+      rawArgs: args
+    };
   }
-  if (args.includes("--update")) {
+  if (commandOverride === "update" || args.includes("--update")) {
     const mode2 = args.includes("--global") ? "global" : args.includes("--local") ? "local" : void 0;
-    return { command: "update", mode: mode2, withConfig: false, noPrompt: false, skillsMode, fullInstall };
+    return {
+      command: "update",
+      mode: mode2,
+      withConfig: false,
+      noPrompt: false,
+      noInteractive: false,
+      quiet: false,
+      outputFormat,
+      skillsMode,
+      fullInstall,
+      rawArgs: args
+    };
   }
-  if (args.includes("--uninstall")) {
+  if (commandOverride === "uninstall" || args.includes("--uninstall")) {
     const mode2 = args.includes("--global") ? "global" : args.includes("--local") ? "local" : void 0;
-    const noPrompt2 = args.includes("--no-prompt");
-    return { command: "uninstall", mode: mode2, withConfig: false, noPrompt: noPrompt2, skillsMode, fullInstall };
+    const noPrompt2 = args.includes("--no-prompt") || args.includes("--no-interactive");
+    return {
+      command: "uninstall",
+      mode: mode2,
+      withConfig: false,
+      noPrompt: noPrompt2,
+      noInteractive: noPrompt2,
+      quiet: args.includes("--quiet"),
+      outputFormat,
+      skillsMode,
+      fullInstall,
+      rawArgs: args
+    };
   }
   const withConfig = args.includes("--with-config") || fullInstall;
-  const noPrompt = args.includes("--no-prompt");
+  const noPrompt = args.includes("--no-prompt") || args.includes("--no-interactive");
+  const noInteractive = args.includes("--no-interactive") || noPrompt;
+  const quiet = args.includes("--quiet");
   let mode;
   if (args.includes("--global")) {
     mode = "global";
@@ -66,34 +182,100 @@ function parseArgs(argv) {
     "--version",
     "--with-config",
     "--no-prompt",
+    "--no-interactive",
+    "--quiet",
+    "--output-format",
     "--full",
+    "--port",
+    "--token",
+    "--stop",
+    "--script",
+    "--headless",
+    "--profile",
+    "--persist-profile",
+    "--chrome-path",
+    "--start-url",
+    "--flag",
+    "--session-id",
+    "--close-browser",
+    "--ws-endpoint",
+    "--host",
+    "--cdp-port",
+    "--url",
+    "--wait-until",
+    "--timeout-ms",
+    "--ref",
+    "--state",
+    "--until",
+    "--mode",
+    "--max-chars",
+    "--cursor",
+    "--text",
+    "--clear",
+    "--submit",
+    "--values",
+    "--dy",
+    "--no-extension",
+    "--extension-only",
+    "--wait-for-extension",
+    "--wait-timeout-ms",
     "--skills-global",
     "--skills-local",
     "--no-skills"
   ]);
   for (const arg of args) {
     if (arg.startsWith("--") && !validFlags.has(arg)) {
-      throw new Error(`Unknown flag: ${arg}`);
+      throw createUsageError(`Unknown flag: ${arg}`);
     }
     if (arg.startsWith("-") && !arg.startsWith("--") && !SHORT_FLAGS[arg]) {
-      throw new Error(`Unknown flag: ${arg}`);
+      throw createUsageError(`Unknown flag: ${arg}`);
     }
   }
-  return { command: "install", mode, withConfig, noPrompt, skillsMode, fullInstall };
+  return {
+    command: commandOverride ?? "install",
+    mode,
+    withConfig,
+    noPrompt,
+    noInteractive,
+    quiet,
+    outputFormat,
+    skillsMode,
+    fullInstall,
+    rawArgs: args
+  };
 }
 function getHelpText() {
   return `
 OpenDevBrowser CLI - Install and manage the OpenDevBrowser plugin
 
 USAGE:
-  npx opendevbrowser [options]
+  npx opendevbrowser [command] [options]
 
 COMMANDS:
-  (default)        Install the plugin (interactive if no mode specified)
-  --update, -u     Clear cached plugin to trigger reinstall
-  --uninstall      Remove plugin from config
-  --help, -h       Show this help message
-  --version, -v    Show version
+  install          Install the plugin (default if no command specified)
+  update           Clear cached plugin to trigger reinstall
+  uninstall        Remove plugin from config
+  serve            Start or stop the local daemon
+  run              Execute a JSON script in a single process
+  launch           Launch a managed browser session via daemon
+  connect          Connect to an existing browser via daemon
+  disconnect       Disconnect a daemon session
+  status           Get daemon session status
+  goto             Navigate current session to a URL
+  wait             Wait for load or a ref to appear
+  snapshot         Capture a snapshot of the active page
+  click            Click an element by ref
+  type             Type into an element by ref
+  select           Select values in a select by ref
+  scroll           Scroll the page or element by ref
+  help             Show this help message
+  version          Show version
+
+ALIASES:
+  --update, -u     Same as update
+  --uninstall      Same as uninstall
+  --help, -h       Same as help
+  --version, -v    Same as version
 
 INSTALL OPTIONS:
   --global, -g     Install to ~/.config/opencode/opencode.json
@@ -101,6 +283,9 @@ INSTALL OPTIONS:
   --with-config    Also create opendevbrowser.jsonc with defaults
   --full, -f       Create config and pre-extract extension assets
   --no-prompt      Skip prompts, use defaults (global install)
+  --no-interactive Alias of --no-prompt
+  --quiet          Suppress non-error output
+  --output-format  Output format: text (default), json, stream-json
   --skills-global  Install bundled skills to ~/.config/opencode/skill (default)
   --skills-local   Install bundled skills to ./.opencode/skill
   --no-skills      Skip installing bundled skills
@@ -117,6 +302,23 @@ EXAMPLES:
   npx opendevbrowser --uninstall --global  # Remove from global config
 `.trim();
 }
+function detectOutputFormat(argv) {
+  const args = expandShortFlags(argv.slice(2));
+  try {
+    return parseOutputFormat(args);
+  } catch {
+    return "text";
+  }
+}
+
+// src/cli/commands/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerCommand(definition) {
+  registry.set(definition.name, definition);
+}
+function getCommand(name) {
+  return registry.get(name);
+}
 
 // src/cli/installers/global.ts
 import * as fs4 from "fs";
@@ -624,6 +826,1178 @@ function findInstalledConfigs() {
   return { global, local };
 }
 
+// src/cli/daemon.ts
+import { createServer } from "http";
+import { timingSafeEqual } from "crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+
+// src/cli/daemon-commands.ts
+async function handleDaemonCommand(core, request) {
+  const params = request.params ?? {};
+  switch (request.name) {
+    case "session.launch":
+      return launchWithRelay(core, params);
+    case "session.connect":
+      return core.manager.connect({
+        wsEndpoint: optionalString(params.wsEndpoint),
+        host: optionalString(params.host),
+        port: optionalNumber(params.port)
+      });
+    case "session.disconnect":
+      await core.manager.disconnect(requireString(params.sessionId, "sessionId"), optionalBoolean(params.closeBrowser) ?? false);
+      return { ok: true };
+    case "session.status":
+      return core.manager.status(requireString(params.sessionId, "sessionId"));
+    case "nav.goto":
+      return core.manager.goto(
+        requireString(params.sessionId, "sessionId"),
+        requireString(params.url, "url"),
+        requireWaitUntil(params.waitUntil),
+        optionalNumber(params.timeoutMs) ?? 3e4
+      );
+    case "nav.wait":
+      if (typeof params.ref === "string") {
+        return core.manager.waitForRef(
+          requireString(params.sessionId, "sessionId"),
+          requireString(params.ref, "ref"),
+          requireState(params.state),
+          optionalNumber(params.timeoutMs) ?? 3e4
+        );
+      }
+      return core.manager.waitForLoad(
+        requireString(params.sessionId, "sessionId"),
+        requireWaitUntil(params.until),
+        optionalNumber(params.timeoutMs) ?? 3e4
+      );
+    case "nav.snapshot":
+      return core.manager.snapshot(
+        requireString(params.sessionId, "sessionId"),
+        requireSnapshotMode(params.mode),
+        optionalNumber(params.maxChars) ?? 16e3,
+        optionalString(params.cursor)
+      );
+    case "interact.click":
+      return core.manager.click(
+        requireString(params.sessionId, "sessionId"),
+        requireString(params.ref, "ref")
+      );
+    case "interact.type":
+      return core.manager.type(
+        requireString(params.sessionId, "sessionId"),
+        requireString(params.ref, "ref"),
+        requireString(params.text, "text"),
+        optionalBoolean(params.clear) ?? false,
+        optionalBoolean(params.submit) ?? false
+      );
+    case "interact.select":
+      return core.manager.select(
+        requireString(params.sessionId, "sessionId"),
+        requireString(params.ref, "ref"),
+        requireStringArray(params.values, "values")
+      );
+    case "interact.scroll":
+      return core.manager.scroll(
+        requireString(params.sessionId, "sessionId"),
+        optionalNumber(params.dy) ?? 0,
+        optionalString(params.ref)
+      );
+    default:
+      throw new Error(`Unknown daemon command: ${request.name}`);
+  }
+}
+async function launchWithRelay(core, params) {
+  let relayStatus = core.relay.status();
+  const relayUrl = core.relay.getCdpUrl();
+  const noExtension = optionalBoolean(params.noExtension) ?? false;
+  const extensionOnly = optionalBoolean(params.extensionOnly) ?? false;
+  const waitForExtension = optionalBoolean(params.waitForExtension) ?? false;
+  const waitTimeoutMs = optionalNumber(params.waitTimeoutMs) ?? 3e4;
+  if (waitForExtension) {
+    const connected = await waitForRelay(core.relay, waitTimeoutMs);
+    if (connected) {
+      relayStatus = core.relay.status();
+    }
+  }
+  const useRelay = Boolean(!noExtension && relayStatus.extensionConnected && relayUrl);
+  let relayWarning = null;
+  if (extensionOnly && !useRelay) {
+    throw new Error("Extension not connected; use --no-extension to launch a new browser.");
+  }
+  if (useRelay && relayUrl) {
+    try {
+      const result2 = await core.manager.connectRelay(relayUrl);
+      return { ...result2, warnings: result2.warnings ?? [] };
+    } catch (error) {
+      if (extensionOnly) {
+        throw error instanceof Error ? error : new Error("Extension relay connection failed.");
+      }
+      relayWarning = "Relay connection failed; falling back to managed Chrome.";
+    }
+  }
+  if (relayUrl && !noExtension) {
+    relayWarning ??= "Extension not connected; launching managed Chrome instead.";
+  }
+  const result = await core.manager.launch({
+    profile: optionalString(params.profile),
+    headless: optionalBoolean(params.headless),
+    startUrl: optionalString(params.startUrl),
+    chromePath: optionalString(params.chromePath),
+    flags: optionalStringArray(params.flags),
+    persistProfile: optionalBoolean(params.persistProfile)
+  });
+  const warnings = [
+    ...result.warnings ?? [],
+    ...relayWarning ? [relayWarning] : []
+  ];
+  return { ...result, warnings };
+}
+function requireString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`Missing ${label}`);
+  }
+  return value;
+}
+function requireStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Invalid ${label}`);
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function requireWaitUntil(value) {
+  if (value === "domcontentloaded" || value === "load" || value === "networkidle") {
+    return value;
+  }
+  return "load";
+}
+function requireSnapshotMode(value) {
+  if (value === "actionables") return "actionables";
+  return "outline";
+}
+function requireState(value) {
+  if (value === "visible" || value === "hidden") return value;
+  return "attached";
+}
+async function waitForRelay(relay, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (relay.status().extensionConnected) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
+  }
+  return false;
+}
+
+// src/cli/daemon.ts
+var DEFAULT_DAEMON_PORT = 8788;
+function getCacheRoot() {
+  const base = process.env.OPENCODE_CACHE_DIR ?? process.env.XDG_CACHE_HOME ?? join8(homedir6(), ".cache");
+  return join8(base, "opendevbrowser");
+}
+function getDaemonMetadataPath() {
+  return join8(getCacheRoot(), "daemon.json");
+}
+function readDaemonMetadata() {
+  const metadataPath = getDaemonMetadataPath();
+  if (!existsSync8(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(metadataPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeDaemonMetadata(state) {
+  const metadataPath = getDaemonMetadataPath();
+  mkdirSync4(join8(getCacheRoot()), { recursive: true });
+  writeFileSync5(metadataPath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function clearDaemonMetadata() {
+  const metadataPath = getDaemonMetadataPath();
+  try {
+    unlinkSync3(metadataPath);
+  } catch {
+  }
+}
+function isAuthorized(request, token) {
+  const header = request.headers.authorization ?? "";
+  if (!header.startsWith("Bearer ")) {
+    return false;
+  }
+  const received = header.slice("Bearer ".length).trim();
+  const expectedBuf = Buffer.from(token, "utf-8");
+  const receivedBuf = Buffer.from(received, "utf-8");
+  if (expectedBuf.length !== receivedBuf.length) {
+    timingSafeEqual(expectedBuf, expectedBuf);
+    return false;
+  }
+  return timingSafeEqual(expectedBuf, receivedBuf);
+}
+function sendJson(response, status, payload) {
+  response.writeHead(status, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store"
+  });
+  response.end(JSON.stringify(payload));
+}
+async function startDaemon(options = {}) {
+  const config = options.config ?? loadGlobalConfig();
+  const port = options.port ?? DEFAULT_DAEMON_PORT;
+  const token = options.token ?? generateSecureToken();
+  const core = createOpenDevBrowserCore({
+    directory: options.directory ?? process.cwd(),
+    worktree: options.worktree ?? null,
+    config
+  });
+  await core.ensureRelay(config.relayPort);
+  const server = createServer(async (request, response) => {
+    if (!isAuthorized(request, token)) {
+      sendJson(response, 401, { error: "Unauthorized" });
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (request.method === "GET" && url.pathname === "/status") {
+      sendJson(response, 200, {
+        ok: true,
+        pid: process.pid,
+        relay: core.relay.status()
+      });
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/stop") {
+      sendJson(response, 200, { ok: true });
+      await stop();
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/command") {
+      try {
+        const body = await readJson(request);
+        const data = await handleDaemonCommand(core, body);
+        sendJson(response, 200, { ok: true, data });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        sendJson(response, 400, { ok: false, error: message });
+      }
+      return;
+    }
+    sendJson(response, 404, { error: "Not found" });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve2());
+  });
+  const state = {
+    port,
+    token,
+    pid: process.pid,
+    relayPort: config.relayPort,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeDaemonMetadata(state);
+  const stop = async () => {
+    clearDaemonMetadata();
+    core.cleanup();
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
+  };
+  process.on("SIGINT", () => {
+    stop().catch(() => {
+    });
+  });
+  process.on("SIGTERM", () => {
+    stop().catch(() => {
+    });
+  });
+  return { state, stop };
+}
+function readJson(request) {
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    request.setEncoding("utf8");
+    request.on("data", (chunk) => {
+      data += chunk;
+    });
+    request.on("end", () => {
+      try {
+        const parsed = JSON.parse(data || "{}");
+        if (!parsed || typeof parsed !== "object") {
+          reject(new Error("Invalid JSON body"));
+          return;
+        }
+        resolve2(parsed);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    request.on("error", reject);
+  });
+}
+
+// src/cli/commands/serve.ts
+function parseServeArgs(rawArgs) {
+  const parsed = { stop: false };
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--stop") {
+      parsed.stop = true;
+      continue;
+    }
+    if (arg === "--port") {
+      const value = rawArgs[i + 1];
+      if (!value) {
+        throw createUsageError("Missing value for --port");
+      }
+      parsed.port = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--port=")) {
+      parsed.port = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+    if (arg === "--token") {
+      const value = rawArgs[i + 1];
+      if (!value) {
+        throw createUsageError("Missing value for --token");
+      }
+      parsed.token = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--token=")) {
+      parsed.token = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runServe(args) {
+  const serveArgs = parseServeArgs(args.rawArgs);
+  if (serveArgs.stop) {
+    const metadata = readDaemonMetadata();
+    if (!metadata) {
+      return { success: false, message: "Daemon not running.", exitCode: EXIT_DISCONNECTED };
+    }
+    try {
+      const response = await fetch(`http://127.0.0.1:${metadata.port}/stop`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${metadata.token}` }
+      });
+      if (!response.ok) {
+        throw new Error(`Stop failed (${response.status})`);
+      }
+      return { success: true, message: "Daemon stopped." };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, message: `Failed to stop daemon: ${message}`, exitCode: EXIT_EXECUTION };
+    }
+  }
+  const { state } = await startDaemon({
+    port: serveArgs.port,
+    token: serveArgs.token
+  });
+  return {
+    success: true,
+    message: `Daemon running on 127.0.0.1:${state.port}`,
+    data: { port: state.port, pid: state.pid, relayPort: state.relayPort },
+    exitCode: null
+  };
+}
+
+// src/cli/commands/run.ts
+import { readFileSync as readFileSync4 } from "fs";
+
+// src/cli/output.ts
+function writeOutput(payload, options) {
+  if (options.quiet) {
+    return;
+  }
+  if (options.format === "text") {
+    if (typeof payload === "string") {
+      console.log(payload);
+    } else {
+      console.log(JSON.stringify(payload, null, 2));
+    }
+    return;
+  }
+  if (options.format === "stream-json") {
+    if (Array.isArray(payload)) {
+      for (const entry of payload) {
+        console.log(JSON.stringify(entry));
+      }
+      return;
+    }
+  }
+  console.log(JSON.stringify(payload));
+}
+
+// src/cli/commands/run.ts
+function parseRunArgs(rawArgs) {
+  const parsed = { flags: [] };
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--script") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --script");
+      parsed.scriptPath = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--script=")) {
+      parsed.scriptPath = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--headless") {
+      parsed.headless = true;
+      continue;
+    }
+    if (arg === "--profile") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --profile");
+      parsed.profile = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--profile=")) {
+      parsed.profile = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--persist-profile") {
+      parsed.persistProfile = true;
+      continue;
+    }
+    if (arg === "--chrome-path") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --chrome-path");
+      parsed.chromePath = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--chrome-path=")) {
+      parsed.chromePath = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--start-url") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --start-url");
+      parsed.startUrl = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--start-url=")) {
+      parsed.startUrl = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--flag") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --flag");
+      parsed.flags.push(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--flag=")) {
+      parsed.flags.push(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+function readScriptFromStdin() {
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("error", reject);
+  });
+}
+async function runScriptCommand(args) {
+  const runArgs = parseRunArgs(args.rawArgs);
+  const outputOptions = { format: args.outputFormat, quiet: args.quiet };
+  let scriptRaw = "";
+  if (runArgs.scriptPath) {
+    scriptRaw = readFileSync4(runArgs.scriptPath, "utf-8");
+  } else if (!process.stdin.isTTY) {
+    scriptRaw = await readScriptFromStdin();
+  } else {
+    throw createUsageError("Provide --script <path> or pipe JSON to stdin.");
+  }
+  let steps = [];
+  try {
+    const parsed = JSON.parse(scriptRaw);
+    if (Array.isArray(parsed)) {
+      steps = parsed;
+    } else if (parsed && typeof parsed === "object" && Array.isArray(parsed.steps)) {
+      steps = parsed.steps;
+    } else {
+      throw new Error("Script must be a JSON array or an object with steps.");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON script.";
+    writeOutput({ success: false, error: message, exitCode: EXIT_USAGE }, outputOptions);
+    return { success: false, message, exitCode: EXIT_USAGE, data: { suppressOutput: true } };
+  }
+  const core = createOpenDevBrowserCore({ directory: process.cwd() });
+  const launchResult = await core.manager.launch({
+    profile: runArgs.profile,
+    headless: runArgs.headless,
+    startUrl: runArgs.startUrl,
+    chromePath: runArgs.chromePath,
+    flags: runArgs.flags.length ? runArgs.flags : void 0,
+    persistProfile: runArgs.persistProfile
+  });
+  try {
+    const result = await core.runner.run(launchResult.sessionId, steps, true);
+    writeOutput({
+      success: true,
+      sessionId: launchResult.sessionId,
+      warnings: launchResult.warnings.length ? launchResult.warnings : void 0,
+      ...result
+    }, outputOptions);
+    return { success: true, data: { suppressOutput: true } };
+  } finally {
+    await core.manager.disconnect(launchResult.sessionId, true);
+    core.cleanup();
+  }
+}
+
+// src/cli/client.ts
+async function callDaemon(command, params) {
+  const metadata = readDaemonMetadata();
+  if (!metadata) {
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
+  let response;
+  try {
+    response = await fetch(`http://127.0.0.1:${metadata.port}/command`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${metadata.token}`
+      },
+      body: JSON.stringify({ name: command, params: params ?? {} })
+    });
+  } catch {
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
+  if (!response.ok) {
+    const message = await response.text();
+    throw new CliError(`Daemon error: ${message || response.status}`, EXIT_EXECUTION);
+  }
+  const payload = await response.json();
+  if (!payload.ok) {
+    throw new CliError(payload.error || "Daemon command failed.", EXIT_EXECUTION);
+  }
+  return payload.data;
+}
+
+// src/cli/commands/session/launch.ts
+function parseLaunchArgs(rawArgs) {
+  const parsed = { flags: [] };
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--headless") {
+      parsed.headless = true;
+      continue;
+    }
+    if (arg === "--profile") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --profile");
+      parsed.profile = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--profile=")) {
+      parsed.profile = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--start-url") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --start-url");
+      parsed.startUrl = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--start-url=")) {
+      parsed.startUrl = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--chrome-path") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --chrome-path");
+      parsed.chromePath = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--chrome-path=")) {
+      parsed.chromePath = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--persist-profile") {
+      parsed.persistProfile = true;
+      continue;
+    }
+    if (arg === "--no-extension") {
+      parsed.noExtension = true;
+      continue;
+    }
+    if (arg === "--extension-only") {
+      parsed.extensionOnly = true;
+      continue;
+    }
+    if (arg === "--wait-for-extension") {
+      parsed.waitForExtension = true;
+      continue;
+    }
+    if (arg === "--wait-timeout-ms") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --wait-timeout-ms");
+      parsed.waitTimeoutMs = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--wait-timeout-ms=")) {
+      parsed.waitTimeoutMs = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+    if (arg === "--flag") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --flag");
+      parsed.flags.push(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--flag=")) {
+      parsed.flags.push(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSessionLaunch(args) {
+  const launchArgs = parseLaunchArgs(args.rawArgs);
+  const result = await callDaemon("session.launch", launchArgs);
+  return {
+    success: true,
+    message: `Session launched: ${result.sessionId}`,
+    data: result
+  };
+}
+
+// src/cli/commands/session/connect.ts
+function parseConnectArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--ws-endpoint") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ws-endpoint");
+      parsed.wsEndpoint = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ws-endpoint=")) {
+      parsed.wsEndpoint = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--host") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --host");
+      parsed.host = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--host=")) {
+      parsed.host = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--cdp-port") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --cdp-port");
+      parsed.port = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--cdp-port=")) {
+      parsed.port = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSessionConnect(args) {
+  const connectArgs = parseConnectArgs(args.rawArgs);
+  const result = await callDaemon("session.connect", connectArgs);
+  return {
+    success: true,
+    message: `Session connected: ${result.sessionId}`,
+    data: result
+  };
+}
+
+// src/cli/commands/session/disconnect.ts
+function parseDisconnectArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--close-browser") {
+      parsed.closeBrowser = true;
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSessionDisconnect(args) {
+  const { sessionId, closeBrowser } = parseDisconnectArgs(args.rawArgs);
+  if (!sessionId) {
+    throw createUsageError("Missing --session-id");
+  }
+  await callDaemon("session.disconnect", { sessionId, closeBrowser });
+  return { success: true, message: `Session disconnected: ${sessionId}` };
+}
+
+// src/cli/commands/session/status.ts
+function parseStatusArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSessionStatus(args) {
+  const { sessionId } = parseStatusArgs(args.rawArgs);
+  if (!sessionId) {
+    throw createUsageError("Missing --session-id");
+  }
+  const result = await callDaemon("session.status", { sessionId });
+  return { success: true, message: `Session status: ${sessionId}`, data: result };
+}
+
+// src/cli/commands/nav/goto.ts
+function parseGotoArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--url") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --url");
+      parsed.url = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--url=")) {
+      parsed.url = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--wait-until") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --wait-until");
+      parsed.waitUntil = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--wait-until=")) {
+      parsed.waitUntil = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--timeout-ms") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--timeout-ms=")) {
+      parsed.timeoutMs = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runGoto(args) {
+  const { sessionId, url, waitUntil, timeoutMs } = parseGotoArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!url) throw createUsageError("Missing --url");
+  const result = await callDaemon("nav.goto", { sessionId, url, waitUntil, timeoutMs });
+  return { success: true, message: `Navigated: ${url}`, data: result };
+}
+
+// src/cli/commands/nav/wait.ts
+function parseWaitArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ref");
+      parsed.ref = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ref=")) {
+      parsed.ref = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--state") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --state");
+      parsed.state = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--state=")) {
+      parsed.state = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--until") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --until");
+      parsed.until = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--until=")) {
+      parsed.until = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--timeout-ms") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--timeout-ms=")) {
+      parsed.timeoutMs = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runWait(args) {
+  const { sessionId, ref, state, until, timeoutMs } = parseWaitArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("nav.wait", { sessionId, ref, state, until, timeoutMs });
+  return { success: true, message: "Wait complete.", data: result };
+}
+
+// src/cli/commands/nav/snapshot.ts
+function parseSnapshotArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--mode") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --mode");
+      parsed.mode = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--mode=")) {
+      parsed.mode = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--max-chars") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --max-chars");
+      parsed.maxChars = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--max-chars=")) {
+      parsed.maxChars = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --cursor");
+      parsed.cursor = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--cursor=")) {
+      parsed.cursor = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSnapshot(args) {
+  const { sessionId, mode, maxChars, cursor } = parseSnapshotArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("nav.snapshot", { sessionId, mode, maxChars, cursor });
+  return { success: true, message: "Snapshot captured.", data: result };
+}
+
+// src/cli/commands/interact/click.ts
+function parseClickArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ref");
+      parsed.ref = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ref=")) {
+      parsed.ref = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runClick(args) {
+  const { sessionId, ref } = parseClickArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("interact.click", { sessionId, ref });
+  return { success: true, message: "Click complete.", data: result };
+}
+
+// src/cli/commands/interact/type.ts
+function parseTypeArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ref");
+      parsed.ref = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ref=")) {
+      parsed.ref = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--text") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --text");
+      parsed.text = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--text=")) {
+      parsed.text = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--clear") {
+      parsed.clear = true;
+      continue;
+    }
+    if (arg === "--submit") {
+      parsed.submit = true;
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runType(args) {
+  const { sessionId, ref, text, clear, submit } = parseTypeArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  if (!text) throw createUsageError("Missing --text");
+  const result = await callDaemon("interact.type", { sessionId, ref, text, clear, submit });
+  return { success: true, message: "Type complete.", data: result };
+}
+
+// src/cli/commands/interact/select.ts
+function parseSelectArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ref");
+      parsed.ref = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ref=")) {
+      parsed.ref = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--values") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --values");
+      parsed.values = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--values=")) {
+      parsed.values = arg.split("=", 2)[1].split(",").map((entry) => entry.trim()).filter(Boolean);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSelect(args) {
+  const { sessionId, ref, values } = parseSelectArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  if (!values || values.length === 0) throw createUsageError("Missing --values");
+  const result = await callDaemon("interact.select", { sessionId, ref, values });
+  return { success: true, message: "Select complete.", data: result };
+}
+
+// src/cli/commands/interact/scroll.ts
+function parseScrollArgs(rawArgs) {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--ref") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --ref");
+      parsed.ref = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--ref=")) {
+      parsed.ref = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--dy") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --dy");
+      parsed.dy = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--dy=")) {
+      parsed.dy = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runScroll(args) {
+  const { sessionId, ref, dy } = parseScrollArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (typeof dy !== "number" || Number.isNaN(dy)) throw createUsageError("Missing --dy");
+  const result = await callDaemon("interact.scroll", { sessionId, ref, dy });
+  return { success: true, message: "Scroll complete.", data: result };
+}
+
 // src/cli/index.ts
 var VERSION = "0.1.0";
 async function promptInstallMode() {
@@ -709,94 +2083,238 @@ async function promptUninstallMode() {
     });
   });
 }
+function emitFatalError(error, outputFormat) {
+  if (outputFormat === "text") {
+    console.error(`Error: ${error.message}`);
+    if (error.exitCode === EXIT_USAGE) {
+      console.error("\nFor help: npx opendevbrowser --help");
+    }
+    return;
+  }
+  writeOutput(formatErrorPayload(error), { format: outputFormat });
+}
 async function main() {
+  let outputFormat = null;
+  let parseSucceeded = false;
   try {
     const args = parseArgs(process.argv);
-    switch (args.command) {
-      case "help":
-        console.log(getHelpText());
-        process.exit(0);
-        break;
-      case "version":
-        console.log(`opendevbrowser v${VERSION}`);
-        process.exit(0);
-        break;
-      case "update": {
-        const result = runUpdate();
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-        break;
+    parseSucceeded = true;
+    outputFormat = args.outputFormat;
+    const outputOptions = { format: args.outputFormat, quiet: args.quiet };
+    const emitResult = (result2, payload) => {
+      const suppressOutput = Boolean(
+        result2.data && typeof result2.data === "object" && "suppressOutput" in result2.data && result2.data.suppressOutput
+      );
+      if (suppressOutput) {
+        return;
       }
-      case "uninstall": {
+      if (args.outputFormat === "text") {
+        if (result2.message) {
+          writeOutput(result2.message, outputOptions);
+        }
+      } else {
+        const exitCode2 = resolveExitCode(result2);
+        writeOutput({
+          success: result2.success,
+          message: result2.message,
+          ...result2.success || !result2.message ? {} : { error: result2.message },
+          ...result2.success || exitCode2 === null ? {} : { exitCode: exitCode2 },
+          ...payload
+        }, outputOptions);
+      }
+    };
+    registerCommand({
+      name: "help",
+      description: "Show help",
+      run: () => ({ success: true, message: getHelpText() })
+    });
+    registerCommand({
+      name: "version",
+      description: "Show version",
+      run: () => ({ success: true, message: `opendevbrowser v${VERSION}` })
+    });
+    registerCommand({
+      name: "update",
+      description: "Clear cached plugin to trigger reinstall",
+      run: () => {
+        const result2 = runUpdate();
+        return { success: result2.success, message: result2.message };
+      }
+    });
+    registerCommand({
+      name: "uninstall",
+      description: "Remove plugin from config",
+      run: async () => {
         let mode = args.mode;
         if (!mode && !args.noPrompt) {
           mode = await promptUninstallMode() ?? void 0;
           if (!mode) {
-            console.log("Uninstall cancelled.");
-            process.exit(0);
+            return { success: true, message: "Uninstall cancelled." };
           }
         }
         if (!mode) {
-          console.error("Error: Please specify --global or --local for uninstall.");
-          process.exit(1);
+          return { success: false, message: "Error: Please specify --global or --local for uninstall.", exitCode: EXIT_USAGE };
         }
-        const result = runUninstall(mode);
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-        break;
+        const result2 = runUninstall(mode);
+        return { success: result2.success, message: result2.message };
       }
-      case "install":
-      default: {
+    });
+    registerCommand({
+      name: "install",
+      description: "Install the plugin",
+      run: async () => {
+        const log = (...values) => {
+          if (args.quiet) return;
+          console.log(...values);
+        };
+        const warn = (...values) => {
+          if (args.quiet) return;
+          console.warn(...values);
+        };
         let mode = args.mode;
         if (!mode) {
           mode = await promptInstallMode();
         }
-        const result = mode === "global" ? installGlobal(args.withConfig) : installLocal(args.withConfig);
-        console.log(result.message);
+        const result2 = mode === "global" ? installGlobal(args.withConfig) : installLocal(args.withConfig);
+        if (args.outputFormat !== "text") {
+          const payload = {
+            alreadyInstalled: result2.alreadyInstalled
+          };
+          if (result2.success && args.skillsMode !== "none") {
+            const skillsResult = installSkills(args.skillsMode);
+            payload.skills = skillsResult;
+          }
+          if (args.fullInstall && result2.success) {
+            try {
+              const extensionPath = extractExtension();
+              payload.extensionPath = extensionPath;
+            } catch (error) {
+              payload.extensionError = error instanceof Error ? error.message : String(error);
+            }
+          }
+          return { success: result2.success, message: result2.message, data: payload };
+        }
+        log(result2.message);
         if (args.skillsMode === "none") {
-          console.log("Skill installation skipped (--no-skills).");
-        } else if (result.success) {
+          log("Skill installation skipped (--no-skills).");
+        } else if (result2.success) {
           const skillsResult = installSkills(args.skillsMode);
           if (skillsResult.success) {
-            console.log(skillsResult.message);
+            log(skillsResult.message);
           } else {
-            console.warn(skillsResult.message);
+            warn(skillsResult.message);
           }
         } else {
-          console.warn("Skill installation skipped because plugin install failed.");
+          warn("Skill installation skipped because plugin install failed.");
         }
-        if (args.fullInstall && result.success) {
+        if (args.fullInstall && result2.success) {
           try {
             const extensionPath = extractExtension();
             if (extensionPath) {
-              console.log(`Extension assets extracted to ${extensionPath}`);
+              log(`Extension assets extracted to ${extensionPath}`);
             } else {
-              console.warn("Extension assets not found; skipping extraction.");
+              warn("Extension assets not found; skipping extraction.");
             }
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            console.warn(`Extension pre-extraction failed: ${message}`);
+            warn(`Extension pre-extraction failed: ${message}`);
           }
         }
-        if (result.success && !result.alreadyInstalled) {
-          console.log("\nNext steps:");
-          console.log("  1. Start or restart OpenCode");
-          console.log("  2. Use opendevbrowser_status to verify the plugin is loaded");
-          console.log("\nFor help: npx opendevbrowser --help");
+        if (result2.success && !result2.alreadyInstalled) {
+          log("\nNext steps:");
+          log("  1. Start or restart OpenCode");
+          log("  2. Use opendevbrowser_status to verify the plugin is loaded");
+          log("\nFor help: npx opendevbrowser --help");
         }
-        process.exit(result.success ? 0 : 1);
-        break;
+        return { success: result2.success, message: result2.message };
       }
+    });
+    registerCommand({
+      name: "serve",
+      description: "Start or stop the local daemon",
+      run: async () => runServe(args)
+    });
+    registerCommand({
+      name: "run",
+      description: "Execute a JSON script in a single process",
+      run: async () => runScriptCommand(args)
+    });
+    registerCommand({
+      name: "launch",
+      description: "Launch a managed browser session via daemon",
+      run: async () => runSessionLaunch(args)
+    });
+    registerCommand({
+      name: "connect",
+      description: "Connect to an existing browser via daemon",
+      run: async () => runSessionConnect(args)
+    });
+    registerCommand({
+      name: "disconnect",
+      description: "Disconnect a daemon session",
+      run: async () => runSessionDisconnect(args)
+    });
+    registerCommand({
+      name: "status",
+      description: "Get daemon session status",
+      run: async () => runSessionStatus(args)
+    });
+    registerCommand({
+      name: "goto",
+      description: "Navigate current session to a URL",
+      run: async () => runGoto(args)
+    });
+    registerCommand({
+      name: "wait",
+      description: "Wait for load or a ref to appear",
+      run: async () => runWait(args)
+    });
+    registerCommand({
+      name: "snapshot",
+      description: "Capture a snapshot of the active page",
+      run: async () => runSnapshot(args)
+    });
+    registerCommand({
+      name: "click",
+      description: "Click an element by ref",
+      run: async () => runClick(args)
+    });
+    registerCommand({
+      name: "type",
+      description: "Type into an element by ref",
+      run: async () => runType(args)
+    });
+    registerCommand({
+      name: "select",
+      description: "Select values in a select by ref",
+      run: async () => runSelect(args)
+    });
+    registerCommand({
+      name: "scroll",
+      description: "Scroll the page or element by ref",
+      run: async () => runScroll(args)
+    });
+    const command = getCommand(args.command);
+    if (!command) {
+      throw new Error(`Unknown command: ${args.command}`);
     }
+    const result = await command.run(args);
+    emitResult(result, result.data ? { data: result.data } : void 0);
+    const exitCode = resolveExitCode(result);
+    if (exitCode === null) {
+      return;
+    }
+    process.exit(exitCode);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: ${message}`);
-    console.error("\nFor help: npx opendevbrowser --help");
-    process.exit(1);
+    const format = outputFormat ?? detectOutputFormat(process.argv);
+    const cliError = toCliError(error, parseSucceeded ? EXIT_EXECUTION : EXIT_USAGE);
+    emitFatalError(cliError, format);
+    process.exit(cliError.exitCode);
   }
 }
 main().catch((error) => {
-  console.error("Unexpected error:", error);
-  process.exit(1);
+  const cliError = toCliError(error, EXIT_EXECUTION);
+  emitFatalError(cliError, detectOutputFormat(process.argv));
+  process.exit(cliError.exitCode);
 });
 //# sourceMappingURL=index.js.map