autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-OV3T5MUH.cjs

@@ -0,0 +1,715 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+
+// src/browser/chrome.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _child_process = require('child_process');
+var _open = require('open'); var _open2 = _interopRequireDefault(_open);
+
+var { chmod, ensureDir, pathExists, readFile, readJson, remove, writeFile, writeJson } = _fsextra2.default;
+var CHROME_NATIVE_HOST_NAME = "ai.autohand.rpc";
+var DEFAULT_CHROME_INSTALL_URL = "https://autohand.ai/chrome/installed";
+var DEFAULT_HANDOFF_TTL_MS = 10 * 60 * 1e3;
+var ALL_BROWSERS = ["chrome", "chromium", "brave", "edge"];
+function getChromeHome(homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  return _path2.default.join(homeDir, "chrome");
+}
+function getBrowserDataRoot(homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  return _path2.default.join(getChromeHome(homeDir), "native-host");
+}
+function getHandoffDir(homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  return _path2.default.join(getChromeHome(homeDir), "handoffs");
+}
+function jsString(value) {
+  return JSON.stringify(value);
+}
+function jsArray(value) {
+  return JSON.stringify(value);
+}
+function normalizeBrowsers(browser) {
+  if (!browser || browser === "all") {
+    return [...ALL_BROWSERS];
+  }
+  const value = browser.toLowerCase();
+  if (ALL_BROWSERS.includes(value)) {
+    return [value];
+  }
+  throw new Error(`Unsupported browser: ${browser}`);
+}
+function getBrowserLaunchTargets(browser, platform = process.platform) {
+  if (platform === "darwin") {
+    const targets = {
+      chrome: [
+        { probe: "/Applications/Google Chrome.app", appName: "Google Chrome", command: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" },
+        { probe: _path2.default.join(_os2.default.homedir(), "Applications", "Google Chrome.app"), appName: "Google Chrome", command: _path2.default.join(_os2.default.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome") }
+      ],
+      chromium: [
+        { probe: "/Applications/Chromium.app", appName: "Chromium", command: "/Applications/Chromium.app/Contents/MacOS/Chromium" },
+        { probe: _path2.default.join(_os2.default.homedir(), "Applications", "Chromium.app"), appName: "Chromium", command: _path2.default.join(_os2.default.homedir(), "Applications", "Chromium.app", "Contents", "MacOS", "Chromium") }
+      ],
+      brave: [
+        { probe: "/Applications/Brave Browser.app", appName: "Brave Browser", command: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser" },
+        { probe: _path2.default.join(_os2.default.homedir(), "Applications", "Brave Browser.app"), appName: "Brave Browser", command: _path2.default.join(_os2.default.homedir(), "Applications", "Brave Browser.app", "Contents", "MacOS", "Brave Browser") }
+      ],
+      edge: [
+        { probe: "/Applications/Microsoft Edge.app", appName: "Microsoft Edge", command: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge" },
+        { probe: _path2.default.join(_os2.default.homedir(), "Applications", "Microsoft Edge.app"), appName: "Microsoft Edge", command: _path2.default.join(_os2.default.homedir(), "Applications", "Microsoft Edge.app", "Contents", "MacOS", "Microsoft Edge") }
+      ]
+    };
+    return targets[browser];
+  }
+  if (platform === "linux") {
+    const targets = {
+      chrome: [
+        { probe: "google-chrome", appName: "google-chrome", command: "google-chrome" },
+        { probe: "google-chrome-stable", appName: "google-chrome", command: "google-chrome-stable" }
+      ],
+      chromium: [
+        { probe: "chromium", appName: "chromium", command: "chromium" },
+        { probe: "chromium-browser", appName: "chromium-browser", command: "chromium-browser" }
+      ],
+      brave: [
+        { probe: "brave-browser", appName: "brave-browser", command: "brave-browser" },
+        { probe: "brave", appName: "brave", command: "brave" }
+      ],
+      edge: [
+        { probe: "microsoft-edge", appName: "microsoft-edge", command: "microsoft-edge" },
+        { probe: "microsoft-edge-stable", appName: "microsoft-edge", command: "microsoft-edge-stable" },
+        { probe: "msedge", appName: "msedge", command: "msedge" }
+      ]
+    };
+    return targets[browser];
+  }
+  if (platform === "win32") {
+    const localAppData = _nullishCoalesce(process.env.LOCALAPPDATA, () => ( ""));
+    const programFiles = _nullishCoalesce(process.env["ProgramFiles"], () => ( "C:\\Program Files"));
+    const programFilesX86 = _nullishCoalesce(process.env["ProgramFiles(x86)"], () => ( "C:\\Program Files (x86)"));
+    const targets = {
+      chrome: [
+        { probe: _path2.default.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: _path2.default.join(programFiles, "Google", "Chrome", "Application", "chrome.exe") },
+        { probe: _path2.default.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: _path2.default.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe") },
+        { probe: _path2.default.join(localAppData, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: _path2.default.join(localAppData, "Google", "Chrome", "Application", "chrome.exe") }
+      ],
+      chromium: [
+        { probe: _path2.default.join(programFiles, "Chromium", "Application", "chrome.exe"), appName: "chromium", command: _path2.default.join(programFiles, "Chromium", "Application", "chrome.exe") },
+        { probe: _path2.default.join(localAppData, "Chromium", "Application", "chrome.exe"), appName: "chromium", command: _path2.default.join(localAppData, "Chromium", "Application", "chrome.exe") }
+      ],
+      brave: [
+        { probe: _path2.default.join(programFiles, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: _path2.default.join(programFiles, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") },
+        { probe: _path2.default.join(programFilesX86, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: _path2.default.join(programFilesX86, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") },
+        { probe: _path2.default.join(localAppData, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: _path2.default.join(localAppData, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") }
+      ],
+      edge: [
+        { probe: _path2.default.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: _path2.default.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe") },
+        { probe: _path2.default.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: _path2.default.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe") },
+        { probe: _path2.default.join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: _path2.default.join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe") }
+      ]
+    };
+    return targets[browser];
+  }
+  return [];
+}
+async function defaultBrowserProbe(probe) {
+  if (probe.includes(_path2.default.sep) || /^[A-Za-z]:\\/.test(probe)) {
+    return pathExists(probe);
+  }
+  const command = process.platform === "win32" ? "where" : "which";
+  const result = _child_process.spawnSync.call(void 0, command, [probe], { stdio: "pipe" });
+  return result.status === 0;
+}
+async function resolveBrowserLaunchTarget(browser, platform = process.platform, probe = defaultBrowserProbe) {
+  const order = browser === "auto" ? ["chrome", "edge", "brave", "chromium"] : [browser];
+  for (const candidateBrowser of order) {
+    const targets = getBrowserLaunchTargets(candidateBrowser, platform);
+    for (const target of targets) {
+      if (await probe(target.probe)) {
+        return target.appName;
+      }
+    }
+  }
+  return null;
+}
+async function resolveBrowserCommand(browser, platform = process.platform, probe = defaultBrowserProbe) {
+  const order = browser === "auto" ? ["chrome", "edge", "brave", "chromium"] : [browser];
+  for (const candidateBrowser of order) {
+    const targets = getBrowserLaunchTargets(candidateBrowser, platform);
+    for (const target of targets) {
+      if (await probe(target.probe)) {
+        return target.command;
+      }
+    }
+  }
+  return null;
+}
+function getBrowserUserDataRoots(platform = process.platform, homeDir = _os2.default.homedir()) {
+  if (platform === "darwin") {
+    return {
+      chrome: _path2.default.join(homeDir, "Library", "Application Support", "Google", "Chrome"),
+      chromium: _path2.default.join(homeDir, "Library", "Application Support", "Chromium"),
+      brave: _path2.default.join(homeDir, "Library", "Application Support", "BraveSoftware", "Brave-Browser"),
+      edge: _path2.default.join(homeDir, "Library", "Application Support", "Microsoft Edge")
+    };
+  }
+  if (platform === "linux") {
+    return {
+      chrome: _path2.default.join(homeDir, ".config", "google-chrome"),
+      chromium: _path2.default.join(homeDir, ".config", "chromium"),
+      brave: _path2.default.join(homeDir, ".config", "BraveSoftware", "Brave-Browser"),
+      edge: _path2.default.join(homeDir, ".config", "microsoft-edge")
+    };
+  }
+  if (platform === "win32") {
+    const localAppData = _nullishCoalesce(process.env.LOCALAPPDATA, () => ( ""));
+    return {
+      chrome: _path2.default.join(localAppData, "Google", "Chrome", "User Data"),
+      chromium: _path2.default.join(localAppData, "Chromium", "User Data"),
+      brave: _path2.default.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data"),
+      edge: _path2.default.join(localAppData, "Microsoft", "Edge", "User Data")
+    };
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+async function detectExtensionProfile(extensionId, browsers = [...ALL_BROWSERS], platform = process.platform, homeDir = _os2.default.homedir()) {
+  const roots = getBrowserUserDataRoots(platform, homeDir);
+  for (const browser of browsers) {
+    const userDataDir = roots[browser];
+    if (!await pathExists(userDataDir)) {
+      continue;
+    }
+    const entries = await _fsextra2.default.readdir(userDataDir);
+    const candidates = entries.filter((entry) => entry === "Default" || entry.startsWith("Profile "));
+    for (const profileDirectory of candidates) {
+      const packedExtensionPath = _path2.default.join(userDataDir, profileDirectory, "Extensions", extensionId);
+      const unpackedExtensionPath = _path2.default.join(userDataDir, profileDirectory, "Local Extension Settings", extensionId);
+      if (await pathExists(packedExtensionPath) || await pathExists(unpackedExtensionPath)) {
+        return {
+          browser,
+          userDataDir,
+          profileDirectory
+        };
+      }
+    }
+  }
+  return null;
+}
+function resolveCliLaunchSpec(cliPath) {
+  if (cliPath && cliPath.trim()) {
+    return { command: cliPath.trim(), args: [] };
+  }
+  const argv1 = process.argv[1];
+  if (argv1 && _path2.default.isAbsolute(argv1) && !argv1.includes("$bunfs")) {
+    return {
+      command: process.execPath,
+      args: [argv1]
+    };
+  }
+  const execBase = _path2.default.basename(process.execPath).toLowerCase();
+  if (execBase.includes("autohand")) {
+    return { command: process.execPath, args: [] };
+  }
+  return { command: "autohand", args: [] };
+}
+function getManifestTarget(browser, platform = process.platform, homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  const hostName = CHROME_NATIVE_HOST_NAME;
+  const manifestPath = _path2.default.join(getBrowserDataRoot(homeDir), `${browser}.json`);
+  if (platform === "darwin") {
+    const roots = {
+      chrome: _path2.default.join(_os2.default.homedir(), "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts"),
+      chromium: _path2.default.join(_os2.default.homedir(), "Library", "Application Support", "Chromium", "NativeMessagingHosts"),
+      brave: _path2.default.join(_os2.default.homedir(), "Library", "Application Support", "BraveSoftware", "Brave-Browser", "NativeMessagingHosts"),
+      edge: _path2.default.join(_os2.default.homedir(), "Library", "Application Support", "Microsoft Edge", "NativeMessagingHosts")
+    };
+    return {
+      browser,
+      manifestPath: _path2.default.join(roots[browser], `${hostName}.json`),
+      registryKey: void 0
+    };
+  }
+  if (platform === "linux") {
+    const roots = {
+      chrome: _path2.default.join(_os2.default.homedir(), ".config", "google-chrome", "NativeMessagingHosts"),
+      chromium: _path2.default.join(_os2.default.homedir(), ".config", "chromium", "NativeMessagingHosts"),
+      brave: _path2.default.join(_os2.default.homedir(), ".config", "BraveSoftware", "Brave-Browser", "NativeMessagingHosts"),
+      edge: _path2.default.join(_os2.default.homedir(), ".config", "microsoft-edge", "NativeMessagingHosts")
+    };
+    return {
+      browser,
+      manifestPath: _path2.default.join(roots[browser], `${hostName}.json`),
+      registryKey: void 0
+    };
+  }
+  if (platform === "win32") {
+    const registryRoots = {
+      chrome: "HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts",
+      chromium: "HKCU\\Software\\Chromium\\NativeMessagingHosts",
+      brave: "HKCU\\Software\\BraveSoftware\\Brave-Browser\\NativeMessagingHosts",
+      edge: "HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts"
+    };
+    return {
+      browser,
+      manifestPath,
+      registryKey: `${registryRoots[browser]}\\${hostName}`
+    };
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function buildNativeHostManifest(options) {
+  const hostName = _nullishCoalesce(options.hostName, () => ( CHROME_NATIVE_HOST_NAME));
+  const allowedOrigins = Array.from(new Set(options.extensionIds.filter(Boolean))).map(
+    (extensionId) => `chrome-extension://${extensionId}/`
+  );
+  return {
+    name: hostName,
+    description: "Autohand Code native messaging bridge",
+    path: options.hostScriptPath,
+    type: "stdio",
+    allowed_origins: allowedOrigins
+  };
+}
+function extensionIdFromAllowedOrigin(origin) {
+  const match = /^chrome-extension:\/\/([^/]+)\/$/.exec(origin);
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _ => _[1]]), () => ( null));
+}
+function mergeExtensionIds(extensionIds, allowedOrigins) {
+  const existingIds = (_nullishCoalesce(allowedOrigins, () => ( []))).map(extensionIdFromAllowedOrigin).filter((id) => Boolean(id));
+  return Array.from(new Set([...existingIds, ...extensionIds].filter(Boolean)));
+}
+function resolveNodePath() {
+  const execPath = process.execPath;
+  const execBase = _path2.default.basename(execPath).toLowerCase();
+  if (!execBase.includes("bun") && !execBase.includes("autohand")) {
+    return execPath;
+  }
+  const candidates = [
+    "/opt/homebrew/bin/node",
+    "/usr/local/bin/node",
+    "/usr/bin/node",
+    _path2.default.join(_os2.default.homedir(), ".nvm/versions/node"),
+    _path2.default.join(_os2.default.homedir(), ".local/bin/node")
+  ];
+  for (const candidate of candidates) {
+    if (candidate.includes(".nvm")) {
+      try {
+        const versions = _fsextra2.default.readdirSync(candidate);
+        if (versions.length) {
+          const latest = versions.sort().pop();
+          const nodeBin = _path2.default.join(candidate, latest, "bin/node");
+          if (_fsextra2.default.existsSync(nodeBin)) return nodeBin;
+        }
+      } catch (e) {
+      }
+      continue;
+    }
+    try {
+      if (_fsextra2.default.existsSync(candidate)) return candidate;
+    } catch (e2) {
+    }
+  }
+  return "/usr/bin/env node";
+}
+function buildNativeHostScript(options) {
+  const cliCommand = options.cliCommand;
+  const cliArgPrefix = _nullishCoalesce(options.cliArgPrefix, () => ( []));
+  const shebang = _nullishCoalesce(options.nodePath, () => ( resolveNodePath()));
+  return `#!${shebang}
+const { spawn } = require("node:child_process");
+const path = require("node:path");
+const os = require("node:os");
+let child = null;
+let stdinBuffer = Buffer.alloc(0);
+let stdoutBuffer = "";
+let stderrBuffer = "";
+let launchSettings = null;
+const DEFAULT_CLI_COMMAND = ${jsString(cliCommand)};
+const DEFAULT_CLI_ARG_PREFIX = ${jsArray(cliArgPrefix)};
+process.stdin.on("data", handleNativeData);
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("exit", shutdown);
+process.on("uncaughtException", (err) => {
+  process.stderr.write("[HOST] uncaughtException: " + err.message + "\\n" + err.stack + "\\n");
+  shutdown();
+});
+process.stdout.on("error", (err) => {
+  process.stderr.write("[HOST] stdout error: " + err.message + "\\n");
+});
+function handleNativeData(chunk) {
+  stdinBuffer = Buffer.concat([stdinBuffer, chunk]);
+  while (stdinBuffer.length >= 4) {
+    const length = stdinBuffer.readUInt32LE(0);
+    if (stdinBuffer.length < 4 + length) {
+      return;
+    }
+    const body = stdinBuffer.subarray(4, 4 + length);
+    stdinBuffer = stdinBuffer.subarray(4 + length);
+    try {
+      handleNativeMessage(JSON.parse(body.toString("utf8")));
+    } catch (err) {
+      process.stderr.write("[HOST] Failed to parse native message: " + (err?.message || String(err)) + "\\n");
+    }
+  }
+}
+function handleNativeMessage(message) {
+  if (message.type === "connect") {
+    launchSettings = message.settings || {};
+    ensureChild();
+    return;
+  }
+  if (message.type === "shutdown") {
+    shutdown();
+    return;
+  }
+  if (message.type === "request") {
+    ensureChild();
+    child.stdin.write(JSON.stringify(message.payload) + "\\n");
+  }
+}
+function ensureChild() {
+  if (child) return;
+  const cliCommand = launchSettings?.cliPath || DEFAULT_CLI_COMMAND;
+  const args = [...DEFAULT_CLI_ARG_PREFIX, "--mode", "rpc"];
+  if (launchSettings?.workspacePath) args.push("--path", launchSettings.workspacePath);
+  if (launchSettings?.modelOverride) args.push("--model", launchSettings.modelOverride);
+  if (launchSettings?.thinkingLevel) args.push("--thinking", launchSettings.thinkingLevel);
+  if (launchSettings?.debug) args.push("--debug");
+  if (launchSettings?.unrestricted) args.push("--unrestricted");
+  if (launchSettings?.restricted) args.push("--restricted");
+  if (launchSettings?.autoCommit) args.push("--auto-commit");
+  if (launchSettings?.syncSettings === false) args.push("--sync-settings", "false");
+  if (launchSettings?.searchEngine) args.push("--search-engine", launchSettings.searchEngine);
+  if (launchSettings?.displayLanguage) args.push("--display-language", launchSettings.displayLanguage);
+  if (launchSettings?.teammateMode) args.push("--teammate-mode", launchSettings.teammateMode);
+  if (launchSettings?.yoloPattern) args.push("--yolo", launchSettings.yoloPattern);
+  if (launchSettings?.timeoutSeconds) args.push("--timeout", String(launchSettings.timeoutSeconds));
+  if (launchSettings?.contextCompact === false) args.push("--no-context-compact");
+  for (const dir of launchSettings?.extraDirs || []) args.push("--add-dir", dir);
+  const cwd = launchSettings?.workspacePath || path.join(os.homedir(), 'Desktop');
+  child = spawn(cliCommand, args, { env: process.env, stdio: ["pipe", "pipe", "pipe"], cwd });
+  child.stdout.on("data", (chunk) => handleCliStdout(chunk.toString("utf8")));
+  child.stdout.on("error", (err) => {
+    process.stderr.write("[HOST] child.stdout error: " + err.message + "\\n");
+  });
+  child.stderr.on("data", (chunk) => handleCliStderr(chunk.toString("utf8")));
+  child.stderr.on("error", (err) => {
+    process.stderr.write("[HOST] child.stderr error: " + err.message + "\\n");
+  });
+  child.on("exit", (code, signal) => {
+    sendNativeMessage({ type: "status", status: "exited", code, signal });
+    child = null;
+  });
+  child.on("error", (err) => {
+    process.stderr.write("[HOST] child process error: " + err.message + "\\n");
+    sendNativeMessage({ type: "status", status: "spawn-error", error: err.message });
+    child = null;
+  });
+}
+function handleCliStdout(text) { stdoutBuffer += text; flushLines("stdout"); }
+function handleCliStderr(text) { stderrBuffer += text; flushLines("stderr"); }
+function flushLines(stream) {
+  let buffer = stream === "stdout" ? stdoutBuffer : stderrBuffer;
+  const lines = buffer.split(/\\r?\\n/);
+  buffer = lines.pop() || "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        sendNativeMessage({ type: "rpc", payload: JSON.parse(trimmed) });
+        continue;
+      } catch {}
+    }
+    try {
+      sendNativeMessage({ type: "log", stream, line: trimmed });
+    } catch (err) {
+      process.stderr.write("[HOST] sendNativeMessage(log) failed: " + (err?.message || String(err)) + "\\n");
+    }
+  }
+  if (stream === "stdout") stdoutBuffer = buffer;
+  else stderrBuffer = buffer;
+}
+function sendNativeMessage(message) {
+  try {
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(body.length, 0);
+    process.stdout.write(header);
+    process.stdout.write(body);
+  } catch (err) {
+    process.stderr.write("[HOST] sendNativeMessage failed: " + (err?.message || String(err)) + "\\n");
+  }
+}
+function shutdown() {
+  if (child) {
+    child.kill("SIGTERM");
+    child = null;
+  }
+  process.exit(0);
+}
+`;
+}
+async function installNativeHost(options) {
+  const homeDir = _nullishCoalesce(options.homeDir, () => ( _chunkKASXKDF2cjs.AUTOHAND_HOME));
+  const browsers = _optionalChain([options, 'access', _2 => _2.browsers, 'optionalAccess', _3 => _3.length]) ? options.browsers : [...ALL_BROWSERS];
+  const hostScriptPath = _path2.default.join(getBrowserDataRoot(homeDir), "host.js");
+  await ensureDir(_path2.default.dirname(hostScriptPath));
+  const script = buildNativeHostScript({
+    cliCommand: _nullishCoalesce(options.cliCommand, () => ( "autohand")),
+    cliArgPrefix: _nullishCoalesce(options.cliArgPrefix, () => ( []))
+  });
+  await writeFile(hostScriptPath, script, "utf8");
+  if (process.platform !== "win32") {
+    await chmod(hostScriptPath, 493);
+  }
+  const targets = [];
+  for (const browser of browsers) {
+    const target = getManifestTarget(browser, process.platform, homeDir);
+    const manifest = buildNativeHostManifest({
+      hostName: options.hostName,
+      extensionIds: options.extensionIds,
+      hostScriptPath
+    });
+    await ensureDir(_path2.default.dirname(target.manifestPath));
+    await writeJson(target.manifestPath, manifest, { spaces: 2 });
+    if (target.registryKey) {
+      const result = _child_process.spawnSync.call(void 0, "reg", ["add", target.registryKey, "/ve", "/t", "REG_SZ", "/d", target.manifestPath, "/f"], {
+        stdio: "pipe"
+      });
+      if (result.status !== 0) {
+        const stderr = _optionalChain([result, 'access', _4 => _4.stderr, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6("utf8")]) || "";
+        throw new Error(`Failed to register native host for ${browser}: ${stderr.trim()}`);
+      }
+    }
+    targets.push({ browser, manifestPath: target.manifestPath, registryKey: target.registryKey });
+  }
+  return { hostScriptPath, targets };
+}
+async function ensureNativeHostInstalled(options) {
+  const homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME;
+  const chromeManifest = getManifestTarget("chrome", process.platform, homeDir);
+  const expectedExtensionIds = [_optionalChain([options, 'optionalAccess', _7 => _7.extensionId])].filter((id) => Boolean(id));
+  const expectedAllowedOrigins = expectedExtensionIds.map((extensionId) => `chrome-extension://${extensionId}/`);
+  const hostScriptPath = _path2.default.join(getBrowserDataRoot(homeDir), "host.js");
+  let installExtensionIds = expectedExtensionIds;
+  if (await pathExists(chromeManifest.manifestPath)) {
+    try {
+      const manifest = await readJson(chromeManifest.manifestPath);
+      installExtensionIds = mergeExtensionIds(expectedExtensionIds, manifest.allowed_origins);
+      if (manifest.path && await pathExists(manifest.path)) {
+        const firstLine = await _asyncNullishCoalesce((await readFile(manifest.path, "utf8")).split("\n")[0], async () => ( ""));
+        const shebangPath = firstLine.replace(/^#!/, "").trim();
+        const shebangParts = shebangPath.split(/\s+/).filter(Boolean);
+        const commandBase = _nullishCoalesce(_optionalChain([shebangParts, 'access', _8 => _8[0], 'optionalAccess', _9 => _9.split, 'call', _10 => _10("/"), 'access', _11 => _11.pop, 'call', _12 => _12(), 'optionalAccess', _13 => _13.toLowerCase, 'call', _14 => _14()]), () => ( ""));
+        const envTarget = commandBase === "env" ? _nullishCoalesce(_optionalChain([shebangParts, 'access', _15 => _15.slice, 'call', _16 => _16(1), 'access', _17 => _17.find, 'call', _18 => _18((part) => !part.startsWith("-")), 'optionalAccess', _19 => _19.split, 'call', _20 => _20("/"), 'access', _21 => _21.pop, 'call', _22 => _22(), 'optionalAccess', _23 => _23.toLowerCase, 'call', _24 => _24()]), () => ( "")) : commandBase;
+        const isValidShebang = envTarget === "node";
+        const hasExpectedOrigin = expectedAllowedOrigins.length === 0 || expectedAllowedOrigins.every((origin) => _optionalChain([manifest, 'access', _25 => _25.allowed_origins, 'optionalAccess', _26 => _26.includes, 'call', _27 => _27(origin)]));
+        const pointsAtManagedHost = _path2.default.resolve(manifest.path) === _path2.default.resolve(hostScriptPath);
+        if (isValidShebang && hasExpectedOrigin && pointsAtManagedHost) {
+          return;
+        }
+      }
+    } catch (e3) {
+    }
+  }
+  const { command, args } = resolveCliLaunchSpec();
+  await installNativeHost({
+    extensionIds: installExtensionIds,
+    cliCommand: command,
+    cliArgPrefix: args.length ? args : void 0
+  });
+}
+async function createBrowserHandoff(options) {
+  const homeDir = _nullishCoalesce(options.homeDir, () => ( _chunkKASXKDF2cjs.AUTOHAND_HOME));
+  const token = _crypto2.default.randomUUID();
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const expiresAt = new Date(Date.now() + DEFAULT_HANDOFF_TTL_MS).toISOString();
+  const record = {
+    token,
+    sessionId: options.sessionId,
+    workspaceRoot: options.workspaceRoot,
+    createdAt,
+    expiresAt,
+    ...options.socketPath ? { socketPath: options.socketPath } : {}
+  };
+  await ensureDir(getHandoffDir(homeDir));
+  await writeJson(_path2.default.join(getHandoffDir(homeDir), `${token}.json`), record, { spaces: 2 });
+  return {
+    ...record,
+    url: buildChromeLaunchUrl({
+      token,
+      extensionId: options.extensionId,
+      installUrl: options.installUrl,
+      launchTarget: options.launchTarget
+    })
+  };
+}
+async function hasActiveHandoff(homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  const handoffDir = getHandoffDir(homeDir);
+  if (!await pathExists(handoffDir)) return false;
+  const entries = await _fsextra2.default.readdir(handoffDir);
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const record = await readJson(_path2.default.join(handoffDir, entry));
+      if (new Date(record.expiresAt).getTime() > Date.now()) return true;
+    } catch (e4) {
+    }
+  }
+  return false;
+}
+async function attachBrowserHandoff(token, homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  const handoffPath = _path2.default.join(getHandoffDir(homeDir), `${token}.json`);
+  if (!await pathExists(handoffPath)) {
+    return null;
+  }
+  const record = await readJson(handoffPath);
+  if (new Date(record.expiresAt).getTime() < Date.now()) {
+    await remove(handoffPath);
+    return null;
+  }
+  await remove(handoffPath);
+  return record;
+}
+async function attachLatestBrowserHandoff(homeDir = _chunkKASXKDF2cjs.AUTOHAND_HOME) {
+  const handoffDir = getHandoffDir(homeDir);
+  if (!await pathExists(handoffDir)) {
+    return null;
+  }
+  const entries = await _fsextra2.default.readdir(handoffDir);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    const recordPath = _path2.default.join(handoffDir, entry);
+    const record = await readJson(recordPath);
+    if (new Date(record.expiresAt).getTime() < Date.now()) {
+      await remove(recordPath);
+      continue;
+    }
+    records.push({ path: recordPath, record });
+  }
+  records.sort((left, right) => {
+    return new Date(right.record.createdAt).getTime() - new Date(left.record.createdAt).getTime();
+  });
+  const latest = records[0];
+  if (!latest) {
+    return null;
+  }
+  await remove(latest.path);
+  return latest.record;
+}
+function buildChromeOpenUrl(options) {
+  if (options.extensionId) {
+    return `chrome-extension://${options.extensionId}/sidepanel.html`;
+  }
+  return options.installUrl || DEFAULT_CHROME_INSTALL_URL;
+}
+function buildChromeLaunchUrl(options) {
+  if (options.launchTarget !== "web" && options.extensionId) {
+    return `chrome-extension://${options.extensionId}/sidepanel.html?handoff=${encodeURIComponent(options.token)}`;
+  }
+  const baseUrl = options.installUrl || DEFAULT_CHROME_INSTALL_URL;
+  if (!/^https?:\/\//.test(baseUrl)) {
+    return baseUrl;
+  }
+  const separator = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${separator}handoff=${encodeURIComponent(options.token)}`;
+}
+async function openUrl(url) {
+  try {
+    await _open2.default.call(void 0, url);
+    return;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!message.includes("xdg-open") && !message.includes("Executable not found") && !message.includes("ENOENT")) {
+      throw err;
+    }
+  }
+  const openers = ["xdg-open", "sensible-browser", "x-www-browser", "firefox", "chromium", "google-chrome"];
+  for (const opener of openers) {
+    try {
+      _child_process.execSync.call(void 0, `which ${opener}`, { stdio: "pipe" });
+      _child_process.spawn.call(void 0, opener, [url], { detached: true, stdio: "ignore" }).unref();
+      return;
+    } catch (e5) {
+    }
+  }
+  console.log(`
+Unable to open a browser automatically. Please open this URL manually:
+${url}
+`);
+}
+async function openChromeContinuation(url, browser = "auto", options = {}) {
+  if (options.userDataDir || options.profileDirectory) {
+    const command = await resolveBrowserCommand(browser);
+    if (command) {
+      const args = [
+        ...options.userDataDir ? [`--user-data-dir=${options.userDataDir}`] : [],
+        ...options.profileDirectory ? [`--profile-directory=${options.profileDirectory}`] : [],
+        url
+      ];
+      const child = _child_process.spawn.call(void 0, command, args, {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return;
+    }
+  }
+  const appName = await resolveBrowserLaunchTarget(browser);
+  if (!appName) {
+    await _open2.default.call(void 0, url);
+    return;
+  }
+  try {
+    await _open2.default.call(void 0, url, { app: { name: appName } });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("xdg-open") || message.includes("Executable not found") || message.includes("ENOENT")) {
+      await _open2.default.call(void 0, url);
+    } else {
+      throw err;
+    }
+  }
+}
+function applyChromeSettings(config, updates) {
+  config.chrome = {
+    ..._nullishCoalesce(config.chrome, () => ( {})),
+    ...updates
+  };
+  return config;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CHROME_NATIVE_HOST_NAME = CHROME_NATIVE_HOST_NAME; exports.DEFAULT_CHROME_INSTALL_URL = DEFAULT_CHROME_INSTALL_URL; exports.DEFAULT_HANDOFF_TTL_MS = DEFAULT_HANDOFF_TTL_MS; exports.normalizeBrowsers = normalizeBrowsers; exports.resolveBrowserLaunchTarget = resolveBrowserLaunchTarget; exports.resolveBrowserCommand = resolveBrowserCommand; exports.detectExtensionProfile = detectExtensionProfile; exports.resolveCliLaunchSpec = resolveCliLaunchSpec; exports.getManifestTarget = getManifestTarget; exports.buildNativeHostManifest = buildNativeHostManifest; exports.buildNativeHostScript = buildNativeHostScript; exports.installNativeHost = installNativeHost; exports.ensureNativeHostInstalled = ensureNativeHostInstalled; exports.createBrowserHandoff = createBrowserHandoff; exports.hasActiveHandoff = hasActiveHandoff; exports.attachBrowserHandoff = attachBrowserHandoff; exports.attachLatestBrowserHandoff = attachLatestBrowserHandoff; exports.buildChromeOpenUrl = buildChromeOpenUrl; exports.buildChromeLaunchUrl = buildChromeLaunchUrl; exports.openUrl = openUrl; exports.openChromeContinuation = openChromeContinuation; exports.applyChromeSettings = applyChromeSettings;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */