@mherod/get-cookie 2.0.0-rc.8 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.8",
+  "version": "2.1.0",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -11,40 +11,44 @@
     "access": "public"
   },
   "scripts": {
-    "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
-    "build": "parcel build",
-    "prepare": "npm run build && npm run prettier",
+    "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",
-    "postbuild": "npm run check",
     "prepublish": "npm run build",
-    "preinstall:global": "npm run build",
-    "install:global": "npm install --force --global .",
-    "postinstall:global": "find $NVM_BIN -exec chmod +x {} \\; || true",
-    "prettier": "prettier --write 'src/{**/*,*}.{js,json,ts}'",
-    "check": "tsc --noEmit"
+    "install:global": "npm run build && npm install --global .",
+    "prettier": "prettier --write ."
   },
   "targets": {
-    "main": {},
     "types": {},
-    "library": {
+    "main": {
       "source": "src/index.ts",
       "distDir": "dist",
       "isLibrary": true,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
-      "includeNodeModules": false
+      "sourceMap": false,
+      "optimize": true,
+      "includeNodeModules": {
+        "@mapbox/node-pre-gyp": false
+      }
     },
     "cli": {
       "source": "src/cli.ts",
       "distDir": "dist",
       "isLibrary": false,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
-      "includeNodeModules": [
-        "colorette"
-      ]
+      "sourceMap": false,
+      "optimize": true,
+      "includeNodeModules": {
+        "@mapbox/node-pre-gyp": false
+      }
     }
   },
   "@parcel/transformer-js": {
@@ -52,37 +56,47 @@
     "inlineEnvironment": true
   },
   "engines": {
-    "node": "16"
+    "node": ">= 16"
   },
   "keywords": [],
   "author": "Matthew Herod",
   "license": "ISC",
   "dependencies": {
-    "colorette": "^2.0.19",
-    "cross-fetch": "^3.1.5",
-    "destr": "^1.1.1",
-    "jsonwebtoken": "^8.5.1",
+    "consola": "3.2.3",
+    "cross-fetch": "^4.0.0",
+    "destr": "2.0.2",
+    "fast-glob": "^3.3.1",
+    "jsonwebtoken": "9.0.0",
     "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
     "lru-cache": "^7.14.0",
-    "minimist": "^1.2.6",
-    "sqlite3": "^5.1.1",
-    "tough-cookie": "^4.1.2",
-    "tough-cookie-file-store": "^2.0.3",
-    "user-agents": "^1.0.1165"
+    "minimist": "^1.2.7",
+    "sqlite3": "^5.1.6",
+    "tough-cookie": "^4.1.2"
   },
   "devDependencies": {
-    "@parcel/packager-ts": "^2.7.0",
-    "@parcel/transformer-typescript-types": "^2.7.0",
+    "@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.8.2",
+    "@types/node": "^18.11.4",
     "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
-    "jest": "^29.0.3",
-    "parcel": "^2.7.0",
-    "prettier": "^2.7.1",
+    "jest": "^29.7.0",
+    "parcel": "^2.10.1",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
-    "typescript": "^4.8.4"
+    "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/CookieRow.ts

@@ -5,3 +5,11 @@ export default interface CookieRow {
   value: Buffer;
   meta?: any;
 }
+
+export function isCookieRow(obj: any): obj is CookieRow {
+  return (
+    obj.domain !== undefined &&
+    obj.name !== undefined &&
+    obj.value !== undefined
+  );
+}

package/src/CookieSpec.ts

@@ -1,4 +1,24 @@
+// Define the CookieSpec interface with domain and name properties
 export default interface CookieSpec {
   domain: string;
   name: string;
 }
+
+// Function to check if an object is of type CookieSpec
+export function isCookieSpec(obj: any): obj is CookieSpec {
+  return (
+    // Check if domain and name properties are of type string
+    typeof obj.domain === "string" && typeof obj.name === "string"
+  );
+}
+
+// Define a type that can be either a single CookieSpec or an array of CookieSpecs
+export type MultiCookieSpec = CookieSpec | CookieSpec[];
+
+// Function to check if an object is of type MultiCookieSpec
+export function isMultiCookieSpec(obj: any): obj is MultiCookieSpec {
+  return (
+    // Check if the object is a CookieSpec or an array of CookieSpecs
+    isCookieSpec(obj) || (Array.isArray(obj) && obj.every(isCookieSpec))
+  );
+}

package/src/CookieStore.ts

@@ -1,10 +1,27 @@
-import { CookieJar } from "tough-cookie";
 import { env } from "./global";
-const { FileCookieStore } = require("tough-cookie-file-store");
+import { parsedArgs } from "./argv";
+import { CookieJar, MemoryCookieStore, Store } from "tough-cookie";
 
-export const cookieStore = new FileCookieStore(
-  `${env["HOME"]}/cookie-star.json`
-);
-// export const cookieStore = new MemoryCookieStore();
+import { FileCookieStore } from "./FileCookieStore";
 
-export const cookieJar = new CookieJar(cookieStore);
+const memoryCookieStore = new MemoryCookieStore();
+
+async function getCookieStore(): Promise<Store> {
+  if (parsedArgs["cs"] == "memory") {
+    return memoryCookieStore;
+  }
+  const fileCookieStore = new FileCookieStore(
+    `${env["HOME"]}/cookie-star.json`,
+    memoryCookieStore,
+  );
+  await fileCookieStore.waitUntilIdle();
+  return fileCookieStore;
+}
+
+export const cookieStorePromise: Promise<Store> = new Promise((resolve) => {
+  getCookieStore().then(resolve);
+});
+
+export const cookieJarPromise: Promise<CookieJar> = new Promise((resolve) => {
+  cookieStorePromise.then((store) => new CookieJar(store)).then(resolve);
+});

package/src/ExportedCookie.ts

@@ -5,3 +5,15 @@ export default interface ExportedCookie {
   expiry?: Date | "Infinity";
   meta?: any;
 }
+
+export function isExportedCookie(obj: any): obj is ExportedCookie {
+  return (
+    typeof obj.domain === "string" &&
+    typeof obj.name === "string" &&
+    typeof obj.value === "string" &&
+    (obj.expiry === undefined ||
+      obj.expiry instanceof Date ||
+      obj.expiry === "Infinity") &&
+    (obj.meta === undefined || typeof obj.meta === "object")
+  );
+}

package/src/FetchResponse.ts

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

package/src/FileCookieStore.ts

@@ -0,0 +1,178 @@
+import { Cookie, MemoryCookieStore, Store } from "tough-cookie";
+import { existsSync, writeFile } from "fs";
+import destr from "destr";
+import { merge } from "lodash";
+import { readFile } from "fs/promises";
+import logger from "./logger";
+
+export class FileCookieStore extends Store {
+  private readonly internalStore: Store;
+
+  synchronous: boolean = false;
+  filePath: string;
+
+  private tasks: Promise<any>[] = [];
+
+  constructor(
+    filePath: string,
+    internalStore: Store = new MemoryCookieStore(),
+  ) {
+    super();
+
+    this.filePath = filePath;
+    this.internalStore = internalStore ?? new MemoryCookieStore();
+
+    logger.debug("Importing cookies from", filePath, internalStore);
+
+    this.tasks.push(
+      this.importSaved(filePath, internalStore).then(
+        console.log,
+        console.error,
+      ),
+    );
+  }
+
+  private async importSaved(filePath: string, store: Store): Promise<Cookie[]> {
+    const cookies: Cookie[] = [];
+    if (existsSync(filePath)) {
+      const data: string = await readFile(filePath, "utf8");
+      // @ts-ignore
+      const cookies: any[] = Object.values(destr(data))
+        .flatMap((domainCookies: any) => Object.values(domainCookies))
+        .flatMap((domainCookies: any) => Object.values(domainCookies));
+      if (process.env["DEBUG"]) {
+        logger.start("Importing", cookies.length, "cookies");
+      }
+      const array = Array.isArray(cookies) ? cookies : Object.values(cookies);
+      const put = await Promise.all(
+        array.map((cookie) => {
+          const fromJSON = Cookie.fromJSON(cookie);
+          if (fromJSON) {
+            return this.putCookieInternal(fromJSON, store);
+          }
+        }),
+      );
+      cookies.push(...put);
+    }
+    return cookies;
+  }
+
+  findCookie(
+    domain: string,
+    path: string,
+    key: string,
+    cb: (err: Error | null, cookie: Cookie | null) => void,
+  ) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.findCookie(domain, path, key, cb);
+    });
+  }
+
+  findCookies(
+    domain: string,
+    path: string,
+    allowSpecialUseDomain: boolean,
+    cb: (err: Error | null, cookie: Cookie[]) => void,
+  ) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.findCookies(domain, path, allowSpecialUseDomain, cb);
+    });
+  }
+
+  putCookie(cookie: Cookie, cb: (err: Error | null) => void) {
+    this.internalStore.putCookie(cookie, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  updateCookie(
+    oldCookie: Cookie,
+    newCookie: Cookie,
+    cb: (err: Error | null) => void,
+  ) {
+    this.internalStore.updateCookie(oldCookie, newCookie, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  removeCookie(
+    domain: string,
+    path: string,
+    key: string,
+    cb: (err: Error | null) => void,
+  ) {
+    this.internalStore.removeCookie(domain, path, key, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  removeCookies(domain: string, path: string, cb: (err: Error | null) => void) {
+    this.internalStore.removeCookies(domain, path, cb);
+    this.internalStore.getAllCookies((err, cookies) => {
+      this.serializeCallback(err, cookies);
+    });
+  }
+
+  getAllCookies(cb: (err: Error | null, cookie: Cookie[]) => void) {
+    this.waitUntilIdle().finally(() => {
+      this.internalStore.getAllCookies(cb);
+    });
+  }
+
+  waitUntilIdle() {
+    return Promise.allSettled(this.tasks).catch(logger.error);
+  }
+
+  private async putCookieInternal(
+    cookie: Cookie,
+    store: Store,
+  ): Promise<Cookie> {
+    await this.waitUntilIdle();
+    return await new Promise<Cookie>(
+      (
+        resolve: (value: PromiseLike<Cookie> | Cookie) => void,
+        reject: (reason?: any) => void,
+      ) => {
+        store.putCookie(cookie, (err: Error | null) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookie);
+          }
+        });
+      },
+    );
+  }
+
+  private serializeCallback(err: Error | null, cookies: Cookie[]) {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    const cookieObjs = cookies.map((cookie: Cookie) => cookie);
+    const idx: any = {};
+    for (const cookie of cookieObjs) {
+      const domain = cookie.domain;
+      if (typeof domain === "string") {
+        const path: string = cookie.path ?? "/";
+        const key: string = cookie.key;
+        merge(idx, {
+          [domain]: {
+            [path]: {
+              [key]: cookie.toJSON(),
+            },
+          },
+        });
+      }
+    }
+    const stringify = JSON.stringify(idx, null, 2);
+    writeFile(this.filePath, stringify, (err) => {
+      if (err) {
+        console.error(err);
+      }
+    });
+  }
+}

package/src/StringToRegex.ts

@@ -1,6 +1,16 @@
+// This function converts a string into a regular expression
 export function stringToRegex(s: string): RegExp {
+  // Replace all occurrences of '.' with a literal '.'
   const s1 = s.replaceAll(/\./gi, ".");
+  // Replace all occurrences of '%' with '.*' to match any number of any characters
   const s2 = s1.replace(/%/g, ".*");
+  // Replace all occurrences of '*' with '.*' to match any number of any characters
   const s3 = s2.replace(/\*/g, ".*");
+  // Return the new string as a RegExp object
   return new RegExp(s3);
 }
+
+/*
+%.example.com -> .*\.example\.com
+example.com -> example\.com
+*/

package/src/argv.ts

@@ -1,5 +1,30 @@
 import minimist from "minimist";
+import { merge } from "lodash";
 
-export const argv: string[] = process.argv ?? [];
+export interface MyParsedArgs extends minimist.ParsedArgs {
+  verbose: boolean;
+  render?: string;
+  fetch?: string;
+  cs?: string;
+  dump?: string;
+  "dump-request-headers"?: string;
+  "dump-response-headers"?: string;
+  "dump-response-body"?: string;
+}
+
+/*
+Usage: get-cookie [name] [domain] [options]
+Options:
+  -h, --help: Show this help
+  -v, --verbose: Show verbose output
+  -d, --dump: Dump all results
+  -D, --dump-grouped: Dump all results, grouped by profile
+  -r, --render: Render all results
+ */
 
-export const parsedArgs: minimist.ParsedArgs = minimist(argv.slice(2));
+export const argv: string[] = process.argv ?? [];
+const minimistArgs: minimist.ParsedArgs = minimist(argv.slice(2));
+const defaultOptions = {
+  verbose: false,
+};
+export const parsedArgs: MyParsedArgs = merge(defaultOptions, minimistArgs);

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -1,16 +1,19 @@
-import ChromeCookieQueryStrategy from "./ChromeCookieQueryStrategy";
-import FirefoxCookieQueryStrategy from "./FirefoxCookieQueryStrategy";
-import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
+import ChromeCookieQueryStrategy from "./chrome/ChromeCookieQueryStrategy";
+import FirefoxCookieQueryStrategy from "./firefox/FirefoxCookieQueryStrategy";
+import SafariCookieQueryStrategy from "./safari/SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 import LRUCache from "lru-cache";
-import CookieStoreQueryStrategy from "./CookieStoreQueryStrategy";
-import { red } from "colorette";
 import { merge } from "lodash";
 import { parsedArgs } from "../argv";
+import consola from "consola";
+import { flatMapAsync } from "../util/flatMapAsync";
 
-const cache = new LRUCache<string, ExportedCookie[]>({
-  ttl: 1000 * 2,
+const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
+  string,
+  ExportedCookie[]
+>({
+  ttl: 1000 * 10, // 10 seconds
   max: 10,
 });
 
@@ -19,11 +22,11 @@ export default class CompositeCookieQueryStrategy
 {
   browserName = "all";
 
-  #strategies;
+  private readonly strategies;
 
   constructor() {
-    this.#strategies = [
-      CookieStoreQueryStrategy,
+    this.strategies = [
+      // CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
@@ -35,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/CookieQueryStrategy.ts

@@ -2,5 +2,6 @@ import ExportedCookie from "../ExportedCookie";
 
 export default interface CookieQueryStrategy {
   browserName: string;
+
   queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
 }

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -1,8 +1,8 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import CookieSpec from "../CookieSpec";
 import ExportedCookie from "../ExportedCookie";
-import { Cookie } from "tough-cookie";
-import { cookieStore, cookieJar } from "../CookieStore";
+import { Cookie, Store } from "tough-cookie";
+import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
 import { stringToRegex } from "../StringToRegex";
 
 export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
@@ -41,7 +41,9 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
     }
 
     if (name == "%") {
-      return exportedCookies;
+      return exportedCookies.filter((cookie: ExportedCookie) => {
+        return cookie.domain.match(stringToRegex(domain));
+      });
     }
 
     return exportedCookies.filter((cookie: ExportedCookie) => {
@@ -57,36 +59,41 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
       domain: cookie.domain ?? cookieSpec.domain,
       name: cookie.key ?? cookieSpec.name,
       value: cookie.value,
-      expiry: cookie.expires ?? Infinity,
+      expiry: cookie.expires ?? "Infinity",
       meta: {
         file: "tough-cookie",
       },
     };
   }
 
-  #getCookies(url: string): Promise<Cookie[]> {
+  async #getCookies(url: string): Promise<Cookie[]> {
+    const cookieJar = await cookieJarPromise;
     return new Promise((resolve, reject) => {
-      // @ts-ignore
-      return cookieJar.getCookies(url, (err, cookies) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(cookies ?? []);
-        }
-      });
+      return cookieJar.getCookies(
+        url,
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        },
+      );
     });
   }
 
-  #getAllCookies(): Promise<Cookie[]> {
+  async #getAllCookies(): Promise<Cookie[]> {
+    const cookieStore: Store = await cookieStorePromise;
     return new Promise((resolve, reject) => {
-      // @ts-ignore
-      return cookieStore.getAllCookies((err, cookies) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(cookies ?? []);
-        }
-      });
+      return cookieStore.getAllCookies(
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        },
+      );
     });
   }
 }