browser-commander 0.20.0 → 0.21.0

package/tests/unit/browser/migration/os-crypt-keys.test.js

@@ -0,0 +1,95 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import path from 'node:path';
+
+import {
+  createSourceKeyResolver,
+  localStatePathForProfile,
+  resolveTargetKey,
+} from '../../../../src/browser/migration/os-crypt-keys.js';
+import { deriveChromiumCookieKey } from '../../../../src/browser/browser-cookie-crypto.js';
+
+describe('createSourceKeyResolver', () => {
+  it('uses the hardcoded key for Linux v10', async () => {
+    const resolve = createSourceKeyResolver({
+      browser: 'chromium',
+      platform: 'linux',
+    });
+    const key = await resolve('v10');
+    assert.deepEqual(key, deriveChromiumCookieKey('peanuts', 'linux'));
+  });
+
+  it('derives the Safe Storage key for Linux v11 and caches it', async () => {
+    let calls = 0;
+    const resolve = createSourceKeyResolver({
+      browser: 'chrome',
+      platform: 'linux',
+      readSafeStoragePassword: async () => {
+        calls += 1;
+        return 'keyring-pass';
+      },
+    });
+    const first = await resolve('v11');
+    const second = await resolve('v11');
+    assert.deepEqual(first, deriveChromiumCookieKey('keyring-pass', 'linux'));
+    assert.deepEqual(second, first);
+    assert.equal(calls, 1);
+  });
+
+  it('reads the Windows key from Local State', async () => {
+    const windowsKey = Buffer.alloc(32, 9);
+    const resolve = createSourceKeyResolver({
+      browser: 'chrome',
+      platform: 'win32',
+      localStatePath: '/fake/Local State',
+      readWindowsEncryptionKey: async ({ localStatePath }) => {
+        assert.equal(localStatePath, '/fake/Local State');
+        return windowsKey;
+      },
+    });
+    assert.deepEqual(await resolve('v10'), windowsKey);
+  });
+
+  it('derives the macOS Safe Storage key', async () => {
+    const resolve = createSourceKeyResolver({
+      browser: 'chrome',
+      platform: 'darwin',
+      readSafeStoragePassword: async () => 'mac-pass',
+    });
+    assert.deepEqual(
+      await resolve('v10'),
+      deriveChromiumCookieKey('mac-pass', 'darwin')
+    );
+  });
+});
+
+describe('resolveTargetKey', () => {
+  it('derives the launching profile key on macOS/Linux', async () => {
+    const result = await resolveTargetKey({
+      browser: 'chrome',
+      platform: 'linux',
+      readSafeStoragePassword: async () => 'target-pass',
+    });
+    assert.deepEqual(
+      result.key,
+      deriveChromiumCookieKey('target-pass', 'linux')
+    );
+    assert.equal(result.prefix, 'v11');
+  });
+
+  it('refuses to derive a Windows key', async () => {
+    await assert.rejects(
+      resolveTargetKey({ browser: 'chrome', platform: 'win32' }),
+      /createWindowsProfileKey/
+    );
+  });
+});
+
+describe('localStatePathForProfile', () => {
+  it('points at Local State next to the profile directory', () => {
+    assert.equal(
+      localStatePathForProfile('/root/google-chrome/Default'),
+      path.join('/root/google-chrome', 'Local State')
+    );
+  });
+});

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

@@ -0,0 +1,144 @@
+import assert from 'node:assert';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+
+import BetterSqlite3 from 'better-sqlite3';
+
+import { migratePasswords } from '../../../../src/browser/migration/passwords.js';
+import { encryptChromiumValue } from '../../../../src/browser/migration/chromium-crypto.js';
+import { deriveChromiumCookieKey } from '../../../../src/browser/browser-cookie-crypto.js';
+import {
+  assertNothingMigrated,
+  assertSourceUnchanged,
+  migrateBetween,
+  readMigratedLogins,
+} from '../../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories();
+
+function writeLoginData(dir, rows) {
+  const db = new BetterSqlite3(path.join(dir, 'Login Data'));
+  db.exec(
+    'CREATE TABLE logins (origin_url TEXT, username_value TEXT, password_value BLOB)'
+  );
+  const insert = db.prepare(
+    'INSERT INTO logins (origin_url, username_value, password_value) VALUES (?, ?, ?)'
+  );
+  for (const row of rows) {
+    insert.run(row.originUrl, row.username, row.passwordValue);
+  }
+  db.close();
+}
+
+// A source login whose password is encrypted with the Linux source key.
+function encryptedLogin({ originUrl, username, plaintext, key, prefix }) {
+  return {
+    originUrl,
+    username,
+    passwordValue: encryptChromiumValue({
+      plaintext,
+      key,
+      platform: 'linux',
+      prefix,
+    }),
+  };
+}
+
+// Migrate on Linux, decrypting the source with `sourceKey`.
+function migrateLinuxPasswords(source, target, { sourceKey, ...options }) {
+  return migrateBetween(migratePasswords, source, target, {
+    platform: 'linux',
+    resolveSourceKey: () => sourceKey,
+    ...options,
+  });
+}
+
+describe('migratePasswords', () => {
+  it('re-encrypts each password for the target key on Linux', async () => {
+    const source = await makeTempDir('bc-pw-src-');
+    const target = await makeTempDir('bc-pw-dst-');
+    const sourceKey = deriveChromiumCookieKey('source-pass', 'linux');
+    const targetKey = deriveChromiumCookieKey('target-pass', 'linux');
+
+    writeLoginData(source, [
+      encryptedLogin({
+        originUrl: 'https://a.example/login',
+        username: 'alice',
+        plaintext: 'secret-A',
+        key: sourceKey,
+        prefix: 'v11',
+      }),
+      encryptedLogin({
+        originUrl: 'https://b.example/login',
+        username: 'bob',
+        plaintext: 'secret-B',
+        key: sourceKey,
+        prefix: 'v10',
+      }),
+    ]);
+
+    const report = await migrateLinuxPasswords(source, target, {
+      sourceKey,
+      targetKey,
+      targetPrefix: 'v11',
+    });
+
+    assert.equal(report.migrated, 2);
+    assert.deepEqual(report.skipped, []);
+
+    const decrypted = readMigratedLogins(target, targetKey).map(
+      (login) => login.password
+    );
+    assert.deepEqual(decrypted, ['secret-A', 'secret-B']);
+  });
+
+  it('reports app-bound v20 passwords as skipped', async () => {
+    const source = await makeTempDir('bc-pw-src-');
+    const target = await makeTempDir('bc-pw-dst-');
+    const targetKey = deriveChromiumCookieKey('target-pass', 'linux');
+    writeLoginData(source, [
+      {
+        originUrl: 'https://locked.example/login',
+        username: 'carol',
+        passwordValue: Buffer.concat([Buffer.from('v20'), Buffer.alloc(32, 1)]),
+      },
+    ]);
+
+    const report = await migrateLinuxPasswords(source, target, {
+      sourceKey: targetKey,
+      targetKey,
+    });
+
+    assertNothingMigrated(report, 'app-bound-v20');
+  });
+
+  it('never modifies the source Login Data', async () => {
+    const source = await makeTempDir('bc-pw-src-');
+    const target = await makeTempDir('bc-pw-dst-');
+    const key = deriveChromiumCookieKey('pw', 'linux');
+    writeLoginData(source, [
+      encryptedLogin({
+        originUrl: 'https://a.example/login',
+        username: 'a',
+        plaintext: 'x',
+        key,
+        prefix: 'v11',
+      }),
+    ]);
+
+    await assertSourceUnchanged(path.join(source, 'Login Data'), () =>
+      migrateLinuxPasswords(source, target, { sourceKey: key, targetKey: key })
+    );
+  });
+
+  it('reports a skip when there is no Login Data', async () => {
+    const source = await makeTempDir('bc-pw-src-');
+    const target = await makeTempDir('bc-pw-dst-');
+    const report = await migrateLinuxPasswords(source, target, {
+      sourceKey: Buffer.alloc(16),
+      targetKey: Buffer.alloc(16),
+    });
+    assertNothingMigrated(report, 'source-missing');
+  });
+});

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

@@ -0,0 +1,77 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  MIGRATED_PREFERENCE_PATHS,
+  mergePreferenceSubset,
+  migratePreferences,
+} from '../../../../src/browser/migration/preferences.js';
+import {
+  assertNothingMigrated,
+  migrateBetween,
+  readProfileJson,
+  writeProfileJson,
+} from '../../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-prefs-');
+
+describe('mergePreferenceSubset', () => {
+  it('copies only the documented subset and skips missing paths', () => {
+    const source = {
+      intl: { accept_languages: 'en-US,en' },
+      download: { default_directory: '/home/alice/Downloads' },
+      homepage: 'https://start.example/',
+      unrelated: { setting: true },
+    };
+    const target = {};
+    const { migratedPaths } = mergePreferenceSubset(source, target);
+
+    assert.equal(target.intl.accept_languages, 'en-US,en');
+    assert.equal(target.homepage, 'https://start.example/');
+    assert.equal(target.unrelated, undefined);
+    assert.ok(migratedPaths.includes('intl.accept_languages'));
+    assert.ok(migratedPaths.includes('homepage'));
+  });
+
+  it('never migrates download.default_directory', () => {
+    assert.ok(
+      !MIGRATED_PREFERENCE_PATHS.includes('download.default_directory')
+    );
+    const source = { download: { default_directory: '/tmp/dl' } };
+    const target = {};
+    mergePreferenceSubset(source, target);
+    assert.equal(target.download, undefined);
+  });
+});
+
+describe('migratePreferences', () => {
+  it('merges the subset into an existing target Preferences', async () => {
+    const source = await makeTempDir();
+    const target = await makeTempDir();
+    await writeProfileJson(source, 'Preferences', {
+      intl: { accept_languages: 'de-DE,de' },
+      download: { default_directory: '/home/bob/Downloads' },
+      session: { restore_on_startup: 4, startup_urls: ['https://x/'] },
+    });
+    await writeProfileJson(target, 'Preferences', {
+      profile: { name: 'existing' },
+    });
+
+    const report = await migrateBetween(migratePreferences, source, target);
+
+    assert.ok(report.migrated >= 2);
+    const merged = await readProfileJson(target, 'Preferences');
+    assert.equal(merged.intl.accept_languages, 'de-DE,de');
+    assert.equal(merged.session.restore_on_startup, 4);
+    assert.equal(merged.profile.name, 'existing');
+    assert.equal(merged.download, undefined);
+  });
+
+  it('reports a skip when the source has no Preferences', async () => {
+    const source = await makeTempDir();
+    const target = await makeTempDir();
+    const report = await migrateBetween(migratePreferences, source, target);
+    assertNothingMigrated(report, 'source-missing');
+  });
+});

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

@@ -0,0 +1,75 @@
+import assert from 'node:assert';
+import { stat } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+
+import BetterSqlite3 from 'better-sqlite3';
+
+import {
+  readDatabaseSnapshot,
+  withDatabaseSnapshot,
+} from '../../../../src/browser/migration/sqlite-snapshot.js';
+import {
+  assertSourceUnchanged,
+  writeChromiumHistory,
+} from '../../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-snap-');
+
+async function makeDatabase(rowCount) {
+  return writeChromiumHistory(await makeTempDir(), rowCount);
+}
+
+describe('withDatabaseSnapshot', () => {
+  it('produces a consistent snapshot readable by the reader', async () => {
+    const dbPath = await makeDatabase(3);
+    const count = await withDatabaseSnapshot({
+      sourcePath: dbPath,
+      read: (snapshotPath) => {
+        const db = new BetterSqlite3(snapshotPath, { readonly: true });
+        try {
+          return db.prepare('SELECT COUNT(*) AS c FROM urls').get().c;
+        } finally {
+          db.close();
+        }
+      },
+    });
+    assert.equal(count, 3);
+  });
+
+  it('deletes the snapshot after the reader completes', async () => {
+    const dbPath = await makeDatabase(1);
+    let capturedPath;
+    await withDatabaseSnapshot({
+      sourcePath: dbPath,
+      read: (snapshotPath) => {
+        capturedPath = snapshotPath;
+      },
+    });
+    await assert.rejects(stat(capturedPath));
+  });
+
+  it('rejects when the source does not exist', async () => {
+    await assert.rejects(
+      withDatabaseSnapshot({
+        sourcePath: '/no/such/History',
+        read: () => null,
+      }),
+      /does not exist/
+    );
+  });
+});
+
+describe('readDatabaseSnapshot', () => {
+  it('opens the snapshot read-only and does not modify the source', async () => {
+    const dbPath = await makeDatabase(2);
+    let count;
+    await assertSourceUnchanged(dbPath, async () => {
+      count = await readDatabaseSnapshot({
+        sourcePath: dbPath,
+        read: (db) => db.prepare('SELECT COUNT(*) AS c FROM urls').get().c,
+      });
+    });
+    assert.equal(Number(count), 2);
+  });
+});

package/tests/unit/browser/open-in-user-browser.test.js

@@ -0,0 +1,123 @@
+// feature-parity: attach.open
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import {
+  buildOpenCommand,
+  openInUserBrowser,
+  validateOpenUrl,
+} from '../../../src/browser/open-in-user-browser.js';
+import { openInUserBrowser as publicOpenInUserBrowser } from '../../../src/index.js';
+
+function recordingRunner() {
+  const calls = [];
+  const runner = async (file, args, options) => {
+    calls.push({ file, args, options });
+    return { stdout: '', stderr: '', code: 0 };
+  };
+  return { calls, runner };
+}
+
+describe('validateOpenUrl', () => {
+  it('accepts http, https and file URLs', () => {
+    assert.equal(
+      validateOpenUrl('https://example.com/'),
+      'https://example.com/'
+    );
+    assert.equal(validateOpenUrl('http://example.com'), 'http://example.com');
+    assert.equal(validateOpenUrl('file:///tmp/x.html'), 'file:///tmp/x.html');
+  });
+
+  it('rejects strings that could be parsed as an option', () => {
+    assert.throws(() => validateOpenUrl('--version'), /cannot start with "-"/);
+    assert.throws(() => validateOpenUrl('-e'), /cannot start with "-"/);
+  });
+
+  it('rejects non-URL strings and disallowed schemes', () => {
+    assert.throws(
+      () => validateOpenUrl('not a url'),
+      /not a valid absolute URL/
+    );
+    assert.throws(
+      () => validateOpenUrl('javascript:alert(1)'),
+      /is not one of/
+    );
+    assert.throws(() => validateOpenUrl(''), /requires a URL string/);
+    assert.throws(() => validateOpenUrl(undefined), /requires a URL string/);
+  });
+});
+
+describe('buildOpenCommand', () => {
+  it('uses open on macOS', () => {
+    assert.deepEqual(buildOpenCommand('https://x.dev/', 'darwin'), [
+      'open',
+      'https://x.dev/',
+    ]);
+  });
+
+  it('uses xdg-open on Linux', () => {
+    assert.deepEqual(buildOpenCommand('https://x.dev/', 'linux'), [
+      'xdg-open',
+      'https://x.dev/',
+    ]);
+  });
+
+  it('uses Explorer on Windows without parsing URL metacharacters as shell syntax', () => {
+    assert.deepEqual(buildOpenCommand('https://x.dev/', 'win32'), [
+      'explorer.exe',
+      'https://x.dev/',
+    ]);
+    assert.deepEqual(buildOpenCommand('https://x.dev/?a=1&b=2', 'win32'), [
+      'explorer.exe',
+      'https://x.dev/?a=1&b=2',
+    ]);
+  });
+
+  it('throws on an unsupported platform', () => {
+    assert.throws(
+      () => buildOpenCommand('https://x.dev/', 'sunos'),
+      /not supported/
+    );
+  });
+});
+
+describe('openInUserBrowser', () => {
+  for (const platform of ['darwin', 'linux', 'win32']) {
+    it(`runs the ${platform} opener and returns the command`, async () => {
+      const { calls, runner } = recordingRunner();
+      const result = await openInUserBrowser('https://example.com/', {
+        platform,
+        runner,
+      });
+      const expected = buildOpenCommand('https://example.com/', platform);
+      assert.equal(result.opened, 'https://example.com/');
+      assert.deepEqual(result.command, expected);
+      assert.equal(calls.length, 1);
+      assert.equal(calls[0].file, expected[0]);
+      assert.deepEqual(calls[0].args, expected.slice(1));
+    });
+  }
+
+  it('passes env through to the runner when provided', async () => {
+    const { calls, runner } = recordingRunner();
+    await openInUserBrowser('https://example.com/', {
+      platform: 'linux',
+      runner,
+      env: { DISPLAY: ':1' },
+    });
+    assert.deepEqual(calls[0].options, { env: { DISPLAY: ':1' } });
+  });
+
+  it('validates before running', async () => {
+    const { calls, runner } = recordingRunner();
+    await assert.rejects(
+      openInUserBrowser('-e', { platform: 'linux', runner }),
+      /cannot start with "-"/
+    );
+    assert.equal(calls.length, 0);
+  });
+
+  it('is exported from the package entry point', () => {
+    assert.equal(typeof publicOpenInUserBrowser, 'function');
+  });
+});