opendevbrowser 0.0.11 → 0.0.15

package/dist/cli/index.js

@@ -1,8 +1,26 @@
 #!/usr/bin/env node
 import {
+  DaemonClient,
+  EXIT_DISCONNECTED,
+  EXIT_EXECUTION,
+  EXIT_USAGE,
+  buildAnnotateResult,
+  callDaemon,
+  createOpenDevBrowserCore,
+  createUsageError,
   extractExtension,
-  generateSecureToken
-} from "../chunk-R5VUZEUU.js";
+  fetchDaemonStatusFromMetadata,
+  fetchWithTimeout,
+  formatErrorPayload,
+  generateSecureToken,
+  getExtensionPath,
+  loadGlobalConfig,
+  readDaemonMetadata,
+  resolveExitCode,
+  startDaemon,
+  toCliError,
+  writeFileAtomic
+} from "../chunk-JVBMT2O5.js";
 
 // src/cli/args.ts
 var SHORT_FLAGS = {
@@ -17,38 +35,142 @@ function expandShortFlags(args) {
   return args.map((arg) => SHORT_FLAGS[arg] ?? arg);
 }
 function parseSkillsMode(args) {
+  const hasLocal = args.includes("--skills-local");
+  const hasGlobal = args.includes("--skills-global");
+  if (hasLocal && hasGlobal) {
+    throw createUsageError("Choose either --skills-local or --skills-global.");
+  }
   if (args.includes("--no-skills")) {
     return "none";
   }
-  if (args.includes("--skills-local")) {
+  if (hasLocal) {
     return "local";
   }
-  if (args.includes("--skills-global")) {
+  if (hasGlobal) {
     return "global";
   }
   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 parseTransport(args) {
+  const transportFlag = args.find((arg) => arg.startsWith("--transport"));
+  if (!transportFlag) {
+    return "relay";
+  }
+  let value;
+  if (transportFlag.includes("=")) {
+    value = transportFlag.split("=", 2)[1];
+  } else {
+    const index = args.indexOf(transportFlag);
+    value = index >= 0 ? args[index + 1] : void 0;
+  }
+  if (value === "relay" || value === "native") {
+    return value;
+  }
+  throw createUsageError(`Invalid --transport: ${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 === "daemon" || candidate === "native" || candidate === "run" || candidate === "launch" || candidate === "connect" || candidate === "disconnect" || candidate === "status" || candidate === "goto" || candidate === "wait" || candidate === "snapshot" || candidate === "click" || candidate === "hover" || candidate === "press" || candidate === "check" || candidate === "uncheck" || candidate === "type" || candidate === "select" || candidate === "scroll" || candidate === "scroll-into-view" || candidate === "targets-list" || candidate === "target-use" || candidate === "target-new" || candidate === "target-close" || candidate === "page" || candidate === "pages" || candidate === "page-close" || candidate === "dom-html" || candidate === "dom-text" || candidate === "dom-attr" || candidate === "dom-value" || candidate === "dom-visible" || candidate === "dom-enabled" || candidate === "dom-checked" || candidate === "clone-page" || candidate === "clone-component" || candidate === "perf" || candidate === "screenshot" || candidate === "console-poll" || candidate === "network-poll" || candidate === "annotate") {
+      commandOverride = candidate;
+      args = args.slice(1);
+    } else {
+      throw createUsageError(`Unknown command: ${candidate}`);
+    }
+  }
+  const hasGlobal = args.includes("--global");
+  const hasLocal = args.includes("--local");
+  if (hasGlobal && hasLocal) {
+    throw createUsageError("Choose either --global or --local.");
+  }
   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);
+  const transport = commandOverride === "annotate" ? "relay" : parseTransport(args);
+  if (commandOverride === "help" || args.includes("--help") || args.includes("-h")) {
+    return {
+      command: "help",
+      withConfig: false,
+      noPrompt: false,
+      noInteractive: false,
+      quiet: false,
+      outputFormat,
+      transport,
+      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,
+      transport,
+      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,
+      transport,
+      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,
+      transport,
+      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 +188,161 @@ 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",
+    "--key",
+    "--attr",
+    "--name",
+    "--target-id",
+    "--tab-id",
+    "--include-urls",
+    "--path",
+    "--since-seq",
+    "--max",
+    "--daemon",
+    "--transport",
+    "--no-extension",
+    "--extension-only",
+    "--extension-legacy",
+    "--wait-for-extension",
+    "--wait-timeout-ms",
     "--skills-global",
     "--skills-local",
-    "--no-skills"
+    "--no-skills",
+    "--screenshot-mode",
+    "--debug",
+    "--context"
+  ]);
+  const validEqualsFlags = /* @__PURE__ */ new Set([
+    "--output-format",
+    "--transport",
+    "--session-id",
+    "--url",
+    "--screenshot-mode",
+    "--context",
+    "--timeout-ms",
+    "--target-id",
+    "--tab-id"
   ]);
   for (const arg of args) {
     if (arg.startsWith("--") && !validFlags.has(arg)) {
-      throw new Error(`Unknown flag: ${arg}`);
+      if (arg.includes("=")) {
+        const baseFlag = arg.split("=", 2)[0] ?? "";
+        if (validEqualsFlags.has(baseFlag)) {
+          continue;
+        }
+      }
+      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,
+    transport,
+    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
+  daemon           Install/uninstall/status daemon auto-start
+  native           Install/uninstall/status native messaging host
+  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 status (or session status with --session-id)
+  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
+  hover            Hover an element by ref
+  press            Press a keyboard key
+  check            Check a checkbox by ref
+  uncheck          Uncheck a checkbox 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
+  scroll-into-view Scroll an element into view by ref
+  targets-list     List page targets
+  target-use       Focus a target by id
+  target-new       Open a new target
+  target-close     Close a target by id
+  page             Open or focus a named page
+  pages            List named pages
+  page-close       Close a named page
+  dom-html         Capture HTML for a ref
+  dom-text         Capture text for a ref
+  dom-attr         Capture attribute value for a ref
+  dom-value        Capture input value for a ref
+  dom-visible      Check visibility for a ref
+  dom-enabled      Check enabled state for a ref
+  dom-checked      Check checked state for a ref
+  clone-page       Clone the active page to React
+  clone-component  Clone a component by ref
+  perf             Capture performance metrics
+  screenshot       Capture a screenshot
+  console-poll     Poll console events
+  network-poll     Poll network events
+  annotate         Request interactive annotations (direct or relay)
+  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 +350,10 @@ 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
+  --transport      Transport: relay (default) or native
   --skills-global  Install bundled skills to ~/.config/opencode/skill (default)
   --skills-local   Install bundled skills to ./.opencode/skill
   --no-skills      Skip installing bundled skills
@@ -115,68 +368,54 @@ EXAMPLES:
   npx opendevbrowser --no-skills      # Skip skill installation
   npx opendevbrowser --update     # Update plugin
   npx opendevbrowser --uninstall --global  # Remove from global config
+  npx opendevbrowser native install <extension-id>  # Install native host
 `.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";
+import * as fs3 from "fs";
 
 // src/cli/utils/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os from "os";
-import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
-
-// src/utils/fs.ts
 import * as fs from "fs";
 import * as path from "path";
-import * as crypto from "crypto";
-function writeFileAtomic(filePath, content, options = {}) {
-  const { encoding = "utf-8", mode } = options;
-  const dir = path.dirname(filePath);
-  const hash = crypto.randomBytes(8).toString("hex");
-  const tempPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${hash}.tmp`);
-  try {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    const writeOptions = { encoding };
-    if (mode !== void 0) {
-      writeOptions.mode = mode;
-    }
-    fs.writeFileSync(tempPath, content, writeOptions);
-    fs.renameSync(tempPath, filePath);
-  } catch (error) {
-    try {
-      if (fs.existsSync(tempPath)) {
-        fs.unlinkSync(tempPath);
-      }
-    } catch {
-    }
-    throw error;
-  }
-}
-
-// src/cli/utils/config.ts
+import * as os from "os";
+import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
 var PLUGIN_NAME = "opendevbrowser";
 var SCHEMA_URL = "https://opencode.ai/config.json";
 function getGlobalConfigPath() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR || path2.join(os.homedir(), ".config", "opencode");
-  return path2.join(configDir, "opencode.json");
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode");
+  return path.join(configDir, "opencode.json");
 }
 function getLocalConfigPath() {
-  return path2.join(process.cwd(), "opencode.json");
+  return path.join(process.cwd(), "opencode.json");
 }
 function ensureDir(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
   }
 }
 function readConfig(configPath) {
-  if (!fs2.existsSync(configPath)) {
+  if (!fs.existsSync(configPath)) {
     return { content: "", config: {} };
   }
-  const content = fs2.readFileSync(configPath, "utf-8");
+  const content = fs.readFileSync(configPath, "utf-8");
   const errors = [];
   const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
   if (errors.length > 0) {
@@ -228,10 +467,10 @@ function removePluginFromContent(content, pluginName = PLUGIN_NAME) {
 }
 
 // src/cli/templates/config.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 import * as os2 from "os";
-function buildConfigTemplate(token) {
+function buildConfigTemplate(relayToken, daemonToken) {
   return `{
   // OpenDevBrowser Plugin Configuration
   // See: https://github.com/anthropics/opendevbrowser#configuration
@@ -295,7 +534,9 @@ function buildConfigTemplate(token) {
   },
 
   "relayPort": 8787,
-  "relayToken": "${token}",
+  "relayToken": "${relayToken}",
+  "daemonPort": 8788,
+  "daemonToken": "${daemonToken}",
 
   "flags": [],
 
@@ -305,22 +546,23 @@ function buildConfigTemplate(token) {
 }
 function getPluginConfigPath(mode) {
   if (mode === "global") {
-    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os2.homedir(), ".config", "opencode");
-    return path3.join(configDir, "opendevbrowser.jsonc");
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path2.join(os2.homedir(), ".config", "opencode");
+    return path2.join(configDir, "opendevbrowser.jsonc");
   }
-  return path3.join(process.cwd(), "opendevbrowser.jsonc");
+  return path2.join(process.cwd(), "opendevbrowser.jsonc");
 }
 function createPluginConfig(mode) {
   const configPath = getPluginConfigPath(mode);
-  if (fs3.existsSync(configPath)) {
+  if (fs2.existsSync(configPath)) {
     return { created: false, path: configPath };
   }
-  const dir = path3.dirname(configPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const dir = path2.dirname(configPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  const token = generateSecureToken();
-  writeFileAtomic(configPath, buildConfigTemplate(token));
+  const relayToken = generateSecureToken();
+  const daemonToken = generateSecureToken();
+  writeFileAtomic(configPath, buildConfigTemplate(relayToken, daemonToken));
   return { created: true, path: configPath };
 }
 
@@ -340,7 +582,7 @@ function installGlobal(withConfig = false) {
     }
     const newContent = updateConfigContent(content, "opendevbrowser");
     ensureDir(configPath.replace(/[/\\][^/\\]+$/, ""));
-    fs4.writeFileSync(configPath, newContent, "utf-8");
+    fs3.writeFileSync(configPath, newContent, "utf-8");
     if (withConfig) {
       createPluginConfig("global");
     }
@@ -364,7 +606,7 @@ function installGlobal(withConfig = false) {
 }
 
 // src/cli/installers/local.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 function installLocal(withConfig = false) {
   const configPath = getLocalConfigPath();
   try {
@@ -379,7 +621,7 @@ function installLocal(withConfig = false) {
       };
     }
     const newContent = updateConfigContent(content, "opendevbrowser");
-    fs5.writeFileSync(configPath, newContent, "utf-8");
+    fs4.writeFileSync(configPath, newContent, "utf-8");
     if (withConfig) {
       createPluginConfig("local");
     }
@@ -403,12 +645,12 @@ function installLocal(withConfig = false) {
 }
 
 // src/cli/installers/skills.ts
-import * as fs7 from "fs";
-import * as path5 from "path";
-
-// src/cli/utils/skills.ts
 import * as fs6 from "fs";
 import * as path4 from "path";
+
+// src/cli/utils/skills.ts
+import * as fs5 from "fs";
+import * as path3 from "path";
 import * as os3 from "os";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "opendevbrowser";
@@ -417,17 +659,17 @@ var cachedPackageRoot = null;
 function findPackageRoot(startDir) {
   let current = startDir;
   while (true) {
-    const pkgPath = path4.join(current, "package.json");
-    if (fs6.existsSync(pkgPath)) {
+    const pkgPath = path3.join(current, "package.json");
+    if (fs5.existsSync(pkgPath)) {
       try {
-        const parsed = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+        const parsed = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
         if (parsed.name === PACKAGE_NAME) {
           return current;
         }
       } catch {
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       break;
     }
@@ -437,23 +679,23 @@ function findPackageRoot(startDir) {
 }
 function getPackageRoot() {
   if (cachedPackageRoot) return cachedPackageRoot;
-  const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
+  const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
   cachedPackageRoot = findPackageRoot(moduleDir);
   return cachedPackageRoot;
 }
 function getBundledSkillsDir() {
-  const skillsDir = path4.join(getPackageRoot(), "skills");
-  if (!fs6.existsSync(skillsDir)) {
+  const skillsDir = path3.join(getPackageRoot(), "skills");
+  if (!fs5.existsSync(skillsDir)) {
     throw new Error(`Bundled skills directory not found at ${skillsDir}`);
   }
   return skillsDir;
 }
 function getGlobalSkillDir() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR || path4.join(os3.homedir(), ".config", "opencode");
-  return path4.join(configDir, SKILL_DIR_NAME);
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os3.homedir(), ".config", "opencode");
+  return path3.join(configDir, SKILL_DIR_NAME);
 }
 function getLocalSkillDir() {
-  return path4.join(process.cwd(), ".opencode", SKILL_DIR_NAME);
+  return path3.join(process.cwd(), ".opencode", SKILL_DIR_NAME);
 }
 
 // src/cli/installers/skills.ts
@@ -463,18 +705,18 @@ function installSkills(mode) {
   const skipped = [];
   try {
     const sourceDir = getBundledSkillsDir();
-    const entries = fs7.readdirSync(sourceDir, { withFileTypes: true });
+    const entries = fs6.readdirSync(sourceDir, { withFileTypes: true });
     ensureDir(targetDir);
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillName = entry.name;
-      const sourcePath = path5.join(sourceDir, skillName);
-      const targetPath = path5.join(targetDir, skillName);
-      if (fs7.existsSync(targetPath)) {
+      const sourcePath = path4.join(sourceDir, skillName);
+      const targetPath = path4.join(targetDir, skillName);
+      if (fs6.existsSync(targetPath)) {
         skipped.push(skillName);
         continue;
       }
-      fs7.cpSync(sourcePath, targetPath, { recursive: true });
+      fs6.cpSync(sourcePath, targetPath, { recursive: true });
       installed.push(skillName);
     }
     const summary = `Skills ${mode} install: ${installed.length} installed${skipped.length ? `, ${skipped.length} skipped` : ""} (${targetDir})`;
@@ -498,31 +740,31 @@ function installSkills(mode) {
 }
 
 // src/cli/commands/update.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 import * as os4 from "os";
 var PLUGIN_NAME2 = "opendevbrowser";
 function getCacheDir() {
-  return process.env.OPENCODE_CACHE_DIR || path6.join(os4.homedir(), ".cache", "opencode");
+  return process.env.OPENCODE_CACHE_DIR || path5.join(os4.homedir(), ".cache", "opencode");
 }
 function rmdir(dirPath) {
   const cacheDir = getCacheDir();
-  const resolvedCache = path6.resolve(cacheDir);
-  const resolvedPath = path6.resolve(dirPath);
-  if (!resolvedPath.startsWith(resolvedCache + path6.sep) || resolvedPath === resolvedCache) {
+  const resolvedCache = path5.resolve(cacheDir);
+  const resolvedPath = path5.resolve(dirPath);
+  if (!resolvedPath.startsWith(resolvedCache + path5.sep) || resolvedPath === resolvedCache) {
     throw new Error(`Security: refusing to delete path outside cache directory: ${dirPath}`);
   }
-  if (fs8.existsSync(dirPath)) {
-    fs8.rmSync(dirPath, { recursive: true, force: true });
+  if (fs7.existsSync(dirPath)) {
+    fs7.rmSync(dirPath, { recursive: true, force: true });
   }
 }
 function runUpdate() {
   const cacheDir = getCacheDir();
-  const nodeModulesDir = path6.join(cacheDir, "node_modules");
-  const pluginCacheDir = path6.join(nodeModulesDir, PLUGIN_NAME2);
+  const nodeModulesDir = path5.join(cacheDir, "node_modules");
+  const pluginCacheDir = path5.join(nodeModulesDir, PLUGIN_NAME2);
   try {
-    if (!fs8.existsSync(pluginCacheDir)) {
-      if (fs8.existsSync(nodeModulesDir)) {
+    if (!fs7.existsSync(pluginCacheDir)) {
+      if (fs7.existsSync(nodeModulesDir)) {
         rmdir(nodeModulesDir);
         return {
           success: true,
@@ -553,20 +795,20 @@ function runUpdate() {
 }
 
 // src/cli/commands/uninstall.ts
-import * as fs9 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 import * as os5 from "os";
 function getPluginConfigPath2(mode) {
   if (mode === "global") {
-    const configDir = process.env.OPENCODE_CONFIG_DIR || path7.join(os5.homedir(), ".config", "opencode");
-    return path7.join(configDir, "opendevbrowser.jsonc");
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path6.join(os5.homedir(), ".config", "opencode");
+    return path6.join(configDir, "opendevbrowser.jsonc");
   }
-  return path7.join(process.cwd(), "opendevbrowser.jsonc");
+  return path6.join(process.cwd(), "opendevbrowser.jsonc");
 }
 function removePluginConfigFile(mode) {
   const configPath = getPluginConfigPath2(mode);
-  if (fs9.existsSync(configPath)) {
-    fs9.unlinkSync(configPath);
+  if (fs8.existsSync(configPath)) {
+    fs8.unlinkSync(configPath);
     return true;
   }
   return false;
@@ -585,7 +827,7 @@ function runUninstall(mode, deleteConfigFile = false) {
       };
     }
     const newContent = removePluginFromContent(content, "opendevbrowser");
-    fs9.writeFileSync(configPath, newContent, "utf-8");
+    fs8.writeFileSync(configPath, newContent, "utf-8");
     let configFileDeleted = false;
     if (deleteConfigFile) {
       configFileDeleted = removePluginConfigFile(mode);
@@ -624,179 +866,3352 @@ function findInstalledConfigs() {
   return { global, local };
 }
 
-// src/cli/index.ts
-var VERSION = "0.1.0";
-async function promptInstallMode() {
-  if (!process.stdin.isTTY) {
-    console.log("Non-interactive mode detected. Using global install.");
-    return "global";
+// src/cli/utils/parse.ts
+function parseNumberFlag(value, flag, options = {}) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
   }
-  return new Promise((resolve2) => {
-    console.log("\nWhere would you like to install opendevbrowser?\n");
-    console.log("  1. Global (~/.config/opencode/opencode.json)");
-    console.log("  2. Local (./opencode.json in this project)\n");
-    process.stdout.write("Enter choice [1]: ");
-    process.stdin.setEncoding("utf8");
-    let resolved = false;
-    let timeoutId = null;
-    const cleanup = () => {
-      if (timeoutId !== null) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
+  const requireInteger = options.integer ?? true;
+  if (requireInteger && !Number.isInteger(parsed)) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
+  }
+  if (typeof options.min === "number" && parsed < options.min) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
+  }
+  if (typeof options.max === "number" && parsed > options.max) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
+  }
+  return parsed;
+}
+
+// src/cli/commands/native.ts
+import * as fs9 from "fs";
+import * as path7 from "path";
+import { homedir as homedir6 } from "os";
+import { execFileSync } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var EXTENSION_ID_RE = /^[a-p]{32}$/;
+var EXTENSION_NAME = "OpenDevBrowser Relay";
+var ANNOTATION_COMMAND_NAME = "toggle-annotation";
+var normalizeExtensionId = (value) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return EXTENSION_ID_RE.test(trimmed) ? trimmed : null;
+};
+var requireExtensionId = (value) => {
+  if (!value) {
+    throw createUsageError("Missing extension ID. Usage: opendevbrowser native install <extension-id>");
+  }
+  const normalized = normalizeExtensionId(value);
+  if (!normalized) {
+    throw createUsageError("Invalid extension ID format. Expected 32 characters (a-p).");
+  }
+  return normalized;
+};
+var parseNativeArgs = (rawArgs) => {
+  const subcommand = rawArgs[0];
+  if (subcommand !== "install" && subcommand !== "uninstall" && subcommand !== "status") {
+    throw createUsageError("Usage: opendevbrowser native <install|uninstall|status> [extension-id]");
+  }
+  if (subcommand === "install") {
+    const extensionId = requireExtensionId(rawArgs[1]);
+    return { subcommand, extensionId };
+  }
+  return { subcommand };
+};
+var getManifestDir = () => {
+  if (process.platform === "darwin") {
+    return path7.join(process.env.HOME || "", "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
+  }
+  if (process.platform === "linux") {
+    return path7.join(process.env.HOME || "", ".config", "google-chrome", "NativeMessagingHosts");
+  }
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || (process.env.USERPROFILE ? path7.join(process.env.USERPROFILE, "AppData", "Local") : "");
+    if (!base) {
+      throw createUsageError("LOCALAPPDATA is not set. Unable to locate NativeMessagingHosts directory.");
+    }
+    return path7.join(base, "Google", "Chrome", "User Data", "NativeMessagingHosts");
+  }
+  throw createUsageError(`Native messaging is not supported on ${process.platform}.`);
+};
+var getScriptsDir = () => {
+  const __filename = fileURLToPath2(import.meta.url);
+  const startDir = path7.dirname(__filename);
+  const rootsToScan = [startDir, process.cwd()];
+  for (const root of rootsToScan) {
+    let current = path7.resolve(root);
+    while (true) {
+      const scriptsDir = path7.join(current, "scripts", "native");
+      const packageJsonPath = path7.join(current, "package.json");
+      if (fs9.existsSync(scriptsDir) && fs9.existsSync(packageJsonPath)) {
+        return scriptsDir;
       }
-    };
-    process.stdin.once("data", (data) => {
-      cleanup();
-      if (resolved) return;
-      resolved = true;
-      const input = data.toString().trim();
-      if (input === "2") {
-        resolve2("local");
-      } else {
-        resolve2("global");
+      const parent = path7.dirname(current);
+      if (parent === current) {
+        break;
       }
-    });
-    process.stdin.once("close", () => {
-      cleanup();
-      if (resolved) return;
-      resolved = true;
-      resolve2("global");
-    });
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      if (resolved) return;
-      resolved = true;
-      console.log("\nTimeout - using global install.");
-      resolve2("global");
-    }, 3e4);
-  });
-}
-async function promptUninstallMode() {
-  const installed = findInstalledConfigs();
-  if (!installed.global && !installed.local) {
-    console.log("opendevbrowser is not installed in any config.");
-    return null;
+      current = parent;
+    }
   }
-  if (installed.global && !installed.local) {
-    return "global";
+  throw createUsageError("Unable to locate scripts/native directory.");
+};
+var getHostScriptPath = () => {
+  return path7.join(getScriptsDir(), "host.cjs");
+};
+var getManifestPath = () => {
+  return path7.join(getManifestDir(), "com.opendevbrowser.native.json");
+};
+var getWrapperPath = () => {
+  const wrapperName = process.platform === "win32" ? "com.opendevbrowser.native.cmd" : "com.opendevbrowser.native.sh";
+  return path7.join(getManifestDir(), wrapperName);
+};
+var readManifest = (manifestPath) => {
+  try {
+    const raw = fs9.readFileSync(manifestPath, "utf8");
+    const data = JSON.parse(raw);
+    const origins = Array.isArray(data.allowed_origins) ? data.allowed_origins : [];
+    const match = origins.find((origin) => origin.startsWith("chrome-extension://"));
+    if (!match) return { extensionId: null };
+    const id = match.replace("chrome-extension://", "").replace("/", "");
+    return { extensionId: EXTENSION_ID_RE.test(id) ? id : null };
+  } catch {
+    return { extensionId: null };
   }
-  if (!installed.global && installed.local) {
-    return "local";
+};
+var runScript = (script, args) => {
+  if (process.platform === "win32") {
+    execFileSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", script, ...args], { stdio: "pipe" });
+    return;
   }
-  if (!process.stdin.isTTY) {
-    console.log("Plugin found in both global and local configs. Use --global or --local flag.");
+  execFileSync("bash", [script, ...args], { stdio: "pipe" });
+};
+var readRegistryPath = () => {
+  if (process.platform !== "win32") return null;
+  const key = "HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\com.opendevbrowser.native";
+  try {
+    const output = execFileSync("reg", ["query", key, "/ve"], { encoding: "utf8" });
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+      if (line.includes("REG_SZ")) {
+        const parts = line.trim().split(/\s{2,}/);
+        return parts[parts.length - 1] || null;
+      }
+    }
+    return null;
+  } catch {
     return null;
   }
-  return new Promise((resolve2) => {
-    console.log("\nopendevbrowser is installed in multiple locations:\n");
-    console.log("  1. Global (~/.config/opencode/opencode.json)");
-    console.log("  2. Local (./opencode.json)");
-    console.log("  3. Cancel\n");
-    process.stdout.write("Which to uninstall? [3]: ");
-    process.stdin.setEncoding("utf8");
-    process.stdin.once("data", (data) => {
-      const input = data.toString().trim();
-      if (input === "1") {
-        resolve2("global");
-      } else if (input === "2") {
-        resolve2("local");
-      } else {
-        resolve2(null);
-      }
-    });
-    process.stdin.once("close", () => {
-      resolve2(null);
-    });
-  });
-}
-async function main() {
+};
+var normalizePath = (value) => {
   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;
+    return fs9.realpathSync(value);
+  } catch {
+    return path7.resolve(value);
+  }
+};
+var getChromeUserDataRoots = () => {
+  if (process.platform === "darwin") {
+    return [
+      path7.join(homedir6(), "Library", "Application Support", "Google", "Chrome"),
+      path7.join(homedir6(), "Library", "Application Support", "Chromium"),
+      path7.join(homedir6(), "Library", "Application Support", "BraveSoftware", "Brave-Browser")
+    ];
+  }
+  if (process.platform === "linux") {
+    return [
+      path7.join(homedir6(), ".config", "google-chrome"),
+      path7.join(homedir6(), ".config", "chromium"),
+      path7.join(homedir6(), ".config", "BraveSoftware", "Brave-Browser")
+    ];
+  }
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || (process.env.USERPROFILE ? path7.join(process.env.USERPROFILE, "AppData", "Local") : "");
+    if (!base) return [];
+    return [
+      path7.join(base, "Google", "Chrome", "User Data"),
+      path7.join(base, "Chromium", "User Data"),
+      path7.join(base, "BraveSoftware", "Brave-Browser", "User Data")
+    ];
+  }
+  return [];
+};
+var PROFILE_PREFERENCES_FILES = ["Preferences", "Secure Preferences"];
+var getProfileDirs = (root) => {
+  try {
+    const entries = fs9.readdirSync(root, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory() && (entry.name === "Default" || entry.name.startsWith("Profile "))).map((entry) => path7.join(root, entry.name)).filter((dir) => PROFILE_PREFERENCES_FILES.some((filename) => fs9.existsSync(path7.join(dir, filename))));
+  } catch {
+    return [];
+  }
+};
+var readProfilePreferences = (profileDir) => {
+  const records = [];
+  for (const filename of PROFILE_PREFERENCES_FILES) {
+    try {
+      const raw = fs9.readFileSync(path7.join(profileDir, filename), "utf8");
+      records.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  return records;
+};
+var findExtensionIdInCommands = (preferences) => {
+  const extensionCommands = preferences.extensions;
+  const commandMaps = [
+    extensionCommands?.commands,
+    preferences.account_values?.extensions?.commands
+  ];
+  for (const commandMap of commandMaps) {
+    if (!commandMap) {
+      continue;
+    }
+    for (const value of Object.values(commandMap)) {
+      if (typeof value !== "object" || value === null) {
+        continue;
       }
-      case "uninstall": {
-        let mode = args.mode;
-        if (!mode && !args.noPrompt) {
-          mode = await promptUninstallMode() ?? void 0;
-          if (!mode) {
-            console.log("Uninstall cancelled.");
-            process.exit(0);
-          }
-        }
-        if (!mode) {
-          console.error("Error: Please specify --global or --local for uninstall.");
-          process.exit(1);
-        }
-        const result = runUninstall(mode);
-        console.log(result.message);
-        process.exit(result.success ? 0 : 1);
-        break;
+      const entry = value;
+      const commandName = typeof entry.command_name === "string" ? entry.command_name : null;
+      const extensionId = typeof entry.extension === "string" ? entry.extension : null;
+      if (commandName === ANNOTATION_COMMAND_NAME && extensionId && EXTENSION_ID_RE.test(extensionId)) {
+        return extensionId;
       }
-      case "install":
-      default: {
-        let mode = args.mode;
-        if (!mode) {
-          mode = await promptInstallMode();
-        }
-        const result = mode === "global" ? installGlobal(args.withConfig) : installLocal(args.withConfig);
-        console.log(result.message);
-        if (args.skillsMode === "none") {
-          console.log("Skill installation skipped (--no-skills).");
-        } else if (result.success) {
-          const skillsResult = installSkills(args.skillsMode);
-          if (skillsResult.success) {
-            console.log(skillsResult.message);
-          } else {
-            console.warn(skillsResult.message);
+    }
+  }
+  return null;
+};
+var findExtensionIdInPreferences = (preferences, extensionPath) => {
+  const extensions = preferences.extensions;
+  const settings = extensions?.settings;
+  if (!settings) return null;
+  const normalizedTargetPath = extensionPath ? normalizePath(extensionPath) : null;
+  let nameMatch = null;
+  for (const [id, entry] of Object.entries(settings)) {
+    if (!EXTENSION_ID_RE.test(id) || typeof entry !== "object" || entry === null) {
+      continue;
+    }
+    const record = entry;
+    const recordPath = typeof record.path === "string" ? record.path : null;
+    if (recordPath && normalizedTargetPath) {
+      if (normalizePath(recordPath) === normalizedTargetPath) {
+        return { id, matchedBy: "path" };
+      }
+    }
+    const manifest = record.manifest;
+    const name = typeof manifest?.name === "string" ? manifest.name : null;
+    if (!nameMatch && name === EXTENSION_NAME) {
+      nameMatch = id;
+    }
+  }
+  if (nameMatch) {
+    return { id: nameMatch, matchedBy: "name" };
+  }
+  return null;
+};
+var getExtensionPathCandidates = () => {
+  const candidates = /* @__PURE__ */ new Set();
+  const primary = getExtensionPath();
+  if (primary) {
+    candidates.add(normalizePath(primary));
+  }
+  const cwdExtension = path7.join(process.cwd(), "extension");
+  if (fs9.existsSync(path7.join(cwdExtension, "manifest.json"))) {
+    candidates.add(normalizePath(cwdExtension));
+  }
+  if (candidates.size === 0) {
+    return [null];
+  }
+  return [...candidates];
+};
+var getNativeStatusSnapshot = () => {
+  const hostScript = getHostScriptPath();
+  const manifestPath = getManifestPath();
+  const wrapperPath = getWrapperPath();
+  const registryPath = readRegistryPath();
+  let installed = false;
+  let manifestExists = false;
+  let wrapperExists = false;
+  let extensionIdValue = null;
+  if (fs9.existsSync(manifestPath)) {
+    manifestExists = true;
+    installed = true;
+    const manifest = readManifest(manifestPath);
+    extensionIdValue = manifest.extensionId;
+  }
+  if (fs9.existsSync(wrapperPath)) {
+    wrapperExists = true;
+  }
+  if (!manifestExists || !wrapperExists) {
+    installed = false;
+  }
+  if (process.platform === "win32" && !registryPath) {
+    installed = false;
+  }
+  return {
+    installed,
+    manifestPath: manifestExists ? manifestPath : null,
+    wrapperPath: wrapperExists ? wrapperPath : null,
+    hostScriptPath: hostScript,
+    extensionId: extensionIdValue,
+    registryPath
+  };
+};
+function discoverExtensionId() {
+  const extensionPaths = getExtensionPathCandidates();
+  const roots = getChromeUserDataRoots();
+  for (const root of roots) {
+    for (const profileDir of getProfileDirs(root)) {
+      let nameFallback = null;
+      let commandFallback = null;
+      for (const preferences of readProfilePreferences(profileDir)) {
+        for (const extensionPath of extensionPaths) {
+          const match = findExtensionIdInPreferences(preferences, extensionPath);
+          if (!match) {
+            continue;
           }
-        } else {
-          console.warn("Skill installation skipped because plugin install failed.");
-        }
-        if (args.fullInstall && result.success) {
-          try {
-            const extensionPath = extractExtension();
-            if (extensionPath) {
-              console.log(`Extension assets extracted to ${extensionPath}`);
-            } else {
-              console.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}`);
+          if (match.matchedBy === "path") {
+            return { extensionId: match.id, matchedBy: match.matchedBy };
+          }
+          if (!nameFallback) {
+            nameFallback = match;
           }
         }
-        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 (!commandFallback) {
+          commandFallback = findExtensionIdInCommands(preferences);
         }
-        process.exit(result.success ? 0 : 1);
-        break;
       }
-    }
+      if (nameFallback) {
+        return { extensionId: nameFallback.id, matchedBy: nameFallback.matchedBy };
+      }
+      if (commandFallback) {
+        return { extensionId: commandFallback, matchedBy: "command" };
+      }
+    }
+  }
+  return { extensionId: null };
+}
+function installNativeHost(extensionId) {
+  const normalized = normalizeExtensionId(extensionId);
+  if (!normalized) {
+    return {
+      success: false,
+      message: "Invalid extension ID format. Expected 32 characters (a-p).",
+      exitCode: EXIT_EXECUTION
+    };
+  }
+  const hostScript = getHostScriptPath();
+  if (!fs9.existsSync(hostScript)) {
+    return {
+      success: false,
+      message: `Native host not found at ${hostScript}.`,
+      exitCode: EXIT_EXECUTION
+    };
+  }
+  const scriptsDir = getScriptsDir();
+  const manifestPath = getManifestPath();
+  const installScript = process.platform === "win32" ? path7.join(scriptsDir, "install.ps1") : path7.join(scriptsDir, "install.sh");
+  try {
+    runScript(installScript, [normalized]);
+    return {
+      success: true,
+      message: `Native host installed for extension ${normalized}.`,
+      data: { manifestPath }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Native install failed: ${message}`,
+      exitCode: EXIT_EXECUTION
+    };
+  }
+}
+async function runNativeCommand(args) {
+  const { subcommand, extensionId } = parseNativeArgs(args.rawArgs);
+  const scriptsDir = getScriptsDir();
+  const uninstallScript = process.platform === "win32" ? path7.join(scriptsDir, "uninstall.ps1") : path7.join(scriptsDir, "uninstall.sh");
+  if (subcommand === "install") {
+    return installNativeHost(extensionId);
+  }
+  if (subcommand === "uninstall") {
+    try {
+      runScript(uninstallScript, []);
+      return { success: true, message: "Native host uninstalled." };
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      return { success: false, message: `Native uninstall failed: ${message2}`, exitCode: EXIT_EXECUTION };
+    }
+  }
+  const data = getNativeStatusSnapshot();
+  if (!data.installed) {
+    return {
+      success: false,
+      message: "Native host not installed.",
+      data,
+      exitCode: EXIT_DISCONNECTED
+    };
+  }
+  const message = data.extensionId ? `Native host installed for extension ${data.extensionId}.` : "Native host installed (extension id missing).";
+  return { success: true, message, data };
+}
+
+// src/cli/commands/serve.ts
+var daemonHandle = null;
+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 = parseNumberFlag(value, "--port", { min: 1, max: 65535 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--port=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) {
+        throw createUsageError("Missing value for --port");
+      }
+      parsed.port = parseNumberFlag(value, "--port", { min: 1, max: 65535 });
+      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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) {
+        throw createUsageError("Missing value for --token");
+      }
+      parsed.token = value;
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runServe(args) {
+  const serveArgs = parseServeArgs(args.rawArgs);
+  if (serveArgs.stop) {
+    const metadata = readDaemonMetadata();
+    if (!metadata) {
+      if (daemonHandle) {
+        await daemonHandle.stop();
+        daemonHandle = null;
+        return { success: true, message: "Daemon stopped." };
+      }
+      return { success: false, message: "Daemon not running.", exitCode: EXIT_DISCONNECTED };
+    }
+    try {
+      const response = await fetchWithTimeout(`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 message2 = error instanceof Error ? error.message : String(error);
+      return { success: false, message: `Failed to stop daemon: ${message2}`, exitCode: EXIT_EXECUTION };
+    }
+  }
+  const config = loadGlobalConfig();
+  let nativeStatus = getNativeStatusSnapshot();
+  let nativeMessage = null;
+  if (!nativeStatus.installed) {
+    const discovered = discoverExtensionId();
+    const extensionId = config.nativeExtensionId ?? discovered.extensionId ?? null;
+    const usedDiscovery = !config.nativeExtensionId && Boolean(discovered.extensionId);
+    if (extensionId) {
+      const installResult = installNativeHost(extensionId);
+      if (installResult.success) {
+        const suffix = usedDiscovery && discovered.matchedBy ? ` (auto-detected by ${discovered.matchedBy})` : "";
+        nativeMessage = `${installResult.message ?? "Native host installed."}${suffix}`;
+        nativeStatus = getNativeStatusSnapshot();
+      } else {
+        nativeMessage = `Native host install skipped: ${installResult.message ?? "unknown error"}`;
+      }
+    } else {
+      nativeMessage = "Native host not installed. Set nativeExtensionId in opendevbrowser.jsonc to auto-install.";
+    }
+  }
+  const handle = await startDaemon({
+    port: serveArgs.port,
+    token: serveArgs.token,
+    config
+  });
+  daemonHandle = handle;
+  const { state } = handle;
+  const baseMessage = `Daemon running on 127.0.0.1:${state.port} (relay ${state.relayPort})`;
+  const message = nativeMessage ? `${baseMessage}
+${nativeMessage}` : baseMessage;
+  return {
+    success: true,
+    message,
+    data: { port: state.port, pid: state.pid, relayPort: state.relayPort, native: nativeStatus },
+    exitCode: null
+  };
+}
+
+// src/cli/daemon-autostart.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname5, join as join8, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var MAC_LABEL = "com.opendevbrowser.daemon";
+var WIN_TASK_NAME = "OpenDevBrowser Daemon";
+var defaultDeps = () => ({
+  platform: process.platform,
+  argv1: process.argv[1] ?? "",
+  moduleUrl: import.meta.url,
+  uid: typeof process.getuid === "function" ? process.getuid() : 0,
+  homedir: homedir7,
+  existsSync: existsSync8,
+  mkdirSync: mkdirSync3,
+  writeFileSync: writeFileSync4,
+  unlinkSync: unlinkSync2,
+  execFileSync: execFileSync2
+});
+var resolveCliPathFromModule = (moduleUrl, exists) => {
+  const modulePath = fileURLToPath3(moduleUrl);
+  const candidate = resolve3(dirname5(modulePath), "..", "index.js");
+  if (!exists(candidate)) {
+    throw new Error(`CLI entrypoint not found at ${candidate}`);
+  }
+  return candidate;
+};
+var resolveCliEntrypoint = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  const exists = resolved.existsSync;
+  let cliPath = null;
+  if (resolved.argv1) {
+    const candidate = resolve3(resolved.argv1);
+    if (exists(candidate)) {
+      cliPath = candidate;
+    }
+  }
+  if (!cliPath) {
+    cliPath = resolveCliPathFromModule(resolved.moduleUrl, exists);
+  }
+  const nodePath = process.execPath;
+  const args = [cliPath, "serve"];
+  const command = `"${nodePath}" "${cliPath}" serve`;
+  return { nodePath, cliPath, args, command };
+};
+var getLaunchAgentPath = (home = homedir7()) => {
+  return join8(home, "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+};
+var buildLaunchAgentPlist = (entrypoint, options = {}) => {
+  const label = options.label ?? MAC_LABEL;
+  const stdoutPath = options.stdoutPath ?? join8(homedir7(), "Library", "Logs", "opendevbrowser-daemon.log");
+  const stderrPath = options.stderrPath ?? join8(homedir7(), "Library", "Logs", "opendevbrowser-daemon.err.log");
+  const programArgs = [entrypoint.nodePath, ...entrypoint.args].map((value) => `      <string>${value}</string>`).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    `  <key>Label</key>`,
+    `  <string>${label}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    programArgs,
+    "  </array>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>KeepAlive</key>",
+    "  <true/>",
+    "  <key>StandardOutPath</key>",
+    `  <string>${stdoutPath}</string>`,
+    "  <key>StandardErrorPath</key>",
+    `  <string>${stderrPath}</string>`,
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+};
+var buildWindowsTaskArgs = (entrypoint, taskName = WIN_TASK_NAME) => {
+  const command = `"${entrypoint.nodePath}" "${entrypoint.cliPath}" serve`;
+  const args = [
+    "/Create",
+    "/TN",
+    taskName,
+    "/TR",
+    command,
+    "/SC",
+    "ONLOGON",
+    "/RL",
+    "LIMITED",
+    "/F"
+  ];
+  return { taskName, command, args };
+};
+var runCommand = (exec, command, args, ignoreFailure = false) => {
+  try {
+    exec(command, args, { stdio: "ignore" });
   } catch (error) {
+    if (ignoreFailure) return;
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: ${message}`);
-    console.error("\nFor help: npx opendevbrowser --help");
-    process.exit(1);
+    throw new Error(`${command} ${args.join(" ")} failed: ${message}`);
+  }
+};
+var installMacAutostart = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  const entrypoint = resolveCliEntrypoint(resolved);
+  const plistPath = getLaunchAgentPath(resolved.homedir());
+  resolved.mkdirSync(dirname5(plistPath), { recursive: true });
+  resolved.writeFileSync(plistPath, buildLaunchAgentPlist(entrypoint), { encoding: "utf-8" });
+  const uid = resolved.uid;
+  runCommand(resolved.execFileSync, "launchctl", ["bootout", `gui/${uid}`, plistPath], true);
+  runCommand(resolved.execFileSync, "launchctl", ["bootstrap", `gui/${uid}`, plistPath]);
+  runCommand(resolved.execFileSync, "launchctl", ["enable", `gui/${uid}/${MAC_LABEL}`], true);
+  runCommand(resolved.execFileSync, "launchctl", ["kickstart", "-k", `gui/${uid}/${MAC_LABEL}`], true);
+  return {
+    platform: "darwin",
+    supported: true,
+    installed: true,
+    location: plistPath,
+    label: MAC_LABEL,
+    command: entrypoint.command
+  };
+};
+var uninstallMacAutostart = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  const plistPath = getLaunchAgentPath(resolved.homedir());
+  const uid = resolved.uid;
+  runCommand(resolved.execFileSync, "launchctl", ["bootout", `gui/${uid}`, plistPath], true);
+  if (resolved.existsSync(plistPath)) {
+    resolved.unlinkSync(plistPath);
+  }
+  return {
+    platform: "darwin",
+    supported: true,
+    installed: false,
+    location: plistPath,
+    label: MAC_LABEL
+  };
+};
+var isWindowsTaskInstalled = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  try {
+    resolved.execFileSync("schtasks", ["/Query", "/TN", WIN_TASK_NAME], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var installWindowsAutostart = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  const entrypoint = resolveCliEntrypoint(resolved);
+  const { args } = buildWindowsTaskArgs(entrypoint, WIN_TASK_NAME);
+  runCommand(resolved.execFileSync, "schtasks", args);
+  return {
+    platform: "win32",
+    supported: true,
+    installed: true,
+    taskName: WIN_TASK_NAME,
+    command: entrypoint.command
+  };
+};
+var uninstallWindowsAutostart = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  runCommand(resolved.execFileSync, "schtasks", ["/Delete", "/TN", WIN_TASK_NAME, "/F"], true);
+  return {
+    platform: "win32",
+    supported: true,
+    installed: false,
+    taskName: WIN_TASK_NAME
+  };
+};
+var getAutostartStatus = (deps = {}) => {
+  const resolved = { ...defaultDeps(), ...deps };
+  const platform = resolved.platform;
+  if (platform === "darwin") {
+    const location = getLaunchAgentPath(resolved.homedir());
+    return {
+      platform,
+      supported: true,
+      installed: resolved.existsSync(location),
+      location,
+      label: MAC_LABEL
+    };
+  }
+  if (platform === "win32") {
+    return {
+      platform,
+      supported: true,
+      installed: isWindowsTaskInstalled(resolved),
+      taskName: WIN_TASK_NAME
+    };
+  }
+  return {
+    platform,
+    supported: false,
+    installed: false
+  };
+};
+var installAutostart = (deps = {}) => {
+  const platform = deps.platform ?? process.platform;
+  if (platform === "darwin") {
+    return installMacAutostart(deps);
+  }
+  if (platform === "win32") {
+    return installWindowsAutostart(deps);
+  }
+  return {
+    platform,
+    supported: false,
+    installed: false
+  };
+};
+var uninstallAutostart = (deps = {}) => {
+  const platform = deps.platform ?? process.platform;
+  if (platform === "darwin") {
+    return uninstallMacAutostart(deps);
+  }
+  if (platform === "win32") {
+    return uninstallWindowsAutostart(deps);
+  }
+  return {
+    platform,
+    supported: false,
+    installed: false
+  };
+};
+
+// src/cli/commands/daemon.ts
+var parseDaemonArgs = (rawArgs) => {
+  const subcommand = rawArgs[0];
+  if (subcommand === "install" || subcommand === "uninstall" || subcommand === "status") {
+    return { subcommand };
+  }
+  throw createUsageError("Usage: opendevbrowser daemon <install|uninstall|status>");
+};
+var stopDaemonIfRunning = async () => {
+  const metadata = readDaemonMetadata();
+  if (!metadata) {
+    return false;
+  }
+  try {
+    const response = await fetchWithTimeout(`http://127.0.0.1:${metadata.port}/stop`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${metadata.token}` }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+var buildStatusMessage = (autostart, running) => {
+  if (!autostart.supported) {
+    return `Daemon autostart is not supported on ${autostart.platform}.`;
+  }
+  const installed = autostart.installed ? "installed" : "not installed";
+  const runningText = running ? "running" : "not running";
+  const location = autostart.location ? ` at ${autostart.location}` : "";
+  const task = autostart.taskName ? ` (${autostart.taskName})` : "";
+  return `Autostart ${installed}${location}${task}. Daemon is ${runningText}.`;
+};
+async function runDaemonCommand(args) {
+  const { subcommand } = parseDaemonArgs(args.rawArgs);
+  if (subcommand === "install") {
+    const result = installAutostart();
+    if (!result.supported) {
+      return {
+        success: false,
+        message: `Daemon autostart is not supported on ${result.platform}.`,
+        data: result,
+        exitCode: EXIT_EXECUTION
+      };
+    }
+    return {
+      success: true,
+      message: `Daemon autostart installed (${result.platform}).`,
+      data: result
+    };
+  }
+  if (subcommand === "uninstall") {
+    const result = uninstallAutostart();
+    if (!result.supported) {
+      return {
+        success: false,
+        message: `Daemon autostart is not supported on ${result.platform}.`,
+        data: result,
+        exitCode: EXIT_EXECUTION
+      };
+    }
+    await stopDaemonIfRunning();
+    return {
+      success: true,
+      message: `Daemon autostart removed (${result.platform}).`,
+      data: result
+    };
+  }
+  const autostart = getAutostartStatus();
+  const daemonStatus = await fetchDaemonStatusFromMetadata();
+  const running = Boolean(daemonStatus);
+  const message = buildStatusMessage(autostart, running);
+  const data = {
+    installed: autostart.installed,
+    running,
+    autostart: autostart.supported ? autostart : void 0
+  };
+  if (!running) {
+    return {
+      success: false,
+      message,
+      data,
+      exitCode: EXIT_DISCONNECTED
+    };
+  }
+  return {
+    success: true,
+    message,
+    data: { ...data, status: daemonStatus }
+  };
+}
+
+// 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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --start-url");
+      parsed.startUrl = value;
+      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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --flag");
+      parsed.flags.push(value);
+      continue;
+    }
+  }
+  return parsed;
+}
+function readScriptFromStdin() {
+  return new Promise((resolve4, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve4(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/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 === "--extension-legacy") {
+      parsed.extensionLegacy = 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 = parseNumberFlag(value, "--wait-timeout-ms", { min: 1 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--wait-timeout-ms=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --wait-timeout-ms");
+      parsed.waitTimeoutMs = parseNumberFlag(value, "--wait-timeout-ms", { min: 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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --flag");
+      parsed.flags.push(value);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runSessionLaunch(args) {
+  const launchArgs = parseLaunchArgs(args.rawArgs);
+  try {
+    const result = await callDaemon("session.launch", launchArgs);
+    return {
+      success: true,
+      message: `Session launched: ${result.sessionId}`,
+      data: result
+    };
+  } catch (error) {
+    if (args.noInteractive) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "";
+    const lower = message.toLowerCase();
+    const isExtensionFailure = message.includes("Extension not connected") || message.includes("Extension relay connection failed") || lower.includes("unauthorized");
+    if (!isExtensionFailure) {
+      throw error;
+    }
+    const retry = await promptYesNo(
+      lower.includes("unauthorized") ? "Relay token mismatch detected. Open the extension popup and click Connect to refresh pairing, then retry now?" : "Extension not connected. Open the extension popup and click Connect, then retry now?",
+      false
+    );
+    if (retry) {
+      try {
+        const result = await callDaemon("session.launch", { ...launchArgs, waitForExtension: true });
+        return {
+          success: true,
+          message: `Session launched: ${result.sessionId}`,
+          data: result
+        };
+      } catch (retryError) {
+        error = retryError;
+      }
+    }
+    const proceedManaged = await promptYesNo("Proceed with a managed session (headed)?", false);
+    if (proceedManaged) {
+      const useHeadless = await promptYesNo("Run headless instead?", false);
+      const result = await callDaemon("session.launch", {
+        ...launchArgs,
+        noExtension: true,
+        headless: useHeadless ? true : false
+      });
+      return {
+        success: true,
+        message: `Session launched: ${result.sessionId}`,
+        data: result
+      };
+    }
+    const proceedCdp = await promptYesNo("Proceed with CDPConnect (requires Chrome --remote-debugging-port=9222)?", false);
+    if (proceedCdp) {
+      const result = await callDaemon("session.connect", {});
+      return {
+        success: true,
+        message: `Session connected: ${result.sessionId}`,
+        data: result
+      };
+    }
+    throw error;
+  }
+}
+function promptYesNo(question, defaultYes) {
+  if (!process.stdin.isTTY) {
+    return Promise.resolve(false);
+  }
+  const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+  return new Promise((resolve4) => {
+    process.stdout.write(`${question}${suffix}`);
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      const input = data.toString().trim().toLowerCase();
+      if (!input) {
+        resolve4(defaultYes);
+        return;
+      }
+      resolve4(input === "y" || input === "yes");
+    });
+  });
+}
+
+// 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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --host");
+      parsed.host = value;
+      continue;
+    }
+    if (arg === "--cdp-port") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --cdp-port");
+      parsed.port = parseNumberFlag(value, "--cdp-port", { min: 1, max: 65535 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--cdp-port=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --cdp-port");
+      parsed.port = parseNumberFlag(value, "--cdp-port", { min: 1, max: 65535 });
+      continue;
+    }
+    if (arg === "--extension-legacy") {
+      parsed.extensionLegacy = true;
+      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 }, { timeoutMs: 2e4 });
+  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/status.ts
+var parseStatusArgs2 = (rawArgs) => {
+  const parsed = { daemon: false };
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--daemon") {
+      parsed.daemon = true;
+      continue;
+    }
+    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 runStatus(args) {
+  const { sessionId, daemon } = parseStatusArgs2(args.rawArgs);
+  if (sessionId && daemon) {
+    throw createUsageError("Use --session-id or --daemon, not both.");
+  }
+  if (sessionId) {
+    return runSessionStatus(args);
+  }
+  if (!daemon && args.transport === "native") {
+    const nativeStatus2 = getNativeStatusSnapshot();
+    if (!nativeStatus2.installed) {
+      return {
+        success: false,
+        message: "Native host not installed.",
+        data: nativeStatus2,
+        exitCode: EXIT_DISCONNECTED
+      };
+    }
+    return {
+      success: true,
+      message: nativeStatus2.extensionId ? `Native host installed for extension ${nativeStatus2.extensionId}.` : "Native host installed.",
+      data: nativeStatus2
+    };
+  }
+  const daemonStatus = await fetchDaemonStatusFromMetadata();
+  if (!daemonStatus) {
+    throw createUsageError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
+  const nativeStatus = getNativeStatusSnapshot();
+  const baseMessage = [
+    `Daemon OK (pid=${daemonStatus.pid})`,
+    `Relay: port=${daemonStatus.relay.port ?? "n/a"} ext=${daemonStatus.relay.extensionConnected ? "on" : "off"} handshake=${daemonStatus.relay.extensionHandshakeComplete ? "on" : "off"} cdp=${daemonStatus.relay.cdpConnected ? "on" : "off"} annotate=${daemonStatus.relay.annotationConnected ? "on" : "off"} ops=${daemonStatus.relay.opsConnected ? "on" : "off"} pairing=${daemonStatus.relay.pairingRequired ? "on" : "off"} health=${daemonStatus.relay.health?.reason ?? "n/a"}`,
+    `Native: ${nativeStatus.installed ? "installed" : "not installed"}${nativeStatus.extensionId ? ` (${nativeStatus.extensionId})` : ""}`,
+    daemonStatus.relay.lastHandshakeError ? `Relay last handshake error: ${daemonStatus.relay.lastHandshakeError.code} (${daemonStatus.relay.lastHandshakeError.message})` : "Relay last handshake error: none",
+    "Legend: ext=extension websocket, handshake=extension handshake, cdp=active /cdp client, annotate=annotation channel, ops=ops clients, pairing=token required, health=relay status"
+  ].join("\n");
+  const message = daemon || args.outputFormat !== "text" ? baseMessage : [
+    "Warning: `status` defaults to daemon status. Use --daemon explicitly or --session-id for session status.",
+    baseMessage
+  ].join("\n");
+  return {
+    success: true,
+    message,
+    data: { ...daemonStatus, native: nativeStatus }
+  };
+}
+
+// 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 = parseNumberFlag(value, "--timeout-ms", { min: 1 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--timeout-ms=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 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 = parseNumberFlag(value, "--timeout-ms", { min: 1 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--timeout-ms=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 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/annotate.ts
+var requireValue = (value, flag) => {
+  if (!value) throw createUsageError(`Missing value for ${flag}`);
+  return value;
+};
+var requireScreenshotMode = (value) => {
+  if (value === "visible" || value === "full" || value === "none") {
+    return value;
+  }
+  throw createUsageError(`Invalid --screenshot-mode: ${value}`);
+};
+var requireTransport = (value) => {
+  if (value === "auto" || value === "direct" || value === "relay") {
+    return value;
+  }
+  throw createUsageError(`Invalid --transport: ${value}`);
+};
+var parseAnnotateArgs = (rawArgs) => {
+  const parsed = {};
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--session-id") {
+      const value = requireValue(rawArgs[i + 1], "--session-id");
+      parsed.sessionId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--session-id=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--session-id");
+      parsed.sessionId = value;
+      continue;
+    }
+    if (arg === "--url") {
+      const value = requireValue(rawArgs[i + 1], "--url");
+      parsed.url = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--url=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--url");
+      parsed.url = value;
+      continue;
+    }
+    if (arg === "--screenshot-mode") {
+      const value = requireValue(rawArgs[i + 1], "--screenshot-mode");
+      parsed.screenshotMode = requireScreenshotMode(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--screenshot-mode=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--screenshot-mode");
+      parsed.screenshotMode = requireScreenshotMode(value);
+      continue;
+    }
+    if (arg === "--transport") {
+      const value = requireValue(rawArgs[i + 1], "--transport");
+      parsed.transport = requireTransport(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--transport=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--transport");
+      parsed.transport = requireTransport(value);
+      continue;
+    }
+    if (arg === "--target-id") {
+      const value = requireValue(rawArgs[i + 1], "--target-id");
+      parsed.targetId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--target-id=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--target-id");
+      parsed.targetId = value;
+      continue;
+    }
+    if (arg === "--tab-id") {
+      const value = requireValue(rawArgs[i + 1], "--tab-id");
+      parsed.tabId = parseNumberFlag(value, "--tab-id", { min: 1 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--tab-id=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--tab-id");
+      parsed.tabId = parseNumberFlag(value, "--tab-id", { min: 1 });
+      continue;
+    }
+    if (arg === "--debug") {
+      parsed.debug = true;
+      continue;
+    }
+    if (arg === "--context") {
+      const value = requireValue(rawArgs[i + 1], "--context");
+      parsed.context = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--context=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--context");
+      parsed.context = value;
+      continue;
+    }
+    if (arg === "--timeout-ms") {
+      const value = requireValue(rawArgs[i + 1], "--timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--timeout-ms=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
+      continue;
+    }
+  }
+  return parsed;
+};
+async function runAnnotate(args) {
+  const { sessionId, url, screenshotMode, debug, context, timeoutMs, transport, targetId, tabId } = parseAnnotateArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const client = new DaemonClient({ autoRenew: true });
+  const callTimeoutMs = typeof timeoutMs === "number" ? timeoutMs + 1e4 : void 0;
+  try {
+    const response = await client.call("annotate", {
+      sessionId,
+      transport,
+      targetId,
+      tabId,
+      url,
+      screenshotMode,
+      debug,
+      context,
+      timeoutMs
+    }, { timeoutMs: callTimeoutMs });
+    if (response.status !== "ok" || !response.payload) {
+      const message2 = response.error?.message ?? "Annotation failed.";
+      throw new Error(message2);
+    }
+    const { message, details, screenshots } = await buildAnnotateResult(response.payload);
+    return { success: true, message, data: { details, screenshots } };
+  } finally {
+    await client.releaseBinding().catch(() => {
+    });
+  }
+}
+
+// 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/hover.ts
+function parseHoverArgs(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 runHover(args) {
+  const { sessionId, ref } = parseHoverArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("interact.hover", { sessionId, ref });
+  return { success: true, message: "Hover complete.", data: result };
+}
+
+// src/cli/commands/interact/press.ts
+function parsePressArgs(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 === "--key") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --key");
+      parsed.key = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--key=")) {
+      parsed.key = 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 runPress(args) {
+  const { sessionId, key, ref } = parsePressArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!key) throw createUsageError("Missing --key");
+  const result = await callDaemon("interact.press", { sessionId, key, ref });
+  return { success: true, message: "Key press complete.", data: result };
+}
+
+// src/cli/commands/interact/check.ts
+function parseCheckArgs(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 runCheck(args) {
+  const { sessionId, ref } = parseCheckArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("interact.check", { sessionId, ref });
+  return { success: true, message: "Check complete.", data: result };
+}
+
+// src/cli/commands/interact/uncheck.ts
+function parseUncheckArgs(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 runUncheck(args) {
+  const { sessionId, ref } = parseUncheckArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("interact.uncheck", { sessionId, ref });
+  return { success: true, message: "Uncheck 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=")) {
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --values");
+      parsed.values = value.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/commands/interact/scroll-into-view.ts
+function parseScrollIntoViewArgs(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 runScrollIntoView(args) {
+  const { sessionId, ref } = parseScrollIntoViewArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("interact.scrollIntoView", { sessionId, ref });
+  return { success: true, message: "Scroll into view complete.", data: result };
+}
+
+// src/cli/commands/targets/list.ts
+function parseTargetsListArgs(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 === "--include-urls") {
+      parsed.includeUrls = true;
+    }
+  }
+  return parsed;
+}
+async function runTargetsList(args) {
+  const { sessionId, includeUrls } = parseTargetsListArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("targets.list", { sessionId, includeUrls });
+  return { success: true, message: `Targets listed for session: ${sessionId}`, data: result };
+}
+
+// src/cli/commands/targets/use.ts
+function parseTargetUseArgs(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 === "--target-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --target-id");
+      parsed.targetId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--target-id=")) {
+      parsed.targetId = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runTargetUse(args) {
+  const { sessionId, targetId } = parseTargetUseArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!targetId) throw createUsageError("Missing --target-id");
+  const result = await callDaemon("targets.use", { sessionId, targetId });
+  return { success: true, message: `Target selected: ${targetId}`, data: result };
+}
+
+// src/cli/commands/targets/new.ts
+function parseTargetNewArgs(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;
+    }
+  }
+  return parsed;
+}
+async function runTargetNew(args) {
+  const { sessionId, url } = parseTargetNewArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("targets.new", { sessionId, url });
+  return { success: true, message: "Target created.", data: result };
+}
+
+// src/cli/commands/targets/close.ts
+function parseTargetCloseArgs(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 === "--target-id") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --target-id");
+      parsed.targetId = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--target-id=")) {
+      parsed.targetId = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runTargetClose(args) {
+  const { sessionId, targetId } = parseTargetCloseArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!targetId) throw createUsageError("Missing --target-id");
+  await callDaemon("targets.close", { sessionId, targetId });
+  return { success: true, message: `Target closed: ${targetId}` };
+}
+
+// src/cli/commands/pages/open.ts
+function parsePageOpenArgs(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 === "--name") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --name");
+      parsed.name = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--name=")) {
+      parsed.name = 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;
+    }
+  }
+  return parsed;
+}
+async function runPageOpen(args) {
+  const { sessionId, name, url } = parsePageOpenArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!name) throw createUsageError("Missing --name");
+  const result = await callDaemon("page.open", { sessionId, name, url });
+  return { success: true, message: `Page ready: ${name}`, data: result };
+}
+
+// src/cli/commands/pages/list.ts
+function parsePagesListArgs(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 runPagesList(args) {
+  const { sessionId } = parsePagesListArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("page.list", { sessionId });
+  return { success: true, message: `Pages listed for session: ${sessionId}`, data: result };
+}
+
+// src/cli/commands/pages/close.ts
+function parsePageCloseArgs(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 === "--name") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --name");
+      parsed.name = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--name=")) {
+      parsed.name = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runPageClose(args) {
+  const { sessionId, name } = parsePageCloseArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!name) throw createUsageError("Missing --name");
+  await callDaemon("page.close", { sessionId, name });
+  return { success: true, message: `Page closed: ${name}` };
+}
+
+// src/cli/commands/dom/html.ts
+function parseDomHtmlArgs(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 === "--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;
+    }
+  }
+  return parsed;
+}
+async function runDomHtml(args) {
+  const { sessionId, ref, maxChars } = parseDomHtmlArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.getHtml", { sessionId, ref, maxChars });
+  return { success: true, message: "DOM HTML captured.", data: result };
+}
+
+// src/cli/commands/dom/text.ts
+function parseDomTextArgs(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 === "--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;
+    }
+  }
+  return parsed;
+}
+async function runDomText(args) {
+  const { sessionId, ref, maxChars } = parseDomTextArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.getText", { sessionId, ref, maxChars });
+  return { success: true, message: "DOM text captured.", data: result };
+}
+
+// src/cli/commands/dom/attr.ts
+function parseDomAttrArgs(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 === "--attr") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --attr");
+      parsed.attr = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--attr=")) {
+      parsed.attr = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runDomAttr(args) {
+  const { sessionId, ref, attr } = parseDomAttrArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  if (!attr) throw createUsageError("Missing --attr");
+  const result = await callDaemon("dom.getAttr", { sessionId, ref, name: attr });
+  return { success: true, message: "DOM attribute captured.", data: result };
+}
+
+// src/cli/commands/dom/value.ts
+function parseDomValueArgs(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 runDomValue(args) {
+  const { sessionId, ref } = parseDomValueArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.getValue", { sessionId, ref });
+  return { success: true, message: "DOM value captured.", data: result };
+}
+
+// src/cli/commands/dom/visible.ts
+function parseDomVisibleArgs(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 runDomVisible(args) {
+  const { sessionId, ref } = parseDomVisibleArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.isVisible", { sessionId, ref });
+  return { success: true, message: "Visibility checked.", data: result };
+}
+
+// src/cli/commands/dom/enabled.ts
+function parseDomEnabledArgs(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 runDomEnabled(args) {
+  const { sessionId, ref } = parseDomEnabledArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.isEnabled", { sessionId, ref });
+  return { success: true, message: "Enabled state checked.", data: result };
+}
+
+// src/cli/commands/dom/checked.ts
+function parseDomCheckedArgs(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 runDomChecked(args) {
+  const { sessionId, ref } = parseDomCheckedArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("dom.isChecked", { sessionId, ref });
+  return { success: true, message: "Checked state reported.", data: result };
+}
+
+// src/cli/commands/export/clone-page.ts
+function parseClonePageArgs(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 runClonePage(args) {
+  const { sessionId } = parseClonePageArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("export.clonePage", { sessionId });
+  return { success: true, message: "Page cloned.", data: result };
+}
+
+// src/cli/commands/export/clone-component.ts
+function parseCloneComponentArgs(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 runCloneComponent(args) {
+  const { sessionId, ref } = parseCloneComponentArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  if (!ref) throw createUsageError("Missing --ref");
+  const result = await callDaemon("export.cloneComponent", { sessionId, ref });
+  return { success: true, message: "Component cloned.", data: result };
+}
+
+// src/cli/commands/devtools/perf.ts
+function parsePerfArgs(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 runPerf(args) {
+  const { sessionId } = parsePerfArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("devtools.perf", { sessionId });
+  return { success: true, message: "Performance metrics captured.", data: result };
+}
+
+// src/cli/commands/devtools/screenshot.ts
+function parseScreenshotArgs(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 === "--path") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --path");
+      parsed.path = value;
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--path=")) {
+      parsed.path = arg.split("=", 2)[1];
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runScreenshot(args) {
+  const { sessionId, path: path8 } = parseScreenshotArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("page.screenshot", { sessionId, path: path8 });
+  return { success: true, message: "Screenshot captured.", data: result };
+}
+
+// src/cli/commands/devtools/console-poll.ts
+function parseConsolePollArgs(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 === "--since-seq") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --since-seq");
+      parsed.sinceSeq = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--since-seq=")) {
+      parsed.sinceSeq = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+    if (arg === "--max") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --max");
+      parsed.max = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--max=")) {
+      parsed.max = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runConsolePoll(args) {
+  const { sessionId, sinceSeq, max } = parseConsolePollArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("devtools.consolePoll", { sessionId, sinceSeq, max });
+  return { success: true, message: "Console events polled.", data: result };
+}
+
+// src/cli/commands/devtools/network-poll.ts
+function parseNetworkPollArgs(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 === "--since-seq") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --since-seq");
+      parsed.sinceSeq = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--since-seq=")) {
+      parsed.sinceSeq = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+    if (arg === "--max") {
+      const value = rawArgs[i + 1];
+      if (!value) throw createUsageError("Missing value for --max");
+      parsed.max = Number(value);
+      i += 1;
+      continue;
+    }
+    if (arg?.startsWith("--max=")) {
+      parsed.max = Number(arg.split("=", 2)[1]);
+      continue;
+    }
+  }
+  return parsed;
+}
+async function runNetworkPoll(args) {
+  const { sessionId, sinceSeq, max } = parseNetworkPollArgs(args.rawArgs);
+  if (!sessionId) throw createUsageError("Missing --session-id");
+  const result = await callDaemon("devtools.networkPoll", { sessionId, sinceSeq, max });
+  return { success: true, message: "Network events polled.", data: result };
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0";
+async function promptInstallMode() {
+  if (!process.stdin.isTTY) {
+    console.log("Non-interactive mode detected. Using global install.");
+    return "global";
+  }
+  return new Promise((resolve4) => {
+    console.log("\nWhere would you like to install opendevbrowser?\n");
+    console.log("  1. Global (~/.config/opencode/opencode.json)");
+    console.log("  2. Local (./opencode.json in this project)\n");
+    process.stdout.write("Enter choice [1]: ");
+    process.stdin.setEncoding("utf8");
+    let resolved = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    process.stdin.once("data", (data) => {
+      cleanup();
+      if (resolved) return;
+      resolved = true;
+      const input = data.toString().trim();
+      if (input === "2") {
+        resolve4("local");
+      } else {
+        resolve4("global");
+      }
+    });
+    process.stdin.once("close", () => {
+      cleanup();
+      if (resolved) return;
+      resolved = true;
+      resolve4("global");
+    });
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      if (resolved) return;
+      resolved = true;
+      console.log("\nTimeout - using global install.");
+      resolve4("global");
+    }, 3e4);
+  });
+}
+async function promptUninstallMode() {
+  const installed = findInstalledConfigs();
+  if (!installed.global && !installed.local) {
+    console.log("opendevbrowser is not installed in any config.");
+    return null;
+  }
+  if (installed.global && !installed.local) {
+    return "global";
+  }
+  if (!installed.global && installed.local) {
+    return "local";
+  }
+  if (!process.stdin.isTTY) {
+    console.log("Plugin found in both global and local configs. Use --global or --local flag.");
+    return null;
+  }
+  return new Promise((resolve4) => {
+    console.log("\nopendevbrowser is installed in multiple locations:\n");
+    console.log("  1. Global (~/.config/opencode/opencode.json)");
+    console.log("  2. Local (./opencode.json)");
+    console.log("  3. Cancel\n");
+    process.stdout.write("Which to uninstall? [3]: ");
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      const input = data.toString().trim();
+      if (input === "1") {
+        resolve4("global");
+      } else if (input === "2") {
+        resolve4("local");
+      } else {
+        resolve4(null);
+      }
+    });
+    process.stdin.once("close", () => {
+      resolve4(null);
+    });
+  });
+}
+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);
+    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;
+      }
+      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) {
+            return { success: true, message: "Uninstall cancelled." };
+          }
+        }
+        if (!mode) {
+          return { success: false, message: "Error: Please specify --global or --local for uninstall.", exitCode: EXIT_USAGE };
+        }
+        const result2 = runUninstall(mode);
+        return { success: result2.success, message: result2.message };
+      }
+    });
+    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 result2 = mode === "global" ? installGlobal(args.withConfig) : installLocal(args.withConfig);
+        const maybeInstallAutostart = () => {
+          const status = getAutostartStatus();
+          if (!status.supported) {
+            return { status, installed: false, message: `Autostart not supported on ${status.platform}.` };
+          }
+          if (status.installed) {
+            return { status, installed: true, message: "Autostart already installed." };
+          }
+          try {
+            const result3 = installAutostart();
+            return { status: result3, installed: result3.installed, message: `Autostart installed (${result3.platform}).` };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { status, installed: false, message };
+          }
+        };
+        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);
+            }
+          }
+          if (result2.success && !result2.alreadyInstalled) {
+            const autostart = maybeInstallAutostart();
+            payload.autostart = autostart.status;
+            if (!autostart.installed) {
+              payload.autostartError = autostart.message;
+            }
+          }
+          return { success: result2.success, message: result2.message, data: payload };
+        }
+        log(result2.message);
+        if (args.skillsMode === "none") {
+          log("Skill installation skipped (--no-skills).");
+        } else if (result2.success) {
+          const skillsResult = installSkills(args.skillsMode);
+          if (skillsResult.success) {
+            log(skillsResult.message);
+          } else {
+            warn(skillsResult.message);
+          }
+        } else {
+          warn("Skill installation skipped because plugin install failed.");
+        }
+        if (args.fullInstall && result2.success) {
+          try {
+            const extensionPath = extractExtension();
+            if (extensionPath) {
+              log(`Extension assets extracted to ${extensionPath}`);
+            } else {
+              warn("Extension assets not found; skipping extraction.");
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warn(`Extension pre-extraction failed: ${message}`);
+          }
+        }
+        if (result2.success && !result2.alreadyInstalled) {
+          const autostart = maybeInstallAutostart();
+          if (autostart.installed) {
+            log(autostart.message);
+          } else {
+            warn(`Autostart install skipped: ${autostart.message}`);
+          }
+        }
+        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");
+        }
+        return { success: result2.success, message: result2.message };
+      }
+    });
+    registerCommand({
+      name: "serve",
+      description: "Start or stop the local daemon",
+      run: async () => runServe(args)
+    });
+    registerCommand({
+      name: "daemon",
+      description: "Install/uninstall/status daemon auto-start",
+      run: async () => runDaemonCommand(args)
+    });
+    registerCommand({
+      name: "native",
+      description: "Install/uninstall/status native messaging host",
+      run: async () => runNativeCommand(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 or session status",
+      run: async () => runStatus(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: "annotate",
+      description: "Request interactive annotations (extension relay)",
+      run: async () => runAnnotate(args)
+    });
+    registerCommand({
+      name: "click",
+      description: "Click an element by ref",
+      run: async () => runClick(args)
+    });
+    registerCommand({
+      name: "hover",
+      description: "Hover an element by ref",
+      run: async () => runHover(args)
+    });
+    registerCommand({
+      name: "press",
+      description: "Press a keyboard key",
+      run: async () => runPress(args)
+    });
+    registerCommand({
+      name: "check",
+      description: "Check a checkbox by ref",
+      run: async () => runCheck(args)
+    });
+    registerCommand({
+      name: "uncheck",
+      description: "Uncheck a checkbox by ref",
+      run: async () => runUncheck(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)
+    });
+    registerCommand({
+      name: "scroll-into-view",
+      description: "Scroll an element into view by ref",
+      run: async () => runScrollIntoView(args)
+    });
+    registerCommand({
+      name: "targets-list",
+      description: "List page targets",
+      run: async () => runTargetsList(args)
+    });
+    registerCommand({
+      name: "target-use",
+      description: "Focus a target by id",
+      run: async () => runTargetUse(args)
+    });
+    registerCommand({
+      name: "target-new",
+      description: "Open a new target",
+      run: async () => runTargetNew(args)
+    });
+    registerCommand({
+      name: "target-close",
+      description: "Close a target by id",
+      run: async () => runTargetClose(args)
+    });
+    registerCommand({
+      name: "page",
+      description: "Open or focus a named page",
+      run: async () => runPageOpen(args)
+    });
+    registerCommand({
+      name: "pages",
+      description: "List named pages",
+      run: async () => runPagesList(args)
+    });
+    registerCommand({
+      name: "page-close",
+      description: "Close a named page",
+      run: async () => runPageClose(args)
+    });
+    registerCommand({
+      name: "dom-html",
+      description: "Capture HTML for a ref",
+      run: async () => runDomHtml(args)
+    });
+    registerCommand({
+      name: "dom-text",
+      description: "Capture text for a ref",
+      run: async () => runDomText(args)
+    });
+    registerCommand({
+      name: "dom-attr",
+      description: "Capture attribute value for a ref",
+      run: async () => runDomAttr(args)
+    });
+    registerCommand({
+      name: "dom-value",
+      description: "Capture input value for a ref",
+      run: async () => runDomValue(args)
+    });
+    registerCommand({
+      name: "dom-visible",
+      description: "Check visibility for a ref",
+      run: async () => runDomVisible(args)
+    });
+    registerCommand({
+      name: "dom-enabled",
+      description: "Check enabled state for a ref",
+      run: async () => runDomEnabled(args)
+    });
+    registerCommand({
+      name: "dom-checked",
+      description: "Check checked state for a ref",
+      run: async () => runDomChecked(args)
+    });
+    registerCommand({
+      name: "clone-page",
+      description: "Clone the active page to React",
+      run: async () => runClonePage(args)
+    });
+    registerCommand({
+      name: "clone-component",
+      description: "Clone a component by ref",
+      run: async () => runCloneComponent(args)
+    });
+    registerCommand({
+      name: "perf",
+      description: "Capture performance metrics",
+      run: async () => runPerf(args)
+    });
+    registerCommand({
+      name: "screenshot",
+      description: "Capture a screenshot",
+      run: async () => runScreenshot(args)
+    });
+    registerCommand({
+      name: "console-poll",
+      description: "Poll console events",
+      run: async () => runConsolePoll(args)
+    });
+    registerCommand({
+      name: "network-poll",
+      description: "Poll network events",
+      run: async () => runNetworkPoll(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 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