autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-ARBEHFCG.js

@@ -0,0 +1,715 @@
+import {
+  AUTOHAND_HOME
+} from "./chunk-TWQDAUZU.js";
+
+// src/browser/chrome.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { spawn, spawnSync } from "child_process";
+import open from "open";
+import { execSync } from "child_process";
+var { chmod, ensureDir, pathExists, readFile, readJson, remove, writeFile, writeJson } = fs;
+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 = AUTOHAND_HOME) {
+  return path.join(homeDir, "chrome");
+}
+function getBrowserDataRoot(homeDir = AUTOHAND_HOME) {
+  return path.join(getChromeHome(homeDir), "native-host");
+}
+function getHandoffDir(homeDir = AUTOHAND_HOME) {
+  return path.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: path.join(os.homedir(), "Applications", "Google Chrome.app"), appName: "Google Chrome", command: path.join(os.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome") }
+      ],
+      chromium: [
+        { probe: "/Applications/Chromium.app", appName: "Chromium", command: "/Applications/Chromium.app/Contents/MacOS/Chromium" },
+        { probe: path.join(os.homedir(), "Applications", "Chromium.app"), appName: "Chromium", command: path.join(os.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: path.join(os.homedir(), "Applications", "Brave Browser.app"), appName: "Brave Browser", command: path.join(os.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: path.join(os.homedir(), "Applications", "Microsoft Edge.app"), appName: "Microsoft Edge", command: path.join(os.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 = process.env.LOCALAPPDATA ?? "";
+    const programFiles = process.env["ProgramFiles"] ?? "C:\\Program Files";
+    const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+    const targets = {
+      chrome: [
+        { probe: path.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: path.join(programFiles, "Google", "Chrome", "Application", "chrome.exe") },
+        { probe: path.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: path.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe") },
+        { probe: path.join(localAppData, "Google", "Chrome", "Application", "chrome.exe"), appName: "chrome", command: path.join(localAppData, "Google", "Chrome", "Application", "chrome.exe") }
+      ],
+      chromium: [
+        { probe: path.join(programFiles, "Chromium", "Application", "chrome.exe"), appName: "chromium", command: path.join(programFiles, "Chromium", "Application", "chrome.exe") },
+        { probe: path.join(localAppData, "Chromium", "Application", "chrome.exe"), appName: "chromium", command: path.join(localAppData, "Chromium", "Application", "chrome.exe") }
+      ],
+      brave: [
+        { probe: path.join(programFiles, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: path.join(programFiles, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") },
+        { probe: path.join(programFilesX86, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: path.join(programFilesX86, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") },
+        { probe: path.join(localAppData, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"), appName: "brave", command: path.join(localAppData, "BraveSoftware", "Brave-Browser", "Application", "brave.exe") }
+      ],
+      edge: [
+        { probe: path.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: path.join(programFiles, "Microsoft", "Edge", "Application", "msedge.exe") },
+        { probe: path.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: path.join(programFilesX86, "Microsoft", "Edge", "Application", "msedge.exe") },
+        { probe: path.join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe"), appName: "msedge", command: path.join(localAppData, "Microsoft", "Edge", "Application", "msedge.exe") }
+      ]
+    };
+    return targets[browser];
+  }
+  return [];
+}
+async function defaultBrowserProbe(probe) {
+  if (probe.includes(path.sep) || /^[A-Za-z]:\\/.test(probe)) {
+    return pathExists(probe);
+  }
+  const command = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(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 = os.homedir()) {
+  if (platform === "darwin") {
+    return {
+      chrome: path.join(homeDir, "Library", "Application Support", "Google", "Chrome"),
+      chromium: path.join(homeDir, "Library", "Application Support", "Chromium"),
+      brave: path.join(homeDir, "Library", "Application Support", "BraveSoftware", "Brave-Browser"),
+      edge: path.join(homeDir, "Library", "Application Support", "Microsoft Edge")
+    };
+  }
+  if (platform === "linux") {
+    return {
+      chrome: path.join(homeDir, ".config", "google-chrome"),
+      chromium: path.join(homeDir, ".config", "chromium"),
+      brave: path.join(homeDir, ".config", "BraveSoftware", "Brave-Browser"),
+      edge: path.join(homeDir, ".config", "microsoft-edge")
+    };
+  }
+  if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? "";
+    return {
+      chrome: path.join(localAppData, "Google", "Chrome", "User Data"),
+      chromium: path.join(localAppData, "Chromium", "User Data"),
+      brave: path.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data"),
+      edge: path.join(localAppData, "Microsoft", "Edge", "User Data")
+    };
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+async function detectExtensionProfile(extensionId, browsers = [...ALL_BROWSERS], platform = process.platform, homeDir = os.homedir()) {
+  const roots = getBrowserUserDataRoots(platform, homeDir);
+  for (const browser of browsers) {
+    const userDataDir = roots[browser];
+    if (!await pathExists(userDataDir)) {
+      continue;
+    }
+    const entries = await fs.readdir(userDataDir);
+    const candidates = entries.filter((entry) => entry === "Default" || entry.startsWith("Profile "));
+    for (const profileDirectory of candidates) {
+      const packedExtensionPath = path.join(userDataDir, profileDirectory, "Extensions", extensionId);
+      const unpackedExtensionPath = path.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 && path.isAbsolute(argv1) && !argv1.includes("$bunfs")) {
+    return {
+      command: process.execPath,
+      args: [argv1]
+    };
+  }
+  const execBase = path.basename(process.execPath).toLowerCase();
+  if (execBase.includes("autohand")) {
+    return { command: process.execPath, args: [] };
+  }
+  return { command: "autohand", args: [] };
+}
+function getManifestTarget(browser, platform = process.platform, homeDir = AUTOHAND_HOME) {
+  const hostName = CHROME_NATIVE_HOST_NAME;
+  const manifestPath = path.join(getBrowserDataRoot(homeDir), `${browser}.json`);
+  if (platform === "darwin") {
+    const roots = {
+      chrome: path.join(os.homedir(), "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts"),
+      chromium: path.join(os.homedir(), "Library", "Application Support", "Chromium", "NativeMessagingHosts"),
+      brave: path.join(os.homedir(), "Library", "Application Support", "BraveSoftware", "Brave-Browser", "NativeMessagingHosts"),
+      edge: path.join(os.homedir(), "Library", "Application Support", "Microsoft Edge", "NativeMessagingHosts")
+    };
+    return {
+      browser,
+      manifestPath: path.join(roots[browser], `${hostName}.json`),
+      registryKey: void 0
+    };
+  }
+  if (platform === "linux") {
+    const roots = {
+      chrome: path.join(os.homedir(), ".config", "google-chrome", "NativeMessagingHosts"),
+      chromium: path.join(os.homedir(), ".config", "chromium", "NativeMessagingHosts"),
+      brave: path.join(os.homedir(), ".config", "BraveSoftware", "Brave-Browser", "NativeMessagingHosts"),
+      edge: path.join(os.homedir(), ".config", "microsoft-edge", "NativeMessagingHosts")
+    };
+    return {
+      browser,
+      manifestPath: path.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 = 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 match?.[1] ?? null;
+}
+function mergeExtensionIds(extensionIds, allowedOrigins) {
+  const existingIds = (allowedOrigins ?? []).map(extensionIdFromAllowedOrigin).filter((id) => Boolean(id));
+  return Array.from(new Set([...existingIds, ...extensionIds].filter(Boolean)));
+}
+function resolveNodePath() {
+  const execPath = process.execPath;
+  const execBase = path.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",
+    path.join(os.homedir(), ".nvm/versions/node"),
+    path.join(os.homedir(), ".local/bin/node")
+  ];
+  for (const candidate of candidates) {
+    if (candidate.includes(".nvm")) {
+      try {
+        const versions = fs.readdirSync(candidate);
+        if (versions.length) {
+          const latest = versions.sort().pop();
+          const nodeBin = path.join(candidate, latest, "bin/node");
+          if (fs.existsSync(nodeBin)) return nodeBin;
+        }
+      } catch {
+      }
+      continue;
+    }
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return "/usr/bin/env node";
+}
+function buildNativeHostScript(options) {
+  const cliCommand = options.cliCommand;
+  const cliArgPrefix = options.cliArgPrefix ?? [];
+  const shebang = 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 = options.homeDir ?? AUTOHAND_HOME;
+  const browsers = options.browsers?.length ? options.browsers : [...ALL_BROWSERS];
+  const hostScriptPath = path.join(getBrowserDataRoot(homeDir), "host.js");
+  await ensureDir(path.dirname(hostScriptPath));
+  const script = buildNativeHostScript({
+    cliCommand: options.cliCommand ?? "autohand",
+    cliArgPrefix: 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(path.dirname(target.manifestPath));
+    await writeJson(target.manifestPath, manifest, { spaces: 2 });
+    if (target.registryKey) {
+      const result = spawnSync("reg", ["add", target.registryKey, "/ve", "/t", "REG_SZ", "/d", target.manifestPath, "/f"], {
+        stdio: "pipe"
+      });
+      if (result.status !== 0) {
+        const stderr = result.stderr?.toString("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 = AUTOHAND_HOME;
+  const chromeManifest = getManifestTarget("chrome", process.platform, homeDir);
+  const expectedExtensionIds = [options?.extensionId].filter((id) => Boolean(id));
+  const expectedAllowedOrigins = expectedExtensionIds.map((extensionId) => `chrome-extension://${extensionId}/`);
+  const hostScriptPath = path.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 readFile(manifest.path, "utf8")).split("\n")[0] ?? "";
+        const shebangPath = firstLine.replace(/^#!/, "").trim();
+        const shebangParts = shebangPath.split(/\s+/).filter(Boolean);
+        const commandBase = shebangParts[0]?.split("/").pop()?.toLowerCase() ?? "";
+        const envTarget = commandBase === "env" ? shebangParts.slice(1).find((part) => !part.startsWith("-"))?.split("/").pop()?.toLowerCase() ?? "" : commandBase;
+        const isValidShebang = envTarget === "node";
+        const hasExpectedOrigin = expectedAllowedOrigins.length === 0 || expectedAllowedOrigins.every((origin) => manifest.allowed_origins?.includes(origin));
+        const pointsAtManagedHost = path.resolve(manifest.path) === path.resolve(hostScriptPath);
+        if (isValidShebang && hasExpectedOrigin && pointsAtManagedHost) {
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+  const { command, args } = resolveCliLaunchSpec();
+  await installNativeHost({
+    extensionIds: installExtensionIds,
+    cliCommand: command,
+    cliArgPrefix: args.length ? args : void 0
+  });
+}
+async function createBrowserHandoff(options) {
+  const homeDir = options.homeDir ?? AUTOHAND_HOME;
+  const token = crypto.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(path.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 = AUTOHAND_HOME) {
+  const handoffDir = getHandoffDir(homeDir);
+  if (!await pathExists(handoffDir)) return false;
+  const entries = await fs.readdir(handoffDir);
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const record = await readJson(path.join(handoffDir, entry));
+      if (new Date(record.expiresAt).getTime() > Date.now()) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function attachBrowserHandoff(token, homeDir = AUTOHAND_HOME) {
+  const handoffPath = path.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 = AUTOHAND_HOME) {
+  const handoffDir = getHandoffDir(homeDir);
+  if (!await pathExists(handoffDir)) {
+    return null;
+  }
+  const entries = await fs.readdir(handoffDir);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    const recordPath = path.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 open(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 {
+      execSync(`which ${opener}`, { stdio: "pipe" });
+      spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+      return;
+    } catch {
+    }
+  }
+  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 = spawn(command, args, {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return;
+    }
+  }
+  const appName = await resolveBrowserLaunchTarget(browser);
+  if (!appName) {
+    await open(url);
+    return;
+  }
+  try {
+    await open(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 open(url);
+    } else {
+      throw err;
+    }
+  }
+}
+function applyChromeSettings(config, updates) {
+  config.chrome = {
+    ...config.chrome ?? {},
+    ...updates
+  };
+  return config;
+}
+
+export {
+  CHROME_NATIVE_HOST_NAME,
+  DEFAULT_CHROME_INSTALL_URL,
+  DEFAULT_HANDOFF_TTL_MS,
+  normalizeBrowsers,
+  resolveBrowserLaunchTarget,
+  resolveBrowserCommand,
+  detectExtensionProfile,
+  resolveCliLaunchSpec,
+  getManifestTarget,
+  buildNativeHostManifest,
+  buildNativeHostScript,
+  installNativeHost,
+  ensureNativeHostInstalled,
+  createBrowserHandoff,
+  hasActiveHandoff,
+  attachBrowserHandoff,
+  attachLatestBrowserHandoff,
+  buildChromeOpenUrl,
+  buildChromeLaunchUrl,
+  openUrl,
+  openChromeContinuation,
+  applyChromeSettings
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */