chrome-tools 1.1.6 → 1.1.7

package/dist/src/core/browsers.js

@@ -1 +1,186 @@
-export const BROWSERS={chrome:{id:"chrome",name:"Google Chrome",aliases:["google-chrome","google chrome"],safeStorageLabel:"Chrome Safe Storage",linuxSecretApp:"chrome",dirs:{darwin:"Google/Chrome",win32:"Google/Chrome/User Data",linux:"google-chrome"}},"chrome-beta":{id:"chrome-beta",name:"Google Chrome Beta",safeStorageLabel:"Chrome Safe Storage",linuxSecretApp:"chrome",dirs:{darwin:"Google/Chrome Beta",win32:"Google/Chrome Beta/User Data",linux:"google-chrome-beta"}},"chrome-canary":{id:"chrome-canary",name:"Google Chrome Canary",aliases:["canary"],safeStorageLabel:"Chrome Safe Storage",linuxSecretApp:"chrome",dirs:{darwin:"Google/Chrome Canary",win32:"Google/Chrome SxS/User Data",linux:"google-chrome-unstable"}},chromium:{id:"chromium",name:"Chromium",safeStorageLabel:"Chromium Safe Storage",linuxSecretApp:"chromium",dirs:{darwin:"Chromium",win32:"Chromium/User Data",linux:"chromium"}},edge:{id:"edge",name:"Microsoft Edge",aliases:["msedge","microsoft-edge","microsoft edge"],safeStorageLabel:"Microsoft Edge Safe Storage",linuxSecretApp:"chromium",dirs:{darwin:"Microsoft Edge",win32:"Microsoft/Edge/User Data",linux:"microsoft-edge"}},brave:{id:"brave",name:"Brave",aliases:["brave-browser"],safeStorageLabel:"Brave Safe Storage",linuxSecretApp:"chrome",dirs:{darwin:"BraveSoftware/Brave-Browser",win32:"BraveSoftware/Brave-Browser/User Data",linux:"BraveSoftware/Brave-Browser"}},comet:{id:"comet",name:"Comet",aliases:["perplexity","perplexity-comet"],safeStorageLabel:"Comet Safe Storage",linuxSecretApp:"chromium",dirs:{darwin:"Comet",win32:"Perplexity/Comet/User Data",linux:"comet"}},vivaldi:{id:"vivaldi",name:"Vivaldi",safeStorageLabel:"Chrome Safe Storage",linuxSecretApp:"chrome",dirs:{darwin:"Vivaldi",win32:"Vivaldi/User Data",linux:"vivaldi"}},opera:{id:"opera",name:"Opera",safeStorageLabel:"Opera Safe Storage",linuxSecretApp:"chromium",dirs:{darwin:"com.operasoftware.Opera",win32:"Opera Software/Opera Stable",linux:"opera"}}};const e="chrome";export function listBrowsers(){return Object.values(BROWSERS)}export function resolveBrowser(e){if(!e)return null;const r=e.trim().toLowerCase();for(const e of listBrowsers()){if(e.id.toLowerCase()===r)return e;if(e.name.toLowerCase()===r)return e;if(e.aliases?.some(e=>e.toLowerCase()===r))return e}return null}let r=BROWSERS[e];export function getActiveBrowser(){return r}export function setActiveBrowser(o){if(!o||!o.trim())return r=BROWSERS[e],r;const a=resolveBrowser(o);if(!a){const e=listBrowsers().map(e=>e.id).join(", ");throw new Error(`Unknown browser "${o}". Supported: ${e}.`)}return r=a,r}
+/**
+ * Chromium-browser registry — the single source of truth for what differs
+ * between Chromium-based browsers (Chrome, Edge, Brave, Comet, …).
+ *
+ * Every supported browser is a Chromium fork, so the *decryption* is identical
+ * per OS (AES-128-CBC + PBKDF2 on macOS/Linux, AES-256-GCM + DPAPI on Windows).
+ * Only two things vary by browser:
+ *   1. the default profile data directory, and
+ *   2. the OS-keystore "Safe Storage" label (macOS Keychain service name /
+ *      Linux Secret Service application).
+ *
+ * "Browser" is therefore a small dimension orthogonal to "platform": the
+ * platform backends (darwin/win32/linux) receive a browser descriptor and stay
+ * otherwise unchanged.
+ */
+/**
+ * Supported browsers. macOS paths/labels are verified; a few Windows/Linux
+ * paths for niche browsers (Comet, Opera) are best-effort and easy to correct —
+ * each is a single edit here, with no other code change required.
+ */
+export const BROWSERS = {
+    chrome: {
+        id: "chrome",
+        name: "Google Chrome",
+        aliases: ["google-chrome", "google chrome"],
+        safeStorageLabel: "Chrome Safe Storage",
+        linuxSecretApp: "chrome",
+        dirs: {
+            darwin: "Google/Chrome",
+            win32: "Google/Chrome/User Data",
+            linux: "google-chrome",
+        },
+    },
+    "chrome-beta": {
+        id: "chrome-beta",
+        name: "Google Chrome Beta",
+        safeStorageLabel: "Chrome Safe Storage",
+        linuxSecretApp: "chrome",
+        dirs: {
+            darwin: "Google/Chrome Beta",
+            win32: "Google/Chrome Beta/User Data",
+            linux: "google-chrome-beta",
+        },
+    },
+    "chrome-canary": {
+        id: "chrome-canary",
+        name: "Google Chrome Canary",
+        aliases: ["canary"],
+        safeStorageLabel: "Chrome Safe Storage",
+        linuxSecretApp: "chrome",
+        dirs: {
+            darwin: "Google/Chrome Canary",
+            win32: "Google/Chrome SxS/User Data",
+            linux: "google-chrome-unstable",
+        },
+    },
+    chromium: {
+        id: "chromium",
+        name: "Chromium",
+        safeStorageLabel: "Chromium Safe Storage",
+        linuxSecretApp: "chromium",
+        dirs: {
+            darwin: "Chromium",
+            win32: "Chromium/User Data",
+            linux: "chromium",
+        },
+    },
+    edge: {
+        id: "edge",
+        name: "Microsoft Edge",
+        aliases: ["msedge", "microsoft-edge", "microsoft edge"],
+        safeStorageLabel: "Microsoft Edge Safe Storage",
+        linuxSecretApp: "chromium",
+        dirs: {
+            darwin: "Microsoft Edge",
+            win32: "Microsoft/Edge/User Data",
+            linux: "microsoft-edge",
+        },
+    },
+    brave: {
+        id: "brave",
+        name: "Brave",
+        aliases: ["brave-browser"],
+        safeStorageLabel: "Brave Safe Storage",
+        linuxSecretApp: "chrome",
+        dirs: {
+            darwin: "BraveSoftware/Brave-Browser",
+            win32: "BraveSoftware/Brave-Browser/User Data",
+            linux: "BraveSoftware/Brave-Browser",
+        },
+    },
+    comet: {
+        id: "comet",
+        name: "Comet",
+        aliases: ["perplexity", "perplexity-comet"],
+        safeStorageLabel: "Comet Safe Storage",
+        linuxSecretApp: "chromium",
+        // macOS dir verified (~/Library/Application Support/Comet); Win/Linux best-effort.
+        dirs: {
+            darwin: "Comet",
+            win32: "Perplexity/Comet/User Data",
+            linux: "comet",
+        },
+    },
+    vivaldi: {
+        id: "vivaldi",
+        name: "Vivaldi",
+        // Vivaldi reuses Chrome's Keychain item rather than minting its own.
+        safeStorageLabel: "Chrome Safe Storage",
+        linuxSecretApp: "chrome",
+        dirs: {
+            darwin: "Vivaldi",
+            win32: "Vivaldi/User Data",
+            linux: "vivaldi",
+        },
+    },
+    opera: {
+        id: "opera",
+        name: "Opera",
+        safeStorageLabel: "Opera Safe Storage",
+        linuxSecretApp: "chromium",
+        // Opera's product dir *is* the user-data root (no nested "User Data").
+        // Profiles are usually still under Default/; some layouts are flat at root —
+        // discoverProfiles handles both.
+        dirs: {
+            darwin: "com.operasoftware.Opera",
+            win32: "Opera Software/Opera Stable",
+            win32Base: "roaming",
+            linux: "opera",
+        },
+    },
+};
+const DEFAULT_BROWSER = "chrome";
+/** All supported browsers, in a stable display order. */
+export function listBrowsers() {
+    return Object.values(BROWSERS);
+}
+/**
+ * Resolves a browser by id, display name, or alias (case-insensitive).
+ * @returns The descriptor, or `null` if unrecognized.
+ */
+export function resolveBrowser(idOrName) {
+    if (!idOrName)
+        return null;
+    const needle = idOrName.trim().toLowerCase();
+    for (const b of listBrowsers()) {
+        if (b.id.toLowerCase() === needle)
+            return b;
+        if (b.name.toLowerCase() === needle)
+            return b;
+        if (b.aliases?.some((a) => a.toLowerCase() === needle))
+            return b;
+    }
+    return null;
+}
+/** Resolves a browser or throws an actionable error without changing global state. */
+export function requireBrowser(idOrName) {
+    const resolved = resolveBrowser(idOrName);
+    if (resolved)
+        return resolved;
+    throw new Error(`Unknown browser "${idOrName}". Supported: ${listBrowsers().map((b) => b.id).join(", ")}.`);
+}
+let _active = BROWSERS[DEFAULT_BROWSER];
+/** The browser currently targeted by dir/key lookups. Defaults to Chrome. */
+export function getActiveBrowser() {
+    return _active;
+}
+/**
+ * Sets the active browser for subsequent dir/key lookups.
+ *
+ * Caches in the platform backends are keyed by their real inputs (Keychain
+ * service label, chromeDir, Linux secret app), so switching browsers never
+ * returns a stale key — no cache flush is needed here.
+ *
+ * @param idOrName - Browser id/name/alias. Empty/undefined resets to Chrome.
+ * @returns The now-active descriptor.
+ * @throws If `idOrName` is non-empty but unrecognized.
+ */
+export function setActiveBrowser(idOrName) {
+    if (!idOrName || !idOrName.trim()) {
+        _active = BROWSERS[DEFAULT_BROWSER];
+        return _active;
+    }
+    _active = requireBrowser(idOrName);
+    return _active;
+}

package/dist/src/core/chrome.d.ts

@@ -37,7 +37,7 @@ export interface ResolveProfilesOptions {
  * Delegates to the active platform backend (macOS/Windows/Linux).
  * @returns The absolute path to Chrome's User Data.
  */
-export declare function getDefaultChromeDir(): string;
+export declare function getDefaultChromeDir(browser?: string | BrowserDescriptor): string;
 export interface InstalledBrowser {
     /** Registry descriptor for the detected browser. */
     browser: BrowserDescriptor;
@@ -51,9 +51,6 @@ export interface InstalledBrowser {
 /**
  * Probes every supported browser for an on-disk profile directory.
  *
- * Temporarily switches the active browser to resolve each one's default dir,
- * then restores the previously-active browser before returning.
- *
  * @param options.includeMissing - When true, also returns browsers with no data
  *   directory (installed: false). Defaults to false (installed browsers only).
  * @returns One entry per matching browser.
@@ -65,6 +62,11 @@ export declare function detectInstalledBrowsers({ includeMissing }?: {
  * Scans the Chrome User Data directory for profile subdirectories.
  * A directory is considered a profile if it contains at least one known data file.
  *
+ * Also handles "flat" layouts (e.g. some Opera installs, or when `chromeDir`
+ * already points at a single profile folder): if no child profiles are found
+ * but the user-data directory itself has profile indicators, it is returned
+ * as a single profile.
+ *
  * @param chromeDir - Chrome User Data path. Defaults to standard macOS location.
  * @returns Discovered profiles with name and absolute path.
  */

package/dist/src/core/chrome.js

@@ -1 +1,240 @@
-import{existsSync as e,readdirSync as t,readFileSync as r,statSync as o}from"node:fs";import{join as i}from"node:path";import{getPlatformChromeDir as n}from"./platform/index.js";import{listBrowsers as a,getActiveBrowser as s,setActiveBrowser as c}from"./browsers.js";const f=["Login Data","History","Bookmarks","Cookies","Web Data","Local Storage","Preferences"];export function getDefaultChromeDir(){return n()}export function detectInstalledBrowsers({includeMissing:t=!1}={}){const r=s(),o=[];try{for(const r of a()){c(r.id);const i=getDefaultChromeDir(),n=Boolean(i)&&e(i);(n||t)&&o.push({browser:r,chromeDir:i,installed:n,profileCount:n?discoverProfiles(i).length:0})}}finally{c(r.id)}return o}export function discoverProfiles(r){const o=r||getDefaultChromeDir();if(!o||!e(o))return[];try{const r=t(o,{withFileTypes:!0}),n=[];for(const t of r){if(!t.isDirectory())continue;const r=i(o,t.name);f.some(t=>e(i(r,t)))&&n.push({name:t.name,path:r})}return n}catch{return[]}}export function getProfileMetadata(t){const o=t||getDefaultChromeDir(),n=i(o,"Local State");if(!e(n))return[];try{const e=r(n,"utf-8"),t=JSON.parse(e),o=t?.profile?.info_cache;return o&&"object"==typeof o?Object.entries(o).map(([e,t])=>{const r=t;return{directory:e,name:r.name||e,gaiaName:r.gaia_name||"",userName:r.user_name||"",email:r.user_name||"",avatarIcon:r.avatar_icon||"",isUsingDefaultName:r.is_using_default_name??!0,isEphemeral:r.is_ephemeral??!1,activeTime:r.active_time||0}}):[]}catch{return[]}}export function getProfileStates(t){const r=t||getDefaultChromeDir(),o=discoverProfiles(r),n=getProfileMetadata(r),a=new Map;for(const e of n)a.set(e.directory,e);return o.map(t=>{const r=a.get(t.name),o=t.path,n={};for(const t of f)n[t.replace(/\s+/g,"_").toLowerCase()]=e(i(o,t));return n.top_sites=e(i(o,"Top Sites")),n.extensions=e(i(o,"Extensions")),{directory:t.name,path:o,displayName:r?.name||t.name,gaiaName:r?.gaiaName||"",email:r?.email||"",avatarIcon:r?.avatarIcon||"",isEphemeral:r?.isEphemeral??!1,activeTime:r?.activeTime||0,dataFiles:n}})}export function getDirectorySize(r){if(!r||!e(r))return 0;let n,a=0;try{n=t(r,{withFileTypes:!0})}catch{return 0}for(const e of n){const t=i(r,e.name);try{if(e.isSymbolicLink())continue;e.isDirectory()?a+=getDirectorySize(t):e.isFile()&&(a+=o(t).size)}catch{}}return a}export function resolveProfilePath(t,r){const o=t||getDefaultChromeDir(),n=i(o,r);return e(n)?n:null}export function resolveTargetProfiles({profilePath:e,chromeDir:t,profile:r,browser:o}={}){o&&c(o);const i=e||t||getDefaultChromeDir(),n=discoverProfiles(i);if(r){const e=n.filter(e=>e.name===r);if(0===e.length)throw new Error(`Profile "${r}" not found in ${i}`);return e}return n}
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { getPlatformChromeDir } from "./platform/index.js";
+import { listBrowsers, requireBrowser, } from "./browsers.js";
+/** Known database/data files that indicate a valid Chrome profile directory. */
+const PROFILE_INDICATORS = [
+    "Login Data",
+    "History",
+    "Bookmarks",
+    "Cookies",
+    "Web Data",
+    "Local Storage",
+    "Preferences",
+];
+/** True when `dir` looks like a Chromium profile (has at least one indicator). */
+function isProfileDirectory(dir) {
+    return PROFILE_INDICATORS.some((file) => existsSync(join(dir, file)));
+}
+/**
+ * Returns the default Chrome User Data directory for the current OS.
+ * Delegates to the active platform backend (macOS/Windows/Linux).
+ * @returns The absolute path to Chrome's User Data.
+ */
+export function getDefaultChromeDir(browser) {
+    return getPlatformChromeDir(browser);
+}
+/**
+ * Probes every supported browser for an on-disk profile directory.
+ *
+ * @param options.includeMissing - When true, also returns browsers with no data
+ *   directory (installed: false). Defaults to false (installed browsers only).
+ * @returns One entry per matching browser.
+ */
+export function detectInstalledBrowsers({ includeMissing = false } = {}) {
+    const out = [];
+    for (const browser of listBrowsers()) {
+        const chromeDir = getDefaultChromeDir(browser);
+        const installed = existsSync(chromeDir);
+        if (!installed && !includeMissing)
+            continue;
+        out.push({
+            browser,
+            chromeDir,
+            installed,
+            profileCount: installed ? discoverProfiles(chromeDir).length : 0,
+        });
+    }
+    return out;
+}
+/**
+ * Scans the Chrome User Data directory for profile subdirectories.
+ * A directory is considered a profile if it contains at least one known data file.
+ *
+ * Also handles "flat" layouts (e.g. some Opera installs, or when `chromeDir`
+ * already points at a single profile folder): if no child profiles are found
+ * but the user-data directory itself has profile indicators, it is returned
+ * as a single profile.
+ *
+ * @param chromeDir - Chrome User Data path. Defaults to standard macOS location.
+ * @returns Discovered profiles with name and absolute path.
+ */
+export function discoverProfiles(chromeDir) {
+    const dir = chromeDir || getDefaultChromeDir();
+    if (!dir || !existsSync(dir)) {
+        return [];
+    }
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const profiles = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const profilePath = join(dir, entry.name);
+            if (isProfileDirectory(profilePath)) {
+                profiles.push({ name: entry.name, path: profilePath });
+            }
+        }
+        // Flat / root-level profile: indicators live on the product dir itself
+        // (no Default/Profile N children), or the caller passed a profile path.
+        if (profiles.length === 0 && isProfileDirectory(dir)) {
+            const name = basename(dir) || "Default";
+            profiles.push({ name, path: dir });
+        }
+        return profiles;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Parses the Chrome "Local State" JSON file to extract profile metadata.
+ * Returns enriched profile info including display name, email, avatar, etc.
+ *
+ * @param chromeDir - Chrome User Data path.
+ * @returns Profile metadata objects.
+ */
+export function getProfileMetadata(chromeDir) {
+    const dir = chromeDir || getDefaultChromeDir();
+    const localStatePath = join(dir, "Local State");
+    if (!existsSync(localStatePath)) {
+        return [];
+    }
+    try {
+        const raw = readFileSync(localStatePath, "utf-8");
+        const localState = JSON.parse(raw);
+        const infoCache = localState?.profile?.info_cache;
+        if (!infoCache || typeof infoCache !== "object") {
+            return [];
+        }
+        return Object.entries(infoCache).map(([dirName, infoAny]) => {
+            const info = infoAny;
+            return {
+                directory: dirName,
+                name: info.name || dirName,
+                gaiaName: info.gaia_name || "",
+                userName: info.user_name || "",
+                email: info.user_name || "",
+                avatarIcon: info.avatar_icon || "",
+                isUsingDefaultName: info.is_using_default_name ?? true,
+                isEphemeral: info.is_ephemeral ?? false,
+                activeTime: info.active_time || 0,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Combines filesystem profile discovery with Local State metadata
+ * to provide a comprehensive view of each profile's state.
+ *
+ * @param chromeDir - Chrome User Data path.
+ * @returns Enriched profile state objects.
+ */
+export function getProfileStates(chromeDir) {
+    const dir = chromeDir || getDefaultChromeDir();
+    const discovered = discoverProfiles(dir);
+    const metadata = getProfileMetadata(dir);
+    const metaMap = new Map();
+    for (const m of metadata) {
+        metaMap.set(m.directory, m);
+    }
+    return discovered.map((profile) => {
+        const meta = metaMap.get(profile.name);
+        const profilePath = profile.path;
+        // Check which data files exist
+        const dataFiles = {};
+        for (const file of PROFILE_INDICATORS) {
+            dataFiles[file.replace(/\s+/g, "_").toLowerCase()] = existsSync(join(profilePath, file));
+        }
+        // Additional files
+        dataFiles.top_sites = existsSync(join(profilePath, "Top Sites"));
+        dataFiles.extensions = existsSync(join(profilePath, "Extensions"));
+        return {
+            directory: profile.name,
+            path: profilePath,
+            displayName: meta?.name || profile.name,
+            gaiaName: meta?.gaiaName || "",
+            email: meta?.email || "",
+            avatarIcon: meta?.avatarIcon || "",
+            isEphemeral: meta?.isEphemeral ?? false,
+            activeTime: meta?.activeTime || 0,
+            dataFiles,
+        };
+    });
+}
+/**
+ * Recursively computes the total size, in bytes, of a directory's contents.
+ * Symbolic links are not followed and unreadable entries are skipped so the
+ * walk never throws on a single permission error.
+ *
+ * @param dirPath - Absolute path to the directory to measure.
+ * @returns Total size of all contained files in bytes (0 if missing/unreadable).
+ */
+export function getDirectorySize(dirPath) {
+    if (!dirPath || !existsSync(dirPath)) {
+        return 0;
+    }
+    let total = 0;
+    let entries;
+    try {
+        entries = readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const entryPath = join(dirPath, entry.name);
+        try {
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                total += getDirectorySize(entryPath);
+            }
+            else if (entry.isFile()) {
+                total += statSync(entryPath).size;
+            }
+        }
+        catch {
+            // Skip entries we cannot stat (e.g. permission denied, race on deletion).
+        }
+    }
+    return total;
+}
+/**
+ * Resolves a profile name to its directory path.
+ *
+ * @param chromeDir - Chrome User Data path.
+ * @param profileName - Profile directory name (e.g., "Default", "Profile 1").
+ * @returns Absolute path to profile directory, or null if not found.
+ */
+export function resolveProfilePath(chromeDir, profileName) {
+    const dir = chromeDir || getDefaultChromeDir();
+    const profilePath = join(dir, profileName);
+    return existsSync(profilePath) ? profilePath : null;
+}
+/**
+ * Helper to get the profiles to operate on based on options.
+ * If a specific profile is specified, returns only that one.
+ * Otherwise returns all discovered profiles.
+ *
+ * @param options - Resolution options.
+ * @returns Array of targeted profiles.
+ */
+export function resolveTargetProfiles({ profilePath, chromeDir, profile, browser, } = {}) {
+    // Validate an explicit browser even when a custom path bypasses default-dir lookup.
+    const targetBrowser = browser ? requireBrowser(browser) : undefined;
+    const dir = profilePath || chromeDir || getDefaultChromeDir(targetBrowser);
+    const allProfiles = discoverProfiles(dir);
+    if (profile) {
+        const match = allProfiles.filter((p) => p.name === profile);
+        if (match.length === 0) {
+            throw new Error(`Profile "${profile}" not found in ${dir}`);
+        }
+        return match;
+    }
+    return allProfiles;
+}

package/dist/src/core/crypto.d.ts

@@ -35,4 +35,4 @@ export declare function decryptValueBufferGcm(encryptedBlob: Buffer | Uint8Array
  * @param chromeTimestamp - Timestamp in microseconds.
  * @returns Human-readable date-time string, or "N/A".
  */
-export declare function chromeTimeToDate(chromeTimestamp: bigint | number | null | undefined): string;
+export declare function chromeTimeToDate(chromeTimestamp: bigint | number | string | null | undefined): string;

package/dist/src/core/crypto.js

@@ -1 +1,113 @@
-import{createDecipheriv as r}from"node:crypto";const t=Buffer.alloc(16," ");export function decryptValue(r,t){const e=decryptValueBuffer(r,t);return Buffer.isBuffer(e)?e.toString("utf-8"):e}export function decryptValueBuffer(e,n){if(!e||0===e.length)return Buffer.alloc(0);const f=Buffer.isBuffer(e)?e:Buffer.from(e),u=f.subarray(0,3).toString("utf-8");if("v10"!==u&&"v11"!==u)return"<unsupported encryption format>";const o=f.subarray(3);try{const e=r("aes-128-cbc",n,t);let f=e.update(o);return f=Buffer.concat([f,e.final()]),f}catch{return"<decryption failed>"}}export function decryptValueBufferGcm(t,e){if(!t||0===t.length)return Buffer.alloc(0);const n=Buffer.isBuffer(t)?t:Buffer.from(t),f=n.subarray(0,3).toString("utf-8");if("v10"!==f&&"v11"!==f)return"<unsupported encryption format>";if(n.length<31)return"<decryption failed>";const u=n.subarray(3,15),o=n.subarray(n.length-16),c=n.subarray(15,n.length-16);try{const t=r("aes-256-gcm",e,u);return t.setAuthTag(o),Buffer.concat([t.update(c),t.final()])}catch{return"<decryption failed>"}}export function chromeTimeToDate(r){if(!r||0===r||0n===r)return"N/A";try{const t=BigInt(r),e=Number((t-11644473600000000n)/1000n),n=new Date(e);return isNaN(n.getTime())?"N/A":n.toLocaleString()}catch{return"N/A"}}
+import { createDecipheriv } from "node:crypto";
+const AES_IV = Buffer.alloc(16, " "); // 16 spaces (0x20)
+// Windows AES-256-GCM layout: "v10" prefix + 12-byte nonce + ciphertext + 16-byte tag.
+const GCM_NONCE_LENGTH = 12;
+const GCM_TAG_LENGTH = 16;
+/**
+ * Decrypts a password/value buffer encrypted by Chrome on macOS or Linux.
+ * Chrome v10+ prefixes the encrypted blob with "v10" or "v11", followed by
+ * AES-128-CBC ciphertext. (Windows uses AES-256-GCM — see decryptValueBufferGcm.)
+ *
+ * @param encryptedBlob - The encrypted blob from the database.
+ * @param derivedKey - The derived 16-byte key.
+ * @returns The decrypted plaintext, or an error placeholder.
+ */
+export function decryptValue(encryptedBlob, derivedKey) {
+    const decrypted = decryptValueBuffer(encryptedBlob, derivedKey);
+    return Buffer.isBuffer(decrypted) ? decrypted.toString("utf-8") : decrypted;
+}
+/**
+ * Decrypts a Chrome encrypted blob and returns the raw plaintext bytes.
+ *
+ * @param encryptedBlob - The encrypted blob from the database.
+ * @param derivedKey - The derived 16-byte key.
+ * @returns The decrypted plaintext bytes, or an error placeholder.
+ */
+export function decryptValueBuffer(encryptedBlob, derivedKey) {
+    if (!encryptedBlob || encryptedBlob.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const blob = Buffer.isBuffer(encryptedBlob)
+        ? encryptedBlob
+        : Buffer.from(encryptedBlob);
+    const prefix = blob.subarray(0, 3).toString("utf-8");
+    if (prefix !== "v10" && prefix !== "v11") {
+        return "<unsupported encryption format>";
+    }
+    const ciphertext = blob.subarray(3);
+    try {
+        const decipher = createDecipheriv("aes-128-cbc", derivedKey, AES_IV);
+        let decrypted = decipher.update(ciphertext);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted;
+    }
+    catch {
+        return "<decryption failed>";
+    }
+}
+/**
+ * Decrypts a Windows Chrome `v10` blob using AES-256-GCM.
+ *
+ * Unlike the macOS/Linux CBC scheme, Windows blobs carry their own 12-byte
+ * nonce after the version prefix and a 16-byte GCM auth tag at the end. The
+ * `key` is the 32-byte AES key recovered from `Local State` via DPAPI.
+ *
+ * @param encryptedBlob - The encrypted blob from the database.
+ * @param key - The 32-byte AES-256 key.
+ * @returns The decrypted plaintext bytes, or a placeholder string.
+ */
+export function decryptValueBufferGcm(encryptedBlob, key) {
+    if (!encryptedBlob || encryptedBlob.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const blob = Buffer.isBuffer(encryptedBlob)
+        ? encryptedBlob
+        : Buffer.from(encryptedBlob);
+    const prefix = blob.subarray(0, 3).toString("utf-8");
+    if (prefix !== "v10" && prefix !== "v11") {
+        // Pre-v10 values are raw DPAPI blobs (no app-level key); not handled here.
+        return "<unsupported encryption format>";
+    }
+    if (blob.length < 3 + GCM_NONCE_LENGTH + GCM_TAG_LENGTH) {
+        return "<decryption failed>";
+    }
+    const nonce = blob.subarray(3, 3 + GCM_NONCE_LENGTH);
+    const tag = blob.subarray(blob.length - GCM_TAG_LENGTH);
+    const ciphertext = blob.subarray(3 + GCM_NONCE_LENGTH, blob.length - GCM_TAG_LENGTH);
+    try {
+        const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    }
+    catch {
+        return "<decryption failed>";
+    }
+}
+/**
+ * Converts a Chrome/Webkit timestamp (microseconds since 1601-01-01)
+ * to a readable local Date string.
+ *
+ * @param chromeTimestamp - Timestamp in microseconds.
+ * @returns Human-readable date-time string, or "N/A".
+ */
+export function chromeTimeToDate(chromeTimestamp) {
+    if (chromeTimestamp === null || chromeTimestamp === undefined) {
+        return "N/A";
+    }
+    try {
+        const timestampBigInt = BigInt(chromeTimestamp);
+        if (timestampBigInt === 0n) {
+            return "N/A";
+        }
+        const unixMicroseconds = timestampBigInt - 11644473600000000n;
+        const ms = Number(unixMicroseconds / 1000n);
+        const date = new Date(ms);
+        if (isNaN(date.getTime())) {
+            return "N/A";
+        }
+        return date.toLocaleString();
+    }
+    catch {
+        return "N/A";
+    }
+}

package/dist/src/core/db.d.ts

@@ -1,6 +1,8 @@
 /**
- * Copies a Chrome SQLite database to a temporary location, executes a query,
- * and cleans up. This avoids SQLite locking issues when Chrome is running.
+ * Creates a transactionally consistent snapshot of a Chrome SQLite database,
+ * executes a query against it, and cleans up. `VACUUM INTO` reads through
+ * SQLite itself, so live WAL contents are included without racing raw file
+ * copies while Chrome is writing.
  *
  * @param dbFilePath - Absolute path to the Chrome database file.
  * @param sql - SQL query to execute.