chrome-tools 1.1.14 → 1.1.16

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[];

package/dist/src/modules/downloads.js

@@ -1,80 +0,0 @@
-import { join } from "node:path";
-import { resolveTargetProfiles } from "../core/chrome.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";
-/** 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, 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, "History");
-        try {
-            // Apply search in SQL before LIMIT so older matches are not truncated away.
-            let sql = `SELECT 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`;
-            const params = [];
-            if (search) {
-                sql += ` WHERE IFNULL(target_path, '') LIKE ? ESCAPE '\\'
-                    OR IFNULL(tab_url, '') LIKE ? ESCAPE '\\'`;
-                const like = sqlLikePattern(search);
-                params.push(like, like);
-            }
-            sql += ` ORDER BY start_time DESC`;
-            if (rowLimit) {
-                sql += ` LIMIT ${rowLimit}`;
-            }
-            const rows = queryDatabase(dbPath, sql, params);
-            for (const row of rows) {
-                results.push({
-                    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),
-                });
-            }
-        }
-        catch {
-            // Skip profiles with errors
-        }
-    }
-    return limitResults(results, limit);
-}

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

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

package/dist/src/modules/extensions.js

@@ -1,71 +0,0 @@
-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 options - Targeting and filtering options.
- * @returns Array of extension entries.
- */
-export function getExtensions({ chromeDir, profilePath, profile, search, browser, } = {}) {
-    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
-    const results = [];
-    for (const p of profiles) {
-        // Prefer Secure Preferences, but continue to Preferences if it has no settings.
-        let settings = null;
-        for (const filename of ["Secure Preferences", "Preferences"]) {
-            const prefsPath = join(p.path, filename);
-            if (existsSync(prefsPath)) {
-                try {
-                    const prefs = JSON.parse(readFileSync(prefsPath, "utf-8"));
-                    const candidate = prefs?.extensions?.settings;
-                    if (candidate && typeof candidate === "object") {
-                        settings = candidate;
-                        break;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-        }
-        if (!settings)
-            continue;
-        for (const [extId, extDataAny] of Object.entries(settings)) {
-            const extData = extDataAny;
-            // 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 && entry.name.toLowerCase().includes(term)) &&
-                    !(entry.id && entry.id.toLowerCase().includes(term))) {
-                    continue;
-                }
-            }
-            results.push(entry);
-        }
-    }
-    return results;
-}