browser-commander 0.23.0 → 0.25.0

package/tests/unit/browser/migration/safari-data.test.js

@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import { readFile, copyFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { describe, it } from 'node:test';
+import {
+  readSafariBookmarks,
+  readSafariHistory,
+  readSafariPasswords,
+} from '../../../../src/browser/migration/safari.js';
+import { migrateProfile } from '../../../../src/browser/migration/index.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+import Database from 'better-sqlite3';
+import path from 'node:path';
+import {
+  deriveChromiumCookieKey,
+  decryptChromiumCookie,
+} from '../../../../src/browser/browser-cookie-crypto.js';
+
+const fixture = (name) =>
+  fileURLToPath(
+    new URL(
+      `../../../../../tests/fixtures/safari-data/${name}`,
+      import.meta.url
+    )
+  );
+
+describe('Safari data sources', () => {
+  for (const format of ['binary', 'xml']) {
+    it(`preserves hierarchy and reading list from ${format} plist`, async () => {
+      const filename = fixture(`Bookmarks-${format}.plist`);
+      const before = await readFile(filename);
+      const tree = await readSafariBookmarks(filename);
+      assert.equal(tree[0].name, 'Work');
+      assert.equal(tree[0].children[0].name, 'Foundation ☃');
+      assert.equal(tree[1].children[0].readingList, true);
+      assert.deepEqual(await readFile(filename), before);
+    });
+  }
+
+  it('preserves all matching visits and converts the Cocoa epoch', async () => {
+    const filename = fixture('History.db');
+    const before = await readFile(filename);
+    const entries = await readSafariHistory(filename, ['github.com']);
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].time, 1778307200250000);
+    assert.deepEqual(await readFile(filename), before);
+  });
+
+  it('reads explicit BOM UTF-8 CSV with quoted newlines and filters domains', async () => {
+    const entries = await readSafariPasswords(fixture('Passwords.csv'), [
+      'github.com',
+    ]);
+    assert.deepEqual(entries, [
+      {
+        origin: 'https://github.com/login',
+        username: 'a,b',
+        password: 'p"a\nss',
+      },
+    ]);
+  });
+
+  const temporary = useTempDirectories('bc-safari-data-');
+  it('rejects password CSV records with missing or extra fields without changing the source', async () => {
+    for (const record of [
+      'https://github.com,a\n',
+      'https://github.com,a,b,c\n',
+    ]) {
+      const filename = path.join(await temporary(), 'Passwords.csv');
+      await writeFile(filename, `URL,Username,Password\n${record}`);
+      const before = await readFile(filename);
+      await assert.rejects(
+        readSafariPasswords(filename),
+        /Invalid Record Length/u
+      );
+      assert.deepEqual(await readFile(filename), before);
+    }
+  });
+
+  it('migrates custom Safari sources into native Chromium stores with target encryption', async () => {
+    const source = await temporary();
+    const target = await temporary();
+    await copyFile(
+      fixture('Bookmarks-binary.plist'),
+      path.join(source, 'Bookmarks.plist')
+    );
+    await copyFile(fixture('History.db'), path.join(source, 'History.db'));
+    const key = deriveChromiumCookieKey('dedicated-target', 'linux');
+    const report = await migrateProfile({
+      from: { browser: 'safari', userDataDir: source },
+      to: target,
+      include: ['bookmarks', 'history', 'passwords'],
+      domains: ['github.com'],
+      passwordCsv: fixture('Passwords.csv'),
+      platform: 'linux',
+      keys: { targetKey: key, targetPrefix: 'v11' },
+    });
+    assert.equal(report.migrated.bookmarks, 2);
+    assert.equal(report.migrated.history, 2);
+    assert.equal(report.migrated.passwords, 1);
+    assert.deepEqual(report.skipped, []);
+    assert.ok(
+      report.warnings.some(
+        ({ reason }) => reason === 'safari-reading-list-translated'
+      )
+    );
+    const db = new Database(path.join(target, 'Login Data'));
+    try {
+      const rows = db
+        .prepare('SELECT origin_url,password_value FROM logins')
+        .all();
+      assert.equal(rows.length, 1);
+      assert.equal(
+        decryptChromiumCookie({
+          encryptedValue: rows[0].password_value,
+          key,
+          platform: 'linux',
+          databaseVersion: 0,
+          host: 'github.com',
+        }),
+        'p"a\nss'
+      );
+    } finally {
+      db.close();
+    }
+  });
+
+  it('names the executing app and retry link for non-cookie protection failures', async () => {
+    const { withSafariAccess } =
+      await import('../../../../src/browser/safari-access.js');
+    for (const code of ['EPERM', 'EACCES']) {
+      await assert.rejects(
+        withSafariAccess(
+          '/Safari/History.db',
+          () => {
+            throw Object.assign(new Error('protected'), { code });
+          },
+          { TERM_PROGRAM: 'FixtureTerminal' }
+        ),
+        /Full Disk Access to FixtureTerminal.*Privacy_AllFiles/u
+      );
+    }
+  });
+});

package/tests/unit/browser/migration/sqlite-snapshot.test.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert';
-import { stat } from 'node:fs/promises';
+import { stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
 import { describe, it } from 'node:test';
 
 import BetterSqlite3 from 'better-sqlite3';
@@ -58,6 +59,60 @@ describe('withDatabaseSnapshot', () => {
       /does not exist/
     );
   });
+
+  it('does not substitute an unverified file copy when backup fails', async () => {
+    const sourcePath = path.join(await makeTempDir(), 'History');
+    await writeFile(sourcePath, 'not a SQLite database');
+    let readerCalled = false;
+    await assert.rejects(
+      withDatabaseSnapshot({
+        sourcePath,
+        read: () => {
+          readerCalled = true;
+        },
+      }),
+      /Consistent SQLite snapshot unavailable.*close the source browser/iu
+    );
+    assert.equal(readerCalled, false);
+  });
+
+  it(
+    'reports guidance for an exclusive lock without invoking the reader',
+    { timeout: 5000 },
+    async () => {
+      const sourcePath = await makeDatabase(1);
+      const writer = new BetterSqlite3(sourcePath);
+      writer.exec('BEGIN EXCLUSIVE');
+      try {
+        await assert.rejects(
+          withDatabaseSnapshot({
+            sourcePath,
+            read: () => assert.fail('locked snapshot reader invoked'),
+          }),
+          /Consistent SQLite snapshot unavailable.*close the source browser/iu
+        );
+      } finally {
+        writer.exec('ROLLBACK');
+        writer.close();
+      }
+    }
+  );
+
+  it('includes committed WAL records while the source connection stays open', async () => {
+    const sourcePath = await makeDatabase(1);
+    const writer = new BetterSqlite3(sourcePath);
+    writer.pragma('journal_mode = WAL');
+    writer.prepare('UPDATE urls SET title = ?').run('committed WAL title');
+    try {
+      const title = await readDatabaseSnapshot({
+        sourcePath,
+        read: (db) => db.prepare('SELECT title FROM urls').get().title,
+      });
+      assert.equal(title, 'committed WAL title');
+    } finally {
+      writer.close();
+    }
+  });
 });
 
 describe('readDatabaseSnapshot', () => {

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

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict';
+import { readdir } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { migrateProfile } from '../../../../src/browser/migration/index.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const temporary = useTempDirectories('bc-validation-');
+
+describe('migration validation before target mutation', () => {
+  it('rejects unknown classes and invalid domain filters', async () => {
+    for (const options of [
+      { include: ['invented'] },
+      { domains: ['https://example.com'] },
+    ]) {
+      const target = await temporary();
+      await assert.rejects(
+        migrateProfile({ from: { browser: 'chrome' }, to: target, ...options })
+      );
+      assert.deepEqual(await readdir(target), []);
+    }
+  });
+
+  it('rejects unsupported target layouts before creating Chromium files', async () => {
+    const target = await temporary();
+    await assert.rejects(
+      migrateProfile({
+        from: { browser: 'chrome' },
+        to: target,
+        include: ['bookmarks'],
+        targetBrowser: 'firefox',
+      }),
+      /target/u
+    );
+    assert.deepEqual(await readdir(target), []);
+  });
+
+  it('rejects detection-only sources before target mutation', async () => {
+    const source = await temporary();
+    const target = await temporary();
+    await assert.rejects(
+      migrateProfile({
+        from: { browser: 'duckduckgo', userDataDir: source },
+        to: target,
+        include: ['history'],
+      }),
+      /detection/u
+    );
+    assert.deepEqual(await readdir(target), []);
+  });
+
+  it('rejects a target that overlaps the source profile', async () => {
+    const source = await temporary();
+    await assert.rejects(
+      migrateProfile({
+        from: { browser: 'opera', userDataDir: source },
+        to: source,
+        include: ['bookmarks'],
+      }),
+      /overlap/u
+    );
+    assert.deepEqual(await readdir(source), []);
+  });
+});

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

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import { it } from 'node:test';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+import { migrateProfile } from '../../../../src/browser/migration/index.js';
+import { encryptChromiumValue } from '../../../../src/browser/migration/chromium-crypto.js';
+import { readMigratedLogins } from '../../../helpers/migration-fixtures.js';
+
+const temporary = useTempDirectories('bc-yandex-');
+function migrateYandexPasswords(source, to, options = {}) {
+  return migrateProfile({
+    from: { browser: 'yandex', userDataDir: source },
+    to,
+    include: ['passwords'],
+    ...options,
+  });
+}
+
+it('identifies Ya Passman Data before prompting for target credentials', async () => {
+  const source = await temporary();
+  const target = await temporary();
+  await mkdir(path.join(source, 'Default'));
+  const db = new Database(path.join(source, 'Default', 'Ya Passman Data'));
+  db.exec(
+    "CREATE TABLE meta(key TEXT,value BLOB); INSERT INTO meta VALUES('local_encryptor_data',x'01')"
+  );
+  db.close();
+  const report = await migrateYandexPasswords(source, target);
+  assert.equal(report.migrated.passwords, 0);
+  assert.equal(
+    report.skipped[0].reason,
+    'yandex-passman-encryption-unsupported'
+  );
+  assert.match(
+    report.skipped[0].detail,
+    /local_encryptor_data.*master password/u
+  );
+});
+
+it('retains supported Login Data beside unsupported Ya Passman Data', async () => {
+  const source = await temporary();
+  const target = await temporary();
+  const profile = path.join(source, 'Default');
+  await mkdir(profile);
+  const passman = path.join(profile, 'Ya Passman Data');
+  await writeFile(passman, 'unsupported-store');
+  const sourceKey = randomBytes(16);
+  const targetKey = randomBytes(16);
+  const loginData = path.join(profile, 'Login Data');
+  const db = new Database(loginData);
+  db.exec(
+    'CREATE TABLE logins(origin_url TEXT,username_value TEXT,password_value BLOB)'
+  );
+  db.prepare('INSERT INTO logins VALUES(?,?,?)').run(
+    'https://example.com',
+    'alice',
+    encryptChromiumValue({
+      plaintext: 'retained-password',
+      key: sourceKey,
+      platform: 'linux',
+      prefix: 'v11',
+    })
+  );
+  db.close();
+  const original = await readFile(loginData);
+  const report = await migrateYandexPasswords(source, target, {
+    platform: 'linux',
+    keys: { targetKey, resolveSourceKey: () => sourceKey },
+  });
+  assert.equal(report.migrated.passwords, 1);
+  assert.equal(
+    report.skipped[0].reason,
+    'yandex-passman-encryption-unsupported'
+  );
+  assert.equal(
+    readMigratedLogins(target, targetKey)[0].password,
+    'retained-password'
+  );
+  assert.deepEqual(await readFile(loginData), original);
+  assert.equal(await readFile(passman, 'utf8'), 'unsupported-store');
+});

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

@@ -203,6 +203,21 @@ describe('launchAndConnectRealBrowser', () => {
     }
   });
 
+  it('rejects non-CDP catalogue browsers before resolving or spawning them', async () => {
+    for (const channel of ['firefox', 'librewolf', 'safari', 'duckduckgo']) {
+      await assert.rejects(
+        launchAndConnectRealBrowserWithDependencies(
+          { channel },
+          {
+            resolveExecutable: () =>
+              assert.fail('non-CDP executable resolution reached'),
+          }
+        ),
+        /does not support CDP/u
+      );
+    }
+  });
+
   it('spawns, waits, connects, and returns process metadata', async () => {
     temporaryDirectory = await makeDedicatedProfile();
     const calls = [];
@@ -285,6 +300,8 @@ describe('launchAndConnectRealBrowser', () => {
           profile: 'Default',
           include: ['cookies', 'bookmarks'],
           domains: ['google.com'],
+          passwordCsv: '/tmp/safari-export.csv',
+          includePaymentCards: true,
         },
       },
       {
@@ -330,6 +347,8 @@ describe('launchAndConnectRealBrowser', () => {
     assert.equal(migrateOptions.targetBrowser, 'chrome');
     assert.deepEqual(migrateOptions.include, ['cookies', 'bookmarks']);
     assert.deepEqual(migrateOptions.domains, ['google.com']);
+    assert.equal(migrateOptions.passwordCsv, '/tmp/safari-export.csv');
+    assert.equal(migrateOptions.includePaymentCards, true);
     assert.deepEqual(migrateOptions.from, {
       browser: 'chrome',
       profile: 'Default',

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/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');
   });
@@ -272,7 +276,7 @@ describe('dispatcher: high-level methods', () => {
     await assert.rejects(dispatcher.dispatch('nope'), { code: -32601 });
     await assert.rejects(dispatcher.dispatch('version', []), { code: -32602 });
     await assert.rejects(
-      dispatcher.dispatch('session.launch', { engine: 'selenium' }),
+      dispatcher.dispatch('session.launch', { engine: 'unknown' }),
       { code: -32602 }
     );
     await assert.rejects(
@@ -351,7 +355,7 @@ describe('dispatcher: generic handle methods', () => {
       'launched with puppeteer'
     );
     await assert.rejects(
-      dispatcher.dispatch('handle.root', { name: 'selenium' }),
+      dispatcher.dispatch('handle.root', { name: 'unknown' }),
       { code: -32602 }
     );
   });

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 () => {