browser-commander 0.21.2 → 0.23.0

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

@@ -0,0 +1,150 @@
+import assert from 'node:assert';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+
+import {
+  listBrowserProfiles,
+  resolveBrowserProfile,
+  resolveSourceBrowser,
+} from '../../../src/browser/browser-profiles.js';
+import { writeFirefoxProfile } from '../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../helpers/temp-directory.js';
+
+const makeDirectory = useTempDirectories();
+
+/** The browser of every profile `listBrowserProfiles` finds. */
+async function listedBrowsers(options) {
+  const profiles = await listBrowserProfiles(options);
+  return profiles.map((profile) => profile.browser);
+}
+
+async function writeChromiumCookieDatabase(profilePath) {
+  const cookiePath = path.join(profilePath, 'Network', 'Cookies');
+  await mkdir(path.dirname(cookiePath), { recursive: true });
+  await writeFile(cookiePath, 'SQLite format 3\u0000');
+  return cookiePath;
+}
+
+describe('listBrowserProfiles with the expanded catalogue', () => {
+  it('reads an Opera single-profile layout from the root itself', async () => {
+    const temporaryDirectory = await makeDirectory('bc-opera-');
+    const root = path.join(temporaryDirectory, '.config', 'opera');
+    await mkdir(root, { recursive: true });
+    const cookiePath = await writeChromiumCookieDatabase(root);
+
+    const profiles = await listBrowserProfiles({
+      browser: 'opera',
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+      environment: {},
+    });
+
+    assert.deepEqual(profiles, [
+      {
+        browser: 'opera',
+        name: 'Default',
+        displayName: 'Default',
+        path: root,
+        isDefault: true,
+      },
+    ]);
+    assert.ok(cookiePath.startsWith(root));
+  });
+
+  it('discovers a Firefox fork (LibreWolf) by its own root', async () => {
+    const temporaryDirectory = await makeDirectory('bc-librewolf-');
+    const profilePath = await writeFirefoxProfile(
+      temporaryDirectory,
+      [{ name: 'a', value: '1', host: '.example.com' }],
+      { root: '.librewolf', name: 'default' }
+    );
+
+    const profiles = await listBrowserProfiles({
+      browser: 'librewolf',
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+    });
+
+    assert.deepEqual(profiles, [
+      {
+        browser: 'librewolf',
+        name: 'default',
+        displayName: 'default',
+        path: profilePath,
+        isDefault: true,
+      },
+    ]);
+  });
+
+  it('lists Firefox once when its channels share a root', async () => {
+    const temporaryDirectory = await makeDirectory('bc-ffshare-');
+    await writeFirefoxProfile(temporaryDirectory, [
+      { name: 'a', value: '1', host: '.example.com' },
+    ]);
+
+    assert.deepEqual(
+      await listedBrowsers({ platform: 'linux', homeDir: temporaryDirectory }),
+      ['firefox']
+    );
+  });
+
+  it('resolves browser: "default" to the system default browser', async () => {
+    const runCommand = async (command, args) => {
+      if (
+        command === 'xdg-settings' &&
+        args.join(' ') === 'get default-web-browser'
+      ) {
+        return 'firefox.desktop\n';
+      }
+      throw new Error('unexpected command');
+    };
+    assert.equal(
+      await resolveSourceBrowser('default', { platform: 'linux', runCommand }),
+      'firefox'
+    );
+    assert.equal(
+      await resolveSourceBrowser('AUTO', { platform: 'linux', runCommand }),
+      'firefox'
+    );
+  });
+
+  it('lists the default browser profile when browser is "default"', async () => {
+    const temporaryDirectory = await makeDirectory('bc-default-');
+    const profilePath = await writeFirefoxProfile(temporaryDirectory, [
+      { name: 'a', value: '1', host: '.example.com' },
+    ]);
+    const runCommand = async () => 'firefox.desktop\n';
+
+    const resolved = await resolveBrowserProfile({
+      browser: 'default',
+      platform: 'linux',
+      homeDir: temporaryDirectory,
+      runCommand,
+    });
+    assert.equal(resolved.browser, 'firefox');
+    assert.equal(resolved.path, profilePath);
+
+    assert.deepEqual(
+      await listedBrowsers({
+        browser: 'auto',
+        platform: 'linux',
+        homeDir: temporaryDirectory,
+        runCommand,
+      }),
+      ['firefox']
+    );
+  });
+
+  it('reports a clear error when the default browser is unknown', async () => {
+    await assert.rejects(
+      resolveSourceBrowser('default', {
+        platform: 'linux',
+        runCommand: async () => {
+          throw new Error('no xdg');
+        },
+      }),
+      /Could not determine the system default browser/
+    );
+  });
+});

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

@@ -0,0 +1,154 @@
+// feature-parity: sources.catalogue@native-typed
+import assert from 'node:assert';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+
+import {
+  BROWSER_IDS,
+  browserFamily,
+  defaultBrowserIdentifiers,
+  findBrowserSource,
+  isSingleProfileBrowser,
+  normalizeBrowserId,
+  resolveBrowserRoots,
+  safeStorageIdentity,
+} from '../../../src/browser/browser-sources.js';
+
+describe('browser-sources catalogue', () => {
+  it('keeps the original five browsers resolvable by id and alias', () => {
+    assert.equal(normalizeBrowserId('chrome'), 'chrome');
+    assert.equal(normalizeBrowserId('msedge'), 'edge');
+    assert.equal(normalizeBrowserId('microsoft-edge'), 'edge');
+    assert.equal(normalizeBrowserId('google-chrome'), 'chrome');
+    assert.equal(normalizeBrowserId('CHROME'), 'chrome');
+  });
+
+  it('adds the new source browsers from #114', () => {
+    for (const id of [
+      'opera',
+      'opera-gx',
+      'vivaldi',
+      'arc',
+      'yandex',
+      'chrome-beta',
+      'chrome-dev',
+      'chrome-canary',
+      'edge-beta',
+      'edge-dev',
+      'librewolf',
+      'waterfox',
+      'zen',
+      'floorp',
+      'firefox-developer',
+      'firefox-nightly',
+    ]) {
+      assert.ok(BROWSER_IDS.includes(id), `missing ${id}`);
+      assert.ok(findBrowserSource(id), `unresolvable ${id}`);
+    }
+  });
+
+  it('rejects an unknown browser with the catalogue listed', () => {
+    assert.throws(
+      () => normalizeBrowserId('netscape'),
+      /Unsupported browser: netscape\. Expected one of .*chrome/
+    );
+  });
+
+  it('classifies browser families', () => {
+    assert.equal(browserFamily('chrome'), 'chromium');
+    assert.equal(browserFamily('opera'), 'chromium');
+    assert.equal(browserFamily('firefox'), 'firefox');
+    assert.equal(browserFamily('librewolf'), 'firefox');
+  });
+
+  // POSIX targets join with the host separator, so a Windows host running
+  // these Linux/macOS cases yields backslashes, like every other path here.
+  it('expands per-platform roots with the home directory', () => {
+    assert.deepEqual(
+      resolveBrowserRoots('chrome', {
+        platform: 'linux',
+        homeDir: '/home/me',
+        environment: {},
+      }),
+      [path.join('/home/me', '.config', 'google-chrome')]
+    );
+    assert.deepEqual(
+      resolveBrowserRoots('firefox', {
+        platform: 'darwin',
+        homeDir: '/Users/me',
+      }),
+      [path.join('/Users/me', 'Library', 'Application Support', 'Firefox')]
+    );
+  });
+
+  it('honours XDG_CONFIG_HOME on Linux', () => {
+    assert.deepEqual(
+      resolveBrowserRoots('chromium', {
+        platform: 'linux',
+        homeDir: '/home/me',
+        environment: { XDG_CONFIG_HOME: '/cfg' },
+      }),
+      [path.join('/cfg', 'chromium')]
+    );
+  });
+
+  it('builds Windows roots with backslashes from %APPDATA%/%LOCALAPPDATA%', () => {
+    assert.deepEqual(
+      resolveBrowserRoots('opera', {
+        platform: 'win32',
+        homeDir: 'C:\\Users\\me',
+        environment: { APPDATA: 'C:\\Users\\me\\AppData\\Roaming' },
+      }),
+      ['C:\\Users\\me\\AppData\\Roaming\\Opera Software\\Opera Stable']
+    );
+    assert.deepEqual(
+      resolveBrowserRoots('chrome', {
+        platform: 'win32',
+        homeDir: 'C:\\Users\\me',
+        environment: { LOCALAPPDATA: 'C:\\Users\\me\\AppData\\Local' },
+      }),
+      ['C:\\Users\\me\\AppData\\Local\\Google\\Chrome\\User Data']
+    );
+  });
+
+  it('returns no root where a browser does not run', () => {
+    assert.deepEqual(
+      resolveBrowserRoots('chrome-canary', {
+        platform: 'linux',
+        homeDir: '/home/me',
+      }),
+      []
+    );
+    assert.deepEqual(
+      resolveBrowserRoots('arc', { platform: 'linux', homeDir: '/home/me' }),
+      []
+    );
+  });
+
+  it('marks Opera-style browsers as single-profile', () => {
+    assert.equal(isSingleProfileBrowser('opera'), true);
+    assert.equal(isSingleProfileBrowser('opera-gx'), true);
+    assert.equal(isSingleProfileBrowser('chrome'), false);
+    assert.equal(isSingleProfileBrowser('vivaldi'), false);
+  });
+
+  it('exposes a Safe Storage identity for Chromium and none for Firefox', () => {
+    assert.deepEqual(safeStorageIdentity('brave'), {
+      service: 'Brave Safe Storage',
+      application: 'brave',
+      folder: 'Brave Keys',
+    });
+    assert.equal(safeStorageIdentity('firefox'), undefined);
+  });
+
+  it('exposes default-browser identifiers per platform', () => {
+    assert.deepEqual(defaultBrowserIdentifiers('chrome', 'darwin'), [
+      'com.google.chrome',
+    ]);
+    assert.deepEqual(defaultBrowserIdentifiers('firefox', 'win32'), [
+      'FirefoxHTML',
+      'FirefoxURL',
+    ]);
+    assert.deepEqual(defaultBrowserIdentifiers('chrome', 'nope'), []);
+  });
+});

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, []);
+  });
 });