browser-commander 0.23.0 → 0.25.0

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

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { it } from 'node:test';
+
+import {
+  ALL_DATA_CLASSES,
+  migrateProfile,
+} from '../../../../src/browser/migration/index.js';
+import { repoPath } from '../../../helpers/repo.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-data-classes-');
+const classes = JSON.parse(
+  await readFile(repoPath('tests/fixtures/migration-data-classes.json'), 'utf8')
+);
+
+it('requires an actual boolean for payment-card consent before target writes', async () => {
+  const target = path.join(await makeTempDir(), 'new-profile');
+  await assert.rejects(
+    migrateProfile({
+      from: { browser: 'chrome', userDataDir: await makeTempDir() },
+      to: target,
+      include: ['paymentCards'],
+      includePaymentCards: 'true',
+    }),
+    /must be a boolean/u
+  );
+  await assert.rejects(readFile(path.join(target, 'Web Data')), {
+    code: 'ENOENT',
+  });
+});
+
+it('reports consented payment cards as unsupported until a native writer exists', async () => {
+  const report = await migrateProfile({
+    from: { browser: 'chrome', userDataDir: await makeTempDir() },
+    to: path.join(await makeTempDir(), 'new-profile'),
+    include: ['paymentCards'],
+    includePaymentCards: true,
+  });
+  assert.equal(report.migrated.paymentCards, 0);
+  assert.equal(report.skipped[0].reason, 'data-class-not-supported');
+});
+
+for (const browser of ['chrome', 'firefox', 'safari']) {
+  it(`reports every selected additional data class for ${browser} without reading protected card data`, async () => {
+    const source = await makeTempDir();
+    const target = path.join(await makeTempDir(), 'new-profile');
+    const profile =
+      browser === 'chrome' ? path.join(source, 'Default') : source;
+    await mkdir(profile, { recursive: true });
+    const marker = Buffer.from(
+      'protected card store must remain unread and unchanged'
+    );
+    await writeFile(path.join(profile, 'Web Data'), marker);
+    const report = await migrateProfile({
+      from: { browser, userDataDir: source },
+      to: target,
+      include: classes.slice(6),
+      platform: 'darwin',
+    });
+    assert.deepEqual(ALL_DATA_CLASSES, classes);
+    assert.deepEqual(Object.keys(report.migrated), classes);
+    assert.ok(Object.values(report.migrated).every((count) => count === 0));
+    for (const type of classes.slice(6)) {
+      assert.ok(
+        report.skipped.some((entry) => entry.type === type),
+        type
+      );
+    }
+    assert.equal(
+      report.skipped.find(({ type }) => type === 'paymentCards').reason,
+      'payment-card-consent-required'
+    );
+    const passkeys = report.skipped.filter(({ type }) => type === 'passkeys');
+    assert.deepEqual(
+      passkeys.map(({ item }) => item),
+      ['iCloud Keychain', 'Google Password Manager', 'Windows Hello']
+    );
+    for (const entry of passkeys) {
+      assert.equal(entry.reason, 'passkey-not-exportable');
+      assert.match(entry.detail, /persistent profile/u);
+    }
+    await assert.rejects(readFile(path.join(target, 'Web Data')), {
+      code: 'ENOENT',
+    });
+    assert.deepEqual(await readFile(path.join(profile, 'Web Data')), marker);
+  });
+}

package/tests/unit/browser/migration/domain-isolation.test.js

@@ -0,0 +1,212 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import Database from 'better-sqlite3';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+import { migrateHistory } from '../../../../src/browser/migration/history.js';
+import { migratePasswords } from '../../../../src/browser/migration/passwords.js';
+import { encryptChromiumValue } from '../../../../src/browser/migration/chromium-crypto.js';
+import {
+  decryptChromiumCookie,
+  deriveChromiumCookieKey,
+} from '../../../../src/browser/browser-cookie-crypto.js';
+
+const temp = useTempDirectories('bc-domain-isolation-');
+describe('per-site domain isolation (#119)', () => {
+  for (const domains of [['github.com'], []]) {
+    it(`re-encrypts login notes and ${domains.length ? 'filters' : 'preserves'} domain metadata`, async () => {
+      const source = await temp();
+      const target = await temp();
+      const sourceKey = randomBytes(16);
+      const targetKey = randomBytes(16);
+      const sourcePath = path.join(source, 'Login Data');
+      const db = new Database(sourcePath);
+      db.exec(
+        await readFile(
+          new URL(
+            '../../../../../tests/fixtures/password-domain-isolation.sql',
+            import.meta.url
+          ),
+          'utf8'
+        )
+      );
+      const encrypted = (plaintext) =>
+        encryptChromiumValue({
+          plaintext,
+          key: sourceKey,
+          platform: 'linux',
+          prefix: 'v11',
+        });
+      db.prepare('UPDATE logins SET password_value=? WHERE id IN (7,8)').run(
+        encrypted('password')
+      );
+      const sourceNote = encrypted('private note ☃');
+      db.prepare(
+        'UPDATE password_notes SET value=? WHERE id IN (70,71,72)'
+      ).run(sourceNote);
+      db.close();
+      const original = await readFile(sourcePath);
+      const report = await migratePasswords({
+        sourceProfileDir: source,
+        targetProfileDir: target,
+        domains,
+        platform: 'linux',
+        resolveSourceKey: () => sourceKey,
+        targetKey,
+      });
+      const filtered = domains.length > 0;
+      assert.equal(report.migrated, filtered ? 1 : 2);
+      const copy = new Database(path.join(target, 'Login Data'));
+      try {
+        assert.deepEqual(
+          copy.prepare('SELECT parent_id FROM insecure_credentials').all(),
+          filtered ? [{ parent_id: 7 }] : [{ parent_id: 7 }, { parent_id: 8 }]
+        );
+        assert.deepEqual(
+          copy.prepare('SELECT origin_domain FROM stats').all(),
+          filtered
+            ? [{ origin_domain: 'https://github.com' }]
+            : [
+                { origin_domain: 'https://github.com' },
+                { origin_domain: 'https://notgithub.com' },
+              ]
+        );
+        const notes = copy
+          .prepare(
+            'SELECT id,value,date_created,confidential FROM password_notes'
+          )
+          .all();
+        assert.equal(notes.length, filtered ? 1 : 2);
+        assert.equal(notes[0].id, 70);
+        assert.equal(notes[0].date_created, 123);
+        assert.equal(notes[0].confidential, 1);
+        for (const note of notes) {
+          assert.equal(
+            decryptChromiumCookie({
+              encryptedValue: note.value,
+              databaseVersion: 0,
+              platform: 'linux',
+              key: targetKey,
+            }),
+            'private note ☃'
+          );
+        }
+        for (const table of [
+          'sync_entities_metadata',
+          'sync_model_metadata',
+          'future_password_metadata',
+        ]) {
+          const preserved = table === 'future_password_metadata' && !filtered;
+          assert.equal(
+            copy.prepare(`SELECT count(*) AS n FROM ${table}`).get().n,
+            preserved ? 1 : 0,
+            table
+          );
+          assert.equal(
+            report.warnings.some((warning) => warning.item === table),
+            !preserved
+          );
+        }
+        assert.ok(
+          report.skipped.some(
+            (entry) =>
+              entry.item === 'password_notes/73' &&
+              entry.reason === 'app-bound-v20'
+          )
+        );
+      } finally {
+        copy.close();
+      }
+      const bytes = await readFile(path.join(target, 'Login Data'));
+      assert.equal(bytes.includes(Buffer.from('unrelated-sync-marker')), false);
+      assert.equal(
+        bytes.includes(Buffer.from('unrelated-future-marker')),
+        !filtered
+      );
+      assert.equal(bytes.includes(sourceNote), false);
+      assert.deepEqual(await readFile(sourcePath), original);
+    });
+  }
+
+  it('excludes unrelated history URLs, their visits, and Top Sites', async () => {
+    const source = await temp();
+    const target = await temp();
+    const db = new Database(path.join(source, 'History'));
+    db.exec(
+      await readFile(
+        new URL(
+          '../../../../../tests/fixtures/history-domain-isolation.sql',
+          import.meta.url
+        ),
+        'utf8'
+      )
+    );
+    db.close();
+    await migrateHistory({
+      sourceProfileDir: source,
+      targetProfileDir: target,
+      domains: ['github.com'],
+    });
+    const copy = new Database(path.join(target, 'History'));
+    try {
+      assert.equal(copy.prepare('SELECT count(*) AS n FROM urls').get().n, 1);
+      assert.equal(copy.prepare('SELECT count(*) AS n FROM visits').get().n, 1);
+      for (const table of [
+        'content_annotations',
+        'context_annotations',
+        'segment_usage',
+        'downloads',
+        'downloads_url_chains',
+        'downloads_slices',
+      ]) {
+        assert.equal(
+          copy.prepare(`SELECT count(*) AS n FROM ${table}`).get().n,
+          1,
+          table
+        );
+      }
+    } finally {
+      copy.close();
+    }
+  });
+
+  it('filters passwords before decryption and removes undecryptable source values', async () => {
+    const source = await temp();
+    const target = await temp();
+    const key = deriveChromiumCookieKey('source', 'linux');
+    const db = new Database(path.join(source, 'Login Data'));
+    db.exec('CREATE TABLE logins(origin_url TEXT, password_value BLOB)');
+    const insert = db.prepare('INSERT INTO logins VALUES (?,?)');
+    insert.run(
+      'https://github.com',
+      encryptChromiumValue({
+        plaintext: 'secret',
+        key,
+        platform: 'linux',
+        prefix: 'v11',
+      })
+    );
+    insert.run('https://notgithub.com', Buffer.from('v20unreadable'));
+    insert.run('https://locked.github.com', Buffer.from('v20unreadable'));
+    db.close();
+    const report = await migratePasswords({
+      sourceProfileDir: source,
+      targetProfileDir: target,
+      domains: ['github.com'],
+      platform: 'linux',
+      resolveSourceKey: () => key,
+      targetKey: key,
+    });
+    assert.equal(report.migrated, 1);
+    const copy = new Database(path.join(target, 'Login Data'));
+    try {
+      assert.deepEqual(copy.prepare('SELECT origin_url FROM logins').all(), [
+        { origin_url: 'https://github.com' },
+      ]);
+    } finally {
+      copy.close();
+    }
+  });
+});

package/tests/unit/browser/migration/firefox-history.test.js

@@ -0,0 +1,130 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { it } from 'node:test';
+
+import BetterSqlite3 from 'better-sqlite3';
+
+import { migrateProfile } from '../../../../src/browser/migration/index.js';
+import { repoPath } from '../../../helpers/repo.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-ff-history-');
+const schema = await readFile(
+  repoPath('tests/fixtures/firefox-history.sql'),
+  'utf8'
+);
+
+async function importHistory({ sql = schema, domains = [] } = {}) {
+  const source = await makeTempDir();
+  const target = path.join(await makeTempDir(), 'new-profile');
+  const filename = path.join(source, 'places.sqlite');
+  const db = new BetterSqlite3(filename);
+  try {
+    db.exec(sql);
+  } finally {
+    db.close();
+  }
+  const before = await readFile(filename);
+  const report = await migrateProfile({
+    from: { browser: 'firefox', userDataDir: source },
+    to: target,
+    include: ['history'],
+    domains,
+  });
+  assert.deepEqual(await readFile(filename), before);
+  return { report, target };
+}
+
+for (const domains of [[], ['GITHUB.COM.']]) {
+  it(`translates Firefox visits with ${domains.length ? 'exact domain filtering' : 'all domains'}`, async () => {
+    const { report, target } = await importHistory({ domains });
+    const count = domains.length ? 3 : 4;
+    assert.equal(report.migrated.history, count);
+    assert.deepEqual(report.skipped, []);
+    assert.equal(
+      report.warnings[0].reason,
+      'firefox-history-metadata-not-translated'
+    );
+    const db = new BetterSqlite3(path.join(target, 'History'), {
+      readonly: true,
+    });
+    try {
+      const rows = db
+        .prepare(
+          'SELECT url,title,visit_count,last_visit_time FROM urls ORDER BY url'
+        )
+        .safeIntegers()
+        .all();
+      assert.deepEqual(rows.slice(0, 2), [
+        {
+          url: 'https://docs.github.com/second',
+          title: '',
+          visit_count: 1n,
+          last_visit_time: 13344473600000003n,
+        },
+        {
+          url: 'https://github.com/first',
+          title: 'First Ω',
+          visit_count: 2n,
+          last_visit_time: 13344473600000002n,
+        },
+      ]);
+      const times = db
+        .prepare('SELECT visit_time FROM visits ORDER BY visit_time')
+        .safeIntegers()
+        .all();
+      assert.deepEqual(
+        times.map(({ visit_time }) => visit_time),
+        [
+          13344473600000001n,
+          13344473600000002n,
+          13344473600000003n,
+          13344473600000004n,
+        ].slice(0, count)
+      );
+    } finally {
+      db.close();
+    }
+    await assert.rejects(readFile(path.join(target, 'places.sqlite')), {
+      code: 'ENOENT',
+    });
+  });
+}
+
+it('reports a missing Firefox visit table before creating the target', async () => {
+  const { report, target } = await importHistory({
+    sql: 'CREATE TABLE moz_places (id INTEGER PRIMARY KEY, url TEXT, title TEXT)',
+  });
+  assert.equal(report.migrated.history, 0);
+  assert.equal(report.skipped[0].reason, 'source-format-unsupported');
+  assert.match(report.skipped[0].detail, /moz_historyvisits/u);
+  await assert.rejects(readFile(path.join(target, 'History')), {
+    code: 'ENOENT',
+  });
+});
+
+for (const [field, values] of [
+  [
+    'timestamp',
+    ['NULL', "'invalid'", '1.5', '-11644473600000001', '9223372036854775807'],
+  ],
+  ['url', ['NULL', "''", "x'0102'"]],
+]) {
+  it(`reports invalid visit ${field} without losing valid visits`, async () => {
+    for (const value of values) {
+      const extra =
+        field === 'timestamp'
+          ? `INSERT INTO moz_historyvisits VALUES (5,1,${value},1)`
+          : `INSERT INTO moz_places VALUES (5,${value},'Invalid'); INSERT INTO moz_historyvisits VALUES (5,5,1700000000000005,1)`;
+      const { report } = await importHistory({
+        sql: `${schema}\n${extra}`,
+        domains: ['github.com'],
+      });
+      assert.equal(report.migrated.history, 3);
+      assert.equal(report.skipped.length, 1);
+      assert.equal(report.skipped[0].reason, `invalid-history-${field}`);
+      assert.equal(report.skipped[0].item, 'places.sqlite visit 5');
+    }
+  });
+}

package/tests/unit/browser/migration/history-metadata.test.js

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { it } from 'node:test';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+import { migrateHistory } from '../../../../src/browser/migration/history.js';
+
+const temporary = useTempDirectories('bc-history-metadata-');
+for (const domains of [['github.com'], []]) {
+  it(`${domains.length ? 'omits with warnings' : 'preserves'} derived history metadata`, async () => {
+    const source = await temporary();
+    const target = await temporary();
+    const filename = path.join(source, 'History');
+    const db = new Database(filename);
+    db.exec(
+      await readFile(
+        new URL(
+          '../../../../../tests/fixtures/history-opaque-metadata.sql',
+          import.meta.url
+        ),
+        'utf8'
+      )
+    );
+    db.close();
+    const before = await readFile(filename);
+    const report = await migrateHistory({
+      sourceProfileDir: source,
+      targetProfileDir: target,
+      domains,
+    });
+    assert.equal(report.migrated, 1);
+    const copy = new Database(path.join(target, 'History'));
+    try {
+      for (const [table, unfilteredCount] of [
+        ['clusters', 2],
+        ['clusters_and_visits', 3],
+        ['cluster_keywords', 2],
+        ['cluster_visit_duplicates', 2],
+        ['future "history" metadata', 1],
+      ]) {
+        const quoted = `"${table.replaceAll('"', '""')}"`;
+        const count = copy
+          .prepare(`SELECT count(*) AS n FROM ${quoted}`)
+          .get().n;
+        assert.equal(count, domains.length ? 0 : unfilteredCount, table);
+        assert.equal(
+          report.warnings.some(
+            (entry) =>
+              entry.item === table &&
+              entry.reason === 'unsupported-history-metadata'
+          ),
+          Boolean(domains.length)
+        );
+      }
+      assert.equal(
+        copy.prepare('SELECT count(*) AS n FROM urls').get().n,
+        domains.length ? 1 : 2
+      );
+      assert.equal(
+        copy.prepare('SELECT value FROM meta WHERE key=?').get('version').value,
+        70
+      );
+    } finally {
+      copy.close();
+    }
+    const bytes = await readFile(path.join(target, 'History'));
+    assert.equal(
+      bytes.includes(Buffer.from('unrelated-history-marker')),
+      !domains.length
+    );
+    assert.deepEqual(await readFile(filename), before);
+  });
+}

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

@@ -67,7 +67,7 @@ describe('migrateProfile', () => {
     assert.equal(report.migrated.cookies, 1);
     assert.equal(report.migrated.bookmarks, 1);
     assert.equal(report.migrated.passwords, 1);
-    // Firefox history cannot be migrated into Chrome's schema.
+    // This bookmark-only fixture has no Firefox visit table.
     assert.equal(report.migrated.history, 0);
     assert.equal(report.migrated.preferences, 0);
     assert.equal(report.migrated.extensions, 0);
@@ -97,6 +97,21 @@ describe('migrateProfile', () => {
     await assert.rejects(() => readFile(path.join(target, 'Login Data')));
   });
 
+  it('reports unsupported Firefox preferences and extensions explicitly', async () => {
+    const report = await migrateProfile({
+      from: { browser: 'firefox', userDataDir: await makeTempDir() },
+      to: await makeTempDir(),
+      include: ['preferences', 'extensions'],
+    });
+    assert.deepEqual(
+      report.skipped.map(({ type, reason }) => [type, reason]),
+      [
+        ['preferences', 'firefox-class-not-supported'],
+        ['extensions', 'firefox-class-not-supported'],
+      ]
+    );
+  });
+
   it('skips passwords with a warning when no target key is available on Windows', async () => {
     const source = await makeTempDir();
     const target = await makeTempDir();

package/tests/unit/browser/migration/opera-keys.test.js

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'node:test';
+import { localStatePathForProfile } from '../../../../src/browser/migration/os-crypt-keys.js';
+
+it('uses Opera single-profile Local State before a parent fallback', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'bc-opera-'));
+  try {
+    const profile = path.join(root, 'Opera Stable');
+    await mkdir(profile);
+    await writeFile(path.join(root, 'Local State'), '{}');
+    await writeFile(path.join(profile, 'Local State'), '{"os_crypt":{}}');
+    assert.equal(
+      localStatePathForProfile(profile),
+      path.join(profile, 'Local State')
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});