chrome-tools 1.0.1

package/src/modules/bookmarks.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { chromeTimeToDate } from "../core/crypto.js";
+
+/**
+ * Converts a Chrome bookmark timestamp (microseconds since 1601-01-01) to a date string.
+ * Bookmark timestamps use the same epoch as Chrome timestamps but are stored as strings.
+ */
+function bookmarkTimeToDate(timestamp) {
+  if (!timestamp || timestamp === "0") return "N/A";
+  return chromeTimeToDate(BigInt(timestamp));
+}
+
+/**
+ * Recursively flattens the bookmark tree into a flat array.
+ *
+ * @param {Object} node - Bookmark tree node.
+ * @param {string} [folderPath=""] - Current folder path for context.
+ * @returns {Array<Object>}
+ */
+function flattenBookmarks(node, folderPath = "") {
+  const results = [];
+  if (!node) return results;
+
+  const currentPath = folderPath
+    ? `${folderPath}/${node.name || ""}`
+    : node.name || "";
+
+  if (node.type === "url") {
+    results.push({
+      title: node.name || "",
+      url: node.url || "",
+      folder: folderPath,
+      dateAdded: bookmarkTimeToDate(node.date_added),
+      dateLastUsed: bookmarkTimeToDate(node.date_last_used),
+      id: node.id,
+      guid: node.guid || "",
+    });
+  }
+
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      results.push(...flattenBookmarks(child, currentPath));
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Reads and parses bookmarks from Chrome's Bookmarks JSON file.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.folder] - Filter by folder name (case-insensitive).
+ * @param {string} [options.search] - Filter by title or URL (case-insensitive).
+ * @returns {Array<{profile: string, title: string, url: string, folder: string, dateAdded: string, dateLastUsed: string}>}
+ */
+export function getBookmarks({ chromeDir, profile, folder, search } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const bookmarksPath = join(p.path, "Bookmarks");
+    if (!existsSync(bookmarksPath)) continue;
+
+    try {
+      const raw = readFileSync(bookmarksPath, "utf-8");
+      const data = JSON.parse(raw);
+      const roots = data.roots;
+
+      if (!roots) continue;
+
+      // Flatten all root bookmark folders
+      const rootNames = ["bookmark_bar", "other", "synced"];
+      for (const rootName of rootNames) {
+        if (roots[rootName]) {
+          const bookmarks = flattenBookmarks(roots[rootName], "");
+          for (const bm of bookmarks) {
+            bm.profile = p.name;
+            results.push(bm);
+          }
+        }
+      }
+    } catch {
+      // Skip profiles with parse errors
+    }
+  }
+
+  let filtered = results;
+
+  if (folder) {
+    const term = folder.toLowerCase();
+    filtered = filtered.filter((b) => b.folder.toLowerCase().includes(term));
+  }
+
+  if (search) {
+    const term = search.toLowerCase();
+    filtered = filtered.filter(
+      (b) =>
+        b.title.toLowerCase().includes(term) ||
+        b.url.toLowerCase().includes(term)
+    );
+  }
+
+  return filtered;
+}

package/src/modules/cookies.js

@@ -0,0 +1,77 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { deriveEncryptionKey } from "../core/keychain.js";
+import { decryptValue, chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/**
+ * Extracts cookies from Chrome's Cookies database.
+ * Encrypted values are decrypted using the same mechanism as passwords.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.domain] - Filter by domain (case-insensitive, partial match).
+ * @param {boolean} [options.decrypt=true] - Whether to decrypt encrypted values.
+ * @param {number} [options.limit=100] - Maximum number of results.
+ * @returns {Array<Object>}
+ */
+export function getCookies({ chromeDir, profile, domain, decrypt = true, limit = 100 } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const derivedKey = decrypt ? deriveEncryptionKey() : null;
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "Cookies");
+    try {
+      if (!tableExists(dbPath, "cookies")) continue;
+
+      let sql = `SELECT host_key, name, value, encrypted_value, path,
+                        expires_utc, is_secure, is_httponly, samesite,
+                        creation_utc, last_access_utc
+                 FROM cookies`;
+      const conditions = [];
+      const params = [];
+
+      if (domain) {
+        conditions.push(`host_key LIKE ?`);
+        params.push(`%${domain}%`);
+      }
+
+      if (conditions.length > 0) {
+        sql += ` WHERE ${conditions.join(" AND ")}`;
+      }
+      sql += ` ORDER BY host_key, name`;
+      if (limit) {
+        sql += ` LIMIT ${parseInt(limit, 10)}`;
+      }
+
+      const rows = queryDatabase(dbPath, sql, params);
+
+      for (const row of rows) {
+        let cookieValue = row.value || "";
+        if (!cookieValue && row.encrypted_value && derivedKey) {
+          cookieValue = decryptValue(row.encrypted_value, derivedKey);
+        }
+
+        results.push({
+          profile: p.name,
+          domain: row.host_key,
+          name: row.name,
+          value: cookieValue,
+          path: row.path || "/",
+          expires: chromeTimeToDate(row.expires_utc || 0),
+          secure: Boolean(row.is_secure),
+          httpOnly: Boolean(row.is_httponly),
+          sameSite: ["unspecified", "lax", "strict", "none"][row.samesite] || "unspecified",
+          created: chromeTimeToDate(row.creation_utc || 0),
+          lastAccessed: chromeTimeToDate(row.last_access_utc || 0),
+        });
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}

package/src/modules/downloads.js

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/** Maps Chrome download state integers to human-readable strings. */
+const DOWNLOAD_STATES = {
+  0: "in_progress",
+  1: "complete",
+  2: "cancelled",
+  3: "interrupted",
+};
+
+/** Maps Chrome download danger type integers to strings. */
+const DANGER_TYPES = {
+  0: "not_dangerous",
+  1: "dangerous_file",
+  2: "dangerous_url",
+  3: "dangerous_content",
+  4: "maybe_dangerous_content",
+  5: "uncommon_content",
+  6: "user_validated",
+  7: "dangerous_host",
+  8: "potentially_unwanted",
+  9: "allowlisted_by_policy",
+};
+
+/**
+ * Retrieves download history from Chrome's History database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.search] - Filter by filename or URL (case-insensitive).
+ * @param {number} [options.limit=100] - Maximum number of results.
+ * @returns {Array<Object>}
+ */
+export function getDownloads({ chromeDir, profile, search, limit = 100 } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "History");
+    try {
+      if (!tableExists(dbPath, "downloads")) continue;
+
+      let sql = `SELECT id, target_path, tab_url, total_bytes, received_bytes,
+                        start_time, end_time, mime_type, original_mime_type,
+                        state, danger_type, opened, referrer, site_url
+                 FROM downloads ORDER BY start_time DESC`;
+      if (limit) {
+        sql += ` LIMIT ${parseInt(limit, 10)}`;
+      }
+
+      const rows = queryDatabase(dbPath, sql);
+
+      for (const row of rows) {
+        const entry = {
+          profile: p.name,
+          targetPath: row.target_path || "",
+          url: row.tab_url || "",
+          siteUrl: row.site_url || "",
+          referrer: row.referrer || "",
+          totalBytes: row.total_bytes || 0,
+          receivedBytes: row.received_bytes || 0,
+          mimeType: row.mime_type || row.original_mime_type || "",
+          state: DOWNLOAD_STATES[row.state] || `unknown(${row.state})`,
+          dangerType: DANGER_TYPES[row.danger_type] || `unknown(${row.danger_type})`,
+          opened: Boolean(row.opened),
+          startTime: chromeTimeToDate(row.start_time || 0),
+          endTime: chromeTimeToDate(row.end_time || 0),
+        };
+
+        if (search) {
+          const term = search.toLowerCase();
+          if (
+            !entry.targetPath.toLowerCase().includes(term) &&
+            !entry.url.toLowerCase().includes(term)
+          ) {
+            continue;
+          }
+        }
+        results.push(entry);
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}

package/src/modules/extensions.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+
+/**
+ * Retrieves installed Chrome extensions from the Preferences JSON file.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.search] - Filter by extension name (case-insensitive).
+ * @returns {Array<Object>}
+ */
+export function getExtensions({ chromeDir, profile, search } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    // Try Secure Preferences first, fallback to Preferences
+    let prefs = null;
+    for (const filename of ["Secure Preferences", "Preferences"]) {
+      const prefsPath = join(p.path, filename);
+      if (existsSync(prefsPath)) {
+        try {
+          prefs = JSON.parse(readFileSync(prefsPath, "utf-8"));
+          break;
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    if (!prefs) continue;
+
+    const settings = prefs?.extensions?.settings;
+    if (!settings || typeof settings !== "object") continue;
+
+    for (const [extId, extData] of Object.entries(settings)) {
+      // Skip component extensions and internal Chrome extensions
+      if (extData.location === 5 || extData.location === 10) continue;
+
+      const manifest = extData.manifest || {};
+      const entry = {
+        profile: p.name,
+        id: extId,
+        name: manifest.name || extData.name || extId,
+        version: manifest.version || extData.version || "unknown",
+        description: manifest.description || "",
+        enabled: extData.state === 1,
+        homepageUrl: manifest.homepage_url || "",
+        updateUrl: manifest.update_url || "",
+        installTime: extData.install_time || "",
+        fromWebstore: extData.from_webstore || false,
+        location: extData.location || 0,
+      };
+
+      // Clean up __MSG_ placeholders in name/description
+      if (entry.name.startsWith("__MSG_")) {
+        entry.name = extId; // Fallback to ID if name is a message key
+      }
+      if (entry.description.startsWith("__MSG_")) {
+        entry.description = "";
+      }
+
+      if (search) {
+        const term = search.toLowerCase();
+        if (
+          !entry.name.toLowerCase().includes(term) &&
+          !entry.id.toLowerCase().includes(term)
+        ) {
+          continue;
+        }
+      }
+
+      results.push(entry);
+    }
+  }
+
+  return results;
+}

package/src/modules/history.js

@@ -0,0 +1,102 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/**
+ * Retrieves browsing history from Chrome's History database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.search] - Filter by URL or title (case-insensitive).
+ * @param {number} [options.limit=100] - Maximum number of results.
+ * @returns {Array<{profile: string, url: string, title: string, visitCount: number, lastVisit: string}>}
+ */
+export function getHistory({ chromeDir, profile, search, limit = 100 } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "History");
+    try {
+      if (!tableExists(dbPath, "urls")) continue;
+
+      let sql = `SELECT url, title, visit_count, last_visit_time
+                 FROM urls ORDER BY last_visit_time DESC`;
+      if (limit) {
+        sql += ` LIMIT ${parseInt(limit, 10)}`;
+      }
+
+      const rows = queryDatabase(dbPath, sql);
+
+      for (const row of rows) {
+        const entry = {
+          profile: p.name,
+          url: row.url,
+          title: row.title || "",
+          visitCount: row.visit_count || 0,
+          lastVisit: chromeTimeToDate(row.last_visit_time || 0),
+        };
+
+        if (search) {
+          const term = search.toLowerCase();
+          if (
+            !entry.url.toLowerCase().includes(term) &&
+            !entry.title.toLowerCase().includes(term)
+          ) {
+            continue;
+          }
+        }
+        results.push(entry);
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Retrieves search terms from Chrome's History database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {number} [options.limit=100] - Maximum number of results.
+ * @returns {Array<{profile: string, term: string, url: string}>}
+ */
+export function getSearchTerms({ chromeDir, profile, limit = 100 } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "History");
+    try {
+      if (!tableExists(dbPath, "keyword_search_terms")) continue;
+
+      let sql = `SELECT kst.term, u.url
+                 FROM keyword_search_terms kst
+                 JOIN urls u ON kst.url_id = u.id
+                 ORDER BY u.last_visit_time DESC`;
+      if (limit) {
+        sql += ` LIMIT ${parseInt(limit, 10)}`;
+      }
+
+      const rows = queryDatabase(dbPath, sql);
+
+      for (const row of rows) {
+        results.push({
+          profile: p.name,
+          term: row.term || "",
+          url: row.url || "",
+        });
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}

package/src/modules/passwords.js

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { deriveEncryptionKey } from "../core/keychain.js";
+import { decryptValue, chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/**
+ * Extracts and decrypts saved passwords from Chrome's Login Data database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @param {string} [options.search] - Filter by URL or username (case-insensitive).
+ * @returns {Array<{profile: string, url: string, username: string, password: string, lastUsed: string}>}
+ */
+export function getPasswords({ chromeDir, profile, search } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const derivedKey = deriveEncryptionKey();
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "Login Data");
+    try {
+      if (!tableExists(dbPath, "logins")) continue;
+      const rows = queryDatabase(
+        dbPath,
+        `SELECT origin_url, username_value, password_value, date_last_used
+         FROM logins ORDER BY origin_url`
+      );
+
+      for (const row of rows) {
+        const entry = {
+          profile: p.name,
+          url: row.origin_url,
+          username: row.username_value,
+          password: decryptValue(row.password_value, derivedKey),
+          lastUsed: chromeTimeToDate(row.date_last_used || 0),
+        };
+
+        if (search) {
+          const term = search.toLowerCase();
+          if (
+            !entry.url.toLowerCase().includes(term) &&
+            !entry.username.toLowerCase().includes(term)
+          ) {
+            continue;
+          }
+        }
+        results.push(entry);
+      }
+    } catch (err) {
+      // Skip profiles with errors, continue with others
+      results.push({
+        profile: p.name,
+        error: err.message,
+      });
+    }
+  }
+
+  return results.filter((r) => !r.error);
+}

package/src/modules/search-engines.js

@@ -0,0 +1,48 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/**
+ * Retrieves search engines configured in Chrome from the Web Data database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @returns {Array<Object>}
+ */
+export function getSearchEngines({ chromeDir, profile } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "Web Data");
+    try {
+      if (!tableExists(dbPath, "keywords")) continue;
+
+      const rows = queryDatabase(
+        dbPath,
+        `SELECT id, short_name, keyword, url, suggestions_url,
+                favicon_url, prepopulate_id, is_active
+         FROM keywords ORDER BY short_name`
+      );
+
+      for (const row of rows) {
+        results.push({
+          profile: p.name,
+          id: row.id,
+          name: row.short_name || "",
+          keyword: row.keyword || "",
+          url: row.url || "",
+          suggestionsUrl: row.suggestions_url || "",
+          faviconUrl: row.favicon_url || "",
+          isDefault: row.prepopulate_id === 1,
+          isActive: row.is_active === 1,
+        });
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}

package/src/modules/top-sites.js

@@ -0,0 +1,43 @@
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+
+/**
+ * Retrieves top sites from Chrome's Top Sites database.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.chromeDir] - Chrome User Data directory.
+ * @param {string} [options.profile] - Specific profile to target.
+ * @returns {Array<Object>}
+ */
+export function getTopSites({ chromeDir, profile } = {}) {
+  const profiles = resolveTargetProfiles({ chromeDir, profile });
+  const results = [];
+
+  for (const p of profiles) {
+    const dbPath = join(p.path, "Top Sites");
+    try {
+      if (!tableExists(dbPath, "top_sites")) continue;
+
+      const rows = queryDatabase(
+        dbPath,
+        `SELECT url, url_rank, title, redirects
+         FROM top_sites ORDER BY url_rank ASC`
+      );
+
+      for (const row of rows) {
+        results.push({
+          profile: p.name,
+          url: row.url || "",
+          title: row.title || "",
+          rank: row.url_rank ?? 0,
+          redirects: row.redirects || "",
+        });
+      }
+    } catch {
+      // Skip profiles with errors
+    }
+  }
+
+  return results;
+}