@mherod/get-cookie 1.1.3 → 1.1.6

package/README.md

@@ -0,0 +1,31 @@
+# get-cookie
+
+## What is it?
+
+get-cookie is a command line utility that allows you to get the value of a cookie from your locally installed browser.
+It is useful for testing web pages that require authentication.
+
+## Installation
+
+To install get-cookie, run the following command:
+
+        $ npm install @mherod/get-cookie --global
+
+## How do I use it?
+
+To use get-cookie, run the following command:
+
+        $ get-cookie <cookie-name> <domain>
+
+For example, to get the value of the `auth` cookie on the `www.example.com` domain, run the following command:
+
+        $ get-cookie auth www.example.com
+
+The output of the command will be the value of the cookie.
+
+The library can also be used as a module.
+
+```javascript
+const {getCookie} = require('@mherod/get-cookie');
+getCookie('auth', 'www.example.com').then(console.log);
+```

package/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const {getFirefoxCookie, getChromeCookie} = require("./index");
+const {printStringValue} = require("./utils");
+
+if (process.argv) {
+    if (process.argv.length > 2) {
+        const name = process.argv[2];
+        const domain = process.argv[3] ?? '%';
+
+        if (process.argv.includes('--verbose')) {
+            process.env.VERBOSE = "true";
+        }
+        if (process.argv.includes("--chrome-only")) {
+            process.env.CHROME_ONLY = "true";
+        }
+        if (process.argv.includes("--firefox-only")) {
+            process.env.FIREFOX_ONLY = "true";
+        }
+        if (process.argv.includes("--ignore-expired")) {
+            process.env.IGNORE_EXPIRED = "true";
+        }
+
+        if (process.env.VERBOSE) {
+            console.log("Verbose mode", process.argv);
+        }
+
+        if (process.env.CHROME_ONLY) {
+            if (process.env.VERBOSE) {
+                console.log('chrome only');
+            }
+            getChromeCookie({name, domain})
+                .then(cookie => {
+                    if (cookie && cookie.length > 0) {
+                        printStringValue(cookie);
+                    } else {
+                        console.log('No cookie found');
+                    }
+                })
+                .catch(err => {
+                    if (process.env.VERBOSE) {
+                        console.error(err);
+                    }
+                });
+        } else if (process.env.FIREFOX_ONLY) {
+            if (process.env.VERBOSE) {
+                console.log('firefox only');
+            }
+            getFirefoxCookie({name, domain})
+                .then(cookie => {
+                    if (cookie && cookie.length > 0) {
+                        printStringValue(cookie);
+                    } else {
+                        console.log('No cookie found');
+                    }
+                })
+                .catch(err => {
+                    if (process.env.VERBOSE) {
+                        console.error("Error getting Firefox cookie", err);
+                    }
+                });
+        } else {
+            getChromeCookie({name, domain})
+                .catch(err => {
+                    if (process.env.VERBOSE) {
+                        console.error("Error getting Chrome cookie", err);
+                    }
+                })
+                .then(r => {
+                    if (typeof r === 'string' && r.trim().length > 0) {
+                        return r;
+                    } else {
+                        return getFirefoxCookie({name, domain})
+                            .catch(err => {
+                                if (process.env.VERBOSE) {
+                                    console.error("Error getting Firefox cookie", err);
+                                }
+                            });
+                    }
+                })
+                .catch((e) => {
+                    if (process.env.VERBOSE) {
+                        console.error("Error getting Chrome or Firefox cookie", e);
+                    }
+                })
+                .then(printStringValue);
+        }
+    }
+}

package/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 const crypto = require('crypto');
-const {exec} = require("child_process");
 const fs = require("fs");
+const {execSimple} = require("./utils");
 
 if (process.platform !== 'darwin') {
     throw new Error('This script only works on macOS');
@@ -13,23 +13,10 @@ if (process.platform !== 'darwin') {
  * @returns {Promise<string>}
  */
 async function getChromePassword() {
-    return await new Promise((resolve, reject) => {
-        exec("security find-generic-password -w -s \"Chrome Safe Storage\"", (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            if (stderr) {
-                reject(error);
-                return;
-            }
-            let s = stdout.toString().trim();
-            resolve(s);
-        });
-    });
+    return await execSimple("security find-generic-password -w -s \"Chrome Safe Storage\"");
 }
 
-async function getCookie() {
+async function getCookie(name, domain) {
     throw new Error('Not implemented');
 }
 
@@ -46,8 +33,11 @@ async function getFirefoxCookie({name, domain}) {
     if (domain && typeof domain !== 'string') {
         throw new Error('domain must be a string');
     }
-    const file = await findFile(`${process.env.HOME}/Library/Application Support/Firefox/Profiles`, "cookies.sqlite")
-    if (!fs.existsSync(file)) {
+    const [file] = await findAllFiles({
+        path: `${process.env.HOME}/Library/Application Support/Firefox/Profiles`,
+        name: "cookies.sqlite"
+    })
+    if (file && !fs.existsSync(file)) {
         throw new Error(`File ${file} does not exist`);
     }
     if (process.env.VERBOSE) {
@@ -73,7 +63,7 @@ async function getFirefoxCookie({name, domain}) {
 const defaultChromeRoot = `${process.env.HOME}/Library/Application Support/Google/Chrome`;
 const defaultChromeCookies = `${defaultChromeRoot}/Default/Cookies`;
 
-async function getEncryptedChromeCookie(name, domain, file = defaultChromeCookies) {
+async function getEncryptedChromeCookie({name, domain, file = defaultChromeCookies}) {
     if (name && typeof name !== 'string') {
         throw new Error('name must be a string');
     }
@@ -134,33 +124,6 @@ async function doSqliteQuery1(file, sql) {
     });
 }
 
-async function doSqliteQuery(file, sql) {
-    const command = `sqlite3 "${file}" "${sql}"`;
-    if (process.env.VERBOSE) {
-        console.log(command);
-    }
-    return await new Promise((resolve, reject) => {
-        exec(command, {encoding: 'binary', maxBuffer: 5 * 1024}, (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            if (stderr) {
-                reject(error);
-                return;
-            }
-            let stdoutAsBuffer = stdout;
-            if (typeof stdoutAsBuffer === 'string' && stdoutAsBuffer.length > 0) {
-                // noinspection JSCheckFunctionSignatures
-                stdoutAsBuffer = Buffer.from(stdoutAsBuffer, 'binary').slice(0, -1);
-            }
-            if (stdoutAsBuffer && stdoutAsBuffer.length > 0) {
-                resolve(stdoutAsBuffer);
-            }
-        });
-    });
-}
-
 /**
  *
  * @param {string} password
@@ -213,8 +176,8 @@ async function decrypt(password, encryptedData) {
                     return;
                 }
 
-                let decoded = decipher.update(encryptedData1, 'binary', 'utf8');
-                // let decoded = decipher.update(encryptedData);
+                // let decoded = decipher.update(encryptedData1, 'binary', 'utf8');
+                let decoded = decipher.update(encryptedData);
                 try {
                     decipher.final('utf-8');
                 } catch (e) {
@@ -242,37 +205,75 @@ async function decrypt(password, encryptedData) {
 /**
  *
  * @param {string|undefined} name
- * @param {string|undefined} domain
+ * @param {string} domain
  * @returns {Promise<string>}
  */
-async function getChromeCookie({name, domain}) {
+async function getChromeCookie({name, domain = '%'}) {
     if (name && typeof name !== 'string') {
         throw new Error('name must be a string');
     }
-    if (domain && typeof domain !== 'string') {
+    if (typeof domain !== 'string') {
         throw new Error('domain must be a string');
     }
     const chromePasswordPromise = getChromePassword();
-    const [encryptedData] = await findAllFiles({path: defaultChromeRoot, name: 'Cookies'}).then(files => {
-        return Promise.all(files.map(file => getEncryptedChromeCookie(name, domain, file)));
+    const encryptedDataItems = await findAllFiles({
+        path: defaultChromeRoot,
+        name: 'Cookies'
+    }).then(files => {
+        const promises = files.map(file => {
+            return getEncryptedChromeCookie({
+                name: name,
+                domain: domain,
+                file: file
+            }).catch(e => {
+                if (process.env.VERBOSE) {
+                    console.log("Error getting encrypted cookie", e);
+                }
+                return null;
+            });
+        });
+        const promise = Promise.all(promises).then(results => {
+            return results.filter(result => {
+                return result;
+            });
+        });
+        if (process.env.VERBOSE) {
+            console.log('promise', promise);
+        }
+        return promise;
+    }).catch(error => {
+        if (process.env.VERBOSE) {
+            console.log('error', error);
+        }
+        return [];
     });
     const password = await chromePasswordPromise;
-    if (process.env.VERBOSE) {
-        console.log("Received encrypted", encryptedData);
-    }
-    let s;
-    try {
-        s = await decrypt(password, encryptedData);
-    } catch (e) {
+    const decrypted = encryptedDataItems.filter(encryptedData => {
+        return encryptedData != null && encryptedData.length > 0;
+    }).map(async encryptedData => {
         if (process.env.VERBOSE) {
-            console.error("Error decrypting", e);
+            console.log("Received encrypted", encryptedData);
         }
-        throw new Error('Failed to decrypt');
-    }
-    if (process.env.VERBOSE) {
-        console.log("Decrypted", s);
-    }
-    return s;
+        let decrypted;
+        try {
+            decrypted = await decrypt(password, encryptedData);
+        } catch (e) {
+            if (process.env.VERBOSE) {
+                console.log("Error decrypting cookie", e);
+            }
+            return null;
+        }
+        if (decrypted) {
+            if (process.env.VERBOSE) {
+                console.log("Decrypted", decrypted);
+            }
+            return decrypted;
+        }
+        return null;
+    });
+    return await Promise.all(decrypted).then(results => {
+        return results.find(result => typeof result === 'string' && result.length > 0);
+    });
 }
 
 /**
@@ -294,9 +295,26 @@ async function findAllFiles({path, name, rootSegments = path.split('/').length,
         console.log(`Searching for ${name} in ${path}`);
     }
     const files = [];
-    for (const file of fs.readdirSync(path)) {
+    let readdirSync;
+    try {
+        readdirSync = fs.readdirSync(path);
+    } catch (e) {
+        if (process.env.VERBOSE) {
+            console.log(`Error reading ${path}`, e);
+        }
+        return files;
+    }
+    for (const file of readdirSync) {
         const filePath = path + '/' + file;
-        const stat = fs.statSync(filePath);
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        } catch (e) {
+            if (process.env.VERBOSE) {
+                console.error(`Error getting stat for ${filePath}`, e);
+            }
+            continue;
+        }
         if (stat.isDirectory()) {
             if (filePath.split('/').length < rootSegments + maxDepth) {
                 try {
@@ -326,40 +344,6 @@ async function findAllFiles({path, name, rootSegments = path.split('/').length,
     return files;
 }
 
-/**
- *
- * @param path
- * @param name
- * @returns {Promise<string>}
- */
-async function findFile(path, name) {
-    return await new Promise((resolve, reject) => {
-        for (const file of fs.readdirSync(path)) {
-            const filePath = path + '/' + file;
-            const stat = fs.statSync(filePath);
-            if (stat.isDirectory()) {
-                findFile(filePath, name).then(resolve).catch(reject);
-            } else if (file === name) {
-                resolve(filePath);
-            }
-        }
-    });
-}
-
-function printStringValue(r) {
-    if (process.env.VERBOSE) {
-        console.log("Printing value", r);
-    }
-    if (r) {
-        if (typeof r === 'string') {
-            console.log(r);
-        } else if (r.toString) {
-            // noinspection JSCheckFunctionSignatures
-            console.log(r.toString('utf8'));
-        }
-    }
-}
-
 // noinspection JSUnusedGlobalSymbols
 module.exports = {
     getDecryptedCookie: getChromeCookie,
@@ -367,88 +351,3 @@ module.exports = {
     getFirefoxCookie,
     getCookie
 };
-
-if (process.argv) {
-    if (process.argv.length > 2) {
-        const name = process.argv[2];
-        const domain = process.argv[3] ?? '%';
-
-        if (process.argv.includes('--verbose')) {
-            process.env.VERBOSE = "true";
-        }
-        if (process.argv.includes("--chrome-only")) {
-            process.env.CHROME_ONLY = "true";
-        }
-        if (process.argv.includes("--firefox-only")) {
-            process.env.FIREFOX_ONLY = "true";
-        }
-        if (process.argv.includes("--ignore-expired")) {
-            process.env.IGNORE_EXPIRED = "true";
-        }
-
-        if (process.env.VERBOSE) {
-            console.log("Verbose mode", process.argv);
-        }
-
-        if (process.env.CHROME_ONLY) {
-            if (process.env.VERBOSE) {
-                console.log('chrome only');
-            }
-            getChromeCookie({name, domain})
-                .then(cookie => {
-                    if (cookie && cookie.length > 0) {
-                        printStringValue(cookie);
-                    } else {
-                        console.log('No cookie found');
-                    }
-                })
-                .catch(err => {
-                    if (process.env.VERBOSE) {
-                        console.error(err);
-                    }
-                });
-        } else if (process.env.FIREFOX_ONLY) {
-            if (process.env.VERBOSE) {
-                console.log('firefox only');
-            }
-            getFirefoxCookie({name, domain})
-                .then(cookie => {
-                    if (cookie && cookie.length > 0) {
-                        printStringValue(cookie);
-                    } else {
-                        console.log('No cookie found');
-                    }
-                })
-                .catch(err => {
-                    if (process.env.VERBOSE) {
-                        console.error("Error getting Firefox cookie", err);
-                    }
-                });
-        } else {
-            getChromeCookie({name, domain})
-                .catch(err => {
-                    if (process.env.VERBOSE) {
-                        console.error("Error getting Chrome cookie", err);
-                    }
-                })
-                .then(r => {
-                    if (typeof r === 'string' && r.trim().length > 0) {
-                        return r;
-                    } else {
-                        return getFirefoxCookie({name, domain})
-                            .catch(err => {
-                                if (process.env.VERBOSE) {
-                                    console.error("Error getting Firefox cookie", err);
-                                }
-                            });
-                    }
-                })
-                .catch((e) => {
-                    if (process.env.VERBOSE) {
-                        console.error("Error getting Chrome or Firefox cookie", e);
-                    }
-                })
-                .then(printStringValue);
-        }
-    }
-}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "1.1.3",
+  "version": "1.1.6",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "main": "index.js",
-  "bin": "index.js",
+  "bin": "cli.js",
   "publishConfig": {
     "access": "public"
   },

package/utils.js

@@ -0,0 +1,76 @@
+// noinspection JSUnusedGlobalSymbols
+
+const {exec} = require('child_process');
+
+async function execSimple(command) {
+    if (typeof command !== 'string') {
+        throw new TypeError('execSimple: command must be a string');
+    }
+    if (process.env.VERBOSE) {
+        console.log(command);
+    }
+    return await new Promise((resolve, reject) => {
+        exec(command, {encoding: 'binary', maxBuffer: 5 * 1024}, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (stderr) {
+                reject(error);
+                return;
+            }
+            if (stdout) {
+                resolve(stdout.toString('utf8').trim());
+            }
+        });
+    });
+}
+
+async function execAsBuffer(command) {
+    if (typeof command !== 'string') {
+        throw new TypeError('execAsBuffer: command must be a string');
+    }
+    if (process.env.VERBOSE) {
+        console.log(command);
+    }
+    return await new Promise((resolve, reject) => {
+        exec(command, {encoding: 'binary', maxBuffer: 5 * 1024}, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (stderr) {
+                reject(error);
+                return;
+            }
+            let stdoutAsBuffer = stdout;
+            if (typeof stdoutAsBuffer === 'string' && stdoutAsBuffer.length > 0) {
+                // noinspection JSCheckFunctionSignatures
+                stdoutAsBuffer = Buffer.from(stdoutAsBuffer, 'binary').slice(0, -1);
+            }
+            if (stdoutAsBuffer && stdoutAsBuffer.length > 0) {
+                resolve(stdoutAsBuffer);
+            }
+        });
+    });
+}
+
+function printStringValue(r) {
+    if (process.env.VERBOSE) {
+        console.log("Printing value", r);
+    }
+    if (r) {
+        if (typeof r === 'string') {
+            console.log(r);
+        } else if (r.toString) {
+            // noinspection JSCheckFunctionSignatures
+            console.log(r.toString('utf8'));
+        }
+    }
+}
+
+module.exports = {
+    execSimple: execSimple,
+    execAsBuffer: execAsBuffer,
+    printStringValue: printStringValue
+};