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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.30",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -11,29 +11,29 @@
     "access": "public"
   },
   "scripts": {
-    "clean": "git clean -fXd && yarn",
-    "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",
+    "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": {
-      "source": [
-        "src/index.ts"
-      ],
+    "main": {
+      "source": "src/index.ts",
       "distDir": "dist",
       "isLibrary": true,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
+      },
+      "sourceMap": false,
+      "optimize": true,
+      "includeNodeModules": {
+        "@mapbox/node-pre-gyp": false
       }
     },
     "cli": {
@@ -41,11 +41,13 @@
       "distDir": "dist",
       "isLibrary": false,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
-      "includeNodeModules": [
-        "colorette"
-      ]
+      "sourceMap": false,
+      "optimize": true,
+      "includeNodeModules": {
+        "@mapbox/node-pre-gyp": false
+      }
     }
   },
   "@parcel/transformer-js": {
@@ -53,35 +55,40 @@
     "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",
+    "colorette": "2.0.20",
+    "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"
+    "minimist": "^1.2.7",
+    "sqlite3": "^5.1.6",
+    "tough-cookie": "^4.1.2",
+    "user-agents": "^1.0.1178"
   },
   "devDependencies": {
-    "@parcel/packager-ts": "^2.7.0",
-    "@parcel/transformer-typescript-types": "^2.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/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",
+    "parcel": "^2.10.1",
+    "prettier": "^2.8.1",
     "ts-node": "^10.9.1",
-    "typescript": "^4.8.4"
+    "typescript": "^5.2.2"
   }
 }

package/src/CookieRow.ts

@@ -1,4 +1,5 @@
 export default interface CookieRow {
+  expiry?: number;
   domain: string;
   name: string;
   value: Buffer;

package/src/CookieSpec.ts

@@ -1,4 +1,6 @@
 export default interface CookieSpec {
-  name: string;
   domain: string;
+  name: string;
 }
+
+export type MultiCookieSpec = CookieSpec | CookieSpec[];

package/src/CookieStore.ts

@@ -0,0 +1,27 @@
+import { env } from "./global";
+import { parsedArgs } from "./argv";
+import { CookieJar, MemoryCookieStore, Store } from "tough-cookie";
+
+import { FileCookieStore } from "./FileCookieStore";
+
+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

@@ -2,5 +2,18 @@ export default interface ExportedCookie {
   domain: string;
   name: string;
   value: string;
+  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,6 +1,5 @@
 // noinspection JSUnusedGlobalSymbols
-
-import { Response } from "cross-fetch";
+import type { Response } from "cross-fetch";
 
 export default interface FetchResponse extends Response {
   status: number;

package/src/FileCookieStore.ts

@@ -0,0 +1,175 @@
+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

@@ -0,0 +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 +1,30 @@
+import minimist from "minimist";
+import { merge } from "lodash";
+
+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 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/ChromeApplicationSupport.ts

@@ -0,0 +1,10 @@
+import { join } from "path";
+import { HOME } from "../global";
+
+export const chromeApplicationSupport: string = join(
+  HOME,
+  "Library",
+  "Application Support",
+  "Google",
+  "Chrome"
+);