chrome-tools 1.0.4 → 1.0.6

package/dist/src/modules/autofill.js

@@ -0,0 +1,178 @@
+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";
+/**
+ * Retrieves autofill entries from Chrome's Web Data database.
+ *
+ * @param options - Filtering and targeting options.
+ * @returns Array of autofill entries.
+ */
+export function getAutofillEntries({ chromeDir, profile, search, limit = 100, } = {}) {
+    const profiles = resolveTargetProfiles({ chromeDir, profile });
+    const results = [];
+    for (const p of profiles) {
+        const dbPath = join(p.path, "Web Data");
+        try {
+            if (!tableExists(dbPath, "autofill"))
+                continue;
+            let sql = `SELECT name, value, date_created, date_last_used, count
+                 FROM autofill ORDER BY date_last_used DESC`;
+            if (limit) {
+                sql += ` LIMIT ${parseInt(limit, 10)}`;
+            }
+            const rows = queryDatabase(dbPath, sql);
+            for (const row of rows) {
+                const entry = {
+                    profile: p.name,
+                    name: row.name || "",
+                    value: row.value || "",
+                    dateCreated: chromeTimeToDate(row.date_created ? BigInt(row.date_created) * 1000000n + 11644473600000000n : 0),
+                    dateLastUsed: chromeTimeToDate(row.date_last_used ? BigInt(row.date_last_used) * 1000000n + 11644473600000000n : 0),
+                    count: row.count || 0,
+                };
+                if (search) {
+                    const term = search.toLowerCase();
+                    if (!(entry.name && entry.name.toLowerCase().includes(term)) &&
+                        !(entry.value && entry.value.toLowerCase().includes(term))) {
+                        continue;
+                    }
+                }
+                results.push(entry);
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return results;
+}
+/**
+ * Retrieves saved credit cards from Chrome's Web Data database.
+ * Card numbers are encrypted and will be decrypted.
+ *
+ * @param options - Targeting options.
+ * @returns Array of credit card entries.
+ */
+export function getCreditCards({ chromeDir, profile } = {}) {
+    const profiles = resolveTargetProfiles({ chromeDir, profile });
+    const derivedKey = deriveEncryptionKey();
+    const results = [];
+    for (const p of profiles) {
+        const dbPath = join(p.path, "Web Data");
+        try {
+            if (!tableExists(dbPath, "credit_cards"))
+                continue;
+            const rows = queryDatabase(dbPath, `SELECT guid, name_on_card, expiration_month, expiration_year,
+                card_number_encrypted, date_modified, origin, use_count,
+                use_date, nickname
+         FROM credit_cards ORDER BY use_date DESC`);
+            for (const row of rows) {
+                let cardNumber = "";
+                if (row.card_number_encrypted) {
+                    cardNumber = decryptValue(row.card_number_encrypted, derivedKey);
+                }
+                results.push({
+                    profile: p.name,
+                    guid: row.guid || "",
+                    nameOnCard: row.name_on_card || "",
+                    expirationMonth: row.expiration_month || 0,
+                    expirationYear: row.expiration_year || 0,
+                    cardNumber,
+                    nickname: row.nickname || "",
+                    origin: row.origin || "",
+                    useCount: row.use_count || 0,
+                    dateModified: chromeTimeToDate(row.date_modified ? BigInt(row.date_modified) * 1000000n + 11644473600000000n : 0),
+                });
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return results;
+}
+/**
+ * Retrieves saved addresses from Chrome's Web Data database.
+ *
+ * @param options - Targeting options.
+ * @returns Array of address entries.
+ */
+export function getAddresses({ 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, "autofill_profiles"))
+                continue;
+            const profileRows = queryDatabase(dbPath, `SELECT guid, company_name, street_address, dependent_locality,
+                city, state, zipcode, country_code, date_modified,
+                origin, use_count, use_date, language_code
+         FROM autofill_profiles ORDER BY use_date DESC`);
+            // Try to join with names, emails, and phones
+            let nameRows = [];
+            let emailRows = [];
+            let phoneRows = [];
+            try {
+                if (tableExists(dbPath, "autofill_profile_names")) {
+                    nameRows = queryDatabase(dbPath, `SELECT guid, first_name, middle_name, last_name, full_name FROM autofill_profile_names`);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                if (tableExists(dbPath, "autofill_profile_emails")) {
+                    emailRows = queryDatabase(dbPath, `SELECT guid, email FROM autofill_profile_emails`);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                if (tableExists(dbPath, "autofill_profile_phones")) {
+                    phoneRows = queryDatabase(dbPath, `SELECT guid, number FROM autofill_profile_phones`);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            const nameMap = new Map();
+            for (const n of nameRows) {
+                nameMap.set(n.guid, n.full_name || [n.first_name, n.middle_name, n.last_name].filter(Boolean).join(" "));
+            }
+            const emailMap = new Map();
+            for (const e of emailRows) {
+                emailMap.set(e.guid, e.email || "");
+            }
+            const phoneMap = new Map();
+            for (const ph of phoneRows) {
+                phoneMap.set(ph.guid, ph.number || "");
+            }
+            for (const row of profileRows) {
+                results.push({
+                    profile: p.name,
+                    guid: row.guid || "",
+                    fullName: nameMap.get(row.guid) || "",
+                    email: emailMap.get(row.guid) || "",
+                    phone: phoneMap.get(row.guid) || "",
+                    companyName: row.company_name || "",
+                    streetAddress: row.street_address || "",
+                    city: row.city || "",
+                    state: row.state || "",
+                    zipcode: row.zipcode || "",
+                    countryCode: row.country_code || "",
+                    origin: row.origin || "",
+                    useCount: row.use_count || 0,
+                    dateModified: chromeTimeToDate(row.date_modified ? BigInt(row.date_modified) * 1000000n + 11644473600000000n : 0),
+                });
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return results;
+}

package/dist/src/modules/bookmarks.d.ts

@@ -0,0 +1,23 @@
+export interface BookmarkOptions {
+    chromeDir?: string;
+    profile?: string;
+    folder?: string;
+    search?: string;
+}
+export interface BookmarkEntry {
+    profile?: string;
+    title: string;
+    url: string;
+    folder: string;
+    dateAdded: string;
+    dateLastUsed: string;
+    id?: string;
+    guid?: string;
+}
+/**
+ * Reads and parses bookmarks from Chrome's Bookmarks JSON file.
+ *
+ * @param options - Options for filtering and targeting.
+ * @returns Filtered bookmark entries.
+ */
+export declare function getBookmarks({ chromeDir, profile, folder, search }?: BookmarkOptions): BookmarkEntry[];

package/dist/src/modules/bookmarks.js

@@ -0,0 +1,92 @@
+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 node - Bookmark tree node.
+ * @param folderPath - Current folder path for context.
+ * @returns Array of flattened bookmark entries.
+ */
+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 options - Options for filtering and targeting.
+ * @returns Filtered bookmark entries.
+ */
+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/dist/src/modules/cookies.d.ts

@@ -0,0 +1,40 @@
+export interface CookieOptions {
+    chromeDir?: string;
+    profile?: string;
+    domain?: string;
+    url?: string;
+    decrypt?: boolean;
+    limit?: number;
+}
+export interface CookieEntry {
+    profile: string;
+    domain: string;
+    name: string;
+    value: string;
+    path: string;
+    expires: string;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite: string;
+    created: string;
+    lastAccessed: string;
+}
+declare function parseURL(urlStr?: string): URL | null;
+declare function getPossibleHostKeys(hostname: string): string[];
+declare function domainMatch(hostname: string, hostKey: string): boolean;
+declare function pathMatch(urlPath: string, cookiePath: string): boolean;
+/**
+ * Extracts cookies from Chrome's Cookies database.
+ * Encrypted values are decrypted using the same mechanism as passwords.
+ *
+ * @param options - Targeting and filtering options.
+ * @returns Array of cookie entries.
+ */
+export declare function getCookies({ chromeDir, profile, domain, url, decrypt, limit, }?: CookieOptions): CookieEntry[];
+export declare const _test: {
+    parseURL: typeof parseURL;
+    getPossibleHostKeys: typeof getPossibleHostKeys;
+    domainMatch: typeof domainMatch;
+    pathMatch: typeof pathMatch;
+};
+export {};

package/dist/src/modules/cookies.js

@@ -0,0 +1,159 @@
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { deriveEncryptionKey } from "../core/keychain.js";
+import { decryptValueBuffer, chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase, tableExists } from "../core/db.js";
+function decodeCookieValue(encryptedValue, derivedKey, hostKey) {
+    const decrypted = decryptValueBuffer(encryptedValue, derivedKey);
+    if (!Buffer.isBuffer(decrypted)) {
+        return decrypted;
+    }
+    const hostHash = createHash("sha256").update(hostKey).digest();
+    const valueBytes = decrypted.length >= hostHash.length && decrypted.subarray(0, hostHash.length).equals(hostHash)
+        ? decrypted.subarray(hostHash.length)
+        : decrypted;
+    return valueBytes.toString("utf-8");
+}
+function parseURL(urlStr) {
+    if (!urlStr)
+        return null;
+    try {
+        return new URL(urlStr);
+    }
+    catch {
+        try {
+            // If it doesn't have a protocol, prepend https://
+            if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(urlStr)) {
+                return new URL("https://" + urlStr);
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return null;
+}
+function getPossibleHostKeys(hostname) {
+    const keys = new Set();
+    keys.add(hostname);
+    keys.add("." + hostname);
+    const parts = hostname.split(".");
+    for (let i = 1; i < parts.length; i++) {
+        const suffix = parts.slice(i).join(".");
+        keys.add(suffix);
+        keys.add("." + suffix);
+    }
+    return Array.from(keys);
+}
+function domainMatch(hostname, hostKey) {
+    if (hostname === hostKey) {
+        return true;
+    }
+    if (hostKey.startsWith(".")) {
+        if (hostname === hostKey.slice(1) || hostname.endsWith(hostKey)) {
+            return true;
+        }
+    }
+    return false;
+}
+function pathMatch(urlPath, cookiePath) {
+    const uPath = urlPath || "/";
+    const cPath = cookiePath || "/";
+    if (cPath === "/") {
+        return true;
+    }
+    if (uPath === cPath) {
+        return true;
+    }
+    if (uPath.startsWith(cPath)) {
+        if (cPath.endsWith("/") || uPath[cPath.length] === "/") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Extracts cookies from Chrome's Cookies database.
+ * Encrypted values are decrypted using the same mechanism as passwords.
+ *
+ * @param options - Targeting and filtering options.
+ * @returns Array of cookie entries.
+ */
+export function getCookies({ chromeDir, profile, domain, url, decrypt = true, limit = 100, } = {}) {
+    const profiles = resolveTargetProfiles({ chromeDir, profile });
+    const derivedKey = decrypt ? deriveEncryptionKey() : null;
+    const results = [];
+    const parsedUrl = parseURL(url);
+    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}%`);
+            }
+            else if (parsedUrl) {
+                const hostKeys = getPossibleHostKeys(parsedUrl.hostname);
+                const placeholders = hostKeys.map(() => "?").join(", ");
+                conditions.push(`host_key IN (${placeholders})`);
+                params.push(...hostKeys);
+            }
+            if (conditions.length > 0) {
+                sql += ` WHERE ${conditions.join(" AND ")}`;
+            }
+            sql += ` ORDER BY host_key, name`;
+            if (limit && !url) {
+                sql += ` LIMIT ${parseInt(limit, 10)}`;
+            }
+            const rows = queryDatabase(dbPath, sql, params);
+            for (const row of rows) {
+                if (parsedUrl) {
+                    if (!domainMatch(parsedUrl.hostname, row.host_key || ""))
+                        continue;
+                    if (!pathMatch(parsedUrl.pathname || "/", row.path || "/"))
+                        continue;
+                    if (row.is_secure && parsedUrl.protocol !== "https:")
+                        continue;
+                }
+                let cookieValue = row.value || "";
+                if (!cookieValue && row.encrypted_value && derivedKey) {
+                    cookieValue = decodeCookieValue(row.encrypted_value, derivedKey, row.host_key || "");
+                }
+                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
+        }
+    }
+    if (limit && url) {
+        return results.slice(0, parseInt(limit, 10));
+    }
+    return results;
+}
+export const _test = {
+    parseURL,
+    getPossibleHostKeys,
+    domainMatch,
+    pathMatch,
+};

package/dist/src/modules/downloads.d.ts

@@ -0,0 +1,28 @@
+export interface DownloadOptions {
+    chromeDir?: string;
+    profile?: string;
+    search?: string;
+    limit?: number;
+}
+export interface DownloadEntry {
+    profile: string;
+    targetPath: string;
+    url: string;
+    siteUrl: string;
+    referrer: string;
+    totalBytes: number;
+    receivedBytes: number;
+    mimeType: string;
+    state: string;
+    dangerType: string;
+    opened: boolean;
+    startTime: string;
+    endTime: string;
+}
+/**
+ * Retrieves download history from Chrome's History database.
+ *
+ * @param options - Targeting, filtering, and limit options.
+ * @returns Array of download entries.
+ */
+export declare function getDownloads({ chromeDir, profile, search, limit, }?: DownloadOptions): DownloadEntry[];

package/dist/src/modules/downloads.js

@@ -0,0 +1,78 @@
+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 options - Targeting, filtering, and limit options.
+ * @returns Array of download entries.
+ */
+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 && entry.targetPath.toLowerCase().includes(term)) &&
+                        !(entry.url && entry.url.toLowerCase().includes(term))) {
+                        continue;
+                    }
+                }
+                results.push(entry);
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return results;
+}

package/dist/src/modules/extensions.d.ts

@@ -0,0 +1,25 @@
+export interface ExtensionOptions {
+    chromeDir?: string;
+    profile?: string;
+    search?: string;
+}
+export interface ExtensionEntry {
+    profile: string;
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    enabled: boolean;
+    homepageUrl: string;
+    updateUrl: string;
+    installTime: string;
+    fromWebstore: boolean;
+    location: number;
+}
+/**
+ * Retrieves installed Chrome extensions from the Preferences JSON file.
+ *
+ * @param options - Targeting and filtering options.
+ * @returns Array of extension entries.
+ */
+export declare function getExtensions({ chromeDir, profile, search }?: ExtensionOptions): ExtensionEntry[];