autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-SJAVBCOA.js → chunk-EEHWALXA.js}

@@ -3,16 +3,36 @@ import {
   showInput,
   showModal,
   showPassword
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-NZ3ZWLUW.js";
 import {
   saveConfig
-} from "./chunk-ZYVS43MU.js";
+} from "./chunk-IEPLQ47J.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/settings.ts
 import chalk from "chalk";
+var SETTING_KEY_ALIASES = {
+  silent_tool_output: "ui.silentToolOutput",
+  tool_output_silent: "ui.silentToolOutput",
+  ui_silent_tool_output: "ui.silentToolOutput",
+  sitrep: "ui.completionReportEnabled",
+  ui_sitrep: "ui.completionReportEnabled",
+  completion_report: "ui.completionReportEnabled",
+  completion_reports: "ui.completionReportEnabled",
+  completionReportEnabled: "ui.completionReportEnabled",
+  completion_report_enabled: "ui.completionReportEnabled",
+  ui_completion_report: "ui.completionReportEnabled",
+  ui_completion_reports: "ui.completionReportEnabled",
+  ui_completion_report_enabled: "ui.completionReportEnabled",
+  "verbs activity": "ui.activityVerbsEnabled",
+  "activity verbs": "ui.activityVerbsEnabled",
+  activity_verbs: "ui.activityVerbsEnabled",
+  verbs_activity: "ui.activityVerbsEnabled",
+  ui_activity_verbs: "ui.activityVerbsEnabled",
+  ui_verbs_activity: "ui.activityVerbsEnabled"
+};
 var SETTING_CATEGORIES = [
   { id: "ui", labelKey: "commands.settings.categories.ui" },
   { id: "agent", labelKey: "commands.settings.categories.agent" },
@@ -28,11 +48,14 @@ var SETTINGS_REGISTRY = [
   { key: "ui.theme", labelKey: "commands.settings.ui.theme", category: "ui", type: "string", redirect: "/theme" },
   { key: "ui.locale", labelKey: "commands.settings.ui.locale", category: "ui", type: "string", redirect: "/language" },
   { key: "ui.autoConfirm", labelKey: "commands.settings.ui.autoConfirm", descriptionKey: "commands.settings.ui.autoConfirmDesc", category: "ui", type: "boolean", defaultValue: false },
+  { key: "ui.silentToolOutput", labelKey: "commands.settings.ui.silentToolOutput", descriptionKey: "commands.settings.ui.silentToolOutputDesc", category: "ui", type: "boolean", defaultValue: false },
   { key: "ui.showThinking", labelKey: "commands.settings.ui.showThinking", descriptionKey: "commands.settings.ui.showThinkingDesc", category: "ui", type: "boolean", defaultValue: true },
   { key: "ui.terminalBell", labelKey: "commands.settings.ui.terminalBell", descriptionKey: "commands.settings.ui.terminalBellDesc", category: "ui", type: "boolean", defaultValue: true },
   { key: "ui.checkForUpdates", labelKey: "commands.settings.ui.checkForUpdates", descriptionKey: "commands.settings.ui.checkForUpdatesDesc", category: "ui", type: "boolean", defaultValue: true },
   { key: "ui.showCompletionNotification", labelKey: "commands.settings.ui.showCompletionNotification", descriptionKey: "commands.settings.ui.showCompletionNotificationDesc", category: "ui", type: "boolean", defaultValue: true },
+  { key: "ui.completionReportEnabled", labelKey: "commands.settings.ui.completionReportEnabled", descriptionKey: "commands.settings.ui.completionReportEnabledDesc", category: "ui", type: "boolean", defaultValue: true },
   { key: "ui.promptSuggestions", labelKey: "commands.settings.ui.promptSuggestions", descriptionKey: "commands.settings.ui.promptSuggestionsDesc", category: "ui", type: "boolean", defaultValue: true },
+  { key: "ui.activityVerbsEnabled", labelKey: "commands.settings.ui.activityVerbsEnabled", descriptionKey: "commands.settings.ui.activityVerbsEnabledDesc", category: "ui", type: "boolean", defaultValue: true },
   { key: "ui.activitySymbol", labelKey: "commands.settings.ui.activitySymbol", descriptionKey: "commands.settings.ui.activitySymbolDesc", category: "ui", type: "string", defaultValue: "\u2733" },
   { key: "ui.updateCheckInterval", labelKey: "commands.settings.ui.updateCheckInterval", descriptionKey: "commands.settings.ui.updateCheckIntervalDesc", category: "ui", type: "number", defaultValue: 24 },
   // Agent Behavior
@@ -86,6 +109,70 @@ function setNestedValue(obj, path, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
+function normalizeSettingKey(input) {
+  const trimmed = input.trim();
+  if (SETTING_KEY_ALIASES[trimmed]) {
+    return SETTING_KEY_ALIASES[trimmed];
+  }
+  if (trimmed.startsWith("ui.") && SETTING_KEY_ALIASES[trimmed.replace(/\./g, "_")]) {
+    return SETTING_KEY_ALIASES[trimmed.replace(/\./g, "_")];
+  }
+  return trimmed;
+}
+function parseBooleanSetting(value) {
+  const normalized = value.trim().toLowerCase();
+  if (["true", "1", "yes", "y", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "n", "off"].includes(normalized)) {
+    return false;
+  }
+  throw new Error(`Expected a boolean value, got "${value}". Use true or false.`);
+}
+function parseSettingValue(setting, rawValue) {
+  switch (setting.type) {
+    case "boolean":
+      return parseBooleanSetting(rawValue);
+    case "number": {
+      const value = Number(rawValue);
+      if (!Number.isFinite(value)) {
+        throw new Error(`Expected a number for ${setting.key}, got "${rawValue}".`);
+      }
+      return value;
+    }
+    case "enum":
+      if (!setting.enumValues?.includes(rawValue)) {
+        throw new Error(`Expected one of ${setting.enumValues?.join(", ") ?? "(none)"} for ${setting.key}.`);
+      }
+      return rawValue;
+    case "password":
+    case "string":
+      return rawValue;
+    default:
+      return rawValue;
+  }
+}
+function setConfigSetting(config, keyInput, rawValue) {
+  const key = normalizeSettingKey(keyInput);
+  const setting = SETTINGS_REGISTRY.find((s) => s.key === key);
+  if (!setting) {
+    throw new Error(`Unknown setting "${keyInput}". Use /settings to browse configurable settings.`);
+  }
+  if (setting.redirect) {
+    throw new Error(`Setting "${setting.key}" is managed by ${setting.redirect}.`);
+  }
+  const value = parseSettingValue(setting, rawValue);
+  setNestedValue(config, setting.key, value);
+  return { key: setting.key, value };
+}
+function parseConfigSetArgs(parts) {
+  if (parts.length < 2) {
+    throw new Error("Usage: autohand config set <key> <value>");
+  }
+  const value = parts[parts.length - 1];
+  const key = parts.slice(0, -1).join(" ");
+  return { key, value };
+}
 function getSettingsForCategory(category) {
   return SETTINGS_REGISTRY.filter((s) => s.category === category);
 }
@@ -247,6 +334,10 @@ export {
   SETTINGS_REGISTRY,
   getNestedValue,
   setNestedValue,
+  normalizeSettingKey,
+  parseSettingValue,
+  setConfigSetting,
+  parseConfigSetArgs,
   getSettingsForCategory,
   formatSettingValue,
   editSetting,

package/dist/chunk-ES2HJQ4N.js

@@ -0,0 +1,37 @@
+// src/commands/yolo.ts
+import chalk from "chalk";
+async function toggleYolo(ctx) {
+  if (!ctx.setYoloMode) {
+    return "YOLO mode toggle not available in this context.";
+  }
+  const isActive = ctx.permissionManager.getMode() === "unrestricted";
+  if (isActive) {
+    ctx.setYoloMode(void 0);
+    console.log();
+    console.log(chalk.cyan("YOLO mode deactivated. Returning to interactive approval."));
+    console.log();
+  } else {
+    ctx.setYoloMode("allow:*");
+    console.log();
+    console.log(chalk.yellow.bold("\u{1F680} YOLO MODE ACTIVATED"));
+    console.log(chalk.gray("You only live once! All actions will be auto-approved."));
+    console.log(chalk.gray("Security blacklist still applies for sensitive files."));
+    console.log();
+  }
+  return null;
+}
+var metadata = {
+  command: "/yolo",
+  description: "Toggle YOLO mode \u2014 auto-approve all actions",
+  implemented: true
+};
+
+export {
+  toggleYolo,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-G27PQQFD.js → chunk-EYHKL4QC.js}

@@ -1,6 +1,6 @@
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/undo.ts
 import chalk from "chalk";

package/dist/{chunk-SV2WA57F.js → chunk-FBQJZKFX.js}

@@ -1,22 +1,22 @@
 import {
   showModal
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-NZ3ZWLUW.js";
 import {
   saveConfig
-} from "./chunk-ZYVS43MU.js";
+} from "./chunk-IEPLQ47J.js";
 import {
   CUSTOM_THEMES_DIR,
   builtInThemes,
   initTheme,
   listAvailableThemes
-} from "./chunk-BYONM7UM.js";
+} from "./chunk-NBGOIFKP.js";
 import {
   getTheme,
   isThemeInitialized
-} from "./chunk-LIEXWM2M.js";
+} from "./chunk-JAQO6XDB.js";
 import {
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/theme.ts
 import chalk from "chalk";
@@ -37,6 +37,9 @@ async function theme(ctx) {
     sandy: "Warm, earthy desert tones",
     tui: "New Zealand-inspired colors",
     "github-dark": "GitHub Dark terminal palette",
+    cappadocia: "Cappadocia-inspired rose valleys, dawn sky, and balloon colors",
+    rio: "Rio-inspired blue macaw, rainforest, and beach-light palette",
+    australia: "Australian coast, wattle, and eucalyptus palette",
     // Curated Ghostty themes
     "Atom One Dark": "Atom editor dark theme",
     "Ayu Mirage": "Soft dark with warm accents",
@@ -63,11 +66,28 @@ async function theme(ctx) {
     const description = descriptions[name] ?? (name in builtInThemes ? "Built-in theme" : "Ghostty theme");
     return { label, value: name, description };
   });
-  const result = await showModal({
-    title: t("commands.theme.selectPrompt"),
-    options,
-    initialIndex: themes.indexOf(currentTheme)
-  });
+  let result = null;
+  let selectedTheme = null;
+  let selectedThemePreview = null;
+  await ctx.onBeforeModal?.();
+  try {
+    result = await showModal({
+      title: t("commands.theme.selectPrompt"),
+      options,
+      initialIndex: themes.indexOf(currentTheme)
+    });
+    if (result) {
+      const selected2 = result.value;
+      if (selected2 !== currentTheme) {
+        selectedThemePreview = initTheme(selected2);
+        ctx.config.ui = { ...ctx.config.ui, theme: selected2 };
+        await saveConfig(ctx.config);
+        selectedTheme = selected2;
+      }
+    }
+  } finally {
+    await ctx.onAfterModal?.();
+  }
   if (!result) {
     console.log(chalk.gray("\nTheme selection cancelled."));
     return null;
@@ -78,15 +98,15 @@ async function theme(ctx) {
 ${t("commands.theme.noChange")}`));
     return null;
   }
-  initTheme(selected);
-  ctx.config.ui = { ...ctx.config.ui, theme: selected };
-  await saveConfig(ctx.config);
   console.log(chalk.green(`
-\u2713 ${t("commands.theme.changed", { theme: selected })}`));
-  const newTheme = getTheme();
+\u2713 ${t("commands.theme.changed", { theme: selectedTheme ?? selected })}`));
+  const newTheme = selectedThemePreview ?? getTheme();
   console.log("\nTheme preview:");
   console.log(`  ${newTheme.fg("accent", "\u25CF accent")}  ${newTheme.fg("success", "\u25CF success")}  ${newTheme.fg("error", "\u25CF error")}  ${newTheme.fg("warning", "\u25CF warning")}`);
   console.log(`  ${newTheme.fg("muted", "\u25CF muted")}  ${newTheme.fg("dim", "\u25CF dim")}  ${newTheme.fg("text", "\u25CF text")}`);
+  if (newTheme.getColorMode() === "none") {
+    console.log(chalk.yellow("  Color output is disabled by NO_COLOR or FORCE_COLOR=0 in your terminal environment."));
+  }
   console.log();
   return null;
 }
@@ -99,6 +119,9 @@ async function themeInfo() {
   console.log(chalk.cyan("\n\u{1F3A8} Current Theme Info\n"));
   console.log(chalk.gray(`Name: ${chalk.white(currentTheme.name)}`));
   console.log(chalk.gray(`Color mode: ${chalk.white(currentTheme.getColorMode())}`));
+  if (currentTheme.getColorMode() === "none") {
+    console.log(chalk.yellow("Color output is disabled by NO_COLOR or FORCE_COLOR=0 in your terminal environment."));
+  }
   console.log(chalk.gray(`Custom themes dir: ${CUSTOM_THEMES_DIR}`));
   console.log();
   console.log("Color preview:");

package/dist/chunk-FFBDRUO5.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/commands/review.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var metadata = {
+  command: "/review",
+  description: "staff-level code review with 10 actionable findings",
+  implemented: true
+};
+async function review(ctx, args = []) {
+  const userInstructions = args.join(" ").trim();
+  const skillPath = _path2.default.resolve(
+    _path2.default.dirname(new URL(import.meta.url).pathname),
+    "../skills/builtin/code-reviewer/SKILL.md"
+  );
+  let skillBody = "";
+  try {
+    const content = await _fsextra2.default.readFile(skillPath, "utf-8");
+    const bodyMatch = content.match(/^---[\s\S]*?---\s*([\s\S]*)$/);
+    skillBody = bodyMatch ? bodyMatch[1].trim() : content;
+  } catch (e) {
+    skillBody = "Perform a thorough code review analyzing architecture, security, performance, error handling, and maintainability.";
+  }
+  const parts = [
+    skillBody,
+    "",
+    "## Review Target",
+    `Workspace: ${ctx.workspaceRoot}`
+  ];
+  if (userInstructions) {
+    parts.push("", "## Additional Focus", userInstructions);
+  }
+  parts.push(
+    "",
+    "## Instructions",
+    "Start the review now. Use the available tools (read_file, fff_grep, fff_find, list_tree, git_status, git_diff) to gather context, then deliver your 10-dimension review."
+  );
+  const prompt = parts.join("\n");
+  if (ctx.isNonInteractive || !ctx.queueInstruction) {
+    return prompt;
+  }
+  ctx.queueInstruction(prompt);
+  console.log(_chalk2.default.cyan("\n  Starting code review..."));
+  if (userInstructions) {
+    console.log(_chalk2.default.gray(`  Focus: ${userInstructions}`));
+  }
+  console.log(_chalk2.default.gray("  Analyzing 10 dimensions: architecture, security, performance, and more.\n"));
+  return null;
+}
+
+
+
+
+exports.metadata = metadata; exports.review = review;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-N7LI55V4.js → chunk-FFHSCM5M.js}

@@ -1,16 +1,16 @@
 import {
   showModal
-} from "./chunk-YZXUDM5X.js";
+} from "./chunk-NZ3ZWLUW.js";
 import {
   saveConfig
-} from "./chunk-ZYVS43MU.js";
+} from "./chunk-IEPLQ47J.js";
 import {
   LANGUAGE_DISPLAY_NAMES,
   SUPPORTED_LOCALES,
   changeLanguage,
   getCurrentLocale,
   t
-} from "./chunk-APIXPPMT.js";
+} from "./chunk-LEZEWKPA.js";
 
 // src/commands/language.ts
 import chalk from "chalk";
@@ -26,11 +26,18 @@ async function language(ctx) {
     label: locale === currentLocale ? `${LANGUAGE_DISPLAY_NAMES[locale]} (${t("common.current")})` : LANGUAGE_DISPLAY_NAMES[locale],
     value: locale
   }));
-  const result = await showModal({
-    title: t("commands.language.selectPrompt"),
-    options,
-    initialIndex: SUPPORTED_LOCALES.indexOf(currentLocale)
-  });
+  await ctx.onBeforeModal?.();
+  const result = await (async () => {
+    try {
+      return await showModal({
+        title: t("commands.language.selectPrompt"),
+        options,
+        initialIndex: SUPPORTED_LOCALES.indexOf(currentLocale)
+      });
+    } finally {
+      await ctx.onAfterModal?.();
+    }
+  })();
   if (!result) {
     console.log(chalk.gray("\nLanguage selection cancelled."));
     return null;

package/dist/{chunk-SAHBLB3E.js → chunk-FP46B4X3.js}

@@ -4,7 +4,7 @@ import * as http from "http";
 import { existsSync } from "fs";
 import { spawn } from "child_process";
 var globalSearchConfig = {
-  provider: "google"
+  provider: "browser-profile"
 };
 function configureSearch(config) {
   globalSearchConfig = { ...globalSearchConfig, ...config };
@@ -16,7 +16,13 @@ function isSearchConfigured() {
   const config = getSearchConfig();
   const braveKey = config.braveApiKey ?? process.env.BRAVE_SEARCH_API_KEY;
   const parallelKey = config.parallelApiKey ?? process.env.PARALLEL_API_KEY;
+  const exaKey = config.exaApiKey ?? process.env.EXA_API_KEY;
   switch (config.provider) {
+    case "browser-profile":
+      return !!findChromePath();
+    // Available if Chrome/Chromium is installed
+    case "exa":
+      return !!exaKey;
     case "brave":
       return !!braveKey;
     case "parallel":
@@ -227,10 +233,23 @@ async function webSearch(query, options = {}) {
       enhancedQuery = `${query} changelog OR release notes OR what's new`;
       break;
   }
-  const provider = options.provider ?? globalSearchConfig.provider;
+  let provider = options.provider ?? globalSearchConfig.provider;
   const braveApiKey = globalSearchConfig.braveApiKey ?? process.env.BRAVE_SEARCH_API_KEY;
   const parallelApiKey = globalSearchConfig.parallelApiKey ?? process.env.PARALLEL_API_KEY;
+  const exaApiKey = globalSearchConfig.exaApiKey ?? process.env.EXA_API_KEY;
+  if (provider === "browser-profile" && !findChromePath()) {
+    provider = "google";
+  }
   switch (provider) {
+    case "browser-profile":
+      return browserProfileSearch(enhancedQuery, maxResults);
+    case "exa":
+      if (!exaApiKey) {
+        throw new Error(
+          "Exa.ai Search requires an API key. Configure it with /search or set EXA_API_KEY environment variable. Get an API key at: https://exa.ai"
+        );
+      }
+      return exaSearch(enhancedQuery, exaApiKey, maxResults);
     case "brave":
       if (!braveApiKey) {
         throw new Error(
@@ -456,6 +475,183 @@ async function braveSearch(query, apiKey, maxResults) {
     });
   });
 }
+async function exaSearch(query, apiKey, maxResults) {
+  const postData = JSON.stringify({
+    query,
+    numResults: maxResults,
+    contents: {
+      text: true
+    }
+  });
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: "api.exa.ai",
+      port: 443,
+      path: "/search",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Length": Buffer.byteLength(postData)
+      }
+    };
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 400) {
+          reject(new Error(`Exa.ai API error: HTTP ${res.statusCode} - ${data}`));
+          return;
+        }
+        try {
+          const json = JSON.parse(data);
+          if (json.results && Array.isArray(json.results)) {
+            const results = json.results.slice(0, maxResults).map((r) => ({
+              title: r.title || r.url || "Untitled",
+              url: r.url || "",
+              snippet: r.text?.slice(0, 300) || r.highlight?.slice(0, 300) || ""
+            }));
+            resolve(results);
+          } else {
+            resolve([]);
+          }
+        } catch (parseError) {
+          reject(new Error(`Failed to parse Exa.ai response: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+        }
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Exa.ai request timed out"));
+    });
+    req.write(postData);
+    req.end();
+  });
+}
+async function browserProfileSearch(query, maxResults) {
+  const chromePath = findChromePath();
+  if (!chromePath) {
+    throw new Error(
+      "No Chrome/Chromium browser found. Install Chrome or configure a different search provider with /search."
+    );
+  }
+  const profile = await findBrowserProfile();
+  if (!profile) {
+    return googleSearch(query, maxResults);
+  }
+  const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}&num=${maxResults}&hl=en`;
+  return new Promise((resolve, reject) => {
+    const port = 9222 + Math.floor(Math.random() * 1e3);
+    const args = [
+      `--remote-debugging-port=${port}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-default-apps",
+      "--disable-background-networking",
+      "--disable-sync",
+      `--user-data-dir=${profile.userDataDir}`,
+      `--profile-directory=${profile.profileDirectory}`,
+      "--headless=new",
+      "--dump-dom",
+      searchUrl
+    ];
+    let stdout = "";
+    let killed = false;
+    const proc = spawn(chromePath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3e4
+    });
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+      if (stdout.length > 5e5) {
+        killed = true;
+        proc.kill("SIGTERM");
+      }
+    });
+    proc.stderr.resume();
+    proc.on("close", (code) => {
+      if (killed) {
+        const results2 = parseGoogleResultsFromDOM(stdout.slice(0, 5e5), maxResults);
+        resolve(results2.length > 0 ? results2 : []);
+        return;
+      }
+      if (code !== 0 && code !== null) {
+        googleSearch(query, maxResults).then(resolve).catch(reject);
+        return;
+      }
+      const results = parseGoogleResultsFromDOM(stdout, maxResults);
+      if (stdout.includes("unusual traffic") || stdout.includes("captcha") || stdout.includes("g-recaptcha")) {
+        googleSearch(query, maxResults).then(resolve).catch(reject);
+        return;
+      }
+      if (results.length > 0) {
+        resolve(results);
+      } else {
+        googleSearch(query, maxResults).then(resolve).catch(reject);
+      }
+    });
+    proc.on("error", () => {
+      googleSearch(query, maxResults).then(resolve).catch(reject);
+    });
+  });
+}
+async function findBrowserProfile() {
+  const os = await import("os");
+  const path = await import("path");
+  const fs = await import("fs-extra");
+  const { pathExists } = fs;
+  const homeDir = os.homedir();
+  const platform = process.platform;
+  const browserRoots = [];
+  if (platform === "darwin") {
+    browserRoots.push(
+      { name: "Chrome", userDataDir: path.join(homeDir, "Library", "Application Support", "Google", "Chrome") },
+      { name: "Chromium", userDataDir: path.join(homeDir, "Library", "Application Support", "Chromium") },
+      { name: "Brave", userDataDir: path.join(homeDir, "Library", "Application Support", "BraveSoftware", "Brave-Browser") },
+      { name: "Edge", userDataDir: path.join(homeDir, "Library", "Application Support", "Microsoft Edge") }
+    );
+  } else if (platform === "linux") {
+    browserRoots.push(
+      { name: "Chrome", userDataDir: path.join(homeDir, ".config", "google-chrome") },
+      { name: "Chromium", userDataDir: path.join(homeDir, ".config", "chromium") },
+      { name: "Brave", userDataDir: path.join(homeDir, ".config", "BraveSoftware", "Brave-Browser") },
+      { name: "Edge", userDataDir: path.join(homeDir, ".config", "microsoft-edge") }
+    );
+  } else if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? "";
+    browserRoots.push(
+      { name: "Chrome", userDataDir: path.join(localAppData, "Google", "Chrome", "User Data") },
+      { name: "Chromium", userDataDir: path.join(localAppData, "Chromium", "User Data") },
+      { name: "Brave", userDataDir: path.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data") },
+      { name: "Edge", userDataDir: path.join(localAppData, "Microsoft", "Edge", "User Data") }
+    );
+  }
+  for (const browser of browserRoots) {
+    if (!await pathExists(browser.userDataDir)) {
+      continue;
+    }
+    try {
+      const entries = await fs.readdir(browser.userDataDir);
+      const profiles = entries.filter(
+        (entry) => entry === "Default" || entry.startsWith("Profile ")
+      );
+      const profileDirectory = profiles.includes("Default") ? "Default" : profiles[0];
+      if (profileDirectory) {
+        return {
+          userDataDir: browser.userDataDir,
+          profileDirectory,
+          browser: browser.name
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 async function fetchUrl(url, options = {}) {
   const maxLength = options.maxLength ?? 3e4;
   try {
@@ -663,16 +859,25 @@ function formatPackageInfo(info) {
   }
   return lines.join("\n");
 }
+var formatNpmInfo = formatPackageInfo;
 
 export {
   configureSearch,
   getSearchConfig,
   isSearchConfigured,
+  findChromePath,
+  parseGoogleResultsFromDOM,
   webSearch,
   fetchUrl,
+  getNpmInfo,
+  getPyPIInfo,
+  getCargoInfo,
+  getRubyGemsInfo,
+  getGoModuleInfo,
   getPackageInfo,
   formatSearchResults,
-  formatPackageInfo
+  formatPackageInfo,
+  formatNpmInfo
 };
 /**
  * @license