browser-commander 0.21.2 → 0.22.0

package/tests/unit/browser/cookie-sources.test.js

@@ -0,0 +1,146 @@
+// feature-parity: sources.cookie-listing@native-typed
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  listCookieSources,
+  resolveImportSource,
+} from '../../../src/browser/browser-cookies.js';
+import { writeFirefoxProfile } from '../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../helpers/temp-directory.js';
+
+const makeDirectory = useTempDirectories();
+
+describe('listCookieSources', () => {
+  it('reports cookie counts per profile without reading values', async () => {
+    const temporaryDirectory = await makeDirectory('bc-src-');
+    const profilePath = await writeFirefoxProfile(temporaryDirectory, [
+      { name: 'a', value: 'secret-1', host: '.example.com' },
+      { name: 'b', value: 'secret-2', host: '.example.com' },
+      { name: 'c', value: 'secret-3', host: '.other.test' },
+    ]);
+
+    const sources = await listCookieSources({
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+    });
+
+    assert.equal(sources.length, 1);
+    const [source] = sources;
+    assert.equal(source.browser, 'firefox');
+    assert.equal(source.path, profilePath);
+    assert.equal(source.cookies, 3);
+    assert.equal(source.byDomain, null);
+    // Never expose a value anywhere in the payload.
+    assert.ok(!JSON.stringify(sources).includes('secret-'));
+  });
+
+  it('counts per domain and omits profiles that hold none', async () => {
+    const temporaryDirectory = await makeDirectory('bc-src2-');
+    await writeFirefoxProfile(temporaryDirectory, [
+      { name: 'a', value: '1', host: '.example.com' },
+      { name: 'b', value: '2', host: '.example.com' },
+    ]);
+
+    const matched = await listCookieSources({
+      domains: ['example.com'],
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+    });
+    assert.equal(matched.length, 1);
+    assert.deepEqual(matched[0].byDomain, { 'example.com': 2 });
+
+    const none = await listCookieSources({
+      domains: ['absent.test'],
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+    });
+    assert.deepEqual(none, []);
+  });
+});
+
+describe('resolveImportSource', () => {
+  // feature-parity: sources.default-domain-fallback@native-typed
+  const firefoxIsDefault = async () => 'firefox.desktop\n';
+  const githubCookie = [{ name: 'a', value: '1', host: '.github.com' }];
+  const otherCookie = [{ name: 'b', value: '2', host: '.other.test' }];
+
+  async function resolve(homeDir, overrides = {}) {
+    return await resolveImportSource({
+      browser: 'default',
+      domains: ['github.com'],
+      platform: 'linux',
+      homeDir,
+      environment: {},
+      runCommand: firefoxIsDefault,
+      ...overrides,
+    });
+  }
+
+  it('keeps the system default when it holds the domains', async () => {
+    const homeDir = await makeDirectory('bc-import-default-');
+    await writeFirefoxProfile(homeDir, githubCookie);
+    await writeFirefoxProfile(homeDir, githubCookie, {
+      root: '.librewolf',
+      name: 'default',
+    });
+
+    assert.deepEqual(await resolve(homeDir), {
+      browser: 'firefox',
+      profile: 'default-release',
+      warning: null,
+    });
+  });
+
+  it('falls back to the installed browser that holds the domains', async () => {
+    const homeDir = await makeDirectory('bc-import-fallback-');
+    await writeFirefoxProfile(homeDir, otherCookie);
+    await writeFirefoxProfile(homeDir, githubCookie, {
+      root: '.librewolf',
+      name: 'default',
+    });
+
+    const source = await resolve(homeDir);
+    assert.equal(source.browser, 'librewolf');
+    assert.equal(source.profile, 'default');
+    assert.equal(source.warning.reason, 'default-browser-fallback');
+    assert.equal(source.warning.item, 'librewolf');
+    assert.match(
+      source.warning.detail,
+      /default browser \(firefox\) holds no cookies for github\.com; imported from librewolf/
+    );
+  });
+
+  it('falls back when the system default cannot be determined', async () => {
+    const homeDir = await makeDirectory('bc-import-unknown-');
+    await writeFirefoxProfile(homeDir, githubCookie, {
+      root: '.librewolf',
+      name: 'default',
+    });
+    const runCommand = async () => {
+      throw new Error('no xdg');
+    };
+
+    const source = await resolve(homeDir, { runCommand });
+    assert.equal(source.browser, 'librewolf');
+    assert.equal(source.warning.reason, 'default-browser-unknown');
+    await assert.rejects(
+      resolve(await makeDirectory('bc-import-none-'), { runCommand }),
+      /no installed browser holds cookies for github\.com/
+    );
+  });
+
+  it('resolves the default plainly without domains', async () => {
+    const homeDir = await makeDirectory('bc-import-plain-');
+    assert.deepEqual(await resolve(homeDir, { domains: undefined }), {
+      browser: 'firefox',
+      profile: undefined,
+      warning: null,
+    });
+    assert.deepEqual(await resolve(homeDir, { browser: 'Opera' }), {
+      browser: 'opera',
+      profile: undefined,
+      warning: null,
+    });
+  });
+});

package/tests/unit/browser/default-browser.test.js

@@ -0,0 +1,121 @@
+// feature-parity: sources.default-browser@native-typed
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  browserForIdentifier,
+  parseMacLaunchServicesHandler,
+  parseWindowsProgId,
+  resolveDefaultBrowser,
+} from '../../../src/browser/default-browser.js';
+
+function runnerReturning(map) {
+  return async (command, args) => {
+    const key = [command, ...args].join(' ');
+    if (!(key in map)) {
+      throw new Error(`unexpected command: ${key}`);
+    }
+    return map[key];
+  };
+}
+
+describe('resolveDefaultBrowser', () => {
+  it('maps a macOS LaunchServices https handler to a browser id', async () => {
+    const output = `(
+      {
+        LSHandlerRoleAll = "com.apple.safari";
+        LSHandlerURLScheme = mailto;
+      },
+      {
+        LSHandlerRoleAll = "com.google.chrome";
+        LSHandlerURLScheme = https;
+      }
+    )`;
+    const runCommand = runnerReturning({
+      'defaults read com.apple.LaunchServices/com.apple.launchservices.secure LSHandlers':
+        output,
+    });
+    assert.equal(
+      await resolveDefaultBrowser({ platform: 'darwin', runCommand }),
+      'chrome'
+    );
+  });
+
+  it('maps a Linux xdg-settings .desktop name to a browser id', async () => {
+    const runCommand = runnerReturning({
+      'xdg-settings get default-web-browser': 'firefox.desktop\n',
+    });
+    assert.equal(
+      await resolveDefaultBrowser({ platform: 'linux', runCommand }),
+      'firefox'
+    );
+  });
+
+  it('falls back to xdg-mime when xdg-settings is unknown', async () => {
+    const runCommand = async (command, args) => {
+      const key = [command, ...args].join(' ');
+      if (key === 'xdg-settings get default-web-browser') {
+        return 'some-unknown.desktop\n';
+      }
+      if (key === 'xdg-mime query default x-scheme-handler/https') {
+        return 'brave-browser.desktop\n';
+      }
+      throw new Error(`unexpected command: ${key}`);
+    };
+    assert.equal(
+      await resolveDefaultBrowser({ platform: 'linux', runCommand }),
+      'brave'
+    );
+  });
+
+  it('maps a Windows UserChoice ProgId to a browser id', async () => {
+    const output = [
+      '',
+      'HKEY_CURRENT_USER\\...\\https\\UserChoice',
+      '    ProgId    REG_SZ    MSEdgeHTM',
+      '',
+    ].join('\r\n');
+    const runCommand = runnerReturning({
+      'reg query HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\https\\UserChoice /v ProgId':
+        output,
+    });
+    assert.equal(
+      await resolveDefaultBrowser({ platform: 'win32', runCommand }),
+      'edge'
+    );
+  });
+
+  it('returns null when nothing matches or the tool fails', async () => {
+    assert.equal(
+      await resolveDefaultBrowser({
+        platform: 'linux',
+        runCommand: async () => {
+          throw new Error('no xdg');
+        },
+      }),
+      null
+    );
+    assert.equal(
+      await resolveDefaultBrowser({
+        platform: 'sunos',
+        runCommand: async () => '',
+      }),
+      null
+    );
+  });
+
+  it('parses handler blocks and ProgId lines directly', () => {
+    assert.equal(
+      parseMacLaunchServicesHandler(
+        '{ LSHandlerURLScheme = https; LSHandlerRoleAll = "com.brave.browser"; }'
+      ),
+      'com.brave.browser'
+    );
+    assert.equal(
+      parseWindowsProgId('  ProgId   REG_SZ   FirefoxHTML'),
+      'FirefoxHTML'
+    );
+    assert.equal(browserForIdentifier('COM.GOOGLE.CHROME', 'darwin'), 'chrome');
+    assert.equal(browserForIdentifier('', 'darwin'), null);
+  });
+});

package/tests/unit/browser/migration/index.test.js

@@ -1,6 +1,6 @@
 // feature-parity: migration.profile@native-typed
 import assert from 'node:assert';
-import { readFile } from 'node:fs/promises';
+import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { describe, it } from 'node:test';
 
@@ -14,6 +14,8 @@ import {
   writeFirefoxCookies,
   writeFirefoxLogins,
   writeFirefoxPlaces,
+  writeFirefoxProfile,
+  writeProfileJson,
 } from '../../../helpers/migration-fixtures.js';
 import { useTempDirectories } from '../../../helpers/temp-directory.js';
 
@@ -114,4 +116,63 @@ describe('migrateProfile', () => {
     );
     assert.equal(report.warnings[0].reason, 'target-key-unavailable');
   });
+
+  it('imports a domain from whichever installed browser holds it', async () => {
+    const homeDir = await makeTempDir();
+    const target = await makeTempDir();
+    await writeFirefoxProfile(homeDir, [
+      { name: 'a', value: '1', host: '.other.test' },
+    ]);
+    await writeFirefoxProfile(
+      homeDir,
+      [{ name: 'session', value: 's', host: '.github.com' }],
+      { root: '.librewolf', name: 'default' }
+    );
+
+    const report = await migrateProfile({
+      from: { browser: 'default' },
+      to: target,
+      include: ['cookies'],
+      domains: ['github.com'],
+      platform: 'linux',
+      homeDir,
+      environment: {},
+      runCommand: async () => 'firefox.desktop\n',
+    });
+
+    assert.equal(report.source.browser, 'librewolf');
+    assert.equal(report.source.profile, 'default');
+    assert.equal(report.migrated.cookies, 1);
+    assert.deepEqual(
+      report.warnings.map(({ reason }) => reason),
+      ['default-browser-fallback']
+    );
+  });
+
+  it('reads a single-profile Chromium browser (Opera) from its root', async () => {
+    const homeDir = await makeTempDir();
+    const target = await makeTempDir();
+    const root = path.join(homeDir, '.config', 'opera');
+    await mkdir(root, { recursive: true });
+    await writeProfileJson(root, 'Bookmarks', {
+      roots: {
+        bookmark_bar: {
+          type: 'folder',
+          children: [{ type: 'url', name: 'A', url: 'https://a.example/' }],
+        },
+      },
+    });
+
+    const report = await migrateProfile({
+      from: { browser: 'opera' },
+      to: target,
+      include: ['bookmarks'],
+      platform: 'linux',
+      homeDir,
+      environment: {},
+    });
+
+    assert.equal(report.migrated.bookmarks, 1);
+    assert.deepEqual(report.skipped, []);
+  });
 });

package/tests/unit/cli/main.test.js

@@ -249,11 +249,38 @@ describe('runCli', () => {
       'a.test',
     ]);
 
-    assert.deepEqual(document.options, {
-      from: 'chrome',
-      include: ['cookies', 'bookmarks'],
-      domains: ['a.test'],
-    });
+    // The source browser is grouped under `from` so migrateProfile receives
+    // `from.browser` (a flat string here was a bug that threw).
+    assert.equal(document.options.from.browser, 'chrome');
+    assert.deepEqual(document.options.include, ['cookies', 'bookmarks']);
+    assert.deepEqual(document.options.domains, ['a.test']);
+  });
+
+  it('lists cookie sources with per-domain counts', async () => {
+    const { exitCode, document } = await cli([
+      'cookies',
+      'sources',
+      '--domain',
+      'example.com',
+    ]);
+
+    assert.equal(exitCode, 0);
+    assert.equal(document.sources[0].browser, 'chrome');
+    assert.equal(document.sources[0].cookies, 7);
+    assert.deepEqual(document.sources[0].byDomain, { 'example.com': 1 });
+  });
+
+  it('lists installed profiles for profile sources', async () => {
+    const { exitCode, document } = await cli([
+      'profile',
+      'sources',
+      '--browser',
+      'firefox',
+    ]);
+
+    assert.equal(exitCode, 0);
+    assert.equal(document.profiles[0].browser, 'firefox');
+    assert.equal(document.profiles[0].isDefault, true);
   });
 
   it('prints a profile snapshot report', async () => {

package/tests/unit/scripts/browser-support.test.js

@@ -0,0 +1,56 @@
+/**
+ * The generated importable-browser support matrix (issue #114).
+ *
+ * `scripts/generate-browser-support.mjs` turns the shared catalogue
+ * `js/src/browser/browser-sources.json` into the table between the
+ * `browser-support:generated` markers in README.md. These tests pin the
+ * rendering against a fixture catalogue, then pin the repository itself: the
+ * committed README must be what the generator writes, so a browser added to
+ * the JSON without regenerating fails CI.
+ */
+
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import { describe, it } from 'node:test';
+import { pathToFileURL } from 'node:url';
+
+import { repoPath } from '../../helpers/repo.js';
+
+const { BEGIN_MARKER, END_MARKER, readCatalogue, renderBrowserSupport } =
+  await import(pathToFileURL(repoPath('scripts/generate-browser-support.mjs')));
+
+describe('generate-browser-support', () => {
+  it('renders a row per browser with per-platform availability', () => {
+    const table = renderBrowserSupport([
+      {
+        id: 'chrome',
+        family: 'chromium',
+        roots: { darwin: ['a'], win32: ['b'], linux: ['c'] },
+      },
+      {
+        id: 'arc',
+        family: 'chromium',
+        roots: { darwin: ['a'], win32: ['b'] },
+      },
+      { id: 'firefox', family: 'firefox', roots: { linux: ['c'] } },
+    ]);
+    // Columns are padded the way Prettier formats Markdown tables.
+    const lines = table.split('\n');
+    assert.equal(lines[0], '| Browser | Family   | macOS | Windows | Linux |');
+    assert.equal(lines[2], '| chrome  | Chromium | Yes   | Yes     | Yes   |');
+    // A browser absent on a platform shows an em dash, not a blank cell.
+    assert.equal(lines[3], '| arc     | Chromium | Yes   | Yes     | —     |');
+    assert.equal(lines[4], '| firefox | Firefox  | —     | —       | Yes   |');
+  });
+
+  it('keeps the committed README in sync with the catalogue', () => {
+    const readme = fs
+      .readFileSync(repoPath('README.md'), 'utf8')
+      .replaceAll('\r\n', '\n');
+    const begin = readme.indexOf(BEGIN_MARKER);
+    const end = readme.indexOf(END_MARKER);
+    assert.ok(begin !== -1 && end > begin, 'README is missing the markers');
+    const between = readme.slice(begin + BEGIN_MARKER.length, end).trim();
+    assert.equal(between, renderBrowserSupport(readCatalogue(repoPath('.'))));
+  });
+});