browser-commander 0.24.0 → 0.26.0

package/src/browser/migration/history.js

@@ -3,6 +3,156 @@ import path from 'node:path';
 import { pathExists } from './fs-utils.js';
 
 import { withDatabaseSnapshot } from './sqlite-snapshot.js';
+import { matchesDomains } from './domains.js';
+import { openSqliteDatabase } from '../browser-cookie-database.js';
+
+async function filterHistory(targetPath, domains, warnings) {
+  if (!domains?.length) {
+    return;
+  }
+  const db = await openSqliteDatabase(targetPath);
+  try {
+    const tables = new Set(
+      db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+        .all()
+        .map((row) => row.name)
+    );
+    if (tables.has('urls')) {
+      const remove = db.prepare('DELETE FROM urls WHERE id = ?');
+      for (const row of db.prepare('SELECT id,url FROM urls').all()) {
+        if (!matchesDomains(row.url, domains)) {
+          remove.run(row.id);
+        }
+      }
+      for (const [table, column] of [
+        ['visits', 'url'],
+        ['segments', 'url_id'],
+        ['keyword_search_terms', 'url_id'],
+      ]) {
+        if (tables.has(table)) {
+          db.exec(
+            `DELETE FROM ${table} WHERE ${column} NOT IN (SELECT id FROM urls)`
+          );
+        }
+      }
+      if (tables.has('visits')) {
+        for (const [table, column] of [
+          ['visit_source', 'id'],
+          ['content_annotations', 'visit_id'],
+          ['context_annotations', 'visit_id'],
+        ]) {
+          if (tables.has(table)) {
+            db.exec(
+              `DELETE FROM ${table} WHERE ${column} NOT IN (SELECT id FROM visits)`
+            );
+          }
+        }
+      }
+      if (tables.has('segments') && tables.has('segment_usage')) {
+        db.exec(
+          'DELETE FROM segment_usage WHERE segment_id NOT IN (SELECT id FROM segments)'
+        );
+      }
+    }
+    filterDownloads(db, tables, domains);
+    if (tables.has('top_sites')) {
+      const remove = db.prepare('DELETE FROM top_sites WHERE url = ?');
+      for (const row of db.prepare('SELECT url FROM top_sites').all()) {
+        if (!matchesDomains(row.url, domains)) {
+          remove.run(row.url);
+        }
+      }
+    }
+    omitUnfilteredMetadata(db, tables, warnings);
+    db.exec('VACUUM');
+  } finally {
+    db.close();
+  }
+}
+
+function omitUnfilteredMetadata(db, tables, warnings) {
+  const filtered = new Set([
+    'urls',
+    'downloads',
+    'top_sites',
+    'meta',
+    'sqlite_sequence',
+  ]);
+  if (tables.has('urls')) {
+    for (const table of ['visits', 'segments', 'keyword_search_terms']) {
+      filtered.add(table);
+    }
+    if (tables.has('visits')) {
+      for (const table of [
+        'visit_source',
+        'content_annotations',
+        'context_annotations',
+      ]) {
+        filtered.add(table);
+      }
+    }
+    if (tables.has('segments')) {
+      filtered.add('segment_usage');
+    }
+  }
+  if (tables.has('downloads')) {
+    filtered.add('downloads_url_chains');
+    filtered.add('downloads_slices');
+  }
+  // Cluster labels and keywords can describe excluded visits even when a
+  // cluster also contains selected visits. Unknown schemas have no safe join.
+  for (const table of [...tables].sort()) {
+    if (filtered.has(table)) {
+      continue;
+    }
+    const identifier = `"${table.replaceAll('"', '""')}"`;
+    const count = db.prepare(`SELECT COUNT(*) AS c FROM ${identifier}`).get().c;
+    db.exec(`DELETE FROM ${identifier}`);
+    if (count > 0) {
+      warnings.push({
+        type: 'history',
+        item: table,
+        reason: 'unsupported-history-metadata',
+        detail: `${count} copied metadata rows removed`,
+      });
+    }
+  }
+}
+
+function filterDownloads(db, tables, domains) {
+  if (!tables.has('downloads')) {
+    return;
+  }
+  const remove = db.prepare('DELETE FROM downloads WHERE id = ?');
+  for (const row of db.prepare('SELECT * FROM downloads').all()) {
+    const urls = ['url', 'site_url', 'tab_url', 'referrer', 'tab_referrer_url']
+      .map((column) => row[column])
+      .filter(Boolean);
+    if (tables.has('downloads_url_chains')) {
+      urls.push(
+        ...db
+          .prepare('SELECT url FROM downloads_url_chains WHERE id = ?')
+          .all(row.id)
+          .map((chain) => chain.url)
+      );
+    }
+    // A redirect outside the selected sites is still unrelated browsing data.
+    if (!urls.length || urls.some((url) => !matchesDomains(url, domains))) {
+      remove.run(row.id);
+    }
+  }
+  for (const [table, column] of [
+    ['downloads_url_chains', 'id'],
+    ['downloads_slices', 'download_id'],
+  ]) {
+    if (tables.has(table)) {
+      db.exec(
+        `DELETE FROM ${table} WHERE ${column} NOT IN (SELECT id FROM downloads)`
+      );
+    }
+  }
+}
 
 /**
  * History and Top Sites migration.
@@ -20,12 +170,13 @@ import { withDatabaseSnapshot } from './sqlite-snapshot.js';
  * already guarantees a point-in-time consistent copy.
  */
 
-function snapshotInto({ sourcePath, targetPath }) {
+function snapshotInto({ sourcePath, targetPath, domains, warnings }) {
   return withDatabaseSnapshot({
     sourcePath,
     read: async (snapshotPath) => {
       const { copyFile } = await import('node:fs/promises');
       await copyFile(snapshotPath, targetPath);
+      await filterHistory(targetPath, domains, warnings);
       // Best-effort URL count for the report.
       try {
         const { openSqliteDatabase } =
@@ -52,7 +203,11 @@ function snapshotInto({ sourcePath, targetPath }) {
  * @param {string} options.targetProfileDir
  * @returns {Promise<{migrated: number, skipped: Array, warnings: Array}>}
  */
-export async function migrateHistory({ sourceProfileDir, targetProfileDir }) {
+export async function migrateHistory({
+  sourceProfileDir,
+  targetProfileDir,
+  domains,
+}) {
   const skipped = [];
   const warnings = [];
   await mkdir(targetProfileDir, { recursive: true });
@@ -64,6 +219,8 @@ export async function migrateHistory({ sourceProfileDir, targetProfileDir }) {
     const count = await snapshotInto({
       sourcePath: historySource,
       targetPath: path.join(targetProfileDir, 'History'),
+      domains,
+      warnings,
     });
     urlCount = count ?? 0;
     migratedDatabases += 1;
@@ -80,6 +237,8 @@ export async function migrateHistory({ sourceProfileDir, targetProfileDir }) {
     await snapshotInto({
       sourcePath: topSitesSource,
       targetPath: path.join(targetProfileDir, 'Top Sites'),
+      domains,
+      warnings,
     });
     migratedDatabases += 1;
   }

package/src/browser/migration/index.js

@@ -7,15 +7,25 @@ import {
   browserProfileRoot,
   resolveBrowserProfile,
 } from '../browser-profiles.js';
+import { migrateSafariClass } from './safari-import.js';
+import {
+  validateMigrationOptions,
+  validateMigrationPaths,
+} from './validation.js';
 import { migrateBookmarks } from './bookmarks.js';
+import { pathExists } from './fs-utils.js';
 import { migrateCookies } from './cookies.js';
+import {
+  ADDITIONAL_DATA_CLASSES,
+  reportAdditionalClasses,
+} from './data-classes.js';
 import { migrateExtensions } from './extensions.js';
 import {
   migrateFirefoxBookmarks,
   migrateFirefoxPasswords,
   readFirefoxCookies,
-  reportFirefoxHistory,
 } from './firefox.js';
+import { migrateFirefoxHistory } from './firefox-history.js';
 import { migrateHistory } from './history.js';
 import { migratePasswords } from './passwords.js';
 import { migratePreferences } from './preferences.js';
@@ -36,8 +46,8 @@ import {
  *
  * Cookies are returned (not written): a running Chromium re-derives its own
  * cookie encryption, so the launcher seeds them over CDP with the existing
- * `seedCookies` path. Every other data class is written into the target profile
- * directory.
+ * `seedCookies` path. Supported file imports are written into the target profile;
+ * classes without a native writer receive explicit skipped reports.
  */
 
 export const ALL_DATA_CLASSES = Object.freeze([
@@ -47,6 +57,7 @@ export const ALL_DATA_CLASSES = Object.freeze([
   'passwords',
   'preferences',
   'extensions',
+  ...ADDITIONAL_DATA_CLASSES,
 ]);
 
 // Classification is driven by the shared catalogue so every Chromium variant
@@ -62,14 +73,7 @@ function isFirefoxBrowser(browser) {
 }
 
 function emptyMigrated() {
-  return {
-    cookies: 0,
-    bookmarks: 0,
-    history: 0,
-    passwords: 0,
-    preferences: 0,
-    extensions: 0,
-  };
+  return Object.fromEntries(ALL_DATA_CLASSES.map((type) => [type, 0]));
 }
 
 async function resolveSourceProfileDir({
@@ -114,34 +118,6 @@ function mergeReport(report, className, fragment) {
   report.warnings.push(...(fragment.warnings ?? []));
 }
 
-function reportSafariClasses(report, selected) {
-  for (const type of ALL_DATA_CLASSES.filter(
-    (name) => name !== 'cookies' && selected.has(name)
-  )) {
-    report.skipped.push({
-      type,
-      item: report.source.browser,
-      reason:
-        type === 'passwords'
-          ? 'safari-password-export-required'
-          : 'safari-class-not-supported',
-      detail:
-        type === 'passwords'
-          ? 'Safari passwords live in the Keychain. Export Passwords from Safari or the Passwords app to CSV; CSV import is tracked separately and is not supported yet.'
-          : 'Safari currently supports cookie import only; this data class has not been translated.',
-    });
-  }
-  if (report.cookies.length > 0) {
-    report.warnings.push({
-      type: 'cookies',
-      item: report.source.browser,
-      reason: 'safari-samesite-unavailable',
-      detail:
-        'Cookies.binarycookies does not store SameSite; imported cookies use Lax.',
-    });
-  }
-}
-
 async function resolvePasswordKeys({
   keys,
   browser,
@@ -179,7 +155,8 @@ async function resolvePasswordKeys({
  * @param {{browser: string, profile: (string|undefined), userDataDir: (string|undefined)}} options.from
  * @param {string} options.to - Target profile directory
  * @param {string[]} [options.include=ALL_DATA_CLASSES]
- * @param {string[]} [options.domains] - Cookie domain filter
+ * @param {string[]} [options.domains] - Per-site host/subdomain filter
+ * @param {boolean} [options.includePaymentCards=false] - Separate explicit payment-card consent
  * @param {string} [options.platform=process.platform]
  * @param {string} [options.targetBrowser] - Launching browser channel (key derivation)
  * @param {Object} [options.keys] - Injected password keys {resolveSourceKey, targetKey, targetPrefix, primaryPassword}
@@ -198,6 +175,8 @@ export async function migrateProfile({
   homeDir = os.homedir(),
   environment = process.env,
   runCommand,
+  passwordCsv,
+  includePaymentCards = false,
 }) {
   if (!from?.browser) {
     throw new TypeError('migrateProfile requires from.browser');
@@ -205,6 +184,17 @@ export async function migrateProfile({
   if (!to) {
     throw new TypeError('migrateProfile requires a target directory (to)');
   }
+  validateMigrationOptions({
+    include,
+    domains,
+    targetBrowser,
+    to,
+    platform,
+    homeDir,
+    environment,
+    classes: ALL_DATA_CLASSES,
+    includePaymentCards,
+  });
   // An explicit userDataDir names the source, so only an installed-browser
   // import is steered towards the profile holding the requested domains.
   const source = await resolveImportSource({
@@ -216,6 +206,11 @@ export async function migrateProfile({
     runCommand,
   });
   const { browser } = source;
+  if (!['chromium', 'firefox', 'safari'].includes(browserFamily(browser))) {
+    throw new TypeError(
+      `Browser ${browser} supports detection only; its profile format is not supported for migration`
+    );
+  }
   const profile = from.profile ?? source.profile ?? 'Default';
   const isFirefox = isFirefoxBrowser(browser);
   const sourceProfileDir = await resolveSourceProfileDir({
@@ -227,6 +222,7 @@ export async function migrateProfile({
     environment,
   });
   const selected = new Set(include);
+  validateMigrationPaths(sourceProfileDir, to);
   const report = {
     source: { browser, profile, userDataDir: from.userDataDir ?? null },
     target: to,
@@ -238,6 +234,13 @@ export async function migrateProfile({
   if (source.warning) {
     report.warnings.push(source.warning);
   }
+  report.skipped.push(
+    ...reportAdditionalClasses({
+      selected,
+      profileDir: sourceProfileDir,
+      includePaymentCards,
+    })
+  );
 
   if (selected.has('cookies')) {
     if (isFirefox) {
@@ -263,8 +266,21 @@ export async function migrateProfile({
   }
 
   if (browserFamily(browser) === 'safari') {
-    reportSafariClasses(report, selected);
-    return report;
+    return migrateSafariProfile({
+      selected,
+      passwordCsv,
+      keys,
+      browser,
+      targetBrowser,
+      platform,
+      sourceProfileDir,
+      environment,
+      from,
+      to,
+      domains,
+      homeDir,
+      report,
+    });
   }
 
   if (selected.has('bookmarks')) {
@@ -288,10 +304,15 @@ export async function migrateProfile({
       report,
       'history',
       isFirefox
-        ? await reportFirefoxHistory({ profileDir: sourceProfileDir })
+        ? await migrateFirefoxHistory({
+            profileDir: sourceProfileDir,
+            targetProfileDir: to,
+            domains,
+          })
         : await migrateHistory({
             sourceProfileDir,
             targetProfileDir: to,
+            domains,
           })
     );
   }
@@ -312,56 +333,181 @@ export async function migrateProfile({
     );
   }
 
+  if (isFirefox) {
+    for (const type of ['preferences', 'extensions']) {
+      if (selected.has(type)) {
+        report.skipped.push({
+          type,
+          item: sourceProfileDir,
+          reason: 'firefox-class-not-supported',
+          detail:
+            'Firefox preferences and extensions cannot be copied into a Chromium profile.',
+        });
+      }
+    }
+  }
+
   if (selected.has('passwords')) {
-    const passwordKeys = await resolvePasswordKeys({
+    await migratePasswordClass(report, {
       keys,
       browser,
-      targetBrowser: targetBrowser ?? (isFirefox ? 'chrome' : browser),
+      targetBrowser,
       platform,
       sourceProfileDir,
       environment,
+      to,
+      isFirefox,
+      domains,
     });
-    if (!passwordKeys?.targetKey) {
-      report.skipped.push({
-        type: 'passwords',
-        item: 'Login Data',
-        reason: 'target-key-unavailable',
-      });
-      report.warnings.push({
-        type: 'passwords',
-        item: 'Login Data',
-        reason: 'target-key-unavailable',
-        detail:
-          'A target encryption key was not available (on Windows the launcher must generate one and write it into the target Local State); passwords were not migrated.',
-      });
-    } else if (isFirefox) {
-      mergeReport(
-        report,
-        'passwords',
-        await migrateFirefoxPasswords({
-          profileDir: sourceProfileDir,
-          targetProfileDir: to,
+  }
+
+  return report;
+}
+
+async function migrateSafariProfile({
+  report,
+  browser,
+  domains,
+  environment,
+  from,
+  homeDir,
+  keys,
+  passwordCsv,
+  platform,
+  selected,
+  sourceProfileDir,
+  targetBrowser,
+  to,
+}) {
+  const passwordKeys =
+    selected.has('passwords') && passwordCsv
+      ? await resolvePasswordKeys({
+          keys,
+          browser,
+          targetBrowser: targetBrowser ?? 'chrome',
           platform,
-          targetKey: passwordKeys.targetKey,
-          targetPrefix: passwordKeys.targetPrefix,
-          primaryPassword: passwordKeys.primaryPassword,
-        })
-      );
-    } else {
-      mergeReport(
-        report,
-        'passwords',
-        await migratePasswords({
           sourceProfileDir,
-          targetProfileDir: to,
-          platform,
-          resolveSourceKey: passwordKeys.resolveSourceKey,
-          targetKey: passwordKeys.targetKey,
-          targetPrefix: passwordKeys.targetPrefix,
+          environment,
         })
-      );
-    }
+      : null;
+  for (const type of ALL_DATA_CLASSES.filter(
+    (type) =>
+      type !== 'cookies' &&
+      !ADDITIONAL_DATA_CLASSES.includes(type) &&
+      selected.has(type)
+  )) {
+    mergeReport(
+      report,
+      type,
+      await migrateSafariClass({
+        type,
+        profileDir: sourceProfileDir,
+        targetProfileDir: to,
+        domains,
+        passwordCsv,
+        passwordKeys,
+        platform,
+        legacyDir:
+          from.userDataDir ||
+          path.basename(path.dirname(sourceProfileDir)) === 'Profiles'
+            ? undefined
+            : path.join(
+                homeDir,
+                'Library',
+                browser === 'safari' ? 'Safari' : 'Safari Technology Preview'
+              ),
+      })
+    );
+  }
+  if (report.cookies.length) {
+    report.warnings.push({
+      type: 'cookies',
+      item: browser,
+      reason: 'safari-samesite-unavailable',
+      detail:
+        'Cookies.binarycookies does not store SameSite; imported cookies use Lax.',
+    });
   }
-
   return report;
 }
+
+async function migratePasswordClass(
+  report,
+  {
+    browser,
+    domains,
+    environment,
+    isFirefox,
+    keys,
+    platform,
+    sourceProfileDir,
+    targetBrowser,
+    to,
+  }
+) {
+  if (
+    browser === 'yandex' &&
+    (await pathExists(path.join(sourceProfileDir, 'Ya Passman Data')))
+  ) {
+    report.skipped.push({
+      type: 'passwords',
+      item: 'Ya Passman Data',
+      reason: 'yandex-passman-encryption-unsupported',
+      detail:
+        'Ya Passman Data uses local_encryptor_data and may require a Yandex master password; this extra encryption layer is not supported. Export passwords to a supported format instead.',
+    });
+    if (!(await pathExists(path.join(sourceProfileDir, 'Login Data')))) {
+      return report;
+    }
+  }
+  const passwordKeys = await resolvePasswordKeys({
+    keys,
+    browser,
+    targetBrowser: targetBrowser ?? (isFirefox ? 'chrome' : browser),
+    platform,
+    sourceProfileDir,
+    environment,
+  });
+  if (!passwordKeys?.targetKey) {
+    report.skipped.push({
+      type: 'passwords',
+      item: 'Login Data',
+      reason: 'target-key-unavailable',
+    });
+    report.warnings.push({
+      type: 'passwords',
+      item: 'Login Data',
+      reason: 'target-key-unavailable',
+      detail:
+        'A target encryption key was not available (on Windows the launcher must generate one and write it into the target Local State); passwords were not migrated.',
+    });
+  } else if (isFirefox) {
+    mergeReport(
+      report,
+      'passwords',
+      await migrateFirefoxPasswords({
+        profileDir: sourceProfileDir,
+        targetProfileDir: to,
+        platform,
+        targetKey: passwordKeys.targetKey,
+        targetPrefix: passwordKeys.targetPrefix,
+        primaryPassword: passwordKeys.primaryPassword,
+        domains,
+      })
+    );
+  } else {
+    mergeReport(
+      report,
+      'passwords',
+      await migratePasswords({
+        sourceProfileDir,
+        targetProfileDir: to,
+        platform,
+        resolveSourceKey: passwordKeys.resolveSourceKey,
+        targetKey: passwordKeys.targetKey,
+        targetPrefix: passwordKeys.targetPrefix,
+        domains,
+      })
+    );
+  }
+}

package/src/browser/migration/os-crypt-keys.js

@@ -1,5 +1,3 @@
-import path from 'node:path';
-
 import { deriveChromiumCookieKey } from '../browser-cookie-crypto.js';
 import {
   decryptWindowsDpapi,
@@ -101,6 +99,4 @@ export async function resolveTargetKey({
 }
 
 /** Convenience: the Local State path next to a profile directory. */
-export function localStatePathForProfile(profileDir) {
-  return path.join(path.dirname(profileDir), 'Local State');
-}
+export { localStatePathForProfile } from '../browser-profile-files.js';