browser-commander 0.23.0 → 0.25.0

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';

package/src/browser/migration/password-metadata.js

@@ -0,0 +1,95 @@
+import { matchesDomains } from './domains.js';
+
+/** Filter Login Data associations after pruning logins; never retain source keys. */
+export async function migratePasswordMetadata({
+  db,
+  domains,
+  rewriteValue,
+  skipped,
+  warnings,
+}) {
+  const tables = db
+    .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+    .all()
+    .map((row) => row.name);
+  for (const table of ['password_notes', 'insecure_credentials']) {
+    if (tables.includes(table)) {
+      db.exec(
+        `DELETE FROM ${table} WHERE NOT EXISTS (SELECT 1 FROM logins WHERE logins.id=${table}.parent_id)`
+      );
+    }
+  }
+  if (tables.includes('password_notes')) {
+    const rows = db
+      .prepare(
+        'SELECT password_notes.rowid AS rowid,logins.origin_url,password_notes.value FROM password_notes JOIN logins ON logins.id=password_notes.parent_id'
+      )
+      .all();
+    for (const row of rows) {
+      const result = await rewriteValue(row.value, row.origin_url);
+      if (result.reason) {
+        db.prepare('DELETE FROM password_notes WHERE rowid=?').run(row.rowid);
+        skipped.push({
+          type: 'passwords',
+          item: `password_notes/${row.rowid}`,
+          ...result,
+        });
+      } else {
+        db.prepare('UPDATE password_notes SET value=? WHERE rowid=?').run(
+          result.value,
+          row.rowid
+        );
+      }
+    }
+  }
+  const syncTables = [
+    'sync_entities_metadata',
+    'sync_model_metadata',
+    'incoming_sharing_invitation_sync_entities_metadata',
+    'incoming_sharing_invitation_sync_model_metadata',
+  ];
+  for (const table of syncTables) {
+    if (tables.includes(table)) {
+      resetMetadata(db, table, 'sync-metadata-reset', warnings);
+    }
+  }
+  if (!domains?.length) {
+    return;
+  }
+  if (tables.includes('stats')) {
+    for (const row of db
+      .prepare('SELECT rowid AS rowid,origin_domain FROM stats')
+      .all()) {
+      if (!matchesDomains(row.origin_domain ?? '', domains)) {
+        db.prepare('DELETE FROM stats WHERE rowid=?').run(row.rowid);
+      }
+    }
+  }
+  const known = new Set([
+    'logins',
+    'meta',
+    'password_notes',
+    'insecure_credentials',
+    'stats',
+    ...syncTables,
+  ]);
+  for (const table of tables) {
+    if (!known.has(table) && !table.startsWith('sqlite_')) {
+      resetMetadata(db, table, 'unsupported-password-metadata', warnings);
+    }
+  }
+}
+
+function resetMetadata(db, table, reason, warnings) {
+  // Only the identifier comes from the database; quote it rather than execute it.
+  const quoted = `"${table.replaceAll('"', '""')}"`;
+  const { changes } = db.prepare(`DELETE FROM ${quoted}`).run();
+  if (changes) {
+    warnings.push({
+      type: 'passwords',
+      item: table,
+      reason,
+      detail: `${changes} copied metadata rows removed`,
+    });
+  }
+}

package/src/browser/migration/passwords.js

@@ -6,6 +6,8 @@ import { decryptChromiumCookie } from '../browser-cookie-crypto.js';
 import { openSqliteDatabase } from '../browser-cookie-database.js';
 import { withDatabaseSnapshot } from './sqlite-snapshot.js';
 import { encryptChromiumValue } from './chromium-crypto.js';
+import { matchesDomains } from './domains.js';
+import { migratePasswordMetadata } from './password-metadata.js';
 
 /**
  * Saved-password migration.
@@ -49,6 +51,44 @@ function hostFromOrigin(originUrl) {
   }
 }
 
+async function rewriteSecret(
+  value,
+  origin,
+  { platform, resolveSourceKey, targetKey, targetPrefix }
+) {
+  const encryptedValue = toBuffer(value);
+  if (!encryptedValue.length) {
+    return { value: encryptedValue };
+  }
+  const prefix = encryptedValue.subarray(0, 3).toString('ascii');
+  if (prefix === 'v20') {
+    return { reason: 'app-bound-v20' };
+  }
+  if (prefix !== 'v10' && prefix !== 'v11') {
+    return { reason: 'unsupported-encryption' };
+  }
+  let plaintext;
+  try {
+    plaintext = decryptChromiumCookie({
+      encryptedValue,
+      host: hostFromOrigin(origin),
+      databaseVersion: 0,
+      platform,
+      key: await resolveSourceKey(prefix),
+    });
+  } catch (error) {
+    return { reason: 'decrypt-failed', detail: error.message };
+  }
+  return {
+    value: encryptChromiumValue({
+      plaintext,
+      key: targetKey,
+      platform,
+      prefix: targetPrefix,
+    }),
+  };
+}
+
 /**
  * Migrate saved passwords into the target profile's `Login Data`.
  *
@@ -69,6 +109,7 @@ export async function migratePasswords({
   resolveSourceKey,
   targetKey,
   targetPrefix = platform === 'win32' ? 'v10' : 'v11',
+  domains,
 }) {
   const sourcePath = path.join(sourceProfileDir, 'Login Data');
   if (!(await pathExists(sourcePath))) {
@@ -112,56 +153,52 @@ export async function migratePasswords({
         const update = db.prepare(
           'UPDATE logins SET password_value = ? WHERE rowid = ?'
         );
+        const remove = db.prepare('DELETE FROM logins WHERE rowid = ?');
+        const skip = (row, reason, detail) => {
+          remove.run(row.rowid);
+          skipped.push({
+            type: 'passwords',
+            item: row.origin_url ?? '(unknown)',
+            reason,
+            ...(detail ? { detail } : {}),
+          });
+        };
         for (const row of rows) {
-          const encryptedValue = toBuffer(row.password_value);
-          if (encryptedValue.length === 0) {
+          if (!matchesDomains(row.origin_url ?? '', domains)) {
+            remove.run(row.rowid);
             continue;
           }
-          const prefix = encryptedValue.subarray(0, 3).toString('ascii');
-          if (prefix === 'v20') {
-            skipped.push({
-              type: 'passwords',
-              item: row.origin_url ?? '(unknown)',
-              reason: 'app-bound-v20',
-            });
-            continue;
-          }
-          if (prefix !== 'v10' && prefix !== 'v11') {
-            skipped.push({
-              type: 'passwords',
-              item: row.origin_url ?? '(unknown)',
-              reason: 'unsupported-encryption',
-            });
-            continue;
-          }
-          let plaintext;
-          try {
-            const key = await resolveSourceKey(prefix);
-            plaintext = decryptChromiumCookie({
-              encryptedValue,
-              host: hostFromOrigin(row.origin_url),
-              databaseVersion: 0,
-              platform,
-              key,
-            });
-          } catch (error) {
-            skipped.push({
-              type: 'passwords',
-              item: row.origin_url ?? '(unknown)',
-              reason: 'decrypt-failed',
-              detail: error.message,
-            });
+          const encryptedValue = toBuffer(row.password_value);
+          if (encryptedValue.length === 0) {
             continue;
           }
-          const reencrypted = encryptChromiumValue({
-            plaintext,
-            key: targetKey,
+          const result = await rewriteSecret(encryptedValue, row.origin_url, {
             platform,
-            prefix: targetPrefix,
+            resolveSourceKey,
+            targetKey,
+            targetPrefix,
           });
-          update.run(reencrypted, row.rowid);
+          if (result.reason) {
+            skip(row, result.reason, result.detail);
+            continue;
+          }
+          update.run(result.value, row.rowid);
           migrated += 1;
         }
+        await migratePasswordMetadata({
+          db,
+          domains,
+          skipped,
+          warnings,
+          rewriteValue: (value, origin) =>
+            rewriteSecret(value, origin, {
+              platform,
+              resolveSourceKey,
+              targetKey,
+              targetPrefix,
+            }),
+        });
+        db.exec('VACUUM');
       } finally {
         db.close();
       }