chrome-tools 1.1.15 → 1.1.16

package/dist/src/index.js

@@ -1,34 +0,0 @@
-/**
- * chrome-tools — Public API
- *
- * This module re-exports all feature modules for use as a Node.js library.
- *
- * @example
- * import { getPasswords, getBookmarks, discoverProfiles } from 'chrome-tools';
- *
- * const passwords = getPasswords({ profile: 'Default' });
- * const bookmarks = getBookmarks({ search: 'github' });
- * const profiles  = discoverProfiles();
- */
-// Core utilities
-export { getDefaultChromeDir, discoverProfiles, getProfileMetadata, getProfileStates, resolveProfilePath, resolveTargetProfiles, detectInstalledBrowsers, } from "./core/chrome.js";
-// Browser registry & selection (all Chromium-based browsers)
-export { BROWSERS, listBrowsers, resolveBrowser, requireBrowser, getActiveBrowser, setActiveBrowser, } from "./core/browsers.js";
-// Platform-aware decryption (macOS / Windows / Linux)
-export { selectPlatform, getPlatformChromeDir, deriveEncryptionKey, decryptValue, decryptValueBuffer, clearKeyCache, } from "./core/platform/index.js";
-// macOS Keychain helpers (macOS-only). `getKeychainPassword` takes a Safe
-// Storage service name; `getChromeKeychainPassword` is the Chrome-specific alias.
-export { getKeychainPassword, getChromeKeychainPassword, clearKeychainCache, setKeychainPasswordProvider, getKeychainPasswordProvider, } from "./core/keychain.js";
-export { chromeTimeToDate, } from "./core/crypto.js";
-export { queryDatabase, tableExists, } from "./core/db.js";
-// Feature modules
-export { getPasswords } from "./modules/passwords.js";
-export { getBookmarks } from "./modules/bookmarks.js";
-export { getHistory, getSearchTerms } from "./modules/history.js";
-export { getCookies } from "./modules/cookies.js";
-export { getLocalStorage } from "./modules/local-storage.js";
-export { getAutofillEntries, getCreditCards, getAddresses } from "./modules/autofill.js";
-export { getDownloads } from "./modules/downloads.js";
-export { getExtensions } from "./modules/extensions.js";
-export { getSearchEngines } from "./modules/search-engines.js";
-export { getTopSites } from "./modules/top-sites.js";

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

@@ -1,68 +0,0 @@
-import { type ResolveProfilesOptions } from "../core/chrome.js";
-export interface AutofillOptions extends ResolveProfilesOptions {
-    search?: string;
-    limit?: number;
-}
-export interface AutofillEntry {
-    profile: string;
-    name: string;
-    value: string;
-    dateCreated: string;
-    dateLastUsed: string;
-    count: number;
-}
-export interface CreditCardOptions extends ResolveProfilesOptions {
-    decryptionKey?: Buffer;
-}
-export interface CreditCardEntry {
-    profile: string;
-    guid: string;
-    nameOnCard: string;
-    expirationMonth: number;
-    expirationYear: number;
-    cardNumber: string;
-    nickname: string;
-    origin: string;
-    useCount: number;
-    dateModified: string;
-}
-export interface AddressOptions extends ResolveProfilesOptions {
-}
-export interface AddressEntry {
-    profile: string;
-    guid: string;
-    fullName: string;
-    email: string;
-    phone: string;
-    companyName: string;
-    streetAddress: string;
-    city: string;
-    state: string;
-    zipcode: string;
-    countryCode: string;
-    origin: string;
-    useCount: number;
-    dateModified: string;
-}
-/**
- * Retrieves autofill entries from Chrome's Web Data database.
- *
- * @param options - Filtering and targeting options.
- * @returns Array of autofill entries.
- */
-export declare function getAutofillEntries({ chromeDir, profilePath, profile, browser, search, limit, }?: AutofillOptions): AutofillEntry[];
-/**
- * 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 declare function getCreditCards({ chromeDir, profilePath, profile, browser, decryptionKey, }?: CreditCardOptions): CreditCardEntry[];
-/**
- * Retrieves saved addresses from Chrome's Web Data database.
- *
- * @param options - Targeting options.
- * @returns Array of address entries.
- */
-export declare function getAddresses({ chromeDir, profilePath, profile, browser }?: AddressOptions): AddressEntry[];

package/dist/src/modules/autofill.js

@@ -1,170 +0,0 @@
-import { join } from "node:path";
-import { resolveTargetProfiles } from "../core/chrome.js";
-import { deriveEncryptionKey, decryptValue } from "../core/platform/index.js";
-import { chromeTimeToDate } from "../core/crypto.js";
-import { queryDatabase } from "../core/db.js";
-import { limitResults, normalizeLimit } from "../core/limit.js";
-import { sqlLikePattern } from "../core/sql.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, profilePath, profile, browser, search, limit = 100, } = {}) {
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    const results = [];
-    const rowLimit = normalizeLimit(limit);
-    for (const p of profiles) {
-        const dbPath = join(p.path, "Web Data");
-        try {
-            // Apply search in SQL before LIMIT so older matches are not truncated away.
-            let sql = `SELECT name, value, date_created, date_last_used, count FROM autofill`;
-            const params = [];
-            if (search) {
-                sql += ` WHERE IFNULL(name, '') LIKE ? ESCAPE '\\' OR IFNULL(value, '') LIKE ? ESCAPE '\\'`;
-                const like = sqlLikePattern(search);
-                params.push(like, like);
-            }
-            sql += ` ORDER BY date_last_used DESC`;
-            if (rowLimit) {
-                sql += ` LIMIT ${rowLimit}`;
-            }
-            const rows = queryDatabase(dbPath, sql, params);
-            for (const row of rows) {
-                results.push({
-                    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,
-                });
-            }
-        }
-        catch {
-            // Skip profiles with errors
-        }
-    }
-    return limitResults(results, limit);
-}
-/**
- * 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, profilePath, profile, browser, decryptionKey, } = {}) {
-    const userDataDir = profilePath || chromeDir;
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    // Pass user-data dir so Windows reads Local State from the same tree as the profiles.
-    let derivedKey = decryptionKey;
-    const results = [];
-    for (const p of profiles) {
-        const dbPath = join(p.path, "Web Data");
-        try {
-            const rows = queryDatabase(dbPath, `SELECT guid, name_on_card, expiration_month, expiration_year,
-                card_number_encrypted, date_modified, origin, use_count,
-                nickname
-         FROM credit_cards ORDER BY use_date DESC`);
-            for (const row of rows) {
-                let cardNumber = "";
-                if (row.card_number_encrypted?.length > 0) {
-                    cardNumber = decryptValue(row.card_number_encrypted, derivedKey ??= deriveEncryptionKey(userDataDir, browser));
-                }
-                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, profilePath, profile, browser } = {}) {
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    const results = [];
-    for (const p of profiles) {
-        const dbPath = join(p.path, "Web Data");
-        try {
-            const profileRows = queryDatabase(dbPath, `SELECT guid, company_name, street_address,
-                city, state, zipcode, country_code, date_modified,
-                origin, use_count
-         FROM autofill_profiles ORDER BY use_date DESC`);
-            // Try to join with names, emails, and phones
-            let nameRows = [];
-            let emailRows = [];
-            let phoneRows = [];
-            try {
-                nameRows = queryDatabase(dbPath, `SELECT guid, first_name, middle_name, last_name, full_name FROM autofill_profile_names`);
-            }
-            catch {
-                /* ignore */
-            }
-            try {
-                emailRows = queryDatabase(dbPath, `SELECT guid, email FROM autofill_profile_emails`);
-            }
-            catch {
-                /* ignore */
-            }
-            try {
-                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

@@ -1,22 +0,0 @@
-import { type ResolveProfilesOptions } from "../core/chrome.js";
-export interface BookmarkOptions extends ResolveProfilesOptions {
-    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, profilePath, profile, folder, search, browser, }?: BookmarkOptions): BookmarkEntry[];

package/dist/src/modules/bookmarks.js

@@ -1,83 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { resolveTargetProfiles } from "../core/chrome.js";
-import { chromeTimeToDate } from "../core/crypto.js";
-/**
- * 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: chromeTimeToDate(node.date_added),
-            dateLastUsed: chromeTimeToDate(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, profilePath, profile, folder, search, browser, } = {}) {
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    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

@@ -1,40 +0,0 @@
-import { type ResolveProfilesOptions } from "../core/chrome.js";
-export interface CookieOptions extends ResolveProfilesOptions {
-    domain?: string;
-    url?: string;
-    decrypt?: boolean;
-    limit?: number;
-    decryptionKey?: Buffer;
-}
-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, profilePath, profile, browser, domain, url, decrypt, limit, decryptionKey, }?: 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

@@ -1,163 +0,0 @@
-import { existsSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { resolveCookiesDatabasePath, resolveTargetProfiles, } from "../core/chrome.js";
-import { deriveEncryptionKey, decryptValueBuffer } from "../core/platform/index.js";
-import { chromeTimeToDate } from "../core/crypto.js";
-import { queryDatabase } from "../core/db.js";
-import { limitResults, normalizeLimit } from "../core/limit.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, profilePath, profile, browser, domain, url, decrypt = true, limit = 100, decryptionKey, } = {}) {
-    const userDataDir = profilePath || chromeDir;
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    let derivedKey = decryptionKey;
-    const results = [];
-    const parsedUrl = parseURL(url);
-    const rowLimit = normalizeLimit(limit);
-    let firstReadError;
-    for (const p of profiles) {
-        const dbPath = resolveCookiesDatabasePath(p.path);
-        if (!existsSync(dbPath))
-            continue;
-        try {
-            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 (rowLimit && !url) {
-                sql += ` LIMIT ${rowLimit}`;
-            }
-            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?.length > 0 && decrypt) {
-                    cookieValue = decodeCookieValue(row.encrypted_value, derivedKey ??= deriveEncryptionKey(userDataDir, browser), 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 (error) {
-            firstReadError ??= new Error(`Could not read cookies for profile "${p.name}" at ${dbPath}: ` +
-                (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    if (results.length === 0 && firstReadError)
-        throw firstReadError;
-    return limitResults(results, limit);
-}
-export const _test = {
-    parseURL,
-    getPossibleHostKeys,
-    domainMatch,
-    pathMatch,
-};

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

@@ -1,27 +0,0 @@
-import { type ResolveProfilesOptions } from "../core/chrome.js";
-export interface DownloadOptions extends ResolveProfilesOptions {
-    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, profilePath, profile, browser, search, limit, }?: DownloadOptions): DownloadEntry[];