@mherod/get-cookie 2.0.0-rc.30 → 2.0.0-rc.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.30",
+  "version": "2.0.0-rc.32",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -14,6 +14,7 @@
     "clean": "git clean -fdX && rm -rf dist && yarn install",
     "lintfix": "prettier --write \"src/**/*.ts\"",
     "prebuild": "npm run lintfix",
+    "tsc": "tsc",
     "build": "parcel build --no-cache",
     "prepare": "parcel build --no-cache",
     "test": "jest",
@@ -61,7 +62,6 @@
   "author": "Matthew Herod",
   "license": "ISC",
   "dependencies": {
-    "colorette": "2.0.20",
     "consola": "3.2.3",
     "cross-fetch": "^4.0.0",
     "destr": "2.0.2",
@@ -72,23 +72,31 @@
     "lru-cache": "^7.14.0",
     "minimist": "^1.2.7",
     "sqlite3": "^5.1.6",
-    "tough-cookie": "^4.1.2",
-    "user-agents": "^1.0.1178"
+    "tough-cookie": "^4.1.2"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
     "@mapbox/node-pre-gyp": "^1.0.11",
     "@parcel/packager-ts": "^2.10.1",
     "@parcel/transformer-typescript-tsc": "^2.10.1",
     "@parcel/transformer-typescript-types": "^2.10.1",
+    "@types/jest": "^29.5.6",
     "@types/jsonwebtoken": "^8.5.9",
     "@types/lodash": "^4.14.186",
     "@types/minimist": "^1.2.2",
     "@types/node": "^18.11.4",
     "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
+    "jest": "^29.7.0",
     "parcel": "^2.10.1",
-    "prettier": "^2.8.1",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.1.6"
+  },
+  "parcelDependencies": {
+    "@parcel/transformer-typescript-tsc": "^2.10.1",
+    "@parcel/transformer-typescript-types": "^2.10.1",
+    "@parcel/packager-ts": "^2.10.1"
   }
 }

package/src/CookieStore.ts

@@ -12,7 +12,7 @@ async function getCookieStore(): Promise<Store> {
   }
   const fileCookieStore = new FileCookieStore(
     `${env["HOME"]}/cookie-star.json`,
-    memoryCookieStore
+    memoryCookieStore,
   );
   await fileCookieStore.waitUntilIdle();
   return fileCookieStore;

package/src/FetchResponse.ts

@@ -1,7 +1,6 @@
 // noinspection JSUnusedGlobalSymbols
-import type { Response } from "cross-fetch";
 
-export default interface FetchResponse extends Response {
+export default interface FetchResponse {
   status: number;
   statusText: string;
   headers: Headers;

package/src/FileCookieStore.ts

@@ -15,7 +15,7 @@ export class FileCookieStore extends Store {
 
   constructor(
     filePath: string,
-    internalStore: Store = new MemoryCookieStore()
+    internalStore: Store = new MemoryCookieStore(),
   ) {
     super();
 
@@ -25,7 +25,10 @@ export class FileCookieStore extends Store {
     logger.debug("Importing cookies from", filePath, internalStore);
 
     this.tasks.push(
-      this.importSaved(filePath, internalStore).then(console.log, console.error)
+      this.importSaved(filePath, internalStore).then(
+        console.log,
+        console.error,
+      ),
     );
   }
 
@@ -47,7 +50,7 @@ export class FileCookieStore extends Store {
           if (fromJSON) {
             return this.putCookieInternal(fromJSON, store);
           }
-        })
+        }),
       );
       cookies.push(...put);
     }
@@ -58,7 +61,7 @@ export class FileCookieStore extends Store {
     domain: string,
     path: string,
     key: string,
-    cb: (err: Error | null, cookie: Cookie | null) => void
+    cb: (err: Error | null, cookie: Cookie | null) => void,
   ) {
     this.waitUntilIdle().finally(() => {
       this.internalStore.findCookie(domain, path, key, cb);
@@ -69,7 +72,7 @@ export class FileCookieStore extends Store {
     domain: string,
     path: string,
     allowSpecialUseDomain: boolean,
-    cb: (err: Error | null, cookie: Cookie[]) => void
+    cb: (err: Error | null, cookie: Cookie[]) => void,
   ) {
     this.waitUntilIdle().finally(() => {
       this.internalStore.findCookies(domain, path, allowSpecialUseDomain, cb);
@@ -86,7 +89,7 @@ export class FileCookieStore extends Store {
   updateCookie(
     oldCookie: Cookie,
     newCookie: Cookie,
-    cb: (err: Error | null) => void
+    cb: (err: Error | null) => void,
   ) {
     this.internalStore.updateCookie(oldCookie, newCookie, cb);
     this.internalStore.getAllCookies((err, cookies) => {
@@ -98,7 +101,7 @@ export class FileCookieStore extends Store {
     domain: string,
     path: string,
     key: string,
-    cb: (err: Error | null) => void
+    cb: (err: Error | null) => void,
   ) {
     this.internalStore.removeCookie(domain, path, key, cb);
     this.internalStore.getAllCookies((err, cookies) => {
@@ -125,13 +128,13 @@ export class FileCookieStore extends Store {
 
   private async putCookieInternal(
     cookie: Cookie,
-    store: Store
+    store: Store,
   ): Promise<Cookie> {
     await this.waitUntilIdle();
     return await new Promise<Cookie>(
       (
         resolve: (value: PromiseLike<Cookie> | Cookie) => void,
-        reject: (reason?: any) => void
+        reject: (reason?: any) => void,
       ) => {
         store.putCookie(cookie, (err: Error | null) => {
           if (err) {
@@ -140,7 +143,7 @@ export class FileCookieStore extends Store {
             resolve(cookie);
           }
         });
-      }
+      },
     );
   }
 

package/src/browsers/ChromeApplicationSupport.ts

@@ -6,5 +6,5 @@ export const chromeApplicationSupport: string = join(
   "Library",
   "Application Support",
   "Google",
-  "Chrome"
+  "Chrome",
 );

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -37,7 +37,7 @@ export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
 async function getPromise1(
   name: string,
   domain: string,
-  file: string
+  file: string,
 ): Promise<CookieRow[]> {
   try {
     return await getEncryptedChromeCookie({
@@ -60,7 +60,7 @@ async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
       name: "Cookies",
     });
     const promises: Promise<CookieRow[]>[] = files.map((file) =>
-      getPromise1(name, domain, file)
+      getPromise1(name, domain, file),
     );
     const results1: CookieRow[][] = await Promise.all(promises);
     return results1.flat().filter(isCookieRow);
@@ -124,7 +124,7 @@ Promise<ExportedCookie[]> {
       return exportedCookie;
     });
   const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
-    isExportedCookie
+    isExportedCookie,
   );
   if (parsedArgs.verbose) {
     console.log("results", results);
@@ -148,7 +148,7 @@ async function getEncryptedChromeCookie({
   if (parsedArgs.verbose) {
     const s = file.split("/").slice(-3).join("/");
     consola.start(
-      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`
+      `Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`,
     );
   }
   let sql;

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -4,15 +4,16 @@ import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 import LRUCache from "lru-cache";
-import { red } from "colorette";
 import { merge } from "lodash";
 import { parsedArgs } from "../argv";
+import consola from "consola";
+import { flatMapAsync } from "../util/flatMapAsync";
 
 const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
   string,
   ExportedCookie[]
 >({
-  ttl: 1000 * 10,
+  ttl: 1000 * 10, // 10 seconds
   max: 10,
 });
 
@@ -21,10 +22,10 @@ export default class CompositeCookieQueryStrategy
 {
   browserName = "all";
 
-  #strategies;
+  private readonly strategies;
 
   constructor() {
-    this.#strategies = [
+    this.strategies = [
       // CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
@@ -37,38 +38,33 @@ export default class CompositeCookieQueryStrategy
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
     const key = `${name}:${domain}`;
-    const cached = cache.get(key);
-    if (cached) {
-      return cached;
+    if (cache.has(key)) {
+      const cached = cache.get(key);
+      if (cached) {
+        return cached;
+      }
     }
     if (parsedArgs.verbose) {
-      console.log("Querying cookies:", name, domain);
+      consola.log("Querying cookies:", name, domain);
     }
-    const results: ExportedCookie[][] = await Promise.all(
-      this.#strategies.map(async (strategy: CookieQueryStrategy) => {
-        // @ts-ignore
-        return strategy
-          .queryCookies(name, domain)
-          .then((cookies: ExportedCookie[]) => {
-            return cookies.map((cookie: ExportedCookie) => {
-              return merge(cookie, {
-                meta: {
-                  browser: strategy.browserName,
-                },
-              });
+    const results = await flatMapAsync(this.strategies, async (strategy) => {
+      return strategy
+        .queryCookies(name, domain)
+        .then((cookies: ExportedCookie[]) => {
+          return cookies.map((cookie: ExportedCookie) => {
+            return merge(cookie, {
+              meta: {
+                browser: strategy.browserName,
+              },
             });
-          })
-          .catch((e) => {
-            console.log(
-              red(`Error querying ${strategy.browserName} cookies`),
-              e
-            );
-            return [];
           });
-      })
-    );
-    const flat: ExportedCookie[] = results.flat();
-    cache.set(`${name}:${domain}`, flat);
-    return flat;
+        })
+        .catch((e) => {
+          consola.error(`Error querying ${strategy.browserName} cookies`, e);
+          return [];
+        });
+    });
+    cache.set(`${name}:${domain}`, results);
+    return results;
   }
 }

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -77,7 +77,7 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
           } else {
             resolve(cookies ?? []);
           }
-        }
+        },
       );
     });
   }
@@ -92,7 +92,7 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
           } else {
             resolve(cookies ?? []);
           }
-        }
+        },
       );
     });
   }

package/src/browsers/DoSqliteQueryWithTransform.ts

@@ -27,7 +27,7 @@ function transformRows(
   rows: any[],
   rowFilter: (row: any) => boolean,
   rowTransform: (row: any) => CookieRow,
-  file: string
+  file: string,
   //
 ): CookieRow[] {
   return rows.filter(rowFilter).map((row: any) => {
@@ -51,7 +51,7 @@ export async function doSqliteQueryWithTransform(
     sql,
     rowFilter = () => true,
     rowTransform,
-  }: DoSqliteQueryWithTransformOptions
+  }: DoSqliteQueryWithTransformOptions,
 ): //
 Promise<CookieRow[]> {
   checkFileExistence(file);
@@ -72,7 +72,7 @@ Promise<CookieRow[]> {
         rows,
         rowFilter,
         rowTransform,
-        file
+        file,
       );
 
       if (parsedArgs.verbose) {

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -36,7 +36,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   }
 
   async #getFirefoxCookie(
-    { name, domain }: CookieSpec //
+    { name, domain }: CookieSpec, //
   ) {
     const files: string[] = findAllFiles({
       path: path.join(
@@ -44,7 +44,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
         "Library",
         "Application Support",
         "Firefox",
-        "Profiles"
+        "Profiles",
       ),
       name: "cookies.sqlite",
     });
@@ -59,7 +59,7 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   async #queryCookiesDb(
     file: string,
     name: string,
-    domain: string
+    domain: string,
   ): Promise<CookieRow[]> {
     if (file && !existsSync(file)) {
       throw new Error(`File ${file} does not exist`);

package/src/browsers/decrypt.ts

@@ -5,7 +5,7 @@ import consola from "consola";
 // Function to decrypt encrypted data using a password
 export async function decrypt(
   password: BinaryLike, // The password to use for decryption
-  encryptedData: Buffer // The data to decrypt
+  encryptedData: Buffer, // The data to decrypt
 ): Promise<string> {
   // Returns a promise that resolves with the decrypted string
   // Check if password is a string
@@ -25,7 +25,7 @@ export async function decrypt(
       // Log if encryptedData is an array of buffers
       if (parsedArgs.verbose) {
         console.log(
-          `encryptedData is an array of buffers, selected first: ${encryptedData1}`
+          `encryptedData is an array of buffers, selected first: ${encryptedData1}`,
         );
       }
     } else {
@@ -56,7 +56,7 @@ export async function decrypt(
           if (parsedArgs.verbose) {
             console.log(
               "Error doing pbkdf2, buffer length is not 16",
-              buffer.length
+              buffer.length,
             );
           }
           reject(new Error("Buffer length is not 16"));
@@ -80,7 +80,7 @@ export async function decrypt(
           if (parsedArgs.verbose) {
             console.log(
               "Error doing pbkdf2, encryptedData length is not a multiple of 16",
-              encryptedData1.length
+              encryptedData1.length,
             );
           }
           reject(new Error("encryptedData length is not a multiple of 16"));

package/src/browsers/getChromePassword.ts

@@ -1,7 +1,7 @@
 import { execSimple } from "../execSimple";
 
 const chromePassword: Promise<string> = execSimple(
-  'security find-generic-password -w -s "Chrome Safe Storage"'
+  'security find-generic-password -w -s "Chrome Safe Storage"',
 );
 
 export async function getChromePassword(): Promise<string> {

package/src/cli.ts

@@ -1,55 +1,12 @@
 #!/usr/bin/env ts-node
 
 import { argv, parsedArgs } from "./argv";
-import { groupBy } from "lodash";
-import { green, red, yellow } from "colorette";
-import { resultsRendered } from "./resultsRendered";
 import { fetchWithCookies } from "./fetchWithCookies";
 import { unpackHeaders } from "./unpackHeaders";
 import CookieSpec from "./CookieSpec";
-import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 import logger from "./logger";
-
-async function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[]) {
-  try {
-    const results = await comboQueryCookieSpec(cookieSpec);
-    if (results == null || results.length == 0) {
-      logger.error(red("No results"));
-      return;
-    }
-    if (parsedArgs["dump"] || parsedArgs["d"]) {
-      logger.log(results);
-      return;
-    }
-    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      logger.log(green(JSON.stringify(groupedByFile, null, 2)));
-      return;
-    }
-    if (
-      parsedArgs["render"] ||
-      parsedArgs["render-merged"] ||
-      parsedArgs["r"]
-    ) {
-      logger.log(yellow(resultsRendered(results)));
-      return;
-    }
-    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      for (const file of Object.keys(groupedByFile)) {
-        let results = groupedByFile[file];
-        logger.log(green(file) + ": ", yellow(resultsRendered(results)));
-      }
-      return;
-    }
-    for (const result of results) {
-      logger.log(result.value);
-    }
-  } catch (e) {
-    logger.error(e);
-  }
-}
+import { cliQueryCookies } from "./cliQueryCookies";
 
 async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
@@ -95,14 +52,14 @@ async function main() {
       {
         //
         headers,
-      }
+      },
       //
     ).then(
       (res) => {
         logger.debug("Response", res);
         onfulfilled(res);
       },
-      logger.error
+      logger.error,
       //
     );
   }

package/src/cliQueryCookies.ts

@@ -0,0 +1,62 @@
+import CookieSpec from "./CookieSpec";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import logger from "./logger";
+import { parsedArgs } from "./argv";
+import { groupBy } from "lodash";
+import { resultsRendered } from "./resultsRendered";
+import ExportedCookie from "./ExportedCookie";
+import { createConsola } from "consola";
+
+const consola = createConsola({
+  fancy: true,
+  formatOptions: {
+    colors: true,
+    date: false,
+  },
+});
+consola.wrapConsole();
+
+export async function cliQueryCookies(
+  cookieSpec: CookieSpec | CookieSpec[],
+  limit?: number,
+  removeExpired?: boolean,
+  //
+) {
+  try {
+    const results: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+    if (results == null || results.length == 0) {
+      consola.error("No results");
+      return;
+    }
+    if (parsedArgs["dump"] || parsedArgs["d"]) {
+      consola.log(results);
+      return;
+    }
+    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      consola.log(JSON.stringify(groupedByFile, null, 2));
+      return;
+    }
+    if (
+      parsedArgs["render"] ||
+      parsedArgs["render-merged"] ||
+      parsedArgs["r"]
+    ) {
+      consola.log(resultsRendered(results));
+      return;
+    }
+    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      for (const file of Object.keys(groupedByFile)) {
+        let results = groupedByFile[file];
+        consola.log(file, ": ", resultsRendered(results));
+      }
+      return;
+    }
+    for (const result of results) {
+      logger.log(result.value);
+    }
+  } catch (e) {
+    logger.error(e);
+  }
+}

package/src/comboQueryCookieSpec.ts

@@ -2,23 +2,20 @@ import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 import { queryCookies } from "./queryCookies";
 import { uniqBy } from "lodash";
+import { flatMapAsync } from "./util/flatMapAsync";
 
 export async function comboQueryCookieSpec(
-  cookieSpec: MultiCookieSpec
+  cookieSpec: MultiCookieSpec,
 ): Promise<ExportedCookie[]> {
-  const cookies: ExportedCookie[] = [];
   if (Array.isArray(cookieSpec)) {
-    const results: Awaited<ExportedCookie[]>[] = await Promise.all(
-      cookieSpec.map((cs) => {
-        return queryCookies(cs);
-      })
-    );
-    for (const exportedCookie of results.flat()) {
-      cookies.push(exportedCookie);
-    }
+    const cookiesForMultiSpec: ExportedCookie[] = //
+      await flatMapAsync(cookieSpec, async (cs) => {
+        return await queryCookies(cs);
+      });
+    return uniqBy(cookiesForMultiSpec, JSON.stringify);
   } else {
-    const singleQuery: ExportedCookie[] = await queryCookies(cookieSpec);
-    cookies.push(...singleQuery);
+    const cookiesForSingleSpec: ExportedCookie[] = //
+      await queryCookies(cookieSpec);
+    return uniqBy(cookiesForSingleSpec, JSON.stringify);
   }
-  return uniqBy(cookies, JSON.stringify);
 }