opendevbrowser 0.0.12 → 0.0.15

package/dist/cli/index.js

@@ -1,52 +1,26 @@
 #!/usr/bin/env node
 import {
+  DaemonClient,
+  EXIT_DISCONNECTED,
+  EXIT_EXECUTION,
+  EXIT_USAGE,
+  buildAnnotateResult,
+  callDaemon,
   createOpenDevBrowserCore,
+  createUsageError,
   extractExtension,
+  fetchDaemonStatusFromMetadata,
+  fetchWithTimeout,
+  formatErrorPayload,
   generateSecureToken,
-  loadGlobalConfig
-} from "../chunk-WTFSMBVH.js";
-
-// src/cli/errors.ts
-var EXIT_SUCCESS = 0;
-var EXIT_USAGE = 1;
-var EXIT_EXECUTION = 2;
-var EXIT_DISCONNECTED = 10;
-var CliError = class extends Error {
-  exitCode;
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-};
-function createUsageError(message) {
-  return new CliError(message, EXIT_USAGE);
-}
-function createDisconnectedError(message) {
-  return new CliError(message, EXIT_DISCONNECTED);
-}
-function toCliError(error, fallbackExitCode = EXIT_EXECUTION) {
-  if (error instanceof CliError) {
-    return error;
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return new CliError(message, fallbackExitCode);
-}
-function formatErrorPayload(error) {
-  return {
-    success: false,
-    error: error.message,
-    exitCode: error.exitCode
-  };
-}
-function resolveExitCode(result) {
-  if (result.exitCode === null) {
-    return null;
-  }
-  if (typeof result.exitCode === "number") {
-    return result.exitCode;
-  }
-  return result.success ? EXIT_SUCCESS : EXIT_EXECUTION;
-}
+  getExtensionPath,
+  loadGlobalConfig,
+  readDaemonMetadata,
+  resolveExitCode,
+  startDaemon,
+  toCliError,
+  writeFileAtomic
+} from "../chunk-JVBMT2O5.js";
 
 // src/cli/args.ts
 var SHORT_FLAGS = {
@@ -61,13 +35,18 @@ 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";
@@ -89,21 +68,44 @@ function parseOutputFormat(args) {
   }
   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) {
   let args = expandShortFlags(argv.slice(2));
   let commandOverride = null;
   if (args[0] && !args[0].startsWith("-")) {
     const candidate = args[0];
-    if (candidate === "install" || candidate === "update" || candidate === "uninstall" || candidate === "help" || candidate === "version" || candidate === "serve" || candidate === "run" || candidate === "launch" || candidate === "connect" || candidate === "disconnect" || candidate === "status" || candidate === "goto" || candidate === "wait" || candidate === "snapshot" || candidate === "click" || candidate === "type" || candidate === "select" || candidate === "scroll") {
+    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");
   const outputFormat = parseOutputFormat(args);
+  const transport = commandOverride === "annotate" ? "relay" : parseTransport(args);
   if (commandOverride === "help" || args.includes("--help") || args.includes("-h")) {
     return {
       command: "help",
@@ -112,6 +114,7 @@ function parseArgs(argv) {
       noInteractive: false,
       quiet: false,
       outputFormat,
+      transport,
       skillsMode,
       fullInstall,
       rawArgs: args
@@ -125,6 +128,7 @@ function parseArgs(argv) {
       noInteractive: false,
       quiet: false,
       outputFormat,
+      transport,
       skillsMode,
       fullInstall,
       rawArgs: args
@@ -140,6 +144,7 @@ function parseArgs(argv) {
       noInteractive: false,
       quiet: false,
       outputFormat,
+      transport,
       skillsMode,
       fullInstall,
       rawArgs: args
@@ -156,6 +161,7 @@ function parseArgs(argv) {
       noInteractive: noPrompt2,
       quiet: args.includes("--quiet"),
       outputFormat,
+      transport,
       skillsMode,
       fullInstall,
       rawArgs: args
@@ -215,16 +221,48 @@ function parseArgs(argv) {
     "--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)) {
+      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]) {
@@ -239,6 +277,7 @@ function parseArgs(argv) {
     noInteractive,
     quiet,
     outputFormat,
+    transport,
     skillsMode,
     fullInstall,
     rawArgs: args
@@ -256,18 +295,46 @@ COMMANDS:
   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 session status
+  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
 
@@ -286,6 +353,7 @@ INSTALL OPTIONS:
   --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
@@ -300,6 +368,7 @@ 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) {
@@ -321,64 +390,32 @@ function getCommand(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) {
@@ -430,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
@@ -497,7 +534,9 @@ function buildConfigTemplate(token) {
   },
 
   "relayPort": 8787,
-  "relayToken": "${token}",
+  "relayToken": "${relayToken}",
+  "daemonPort": 8788,
+  "daemonToken": "${daemonToken}",
 
   "flags": [],
 
@@ -507,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 };
 }
 
@@ -542,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");
     }
@@ -566,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 {
@@ -581,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");
     }
@@ -605,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";
@@ -619,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;
     }
@@ -639,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
@@ -665,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})`;
@@ -700,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,
@@ -755,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;
@@ -787,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);
@@ -826,331 +866,399 @@ function findInstalledConfigs() {
   return { global, local };
 }
 
-// src/cli/daemon.ts
-import { createServer } from "http";
-import { timingSafeEqual } from "crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8 } from "path";
-
-// src/cli/daemon-commands.ts
-async function handleDaemonCommand(core, request) {
-  const params = request.params ?? {};
-  switch (request.name) {
-    case "session.launch":
-      return launchWithRelay(core, params);
-    case "session.connect":
-      return core.manager.connect({
-        wsEndpoint: optionalString(params.wsEndpoint),
-        host: optionalString(params.host),
-        port: optionalNumber(params.port)
-      });
-    case "session.disconnect":
-      await core.manager.disconnect(requireString(params.sessionId, "sessionId"), optionalBoolean(params.closeBrowser) ?? false);
-      return { ok: true };
-    case "session.status":
-      return core.manager.status(requireString(params.sessionId, "sessionId"));
-    case "nav.goto":
-      return core.manager.goto(
-        requireString(params.sessionId, "sessionId"),
-        requireString(params.url, "url"),
-        requireWaitUntil(params.waitUntil),
-        optionalNumber(params.timeoutMs) ?? 3e4
-      );
-    case "nav.wait":
-      if (typeof params.ref === "string") {
-        return core.manager.waitForRef(
-          requireString(params.sessionId, "sessionId"),
-          requireString(params.ref, "ref"),
-          requireState(params.state),
-          optionalNumber(params.timeoutMs) ?? 3e4
-        );
-      }
-      return core.manager.waitForLoad(
-        requireString(params.sessionId, "sessionId"),
-        requireWaitUntil(params.until),
-        optionalNumber(params.timeoutMs) ?? 3e4
-      );
-    case "nav.snapshot":
-      return core.manager.snapshot(
-        requireString(params.sessionId, "sessionId"),
-        requireSnapshotMode(params.mode),
-        optionalNumber(params.maxChars) ?? 16e3,
-        optionalString(params.cursor)
-      );
-    case "interact.click":
-      return core.manager.click(
-        requireString(params.sessionId, "sessionId"),
-        requireString(params.ref, "ref")
-      );
-    case "interact.type":
-      return core.manager.type(
-        requireString(params.sessionId, "sessionId"),
-        requireString(params.ref, "ref"),
-        requireString(params.text, "text"),
-        optionalBoolean(params.clear) ?? false,
-        optionalBoolean(params.submit) ?? false
-      );
-    case "interact.select":
-      return core.manager.select(
-        requireString(params.sessionId, "sessionId"),
-        requireString(params.ref, "ref"),
-        requireStringArray(params.values, "values")
-      );
-    case "interact.scroll":
-      return core.manager.scroll(
-        requireString(params.sessionId, "sessionId"),
-        optionalNumber(params.dy) ?? 0,
-        optionalString(params.ref)
-      );
-    default:
-      throw new Error(`Unknown daemon command: ${request.name}`);
+// src/cli/utils/parse.ts
+function parseNumberFlag(value, flag, options = {}) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
+  }
+  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;
 }
-async function launchWithRelay(core, params) {
-  let relayStatus = core.relay.status();
-  const relayUrl = core.relay.getCdpUrl();
-  const noExtension = optionalBoolean(params.noExtension) ?? false;
-  const extensionOnly = optionalBoolean(params.extensionOnly) ?? false;
-  const waitForExtension = optionalBoolean(params.waitForExtension) ?? false;
-  const waitTimeoutMs = optionalNumber(params.waitTimeoutMs) ?? 3e4;
-  if (waitForExtension) {
-    const connected = await waitForRelay(core.relay, waitTimeoutMs);
-    if (connected) {
-      relayStatus = core.relay.status();
-    }
+
+// 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 useRelay = Boolean(!noExtension && relayStatus.extensionConnected && relayUrl);
-  let relayWarning = null;
-  if (extensionOnly && !useRelay) {
-    throw new Error("Extension not connected; use --no-extension to launch a new browser.");
+  const normalized = normalizeExtensionId(value);
+  if (!normalized) {
+    throw createUsageError("Invalid extension ID format. Expected 32 characters (a-p).");
   }
-  if (useRelay && relayUrl) {
-    try {
-      const result2 = await core.manager.connectRelay(relayUrl);
-      return { ...result2, warnings: result2.warnings ?? [] };
-    } catch (error) {
-      if (extensionOnly) {
-        throw error instanceof Error ? error : new Error("Extension relay connection failed.");
-      }
-      relayWarning = "Relay connection failed; falling back to managed Chrome.";
-    }
+  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 (relayUrl && !noExtension) {
-    relayWarning ??= "Extension not connected; launching managed Chrome instead.";
+  if (subcommand === "install") {
+    const extensionId = requireExtensionId(rawArgs[1]);
+    return { subcommand, extensionId };
   }
-  const result = await core.manager.launch({
-    profile: optionalString(params.profile),
-    headless: optionalBoolean(params.headless),
-    startUrl: optionalString(params.startUrl),
-    chromePath: optionalString(params.chromePath),
-    flags: optionalStringArray(params.flags),
-    persistProfile: optionalBoolean(params.persistProfile)
-  });
-  const warnings = [
-    ...result.warnings ?? [],
-    ...relayWarning ? [relayWarning] : []
-  ];
-  return { ...result, warnings };
-}
-function requireString(value, label) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`Missing ${label}`);
+  return { subcommand };
+};
+var getManifestDir = () => {
+  if (process.platform === "darwin") {
+    return path7.join(process.env.HOME || "", "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
   }
-  return value;
-}
-function requireStringArray(value, label) {
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error(`Invalid ${label}`);
+  if (process.platform === "linux") {
+    return path7.join(process.env.HOME || "", ".config", "google-chrome", "NativeMessagingHosts");
   }
-  return value;
-}
-function optionalString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function optionalStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
-}
-function optionalNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function optionalBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function requireWaitUntil(value) {
-  if (value === "domcontentloaded" || value === "load" || value === "networkidle") {
-    return value;
+  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");
   }
-  return "load";
-}
-function requireSnapshotMode(value) {
-  if (value === "actionables") return "actionables";
-  return "outline";
-}
-function requireState(value) {
-  if (value === "visible" || value === "hidden") return value;
-  return "attached";
-}
-async function waitForRelay(relay, timeoutMs) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (relay.status().extensionConnected) {
-      return true;
+  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;
+      }
+      const parent = path7.dirname(current);
+      if (parent === current) {
+        break;
+      }
+      current = parent;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
-  return false;
-}
-
-// src/cli/daemon.ts
-var DEFAULT_DAEMON_PORT = 8788;
-function getCacheRoot() {
-  const base = process.env.OPENCODE_CACHE_DIR ?? process.env.XDG_CACHE_HOME ?? join8(homedir6(), ".cache");
-  return join8(base, "opendevbrowser");
-}
-function getDaemonMetadataPath() {
-  return join8(getCacheRoot(), "daemon.json");
-}
-function readDaemonMetadata() {
-  const metadataPath = getDaemonMetadataPath();
-  if (!existsSync8(metadataPath)) {
-    return null;
+  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 };
+  }
+};
+var runScript = (script, args) => {
+  if (process.platform === "win32") {
+    execFileSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", script, ...args], { stdio: "pipe" });
+    return;
   }
+  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 content = readFileSync3(metadataPath, "utf-8");
-    return JSON.parse(content);
+    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;
   }
-}
-function writeDaemonMetadata(state) {
-  const metadataPath = getDaemonMetadataPath();
-  mkdirSync4(join8(getCacheRoot()), { recursive: true });
-  writeFileSync5(metadataPath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
-}
-function clearDaemonMetadata() {
-  const metadataPath = getDaemonMetadataPath();
+};
+var normalizePath = (value) => {
   try {
-    unlinkSync3(metadataPath);
+    return fs9.realpathSync(value);
   } catch {
+    return path7.resolve(value);
   }
-}
-function isAuthorized(request, token) {
-  const header = request.headers.authorization ?? "";
-  if (!header.startsWith("Bearer ")) {
-    return false;
+};
+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")
+    ];
   }
-  const received = header.slice("Bearer ".length).trim();
-  const expectedBuf = Buffer.from(token, "utf-8");
-  const receivedBuf = Buffer.from(received, "utf-8");
-  if (expectedBuf.length !== receivedBuf.length) {
-    timingSafeEqual(expectedBuf, expectedBuf);
-    return false;
+  if (process.platform === "linux") {
+    return [
+      path7.join(homedir6(), ".config", "google-chrome"),
+      path7.join(homedir6(), ".config", "chromium"),
+      path7.join(homedir6(), ".config", "BraveSoftware", "Brave-Browser")
+    ];
   }
-  return timingSafeEqual(expectedBuf, receivedBuf);
-}
-function sendJson(response, status, payload) {
-  response.writeHead(status, {
-    "Content-Type": "application/json",
-    "Cache-Control": "no-store"
-  });
-  response.end(JSON.stringify(payload));
-}
-async function startDaemon(options = {}) {
-  const config = options.config ?? loadGlobalConfig();
-  const port = options.port ?? DEFAULT_DAEMON_PORT;
-  const token = options.token ?? generateSecureToken();
-  const core = createOpenDevBrowserCore({
-    directory: options.directory ?? process.cwd(),
-    worktree: options.worktree ?? null,
-    config
-  });
-  await core.ensureRelay(config.relayPort);
-  const server = createServer(async (request, response) => {
-    if (!isAuthorized(request, token)) {
-      sendJson(response, 401, { error: "Unauthorized" });
-      return;
+  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 {
     }
-    const url = new URL(request.url ?? "/", "http://127.0.0.1");
-    if (request.method === "GET" && url.pathname === "/status") {
-      sendJson(response, 200, {
-        ok: true,
-        pid: process.pid,
-        relay: core.relay.status()
-      });
-      return;
+  }
+  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;
     }
-    if (request.method === "POST" && url.pathname === "/stop") {
-      sendJson(response, 200, { ok: true });
-      await stop();
-      return;
+    for (const value of Object.values(commandMap)) {
+      if (typeof value !== "object" || value === null) {
+        continue;
+      }
+      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;
+      }
     }
-    if (request.method === "POST" && url.pathname === "/command") {
-      try {
-        const body = await readJson(request);
-        const data = await handleDaemonCommand(core, body);
-        sendJson(response, 200, { ok: true, data });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        sendJson(response, 400, { ok: false, error: message });
+  }
+  return 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" };
       }
-      return;
     }
-    sendJson(response, 404, { error: "Not found" });
-  });
-  await new Promise((resolve2, reject) => {
-    server.once("error", reject);
-    server.listen(port, "127.0.0.1", () => resolve2());
-  });
-  const state = {
-    port,
-    token,
-    pid: process.pid,
-    relayPort: config.relayPort,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeDaemonMetadata(state);
-  const stop = async () => {
-    clearDaemonMetadata();
-    core.cleanup();
-    await new Promise((resolve2) => {
-      server.close(() => resolve2());
-    });
+    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
   };
-  process.on("SIGINT", () => {
-    stop().catch(() => {
-    });
-  });
-  process.on("SIGTERM", () => {
-    stop().catch(() => {
-    });
-  });
-  return { state, stop };
-}
-function readJson(request) {
-  return new Promise((resolve2, reject) => {
-    let data = "";
-    request.setEncoding("utf8");
-    request.on("data", (chunk) => {
-      data += chunk;
-    });
-    request.on("end", () => {
-      try {
-        const parsed = JSON.parse(data || "{}");
-        if (!parsed || typeof parsed !== "object") {
-          reject(new Error("Invalid JSON body"));
-          return;
+};
+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;
+          }
+          if (match.matchedBy === "path") {
+            return { extensionId: match.id, matchedBy: match.matchedBy };
+          }
+          if (!nameFallback) {
+            nameFallback = match;
+          }
+        }
+        if (!commandFallback) {
+          commandFallback = findExtensionIdInCommands(preferences);
         }
-        resolve2(parsed);
-      } catch (error) {
-        reject(error);
       }
-    });
-    request.on("error", reject);
-  });
+      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) {
@@ -1164,12 +1272,16 @@ function parseServeArgs(rawArgs) {
       if (!value) {
         throw createUsageError("Missing value for --port");
       }
-      parsed.port = Number(value);
+      parsed.port = parseNumberFlag(value, "--port", { min: 1, max: 65535 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--port=")) {
-      parsed.port = Number(arg.split("=", 2)[1]);
+      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") {
@@ -1182,7 +1294,11 @@ function parseServeArgs(rawArgs) {
       continue;
     }
     if (arg?.startsWith("--token=")) {
-      parsed.token = arg.split("=", 2)[1];
+      const value = arg.split("=", 2)[1];
+      if (!value) {
+        throw createUsageError("Missing value for --token");
+      }
+      parsed.token = value;
       continue;
     }
   }
@@ -1193,10 +1309,15 @@ async function runServe(args) {
   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 fetch(`http://127.0.0.1:${metadata.port}/stop`, {
+      const response = await fetchWithTimeout(`http://127.0.0.1:${metadata.port}/stop`, {
         method: "POST",
         headers: { Authorization: `Bearer ${metadata.token}` }
       });
@@ -1205,22 +1326,367 @@ async function runServe(args) {
       }
       return { success: true, message: "Daemon stopped." };
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return { success: false, message: `Failed to stop daemon: ${message}`, exitCode: EXIT_EXECUTION };
+      const 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 { state } = await startDaemon({
+  const handle = await startDaemon({
     port: serveArgs.port,
-    token: serveArgs.token
+    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: `Daemon running on 127.0.0.1:${state.port}`,
-    data: { port: state.port, pid: state.pid, relayPort: state.relayPort },
+    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);
+    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";
 
@@ -1302,7 +1768,9 @@ function parseRunArgs(rawArgs) {
       continue;
     }
     if (arg?.startsWith("--start-url=")) {
-      parsed.startUrl = arg.split("=", 2)[1];
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --start-url");
+      parsed.startUrl = value;
       continue;
     }
     if (arg === "--flag") {
@@ -1313,20 +1781,22 @@ function parseRunArgs(rawArgs) {
       continue;
     }
     if (arg?.startsWith("--flag=")) {
-      parsed.flags.push(arg.split("=", 2)[1]);
+      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((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("end", () => resolve4(data));
     process.stdin.on("error", reject);
   });
 }
@@ -1380,36 +1850,6 @@ async function runScriptCommand(args) {
   }
 }
 
-// src/cli/client.ts
-async function callDaemon(command, params) {
-  const metadata = readDaemonMetadata();
-  if (!metadata) {
-    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
-  }
-  let response;
-  try {
-    response = await fetch(`http://127.0.0.1:${metadata.port}/command`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${metadata.token}`
-      },
-      body: JSON.stringify({ name: command, params: params ?? {} })
-    });
-  } catch {
-    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
-  }
-  if (!response.ok) {
-    const message = await response.text();
-    throw new CliError(`Daemon error: ${message || response.status}`, EXIT_EXECUTION);
-  }
-  const payload = await response.json();
-  if (!payload.ok) {
-    throw new CliError(payload.error || "Daemon command failed.", EXIT_EXECUTION);
-  }
-  return payload.data;
-}
-
 // src/cli/commands/session/launch.ts
 function parseLaunchArgs(rawArgs) {
   const parsed = { flags: [] };
@@ -1464,6 +1904,10 @@ function parseLaunchArgs(rawArgs) {
       parsed.extensionOnly = true;
       continue;
     }
+    if (arg === "--extension-legacy") {
+      parsed.extensionLegacy = true;
+      continue;
+    }
     if (arg === "--wait-for-extension") {
       parsed.waitForExtension = true;
       continue;
@@ -1471,12 +1915,14 @@ function parseLaunchArgs(rawArgs) {
     if (arg === "--wait-timeout-ms") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --wait-timeout-ms");
-      parsed.waitTimeoutMs = Number(value);
+      parsed.waitTimeoutMs = parseNumberFlag(value, "--wait-timeout-ms", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--wait-timeout-ms=")) {
-      parsed.waitTimeoutMs = Number(arg.split("=", 2)[1]);
+      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") {
@@ -1487,7 +1933,9 @@ function parseLaunchArgs(rawArgs) {
       continue;
     }
     if (arg?.startsWith("--flag=")) {
-      parsed.flags.push(arg.split("=", 2)[1]);
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --flag");
+      parsed.flags.push(value);
       continue;
     }
   }
@@ -1495,12 +1943,82 @@ function parseLaunchArgs(rawArgs) {
 }
 async function runSessionLaunch(args) {
   const launchArgs = parseLaunchArgs(args.rawArgs);
-  const result = await callDaemon("session.launch", launchArgs);
-  return {
-    success: true,
-    message: `Session launched: ${result.sessionId}`,
-    data: result
-  };
+  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
@@ -1527,18 +2045,26 @@ function parseConnectArgs(rawArgs) {
       continue;
     }
     if (arg?.startsWith("--host=")) {
-      parsed.host = arg.split("=", 2)[1];
+      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 = Number(value);
+      parsed.port = parseNumberFlag(value, "--cdp-port", { min: 1, max: 65535 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--cdp-port=")) {
-      parsed.port = Number(arg.split("=", 2)[1]);
+      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;
     }
   }
@@ -1582,7 +2108,7 @@ async function runSessionDisconnect(args) {
   if (!sessionId) {
     throw createUsageError("Missing --session-id");
   }
-  await callDaemon("session.disconnect", { sessionId, closeBrowser });
+  await callDaemon("session.disconnect", { sessionId, closeBrowser }, { timeoutMs: 2e4 });
   return { success: true, message: `Session disconnected: ${sessionId}` };
 }
 
@@ -1614,6 +2140,76 @@ async function runSessionStatus(args) {
   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 = {};
@@ -1655,12 +2251,14 @@ function parseGotoArgs(rawArgs) {
     if (arg === "--timeout-ms") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --timeout-ms");
-      parsed.timeoutMs = Number(value);
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--timeout-ms=")) {
-      parsed.timeoutMs = Number(arg.split("=", 2)[1]);
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
       continue;
     }
   }
@@ -1726,12 +2324,14 @@ function parseWaitArgs(rawArgs) {
     if (arg === "--timeout-ms") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --timeout-ms");
-      parsed.timeoutMs = Number(value);
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--timeout-ms=")) {
-      parsed.timeoutMs = Number(arg.split("=", 2)[1]);
+      const value = arg.split("=", 2)[1];
+      if (!value) throw createUsageError("Missing value for --timeout-ms");
+      parsed.timeoutMs = parseNumberFlag(value, "--timeout-ms", { min: 1 });
       continue;
     }
   }
@@ -1803,104 +2403,1030 @@ async function runSnapshot(args) {
   return { success: true, message: "Snapshot captured.", data: result };
 }
 
-// src/cli/commands/interact/click.ts
-function parseClickArgs(rawArgs) {
+// 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 = rawArgs[i + 1];
-      if (!value) throw createUsageError("Missing value for --session-id");
+      const value = requireValue(rawArgs[i + 1], "--session-id");
       parsed.sessionId = value;
       i += 1;
       continue;
     }
     if (arg?.startsWith("--session-id=")) {
-      parsed.sessionId = arg.split("=", 2)[1];
+      const value = requireValue(arg.split("=", 2)[1], "--session-id");
+      parsed.sessionId = value;
       continue;
     }
-    if (arg === "--ref") {
-      const value = rawArgs[i + 1];
-      if (!value) throw createUsageError("Missing value for --ref");
-      parsed.ref = value;
+    if (arg === "--url") {
+      const value = requireValue(rawArgs[i + 1], "--url");
+      parsed.url = value;
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--ref=")) {
-      parsed.ref = arg.split("=", 2)[1];
+    if (arg?.startsWith("--url=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--url");
+      parsed.url = value;
       continue;
     }
-  }
-  return parsed;
-}
-async function runClick(args) {
-  const { sessionId, ref } = parseClickArgs(args.rawArgs);
-  if (!sessionId) throw createUsageError("Missing --session-id");
-  if (!ref) throw createUsageError("Missing --ref");
-  const result = await callDaemon("interact.click", { sessionId, ref });
-  return { success: true, message: "Click complete.", data: result };
-}
-
-// src/cli/commands/interact/type.ts
-function parseTypeArgs(rawArgs) {
-  const parsed = {};
-  for (let i = 0; i < rawArgs.length; i += 1) {
-    const arg = rawArgs[i];
-    if (arg === "--session-id") {
-      const value = rawArgs[i + 1];
-      if (!value) throw createUsageError("Missing value for --session-id");
-      parsed.sessionId = value;
+    if (arg === "--screenshot-mode") {
+      const value = requireValue(rawArgs[i + 1], "--screenshot-mode");
+      parsed.screenshotMode = requireScreenshotMode(value);
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--session-id=")) {
-      parsed.sessionId = arg.split("=", 2)[1];
+    if (arg?.startsWith("--screenshot-mode=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--screenshot-mode");
+      parsed.screenshotMode = requireScreenshotMode(value);
       continue;
     }
-    if (arg === "--ref") {
-      const value = rawArgs[i + 1];
-      if (!value) throw createUsageError("Missing value for --ref");
-      parsed.ref = value;
+    if (arg === "--transport") {
+      const value = requireValue(rawArgs[i + 1], "--transport");
+      parsed.transport = requireTransport(value);
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--ref=")) {
-      parsed.ref = arg.split("=", 2)[1];
+    if (arg?.startsWith("--transport=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--transport");
+      parsed.transport = requireTransport(value);
       continue;
     }
-    if (arg === "--text") {
-      const value = rawArgs[i + 1];
-      if (!value) throw createUsageError("Missing value for --text");
-      parsed.text = value;
+    if (arg === "--target-id") {
+      const value = requireValue(rawArgs[i + 1], "--target-id");
+      parsed.targetId = value;
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--text=")) {
-      parsed.text = arg.split("=", 2)[1];
+    if (arg?.startsWith("--target-id=")) {
+      const value = requireValue(arg.split("=", 2)[1], "--target-id");
+      parsed.targetId = value;
       continue;
     }
-    if (arg === "--clear") {
-      parsed.clear = true;
+    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 === "--submit") {
+    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);
+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");
-  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 };
+  const result = await callDaemon("dom.isVisible", { sessionId, ref });
+  return { success: true, message: "Visibility checked.", data: result };
 }
 
-// src/cli/commands/interact/select.ts
-function parseSelectArgs(rawArgs) {
+// src/cli/commands/dom/enabled.ts
+function parseDomEnabledArgs(rawArgs) {
   const parsed = {};
   for (let i = 0; i < rawArgs.length; i += 1) {
     const arg = rawArgs[i];
@@ -1926,31 +3452,83 @@ function parseSelectArgs(rawArgs) {
       parsed.ref = arg.split("=", 2)[1];
       continue;
     }
-    if (arg === "--values") {
+  }
+  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 --values");
-      parsed.values = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--values=")) {
-      parsed.values = arg.split("=", 2)[1].split(",").map((entry) => entry.trim()).filter(Boolean);
+    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 runSelect(args) {
-  const { sessionId, ref, values } = parseSelectArgs(args.rawArgs);
+async function runDomChecked(args) {
+  const { sessionId, ref } = parseDomCheckedArgs(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 };
+  const result = await callDaemon("dom.isChecked", { sessionId, ref });
+  return { success: true, message: "Checked state reported.", data: result };
 }
 
-// src/cli/commands/interact/scroll.ts
-function parseScrollArgs(rawArgs) {
+// 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];
@@ -1976,26 +3554,174 @@ function parseScrollArgs(rawArgs) {
       parsed.ref = arg.split("=", 2)[1];
       continue;
     }
-    if (arg === "--dy") {
+  }
+  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 --dy");
-      parsed.dy = Number(value);
+      if (!value) throw createUsageError("Missing value for --session-id");
+      parsed.sessionId = value;
       i += 1;
       continue;
     }
-    if (arg?.startsWith("--dy=")) {
-      parsed.dy = Number(arg.split("=", 2)[1]);
+    if (arg?.startsWith("--session-id=")) {
+      parsed.sessionId = arg.split("=", 2)[1];
       continue;
     }
   }
   return parsed;
 }
-async function runScroll(args) {
-  const { sessionId, ref, dy } = parseScrollArgs(args.rawArgs);
+async function runPerf(args) {
+  const { sessionId } = parsePerfArgs(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 };
+  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
@@ -2005,7 +3731,7 @@ async function promptInstallMode() {
     console.log("Non-interactive mode detected. Using global install.");
     return "global";
   }
-  return new Promise((resolve2) => {
+  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");
@@ -2025,23 +3751,23 @@ async function promptInstallMode() {
       resolved = true;
       const input = data.toString().trim();
       if (input === "2") {
-        resolve2("local");
+        resolve4("local");
       } else {
-        resolve2("global");
+        resolve4("global");
       }
     });
     process.stdin.once("close", () => {
       cleanup();
       if (resolved) return;
       resolved = true;
-      resolve2("global");
+      resolve4("global");
     });
     timeoutId = setTimeout(() => {
       timeoutId = null;
       if (resolved) return;
       resolved = true;
       console.log("\nTimeout - using global install.");
-      resolve2("global");
+      resolve4("global");
     }, 3e4);
   });
 }
@@ -2061,7 +3787,7 @@ async function promptUninstallMode() {
     console.log("Plugin found in both global and local configs. Use --global or --local flag.");
     return null;
   }
-  return new Promise((resolve2) => {
+  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)");
@@ -2071,15 +3797,15 @@ async function promptUninstallMode() {
     process.stdin.once("data", (data) => {
       const input = data.toString().trim();
       if (input === "1") {
-        resolve2("global");
+        resolve4("global");
       } else if (input === "2") {
-        resolve2("local");
+        resolve4("local");
       } else {
-        resolve2(null);
+        resolve4(null);
       }
     });
     process.stdin.once("close", () => {
-      resolve2(null);
+      resolve4(null);
     });
   });
 }
@@ -2176,6 +3902,22 @@ async function main() {
           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
@@ -2192,6 +3934,13 @@ async function main() {
               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);
@@ -2220,6 +3969,14 @@ async function main() {
             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");
@@ -2234,6 +3991,16 @@ async function main() {
       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",
@@ -2256,8 +4023,8 @@ async function main() {
     });
     registerCommand({
       name: "status",
-      description: "Get daemon session status",
-      run: async () => runSessionStatus(args)
+      description: "Get daemon or session status",
+      run: async () => runStatus(args)
     });
     registerCommand({
       name: "goto",
@@ -2274,11 +4041,36 @@ async function main() {
       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",
@@ -2294,6 +4086,111 @@ async function main() {
       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}`);