browser-commander 0.21.2 → 0.22.0

package/src/browser/browser-profiles.js

@@ -2,28 +2,74 @@ import { access, readdir, readFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-export const SUPPORTED_COOKIE_BROWSERS = [
-  'chrome',
-  'edge',
-  'brave',
-  'chromium',
-  'firefox',
-];
+import {
+  BROWSER_IDS,
+  browserFamily,
+  isSingleProfileBrowser,
+  normalizeBrowserId,
+  resolveBrowserRoots,
+} from './browser-sources.js';
+import { resolveDefaultBrowser } from './default-browser.js';
 
-function platformPath(platform) {
-  return platform === 'win32' ? path.win32 : path;
+/**
+ * Keywords that select the operating-system default browser instead of a named
+ * one, so `browser: 'default'` (or `'auto'`) imports from whatever a person
+ * actually uses. Importing stays opt-in: callers pass this explicitly.
+ */
+const DEFAULT_BROWSER_KEYWORDS = new Set(['default', 'auto']);
+
+/** Whether `browser` asks for the system default rather than a named browser. */
+export function isDefaultBrowserKeyword(browser) {
+  return (
+    typeof browser === 'string' &&
+    DEFAULT_BROWSER_KEYWORDS.has(browser.trim().toLowerCase())
+  );
 }
 
-export function normalizeCookieBrowser(browser) {
-  const normalized = browser === 'msedge' ? 'edge' : browser;
-  if (!SUPPORTED_COOKIE_BROWSERS.includes(normalized)) {
+/**
+ * Resolve a requested browser to a canonical catalogue id, expanding the
+ * `default`/`auto` keywords to the system default browser. Named browsers are
+ * normalized through the catalogue as before.
+ */
+export async function resolveSourceBrowser(
+  browser,
+  { platform = process.platform, environment = process.env, runCommand } = {}
+) {
+  if (!isDefaultBrowserKeyword(browser)) {
+    return normalizeCookieBrowser(browser);
+  }
+  const resolved = await resolveDefaultBrowser({
+    platform,
+    environment,
+    runCommand,
+  });
+  if (!resolved) {
     throw new Error(
-      `Unsupported browser: ${browser}. Expected one of ${SUPPORTED_COOKIE_BROWSERS.join(', ')}`
+      'Could not determine the system default browser; pass an explicit browser instead of "default".'
     );
   }
-  return normalized;
+  return resolved;
+}
+
+/**
+ * Every browser profile discovery can read from. Driven by the shared
+ * `browser-sources.json` catalogue, so adding a browser there adds it here.
+ */
+export const SUPPORTED_COOKIE_BROWSERS = BROWSER_IDS;
+
+function platformPath(platform) {
+  return platform === 'win32' ? path.win32 : path;
+}
+
+/** Resolve a browser name (id or alias) to its canonical id. */
+export function normalizeCookieBrowser(browser) {
+  return normalizeBrowserId(browser);
 }
 
+/**
+ * The primary profile root a browser uses on a platform, or `undefined` when
+ * the browser does not run there.
+ */
 export function browserProfileRoot(
   browser,
   {
@@ -32,46 +78,12 @@ export function browserProfileRoot(
     environment = process.env,
   } = {}
 ) {
-  const normalizedBrowser = normalizeCookieBrowser(browser);
-  const pathApi = platformPath(platform);
-  if (platform === 'darwin') {
-    const support = pathApi.join(homeDir, 'Library', 'Application Support');
-    const roots = {
-      brave: pathApi.join(support, 'BraveSoftware', 'Brave-Browser'),
-      chrome: pathApi.join(support, 'Google', 'Chrome'),
-      chromium: pathApi.join(support, 'Chromium'),
-      edge: pathApi.join(support, 'Microsoft Edge'),
-      firefox: pathApi.join(support, 'Firefox'),
-    };
-    return roots[normalizedBrowser];
-  }
-  if (platform === 'win32') {
-    const localAppData =
-      environment.LOCALAPPDATA ?? pathApi.join(homeDir, 'AppData', 'Local');
-    const roamingAppData =
-      environment.APPDATA ?? pathApi.join(homeDir, 'AppData', 'Roaming');
-    const roots = {
-      brave: pathApi.join(
-        localAppData,
-        'BraveSoftware',
-        'Brave-Browser',
-        'User Data'
-      ),
-      chrome: pathApi.join(localAppData, 'Google', 'Chrome', 'User Data'),
-      chromium: pathApi.join(localAppData, 'Chromium', 'User Data'),
-      edge: pathApi.join(localAppData, 'Microsoft', 'Edge', 'User Data'),
-      firefox: pathApi.join(roamingAppData, 'Mozilla', 'Firefox'),
-    };
-    return roots[normalizedBrowser];
-  }
-  const roots = {
-    brave: pathApi.join(homeDir, '.config', 'BraveSoftware', 'Brave-Browser'),
-    chrome: pathApi.join(homeDir, '.config', 'google-chrome'),
-    chromium: pathApi.join(homeDir, '.config', 'chromium'),
-    edge: pathApi.join(homeDir, '.config', 'microsoft-edge'),
-    firefox: pathApi.join(homeDir, '.mozilla', 'firefox'),
-  };
-  return roots[normalizedBrowser];
+  const [root] = resolveBrowserRoots(browser, {
+    platform,
+    homeDir,
+    environment,
+  });
+  return root;
 }
 
 async function pathExists(filePath) {
@@ -100,7 +112,7 @@ function chromiumCookiePaths(profilePath, pathApi = path) {
 
 export async function findCookieDatabase(browser, profilePath, platform) {
   const pathApi = platformPath(platform ?? process.platform);
-  if (normalizeCookieBrowser(browser) === 'firefox') {
+  if (browserFamily(browser) === 'firefox') {
     const candidate = pathApi.join(profilePath, 'cookies.sqlite');
     return (await pathExists(candidate)) ? candidate : null;
   }
@@ -112,11 +124,38 @@ export async function findCookieDatabase(browser, profilePath, platform) {
   return null;
 }
 
+/** Default profile first, then by name. */
+function sortProfiles(profiles) {
+  return profiles.sort(
+    (left, right) =>
+      Number(right.isDefault) - Number(left.isDefault) ||
+      left.name.localeCompare(right.name)
+  );
+}
+
 async function listChromiumProfiles(browser, root, platform) {
   if (!(await pathExists(root))) {
     return [];
   }
   const pathApi = platformPath(platform);
+
+  // Opera-style browsers keep one profile in the root itself rather than in
+  // Default/Profile N subdirectories.
+  if (isSingleProfileBrowser(browser)) {
+    if (!(await findCookieDatabase(browser, root, platform))) {
+      return [];
+    }
+    return [
+      {
+        browser,
+        name: 'Default',
+        displayName: 'Default',
+        path: root,
+        isDefault: true,
+      },
+    ];
+  }
+
   const localState = await readJson(pathApi.join(root, 'Local State'));
   const infoCache = localState.profile?.info_cache ?? {};
   const names = new Set(Object.keys(infoCache));
@@ -150,11 +189,7 @@ async function listChromiumProfiles(browser, root, platform) {
         (names.size === 1 && name === 'Default'),
     });
   }
-  return profiles.sort(
-    (left, right) =>
-      Number(right.isDefault) - Number(left.isDefault) ||
-      left.name.localeCompare(right.name)
-  );
+  return sortProfiles(profiles);
 }
 
 function parseIni(text) {
@@ -176,7 +211,7 @@ function parseIni(text) {
   return sections;
 }
 
-async function listFirefoxProfiles(root, platform) {
+async function listFirefoxProfiles(browser, root, platform) {
   if (!(await pathExists(root))) {
     return [];
   }
@@ -215,23 +250,37 @@ async function listFirefoxProfiles(root, platform) {
       section.IsRelative === '0'
         ? section.Path
         : pathApi.resolve(relativeRoot, section.Path);
-    if (!(await findCookieDatabase('firefox', profilePath, platform))) {
+    if (!(await findCookieDatabase(browser, profilePath, platform))) {
       continue;
     }
     const displayName = section.Name ?? pathApi.basename(profilePath);
     profiles.push({
-      browser: 'firefox',
+      browser,
       name: displayName,
       displayName,
       path: profilePath,
       isDefault: section.Default === '1',
     });
   }
-  return profiles.sort(
-    (left, right) =>
-      Number(right.isDefault) - Number(left.isDefault) ||
-      left.name.localeCompare(right.name)
-  );
+  return sortProfiles(profiles);
+}
+
+async function listProfilesForBrowser(browser, platform, homeDir, environment) {
+  const roots = resolveBrowserRoots(browser, {
+    platform,
+    homeDir,
+    environment,
+  });
+  const family = browserFamily(browser);
+  const profiles = [];
+  for (const root of roots) {
+    profiles.push(
+      ...(family === 'firefox'
+        ? await listFirefoxProfiles(browser, root, platform)
+        : await listChromiumProfiles(browser, root, platform))
+    );
+  }
+  return profiles;
 }
 
 /** Discover cookie-bearing profiles from installed browsers. */
@@ -240,28 +289,45 @@ export async function listBrowserProfiles({
   platform = process.platform,
   homeDir = os.homedir(),
   environment = process.env,
+  runCommand,
 } = {}) {
   const browsers = browser
-    ? [normalizeCookieBrowser(browser)]
-    : SUPPORTED_COOKIE_BROWSERS;
+    ? [
+        await resolveSourceBrowser(browser, {
+          platform,
+          environment,
+          runCommand,
+        }),
+      ]
+    : BROWSER_IDS;
   const profiles = [];
+  // Several Firefox channels (firefox, firefox-developer, firefox-nightly)
+  // share one profile root, so a catalogue-wide scan would otherwise report
+  // the same profile under each id. Keep the first (canonical) browser.
+  const seen = new Set();
   for (const candidate of browsers) {
-    const root = browserProfileRoot(candidate, {
+    for (const profile of await listProfilesForBrowser(
+      candidate,
       platform,
       homeDir,
-      environment,
-    });
-    profiles.push(
-      ...(candidate === 'firefox'
-        ? await listFirefoxProfiles(root, platform)
-        : await listChromiumProfiles(candidate, root, platform))
-    );
+      environment
+    )) {
+      if (seen.has(profile.path)) {
+        continue;
+      }
+      seen.add(profile.path);
+      profiles.push(profile);
+    }
   }
   return profiles;
 }
 
 export async function resolveBrowserProfile(options) {
-  const browser = normalizeCookieBrowser(options.browser);
+  const browser = await resolveSourceBrowser(options.browser, {
+    platform: options.platform,
+    environment: options.environment,
+    runCommand: options.runCommand,
+  });
   const profiles = await listBrowserProfiles({ ...options, browser });
   const requested = options.profile;
   const selected = requested

package/src/browser/browser-sources.js

@@ -0,0 +1,184 @@
+/**
+ * Catalogue of installed browsers Browser Commander can import from (#114).
+ *
+ * The data lives in `browser-sources.json`, a shared asset Python and Rust
+ * duplicate byte-for-byte (checked by
+ * `scripts/check-shared-fingerprint-assets.sh`). This module turns that data
+ * into the lookups the rest of the browser code needs: canonical ids with
+ * their aliases, the per-platform profile roots, the Chromium Safe Storage
+ * identity, and the operating-system identifiers that mark a browser as the
+ * system default.
+ *
+ * Keeping it data-driven is what lets a single JSON edit add Opera, Vivaldi,
+ * Arc, a Firefox fork, or a Chrome channel to all three implementations at
+ * once, rather than touching hand-written per-platform maps in each language.
+ */
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const registry = JSON.parse(
+  readFileSync(new URL('./browser-sources.json', import.meta.url), 'utf8')
+);
+
+/**
+ * Every known browser, in catalogue order.
+ *
+ * @type {ReadonlyArray<object>}
+ */
+export const BROWSER_SOURCES = Object.freeze(
+  registry.browsers.map((browser) => Object.freeze(browser))
+);
+
+/** Canonical ids, in catalogue order. */
+export const BROWSER_IDS = Object.freeze(
+  BROWSER_SOURCES.map((browser) => browser.id)
+);
+
+const BY_NAME = new Map();
+for (const browser of BROWSER_SOURCES) {
+  BY_NAME.set(browser.id, browser);
+  for (const alias of browser.aliases ?? []) {
+    BY_NAME.set(alias, browser);
+  }
+}
+
+function platformPath(platform) {
+  return platform === 'win32' ? path.win32 : path;
+}
+
+/**
+ * Resolve a name (canonical id or alias) to its catalogue entry.
+ *
+ * @param {string} name
+ * @returns {object|undefined}
+ */
+export function findBrowserSource(name) {
+  if (typeof name !== 'string') {
+    return undefined;
+  }
+  return BY_NAME.get(name) ?? BY_NAME.get(name.toLowerCase());
+}
+
+/**
+ * Resolve a name to its canonical id, throwing a readable error otherwise.
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export function normalizeBrowserId(name) {
+  return normalizeBrowserSource(name).id;
+}
+
+/** The family ('chromium' or 'firefox') of a browser name. */
+export function browserFamily(name) {
+  return normalizeBrowserSource(name).family;
+}
+
+function normalizeBrowserSource(name) {
+  const source = findBrowserSource(name);
+  if (!source) {
+    throw new Error(
+      `Unsupported browser: ${name}. Expected one of ${BROWSER_IDS.join(', ')}`
+    );
+  }
+  return source;
+}
+
+function templateVariables(platform, homeDir, environment) {
+  const pathApi = platformPath(platform);
+  if (platform === 'darwin') {
+    return {
+      home: homeDir,
+      appSupport: pathApi.join(homeDir, 'Library', 'Application Support'),
+    };
+  }
+  if (platform === 'win32') {
+    return {
+      home: homeDir,
+      localAppData:
+        environment.LOCALAPPDATA ?? pathApi.join(homeDir, 'AppData', 'Local'),
+      appData:
+        environment.APPDATA ?? pathApi.join(homeDir, 'AppData', 'Roaming'),
+    };
+  }
+  return {
+    home: homeDir,
+    config: environment.XDG_CONFIG_HOME ?? pathApi.join(homeDir, '.config'),
+  };
+}
+
+function expandTemplate(template, variables, pathApi) {
+  const match = /^\{(\w+)\}(.*)$/.exec(template);
+  if (!match) {
+    return template;
+  }
+  const base = variables[match[1]];
+  if (base === undefined) {
+    return undefined;
+  }
+  const rest = match[2].split('/').filter(Boolean);
+  return pathApi.join(base, ...rest);
+}
+
+/**
+ * The absolute profile roots a browser uses on a platform. Returns an empty
+ * array when the browser does not run on that platform (for example Chrome
+ * Canary on Linux).
+ *
+ * @param {string} name
+ * @param {Object} [options]
+ * @param {string} [options.platform=process.platform]
+ * @param {string} [options.homeDir=os.homedir()]
+ * @param {Object} [options.environment=process.env]
+ * @returns {string[]}
+ */
+export function resolveBrowserRoots(
+  name,
+  {
+    platform = process.platform,
+    homeDir = os.homedir(),
+    environment = process.env,
+  } = {}
+) {
+  const source = normalizeBrowserSource(name);
+  const templates = source.roots?.[platform] ?? [];
+  const pathApi = platformPath(platform);
+  const variables = templateVariables(platform, homeDir, environment);
+  const roots = [];
+  for (const template of templates) {
+    const resolved = expandTemplate(template, variables, pathApi);
+    if (resolved !== undefined) {
+      roots.push(resolved);
+    }
+  }
+  return roots;
+}
+
+/** True when a browser stores one profile in the root itself (Opera-style). */
+export function isSingleProfileBrowser(name) {
+  return normalizeBrowserSource(name).singleProfile === true;
+}
+
+/**
+ * The Chromium Safe Storage identity for a browser, or undefined for a
+ * Firefox-family browser (which does not use OSCrypt).
+ *
+ * @param {string} name
+ * @returns {{service: string, application: string, folder: string}|undefined}
+ */
+export function safeStorageIdentity(name) {
+  return normalizeBrowserSource(name).safeStorage;
+}
+
+/**
+ * The operating-system identifiers that mark a browser as the system default:
+ * macOS bundle ids, Linux `.desktop` file names, or Windows ProgIds.
+ *
+ * @param {string} name
+ * @param {string} platform
+ * @returns {string[]}
+ */
+export function defaultBrowserIdentifiers(name, platform) {
+  return normalizeBrowserSource(name).default?.[platform] ?? [];
+}