browser-commander 0.24.0 → 0.26.0

package/tests/unit/browser/safari-cookies.test.js

@@ -49,6 +49,22 @@ async function installed(browser = 'safari', legacy = false) {
 }
 
 describe('Safari cookies', { timeout: 10000 }, () => {
+  it('uses whole domains for discovery while retaining reader substring filters', async () => {
+    const options = await installed();
+    const sources = await listCookieSources({
+      ...options,
+      domains: ['hub.com', 'github.co'],
+    });
+    assert.deepEqual(sources, []);
+    assert.deepEqual(
+      await readBrowserCookiesWithDependencies(
+        { browser: 'safari', domainFilter: 'hub.com', cache: false },
+        options
+      ),
+      expected.slice(0, 2)
+    );
+  });
+
   it('decodes multiple pages, flags, UTF-8 and Apple epoch without guessing session cookies', () => {
     assert.deepEqual(parseSafariCookies(fixture), expected);
   });
@@ -133,7 +149,16 @@ describe('Safari cookies', { timeout: 10000 }, () => {
     });
     assert.deepEqual(report.cookies, expected.slice(0, 2));
     assert.equal(report.migrated.cookies, 2);
-    assert.equal(report.skipped.length, 5);
+    const classes = JSON.parse(
+      await readFile(
+        repoPath('tests/fixtures/migration-data-classes.json'),
+        'utf8'
+      )
+    );
+    assert.deepEqual(
+      new Set(report.skipped.map((entry) => entry.type)),
+      new Set(classes.filter((type) => type !== 'cookies'))
+    );
     assert.equal(
       report.skipped.find((entry) => entry.type === 'passwords').reason,
       'safari-password-export-required'

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

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict';
+import { copyFile, mkdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { it } from 'node:test';
+import Database from 'better-sqlite3';
+import { listBrowserProfiles } from '../../../src/browser/browser-profiles.js';
+import { listCookieSources } from '../../../src/browser/browser-cookies.js';
+import { findSafariCookieFile } from '../../../src/browser/safari-cookies.js';
+import { repoPath } from '../../helpers/repo.js';
+import { useTempDirectories } from '../../helpers/temp-directory.js';
+
+const temporary = useTempDirectories('bc-safari-stores-');
+const uuid = '11111111-2222-3333-4444-555555555555';
+
+it('discovers Safari named profiles and prefers WebKit stores to stale legacy cookies', async () => {
+  const homeDir = await temporary();
+  const root = path.join(
+    homeDir,
+    'Library/Containers/com.apple.Safari/Data/Library'
+  );
+  const named = path.join(root, 'Safari/Profiles', uuid);
+  await mkdir(named, { recursive: true });
+  const db = new Database(path.join(root, 'Safari/SafariTabs.db'));
+  db.exec(
+    await readFile(
+      repoPath('tests/fixtures/safari-data/SafariTabs.sql'),
+      'utf8'
+    )
+  );
+  db.close();
+  const locations = [
+    'Cookies',
+    'WebKit/WebsiteData/Default/Cookies',
+    `WebKit/WebsiteDataStore/${uuid}/Cookies`,
+  ];
+  for (const location of locations) {
+    await mkdir(path.join(root, location), { recursive: true });
+    await copyFile(
+      repoPath('tests/fixtures/safari/Cookies.binarycookies'),
+      path.join(root, location, 'Cookies.binarycookies')
+    );
+  }
+  const profiles = await listBrowserProfiles({
+    browser: 'safari',
+    platform: 'darwin',
+    homeDir,
+    environment: {},
+  });
+  assert.deepEqual(
+    profiles.map(({ name }) => name),
+    ['Default', uuid]
+  );
+  assert.equal(profiles[1].displayName, 'Work');
+  assert.equal(profiles[1].path, named);
+  assert.equal(
+    await findSafariCookieFile(root),
+    path.join(root, locations[1], 'Cookies.binarycookies')
+  );
+  assert.equal(
+    await findSafariCookieFile(named),
+    path.join(root, locations[2], 'Cookies.binarycookies')
+  );
+});
+
+it('preserves a Safari catalogue error while listing its readable cookies and other browsers', async () => {
+  const homeDir = await temporary();
+  const root = path.join(
+    homeDir,
+    'Library/Containers/com.apple.Safari/Data/Library'
+  );
+  await mkdir(path.join(root, 'Safari'), { recursive: true });
+  await mkdir(path.join(root, 'Cookies'));
+  await copyFile(
+    repoPath('tests/fixtures/safari/Cookies.binarycookies'),
+    path.join(root, 'Cookies/Cookies.binarycookies')
+  );
+  const tabs = path.join(root, 'Safari/SafariTabs.db');
+  new Database(tabs).close();
+  const chromium = path.join(
+    homeDir,
+    'Library/Application Support/Google/Chrome/Default'
+  );
+  await mkdir(chromium, { recursive: true });
+  const db = new Database(path.join(chromium, 'Cookies'));
+  db.exec(
+    "CREATE TABLE cookies(host_key TEXT); INSERT INTO cookies VALUES ('.github.com')"
+  );
+  db.close();
+  const before = await readFile(tabs);
+  const options = { platform: 'darwin', homeDir, environment: {} };
+  const profiles = await listBrowserProfiles(options);
+  assert.equal(
+    profiles.filter(({ browser }) => browser === 'safari').length,
+    2
+  );
+  const sources = await listCookieSources({
+    ...options,
+    domains: ['github.com'],
+  });
+  assert.equal(sources.find(({ browser }) => browser === 'chrome').cookies, 1);
+  assert.equal(
+    sources.find(({ browser, error }) => browser === 'safari' && !error)
+      .cookies,
+    4
+  );
+  assert.match(
+    sources.find(({ browser, error }) => browser === 'safari' && error).error,
+    /no such table/u
+  );
+  assert.deepEqual(await readFile(tabs), before);
+});

package/tests/unit/browser/safari.test.js

@@ -0,0 +1,192 @@
+// feature-parity: safari.control@native-typed safari.setup@native-typed safari.seed@native-typed safari.unsupported@native-typed
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import vm from 'node:vm';
+import { findBrowserSource } from '../../../src/browser/browser-sources.js';
+import {
+  buildDriverServerArgs,
+  resolveWebDriverExecutable,
+} from '../../../src/browser/webdriver.js';
+import {
+  WebDriverPage,
+  createWebDriverPage,
+} from '../../../src/core/webdriver-page.js';
+import { createMockDriver } from '../../helpers/webdriver-mocks.js';
+import { launchBrowserWithDependencies } from '../../../src/browser/launcher.js';
+import { launchAndConnectRealBrowserWithDependencies } from '../../../src/browser/real-browser.js';
+import {
+  SafariSetupError,
+  SafariUnsupportedError,
+  safariLaunchError,
+  openSafariSettings,
+} from '../../../src/browser/safari-support.js';
+import { startTrace } from '../../../src/traces/recorder.js';
+import {
+  buildLaunchOptions,
+  sessionFromLaunch,
+} from '../../../src/cli/sessions.js';
+
+it('catalogue exposes both Safari WebDriver executables', () => {
+  for (const channel of ['safari', 'safari-tp']) {
+    const source = findBrowserSource(channel);
+    assert.equal(source.controlProtocol, 'webdriver');
+    assert.ok(source.executables.darwin[0].endsWith('/safaridriver'));
+  }
+});
+
+it('Safari channels route real/common launch and CLI to Selenium and seed cookies', async () => {
+  for (const launch of [
+    launchBrowserWithDependencies,
+    launchAndConnectRealBrowserWithDependencies,
+  ]) {
+    const driver = createMockDriver({
+      capabilities: { browserName: 'safari' },
+    });
+    const page = await createWebDriverPage(driver);
+    let calls = 0;
+    const launched = await launch(
+      {
+        channel: 'safari-tp',
+        seedCookies: [
+          {
+            name: 'auth',
+            value: 'yes',
+            domain: '.example.test',
+            secure: true,
+            httpOnly: true,
+            expires: -1,
+          },
+        ],
+      },
+      {
+        launchWebDriver: async (options) => {
+          calls++;
+          assert.equal(options.browser, 'safari-technology-preview');
+          return {
+            driver,
+            page,
+            close: () => driver.quit(),
+            driverPath: '/Safari TP/safaridriver',
+          };
+        },
+        resolveExecutable: () => assert.fail('Safari must bypass CDP'),
+        resolveSystem: () =>
+          assert.fail('Safari must bypass Chromium resolution'),
+      }
+    );
+    assert.equal(calls, 1);
+    assert.equal(launched.engine, 'selenium');
+    assert.equal(launched.browser, driver);
+    assert.equal(driver.state.url, 'about:blank');
+    assert.ok(
+      driver.calls.some(
+        ([method, url]) => method === 'get' && url === 'https://example.test'
+      )
+    );
+    assert.ok(
+      driver.calls.some(
+        ([method, cookie]) => method === 'addCookie' && cookie.httpOnly
+      )
+    );
+    assert.equal(sessionFromLaunch('playwright', launched).engine, 'selenium');
+    await launched.close();
+  }
+  assert.equal(buildLaunchOptions({ browser: 'safari' }).channel, 'safari');
+});
+
+it('Safari fails unsupported launch options before starting and page features before writes', async () => {
+  for (const options of [
+    { headless: true },
+    { userDataDir: '/tmp/profile' },
+    { args: ['--flag'] },
+    { fingerprint: {} },
+    { downloads: true },
+  ]) {
+    await assert.rejects(
+      () =>
+        launchBrowserWithDependencies(
+          { channel: 'safari', ...options },
+          { launchWebDriver: () => assert.fail('must reject before starting') }
+        ),
+      SafariUnsupportedError
+    );
+  }
+  const page = new WebDriverPage(createMockDriver(), { browserName: 'safari' });
+  await assert.rejects(
+    () => page.pdf(),
+    (error) =>
+      error instanceof SafariUnsupportedError && error.feature === 'PDF'
+  );
+  await assert.rejects(
+    () => page.setRequestInterception(true),
+    SafariUnsupportedError
+  );
+  await assert.rejects(
+    () => startTrace({ page, output: '/must-not-create' }),
+    SafariUnsupportedError
+  );
+});
+
+it('Safari async evaluation uses execute/async and returns rejected promises as errors', async () => {
+  const driver = createMockDriver();
+  let mode = 'success';
+  driver.executeAsyncScript = (source, ...args) =>
+    new Promise((resolve) => {
+      vm.runInNewContext(`(function(){${source}}).apply(null, args)`, {
+        args: [...args, resolve],
+        location: { href: 'https://example.test' },
+        setTimeout,
+        mode,
+      });
+    });
+  const page = new WebDriverPage(driver, { browserName: 'safari' });
+  assert.equal(await page.evaluateAsync(async (value) => value + 1, 4), 5);
+  mode = 'error';
+  await assert.rejects(
+    () =>
+      page.evaluateAsync(async () => {
+        throw new Error('rejected');
+      }),
+    /rejected/
+  );
+});
+
+it('setup errors identify both authorization steps and offer an explicit settings opener', async () => {
+  for (const message of [
+    "You must enable the 'Allow Remote Automation' option",
+    'safaridriver requires --enable authorization',
+  ]) {
+    const error = safariLaunchError(
+      new Error(message),
+      'safari-technology-preview'
+    );
+    assert.ok(error instanceof SafariSetupError);
+    assert.match(error.message, /Show features for web developers/);
+    assert.match(error.message, /admin password/);
+    assert.match(error.message, /Safari Technology Preview.app/);
+    assert.equal(typeof error.openSettings, 'function');
+  }
+  const other = new Error('port already in use');
+  assert.equal(safariLaunchError(other, 'safari'), other);
+  let argv;
+  await openSafariSettings({
+    channel: 'safari-tp',
+    platform: 'darwin',
+    run: async (file, args) => {
+      assert.equal(file, 'osascript');
+      argv = args;
+    },
+  });
+  assert.ok(argv.some((arg) => arg.includes('Safari Technology Preview')));
+});
+
+it('Safari uses its bundled driver and the native --port argument', async () => {
+  assert.deepEqual(buildDriverServerArgs('safari', 12345), ['--port', '12345']);
+  const result = await resolveWebDriverExecutable({
+    browser: 'safari',
+    platform: 'darwin',
+    checkAccess: async () => {},
+    runCommand: () => assert.fail('Safari needs no Selenium Manager'),
+  });
+  assert.equal(result.driverPath, '/usr/bin/safaridriver');
+});

package/tests/unit/browser/webdriver.test.js

@@ -92,7 +92,7 @@ function createMockSelenium(driver = createMockDriver()) {
     record,
     driver,
     selenium: {
-      webdriver: { Builder },
+      webdriver: { Builder, Capabilities: Options },
       chrome: {
         Options: class extends Options {
           constructor() {
@@ -265,8 +265,8 @@ describe('resolveWebDriverExecutable', () => {
 
   it('rejects browsers it has no driver for', async () => {
     await assert.rejects(
-      () => resolveWebDriverExecutable({ browser: 'safari' }),
-      /Unsupported WebDriver browser: safari/
+      () => resolveWebDriverExecutable({ browser: 'unknown-browser' }),
+      /Unsupported WebDriver browser: unknown-browser/
     );
   });
 });
@@ -446,6 +446,51 @@ describe('launchWebDriver', () => {
   });
 });
 
+function safariDependencies() {
+  return launchDependencies({
+    platform: 'darwin',
+    checkAccess: async () => {},
+  });
+}
+
+describe('Safari driver lifecycle', () => {
+  it('uses no disk profile or Chromium/BiDi capabilities and closes idempotently', async () => {
+    const { dependencies, started, mock } = safariDependencies();
+    mock.driver.state.url = '';
+    const result = await launchWebDriver(
+      { browser: 'safari-technology-preview' },
+      dependencies
+    );
+    assert.equal(result.page.url(), 'about:blank');
+    assert.equal(result.userDataDir, undefined);
+    assert.equal(result.temporaryProfile, false);
+    assert.equal(
+      mock.record.builders[0].capabilities.capabilities.browserName,
+      'Safari Technology Preview'
+    );
+    assert.deepEqual(started[0].args, ['--port', '41001']);
+    assert.match(started[0].file, /Safari Technology Preview.app/);
+    await Promise.all([result.close(), result.close()]);
+    assert.equal(
+      mock.driver.calls.filter(([name]) => name === 'quit').length,
+      1
+    );
+    assert.ok(started[0].child.killed);
+  });
+
+  it('cleans up the driver if Safari authorization fails', async () => {
+    const { dependencies, started, mock } = safariDependencies();
+    mock.selenium.webdriver.Builder.prototype.build = () => {
+      throw new Error("You must enable the 'Allow Remote Automation' option");
+    };
+    await assert.rejects(
+      () => launchWebDriver({ browser: 'safari' }, dependencies),
+      (error) => error.code === 'SAFARI_SETUP_REQUIRED'
+    );
+    assert.ok(started[0].child.killed);
+  });
+});
+
 describe('connectWebDriver', () => {
   it('opens a session on a running server with the given capabilities', async () => {
     const mock = createMockSelenium();

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

@@ -182,8 +182,12 @@ describe('dispatcher: high-level methods', () => {
     const migrated = await dispatch('profile.migrate', {
       from: 'chrome',
       include: ['cookies'],
+      passwordCsv: '/tmp/export.csv',
+      includePaymentCards: true,
     });
     assert.deepEqual(migrated.options.include, ['cookies']);
+    assert.equal(migrated.options.passwordCsv, '/tmp/export.csv');
+    assert.equal(migrated.options.includePaymentCards, true);
     assert.deepEqual(await dispatch('doctor', {}), { ok: true, unlisted: [] });
     assert.equal((await dispatch('version')).language, 'js');
   });
@@ -276,7 +280,7 @@ describe('dispatcher: high-level methods', () => {
       { code: -32602 }
     );
     await assert.rejects(
-      dispatcher.dispatch('session.launch', { browser: 'safari' }),
+      dispatcher.dispatch('session.launch', { browser: 'unknown-browser' }),
       { code: -32602 }
     );
     await assert.rejects(dispatcher.dispatch('page.goto', { url: 'x' }), {

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

@@ -247,6 +247,9 @@ describe('runCli', () => {
       'cookies, bookmarks',
       '--domain',
       'a.test',
+      '--password-csv',
+      '/tmp/export.csv',
+      '--include-payment-cards',
     ]);
 
     // The source browser is grouped under `from` so migrateProfile receives
@@ -254,6 +257,8 @@ describe('runCli', () => {
     assert.equal(document.options.from.browser, 'chrome');
     assert.deepEqual(document.options.include, ['cookies', 'bookmarks']);
     assert.deepEqual(document.options.domains, ['a.test']);
+    assert.equal(document.options.passwordCsv, '/tmp/export.csv');
+    assert.equal(document.options.includePaymentCards, true);
   });
 
   it('lists cookie sources with per-domain counts', async () => {

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

@@ -16,12 +16,13 @@ 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')));
+const generator = 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([
+    const table = generator.renderBrowserSupport([
       {
         id: 'chrome',
         family: 'chromium',
@@ -47,10 +48,16 @@ describe('generate-browser-support', () => {
     const readme = fs
       .readFileSync(repoPath('README.md'), 'utf8')
       .replaceAll('\r\n', '\n');
-    const begin = readme.indexOf(BEGIN_MARKER);
-    const end = readme.indexOf(END_MARKER);
+    const begin = readme.indexOf(generator.BEGIN_MARKER);
+    const end = readme.indexOf(generator.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('.'))));
+    const between = readme
+      .slice(begin + generator.BEGIN_MARKER.length, end)
+      .trim();
+    const browsers = generator.readCatalogue(repoPath('.'));
+    assert.equal(
+      between,
+      `${generator.renderBrowserSupport(browsers)}\n\n${generator.renderBrowserControls(browsers)}`
+    );
   });
 });

package/tests/unit/scripts/check-pipeline-status.test.js

@@ -5,10 +5,12 @@
  * *failed*, and a run whose only casualty is a cancelled job is filed under
  * `cancelled` as well - run 24045269874 of this repository is one such run on
  * `main`. scripts/check-pipeline-status.sh is the only thing that looks at
- * that, so these tests pin the four readings it has to get right: a failure is
+ * that, so these tests pin the readings it has to get right: a failure is
  * always an error, a cancellation off the default branch is a warning, a
  * cancellation on the default branch is an error unless a newer run has already
  * taken over the branch head.
+ * Hosted-runner failures can report an undocumented abandoned result; it and
+ * other unexpected/missing results must fail on every branch.
  *
  * See docs/CI-TIMEOUT-BUDGETS.md.
  */
@@ -66,6 +68,36 @@ describe('check-pipeline-status.sh', { skip: !BASH_AVAILABLE }, () => {
     assert.match(output, /::error::Pipeline failed\. Failing jobs: lint/);
   });
 
+  for (const env of [
+    { IS_MAIN: 'false' },
+    { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: 'def' },
+  ]) {
+    it(`fails on an abandoned runner job with IS_MAIN=${env.IS_MAIN}`, () => {
+      // Hosted-runner acquisition failure in run 37362314527 left the macOS
+      // check cancelled, but GitHub sent "abandoned" to the needs context.
+      const { status, output } = runGate(
+        results({ lint: 'success', test: 'abandoned', release: 'skipped' }),
+        env
+      );
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(abandoned\)/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
+  for (const result of ['timed_out', null, undefined]) {
+    it(`rejects an unexpected result of ${result}`, () => {
+      const { status, output } = runGate(results({ test: result }));
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
   it('only warns about a cancellation off the default branch', () => {
     const { status, output } = runGate(results({ test: 'cancelled' }), {
       IS_MAIN: 'false',

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

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { it } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { repoPath } from '../../helpers/repo.js';
+import { ALL_DATA_CLASSES } from '../../../src/browser/migration/index.js';
+
+const { BEGIN_MARKER, END_MARKER, readCapabilities, renderMigrationSupport } =
+  await import(
+    pathToFileURL(repoPath('scripts/generate-migration-support.mjs'))
+  );
+it('generates each source/target/class cell and declares unsupported target writers', () => {
+  const capabilities = readCapabilities(repoPath('.'));
+  assert.deepEqual(ALL_DATA_CLASSES, capabilities.classes);
+  const table = renderMigrationSupport(capabilities);
+  assert.equal(table.split('\n').length, 11);
+  assert.match(table, /safari\s+\| chromium\s+\| seed\s+\| translate/u);
+  const doc = readFileSync(
+    repoPath('docs/profile-migration.md'),
+    'utf8'
+  ).replaceAll('\r\n', '\n');
+  assert.equal(
+    doc
+      .slice(
+        doc.indexOf(BEGIN_MARKER) + BEGIN_MARKER.length,
+        doc.indexOf(END_MARKER)
+      )
+      .trim(),
+    table
+  );
+});