browser-commander 0.23.0 → 0.25.0

package/src/browser/migration/firefox.js

@@ -1,9 +1,10 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { matchesDomains } from './domains.js';
 import { profileFileIfPresent } from './fs-utils.js';
 
 import { openSqliteDatabase } from '../browser-cookie-database.js';
-import { mapFirefoxCookieRows } from '../browser-cookies.js';
+import { mapFirefoxCookieRows, readFirefoxRows } from '../browser-cookies.js';
 import { readDatabaseSnapshot } from './sqlite-snapshot.js';
 import { encryptChromiumValue } from './chromium-crypto.js';
 import { firefoxBookmarksToChrome } from './firefox-bookmarks.js';
@@ -24,8 +25,8 @@ import {
  *   them over CDP.
  * - **bookmarks:** read from `places.sqlite` (`moz_bookmarks` + `moz_places`)
  *   and converted to Chrome's `Bookmarks` JSON.
- * - **history:** counted from `places.sqlite` and reported; it is not written,
- *   because Chrome's `History` schema is incompatible with Firefox's.
+ * - **history:** translated from `moz_historyvisits` into Chrome's `History`,
+ *   preserving individual visit dates and reporting untranslated metadata.
  * - **passwords:** decrypted from `logins.json` with the NSS key in `key4.db`
  *   and re-encrypted into a Chrome `Login Data`. When a primary password is set
  *   and not supplied, they are reported as `primary-password-set`.
@@ -102,20 +103,11 @@ export async function readFirefoxCookies({ profileDir, domains }) {
   return readDatabaseSnapshot({
     sourcePath: cookiePath,
     read: (db) => {
-      const rows = db
-        .prepare(
-          `SELECT name, value, host, path, expiry, isSecure, isHttpOnly, sameSite
-             FROM moz_cookies ORDER BY host, name, path`
-        )
-        .all();
+      const rows = readFirefoxRows(db);
       // The installed-browser cookie reader owns the row → cookie mapping, so
       // a migrated cookie and an imported one always have the same shape.
       return mapFirefoxCookieRows(
-        rows.filter((row) =>
-          Array.isArray(domains) && domains.length > 0
-            ? domains.some((domain) => (row.host ?? '').includes(domain))
-            : true
-        )
+        rows.filter((row) => matchesDomains(row.host ?? '', domains))
       );
     },
   });
@@ -228,6 +220,7 @@ export async function migrateFirefoxPasswords({
   targetKey,
   targetPrefix = platform === 'win32' ? 'v10' : 'v11',
   primaryPassword = Buffer.alloc(0),
+  domains,
 }) {
   const loginsPath = await profileFileIfPresent(profileDir, 'logins.json');
   const key4Path = await profileFileIfPresent(profileDir, 'key4.db');
@@ -271,6 +264,9 @@ export async function migrateFirefoxPasswords({
   const decrypted = [];
   const skipped = [];
   for (const login of logins) {
+    if (!matchesDomains(login.hostname ?? '', domains)) {
+      continue;
+    }
     try {
       decrypted.push({
         origin: login.hostname,
@@ -287,6 +283,33 @@ export async function migrateFirefoxPasswords({
     }
   }
 
+  const migrated = await writeChromiumPasswords({
+    entries: decrypted,
+    targetProfileDir,
+    platform,
+    targetKey,
+    targetPrefix,
+  });
+
+  const warnings = [];
+  if (migrated > 0) {
+    warnings.push({
+      type: 'passwords',
+      item: 'Login Data',
+      reason: 'reencrypted-for-chrome',
+      detail: `${migrated} Firefox logins were decrypted and re-encrypted into a Chrome Login Data; Chrome may re-key the store on first launch.`,
+    });
+  }
+  return { migrated, skipped, warnings };
+}
+
+export async function writeChromiumPasswords({
+  entries,
+  targetProfileDir,
+  platform,
+  targetKey,
+  targetPrefix,
+}) {
   await mkdir(targetProfileDir, { recursive: true });
   const targetPath = path.join(targetProfileDir, 'Login Data');
   const db = await openSqliteDatabase(targetPath);
@@ -301,7 +324,7 @@ export async function migrateFirefoxPasswords({
          date_last_used, date_password_modified
        ) VALUES (?, ?, '', ?, '', ?, '', ?, 0, 0, 0, 0, 0, 0, 0)`
     );
-    for (const entry of decrypted) {
+    for (const entry of entries) {
       const encrypted = encryptChromiumValue({
         plaintext: entry.password,
         key: targetKey,
@@ -321,14 +344,5 @@ export async function migrateFirefoxPasswords({
     db.close();
   }
 
-  const warnings = [];
-  if (migrated > 0) {
-    warnings.push({
-      type: 'passwords',
-      item: 'Login Data',
-      reason: 'reencrypted-for-chrome',
-      detail: `${migrated} Firefox logins were decrypted and re-encrypted into a Chrome Login Data; Chrome may re-key the store on first launch.`,
-    });
-  }
-  return { migrated, skipped, warnings };
+  return migrated;
 }

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