chrome-tools 1.1.7 → 1.1.8

package/dist/src/modules/passwords.js

@@ -1,5 +1,7 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
-import { resolveTargetProfiles } from "../core/chrome.js";
+import { discoverProfiles, 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";
@@ -14,6 +16,44 @@ const PASSWORD_STORES = [
     { file: "Login Data", source: "device" },
     { file: "Login Data For Account", source: "account" },
 ];
+/** Where a CDP launcher keeps the User Data directory it drives Chrome with. */
+const AUTOMATION_DIR = join(homedir(), ".chrome_cdp_profile");
+/** …and where it records a relocated one. */
+const AUTOMATION_CONFIG = join(homedir(), ".config", "chrome-cdp-manager", "config.json");
+/** `CHROME_AUTOMATION_DIR` values meaning "do not look there at all". */
+const AUTOMATION_OFF = ["0", "off", "none", "false"];
+/**
+ * The automation profile tree, on a machine that has one.
+ *
+ * Most machines do not: no CDP launcher is installed, the directory was never
+ * created, or it exists but holds no profile yet. All three answer undefined,
+ * which leaves the search exactly as it was before this existed — the everyday
+ * profile, alone. Nothing here is required for a plain Chrome install.
+ *
+ * `CHROME_AUTOMATION_DIR` names the tree explicitly, and `off` (or `0`, `none`,
+ * `false`) skips it even where one exists.
+ */
+function automationChromeDir() {
+    const override = process.env.CHROME_AUTOMATION_DIR?.trim();
+    if (override && AUTOMATION_OFF.includes(override.toLowerCase()))
+        return undefined;
+    const dir = override || configuredAutomationDir() || AUTOMATION_DIR;
+    // Holding a profile is what makes it a tree worth reading — an absent or
+    // empty directory would otherwise add a root every lookup searches for
+    // nothing, and turn a missing `--profile` into a spurious refusal.
+    return discoverProfiles(dir).length > 0 ? dir : undefined;
+}
+/** The profile directory a CDP launcher was configured with, if it says. */
+function configuredAutomationDir() {
+    try {
+        const stored = JSON.parse(readFileSync(AUTOMATION_CONFIG, "utf-8"));
+        return typeof stored.profileDir === "string" && stored.profileDir ? stored.profileDir : undefined;
+    }
+    catch {
+        // No launcher config, or an unreadable one: fall back to its default path.
+        return undefined;
+    }
+}
 /**
  * Extracts and decrypts saved passwords from Chrome's password databases.
  * Reads both the device-local and account-synced stores, labelling each entry
@@ -24,41 +64,68 @@ const PASSWORD_STORES = [
  */
 export function getPasswords({ chromeDir, profilePath, profile, search, 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;
+    // The automation User Data directory first, then the everyday one. A Chrome
+    // driven over CDP keeps its own profile tree, so a login saved while signing
+    // in to that window is stored there and nowhere else — looking only at the
+    // everyday tree could not find it. Naming a directory or a browser answers
+    // "which tree?" outright, and is used as given.
+    const roots = [];
+    const automation = userDataDir || browser ? undefined : automationChromeDir();
+    if (automation)
+        roots.push(automation);
+    roots.push(userDataDir);
     const results = [];
     const term = search?.toLowerCase();
-    for (const p of profiles) {
-        for (const store of PASSWORD_STORES) {
-            const dbPath = join(p.path, store.file);
-            try {
-                const rows = queryDatabase(dbPath, `SELECT origin_url, username_value, password_value, date_last_used
-           FROM logins ORDER BY origin_url`);
-                for (const row of rows) {
-                    const entry = {
-                        profile: p.name,
-                        source: store.source,
-                        url: row.origin_url,
-                        username: row.username_value,
-                        password: row.password_value?.length > 0
-                            ? decryptValue(row.password_value, derivedKey ??= deriveEncryptionKey(userDataDir, browser))
-                            : "",
-                        lastUsed: chromeTimeToDate(row.date_last_used || 0),
-                    };
-                    if (term) {
-                        if (!(entry.url && entry.url.toLowerCase().includes(term)) &&
-                            !(entry.username && entry.username.toLowerCase().includes(term))) {
-                            continue;
+    // A named profile missing from one tree is not a failure while another is
+    // still to come — but a profile in none of them is still an error, so the
+    // first refusal is kept and raised if no tree resolved at all.
+    let refusal;
+    let resolved = false;
+    for (const root of roots) {
+        let profiles;
+        try {
+            profiles = resolveTargetProfiles({ chromeDir: root, profile, browser });
+        }
+        catch (error) {
+            refusal ??= error;
+            continue;
+        }
+        resolved = true;
+        // Per root: on Windows the key comes from that tree's own Local State.
+        let derivedKey = decryptionKey;
+        for (const p of profiles) {
+            for (const store of PASSWORD_STORES) {
+                const dbPath = join(p.path, store.file);
+                try {
+                    const rows = queryDatabase(dbPath, `SELECT origin_url, username_value, password_value, date_last_used
+             FROM logins ORDER BY origin_url`);
+                    for (const row of rows) {
+                        const entry = {
+                            profile: p.name,
+                            source: store.source,
+                            url: row.origin_url,
+                            username: row.username_value,
+                            password: row.password_value?.length > 0
+                                ? decryptValue(row.password_value, derivedKey ??= deriveEncryptionKey(root, browser))
+                                : "",
+                            lastUsed: chromeTimeToDate(row.date_last_used || 0),
+                        };
+                        if (term) {
+                            if (!(entry.url && entry.url.toLowerCase().includes(term)) &&
+                                !(entry.username && entry.username.toLowerCase().includes(term))) {
+                                continue;
+                            }
                         }
+                        results.push(entry);
                     }
-                    results.push(entry);
                 }
-            }
-            catch {
-                // Skip missing or unreadable stores and continue with the others.
+                catch {
+                    // Skip missing or unreadable stores and continue with the others.
+                }
             }
         }
     }
+    if (!resolved && refusal)
+        throw refusal;
     return results;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-tools",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "CLI & Node.js library for chrome",
   "type": "module",
   "main": "./dist/src/index.js",