chrome-tools 1.1.5 → 1.1.7

package/dist/src/modules/cookies.js

@@ -1 +1,157 @@
-import{join as t}from"node:path";import{createHash as e}from"node:crypto";import{resolveTargetProfiles as o}from"../core/chrome.js";import{deriveEncryptionKey as n,decryptValueBuffer as s}from"../core/platform/index.js";import{chromeTimeToDate as r}from"../core/crypto.js";import{queryDatabase as i,tableExists as c}from"../core/db.js";function a(t,o,n){const r=s(t,o);if(!Buffer.isBuffer(r))return r;const i=e("sha256").update(n).digest();return(r.length>=i.length&&r.subarray(0,i.length).equals(i)?r.subarray(i.length):r).toString("utf-8")}function u(t){if(!t)return null;try{return new URL(t)}catch{try{if(!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(t))return new URL("https://"+t)}catch{}}return null}function p(t){const e=new Set;e.add(t),e.add("."+t);const o=t.split(".");for(let t=1;t<o.length;t++){const n=o.slice(t).join(".");e.add(n),e.add("."+n)}return Array.from(e)}function h(t,e){return t===e||!(!e.startsWith(".")||t!==e.slice(1)&&!t.endsWith(e))}function l(t,e){const o=t||"/",n=e||"/";return"/"===n||(o===n||!(!o.startsWith(n)||!n.endsWith("/")&&"/"!==o[n.length]))}export function getCookies({chromeDir:e,profile:s,browser:f,domain:m,url:d,decrypt:_=!0,limit:y=100}={}){const g=o({chromeDir:e,profile:s,browser:f}),k=_?n():null,j=[],x=u(d);for(const e of g){const o=t(e.path,"Cookies");try{if(!c(o,"cookies"))continue;let t="SELECT host_key, name, value, encrypted_value, path,\n                        expires_utc, is_secure, is_httponly, samesite,\n                        creation_utc, last_access_utc\n                 FROM cookies";const n=[],s=[];if(m)n.push("host_key LIKE ?"),s.push(`%${m}%`);else if(x){const t=p(x.hostname),e=t.map(()=>"?").join(", ");n.push(`host_key IN (${e})`),s.push(...t)}n.length>0&&(t+=` WHERE ${n.join(" AND ")}`),t+=" ORDER BY host_key, name",y&&!d&&(t+=` LIMIT ${parseInt(y,10)}`);const u=i(o,t,s);for(const t of u){if(x){if(!h(x.hostname,t.host_key||""))continue;if(!l(x.pathname||"/",t.path||"/"))continue;if(t.is_secure&&"https:"!==x.protocol)continue}let o=t.value||"";!o&&t.encrypted_value&&k&&(o=a(t.encrypted_value,k,t.host_key||"")),j.push({profile:e.name,domain:t.host_key||"",name:t.name||"",value:o,path:t.path||"/",expires:r(t.expires_utc||0),secure:Boolean(t.is_secure),httpOnly:Boolean(t.is_httponly),sameSite:["unspecified","lax","strict","none"][t.samesite]||"unspecified",created:r(t.creation_utc||0),lastAccessed:r(t.last_access_utc||0)})}}catch{}}return y&&d?j.slice(0,parseInt(y,10)):j}export const _test={parseURL:u,getPossibleHostKeys:p,domainMatch:h,pathMatch:l};
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { 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);
+    for (const p of profiles) {
+        const dbPath = join(p.path, "Cookies");
+        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 {
+            // Skip profiles with errors
+        }
+    }
+    return limitResults(results, limit);
+}
+export const _test = {
+    parseURL,
+    getPossibleHostKeys,
+    domainMatch,
+    pathMatch,
+};

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

@@ -1,7 +1,5 @@
-export interface DownloadOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface DownloadOptions extends ResolveProfilesOptions {
     search?: string;
     limit?: number;
 }
@@ -26,4 +24,4 @@ export interface DownloadEntry {
  * @param options - Targeting, filtering, and limit options.
  * @returns Array of download entries.
  */
-export declare function getDownloads({ chromeDir, profile, browser, search, limit, }?: DownloadOptions): DownloadEntry[];
+export declare function getDownloads({ chromeDir, profilePath, profile, browser, search, limit, }?: DownloadOptions): DownloadEntry[];

package/dist/src/modules/downloads.js

@@ -1 +1,80 @@
-import{join as e}from"node:path";import{resolveTargetProfiles as t}from"../core/chrome.js";import{chromeTimeToDate as r}from"../core/crypto.js";import{queryDatabase as o,tableExists as n}from"../core/db.js";const a={0:"in_progress",1:"complete",2:"cancelled",3:"interrupted"},s={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"};export function getDownloads({chromeDir:i,profile:_,browser:l,search:d,limit:c=100}={}){const m=t({chromeDir:i,profile:_,browser:l}),p=[];for(const t of m){const i=e(t.path,"History");try{if(!n(i,"downloads"))continue;let e="SELECT id, target_path, tab_url, total_bytes, received_bytes,\n                        start_time, end_time, mime_type, original_mime_type,\n                        state, danger_type, opened, referrer, site_url\n                 FROM downloads ORDER BY start_time DESC";c&&(e+=` LIMIT ${parseInt(c,10)}`);const _=o(i,e);for(const e of _){const o={profile:t.name,targetPath:e.target_path||"",url:e.tab_url||"",siteUrl:e.site_url||"",referrer:e.referrer||"",totalBytes:e.total_bytes||0,receivedBytes:e.received_bytes||0,mimeType:e.mime_type||e.original_mime_type||"",state:a[e.state]||`unknown(${e.state})`,dangerType:s[e.danger_type]||`unknown(${e.danger_type})`,opened:Boolean(e.opened),startTime:r(e.start_time||0),endTime:r(e.end_time||0)};if(d){const e=d.toLowerCase();if(!(o.targetPath&&o.targetPath.toLowerCase().includes(e)||o.url&&o.url.toLowerCase().includes(e)))continue}p.push(o)}}catch{}}return p}
+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,7 +1,5 @@
-export interface ExtensionOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface ExtensionOptions extends ResolveProfilesOptions {
     search?: string;
 }
 export interface ExtensionEntry {
@@ -23,4 +21,4 @@ export interface ExtensionEntry {
  * @param options - Targeting and filtering options.
  * @returns Array of extension entries.
  */
-export declare function getExtensions({ chromeDir, profile, search, browser }?: ExtensionOptions): ExtensionEntry[];
+export declare function getExtensions({ chromeDir, profilePath, profile, search, browser, }?: ExtensionOptions): ExtensionEntry[];

package/dist/src/modules/extensions.js

@@ -1 +1,71 @@
-import{existsSync as e,readFileSync as o}from"node:fs";import{join as t}from"node:path";import{resolveTargetProfiles as n}from"../core/chrome.js";export function getExtensions({chromeDir:r,profile:i,search:s,browser:c}={}){const a=n({chromeDir:r,profile:i,browser:c}),f=[];for(const n of a){let r=null;for(const i of["Secure Preferences","Preferences"]){const s=t(n.path,i);if(e(s))try{r=JSON.parse(o(s,"utf-8"));break}catch{continue}}if(!r)continue;const i=r?.extensions?.settings;if(i&&"object"==typeof i)for(const[e,o]of Object.entries(i)){const t=o;if(5===t.location||10===t.location)continue;const r=t.manifest||{},i={profile:n.name,id:e,name:r.name||t.name||e,version:r.version||t.version||"unknown",description:r.description||"",enabled:1===t.state,homepageUrl:r.homepage_url||"",updateUrl:r.update_url||"",installTime:t.install_time||"",fromWebstore:t.from_webstore||!1,location:t.location||0};if(i.name.startsWith("__MSG_")&&(i.name=e),i.description.startsWith("__MSG_")&&(i.description=""),s){const e=s.toLowerCase();if(!(i.name&&i.name.toLowerCase().includes(e)||i.id&&i.id.toLowerCase().includes(e)))continue}f.push(i)}}return f}
+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;
+}

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

@@ -1,7 +1,5 @@
-export interface HistoryOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface HistoryOptions extends ResolveProfilesOptions {
     search?: string;
     limit?: number;
 }
@@ -12,10 +10,7 @@ export interface HistoryEntry {
     visitCount: number;
     lastVisit: string;
 }
-export interface SearchTermOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+export interface SearchTermOptions extends ResolveProfilesOptions {
     limit?: number;
 }
 export interface SearchTermEntry {
@@ -29,11 +24,11 @@ export interface SearchTermEntry {
  * @param options - Filtering and targeting options.
  * @returns Array of history entries.
  */
-export declare function getHistory({ chromeDir, profile, search, limit, browser }?: HistoryOptions): HistoryEntry[];
+export declare function getHistory({ chromeDir, profilePath, profile, search, limit, browser, }?: HistoryOptions): HistoryEntry[];
 /**
  * Retrieves search terms from Chrome's History database.
  *
  * @param options - Targeting and limit options.
  * @returns Array of search term entries.
  */
-export declare function getSearchTerms({ chromeDir, profile, limit, browser }?: SearchTermOptions): SearchTermEntry[];
+export declare function getSearchTerms({ chromeDir, profilePath, profile, limit, browser, }?: SearchTermOptions): SearchTermEntry[];

package/dist/src/modules/history.js

@@ -1 +1,83 @@
-import{join as t}from"node:path";import{resolveTargetProfiles as r}from"../core/chrome.js";import{chromeTimeToDate as o}from"../core/crypto.js";import{queryDatabase as e,tableExists as i}from"../core/db.js";export function getHistory({chromeDir:s,profile:c,search:n,limit:l=100,browser:u}={}){const m=r({chromeDir:s,profile:c,browser:u}),f=[];for(const r of m){const s=t(r.path,"History");try{if(!i(s,"urls"))continue;let t="SELECT url, title, visit_count, last_visit_time\n                 FROM urls ORDER BY last_visit_time DESC";l&&(t+=` LIMIT ${parseInt(l,10)}`);const c=e(s,t);for(const t of c){const e={profile:r.name,url:t.url,title:t.title||"",visitCount:t.visit_count||0,lastVisit:o(t.last_visit_time||0)};if(n){const t=n.toLowerCase();if(!(e.url&&e.url.toLowerCase().includes(t)||e.title&&e.title.toLowerCase().includes(t)))continue}f.push(e)}}catch{}}return f}export function getSearchTerms({chromeDir:o,profile:s,limit:c=100,browser:n}={}){const l=r({chromeDir:o,profile:s,browser:n}),u=[];for(const r of l){const o=t(r.path,"History");try{if(!i(o,"keyword_search_terms"))continue;let t="SELECT kst.term, u.url\n                 FROM keyword_search_terms kst\n                 JOIN urls u ON kst.url_id = u.id\n                 ORDER BY u.last_visit_time DESC";c&&(t+=` LIMIT ${parseInt(c,10)}`);const s=e(o,t);for(const t of s)u.push({profile:r.name,term:t.term||"",url:t.url||""})}catch{}}return u}
+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";
+/**
+ * Retrieves browsing history from Chrome's History database.
+ *
+ * @param options - Filtering and targeting options.
+ * @returns Array of history entries.
+ */
+export function getHistory({ chromeDir, profilePath, profile, search, limit = 100, browser, } = {}) {
+    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 url, title, visit_count, last_visit_time FROM urls`;
+            const params = [];
+            if (search) {
+                sql += ` WHERE url LIKE ? ESCAPE '\\' OR IFNULL(title, '') LIKE ? ESCAPE '\\'`;
+                const like = sqlLikePattern(search);
+                params.push(like, like);
+            }
+            sql += ` ORDER BY last_visit_time DESC`;
+            if (rowLimit) {
+                sql += ` LIMIT ${rowLimit}`;
+            }
+            const rows = queryDatabase(dbPath, sql, params);
+            for (const row of rows) {
+                results.push({
+                    profile: p.name,
+                    url: row.url,
+                    title: row.title || "",
+                    visitCount: row.visit_count || 0,
+                    lastVisit: chromeTimeToDate(row.last_visit_time || 0),
+                });
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return limitResults(results, limit);
+}
+/**
+ * Retrieves search terms from Chrome's History database.
+ *
+ * @param options - Targeting and limit options.
+ * @returns Array of search term entries.
+ */
+export function getSearchTerms({ chromeDir, profilePath, profile, limit = 100, browser, } = {}) {
+    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 {
+            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 (rowLimit) {
+                sql += ` LIMIT ${rowLimit}`;
+            }
+            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 limitResults(results, limit);
+}

package/dist/src/modules/local-storage.d.ts

@@ -1,7 +1,5 @@
-export interface LocalStorageOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface LocalStorageOptions extends ResolveProfilesOptions {
     origin?: string;
     url?: string;
     key?: string;
@@ -26,7 +24,7 @@ interface RawLevelDBRecord {
  * @param options - Targeting and filtering options.
  * @returns Array of localStorage entries.
  */
-export declare function getLocalStorage({ chromeDir, profile, browser, origin, url, key, search, limit, }?: LocalStorageOptions): LocalStorageEntry[];
+export declare function getLocalStorage({ chromeDir, profilePath, profile, browser, origin, url, key, search, limit, }?: LocalStorageOptions): LocalStorageEntry[];
 declare function parseLocalStorageRecord(rawKey: Buffer, rawValue: Buffer): {
     origin: string;
     key: string;