@mherod/get-cookie 2.0.0-rc.18 → 2.0.0-rc.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.18",
+  "version": "2.0.0-rc.19",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -12,23 +12,22 @@
   },
   "scripts": {
     "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
-    "build": "parcel build",
-    "postbuild": "npm run check",
+    "build": "tsc && parcel build",
     "prepare": "npm run build && npm run prettier",
     "test": "jest",
     "prepublish": "npm run build",
-    "install:global": "npm run build && npm install --force --global .",
-    "prettier": "prettier --write 'src/{**/*,*}.{js,json,ts}'",
-    "check": "tsc --noEmit"
+    "install:global": "npm run build && npm install --global .",
+    "prettier": "prettier --write ."
   },
   "targets": {
+    "types": {},
     "main": {},
     "library": {
       "source": "src/index.ts",
       "distDir": "dist",
       "isLibrary": true,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
       "sourceMap": true,
       "includeNodeModules": false
@@ -38,9 +37,10 @@
       "distDir": "dist",
       "isLibrary": false,
       "engines": {
-        "node": "16"
+        "node": ">= 16"
       },
       "sourceMap": false,
+      "optimize": false,
       "includeNodeModules": [
         "colorette"
       ]
@@ -51,7 +51,7 @@
     "inlineEnvironment": true
   },
   "engines": {
-    "node": "16"
+    "node": ">= 16"
   },
   "keywords": [],
   "author": "Matthew Herod",
@@ -62,11 +62,11 @@
     "destr": "^1.2.0",
     "jsonwebtoken": "^8.5.1",
     "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
     "lru-cache": "^7.14.0",
     "minimist": "^1.2.7",
     "sqlite3": "^5.1.2",
     "tough-cookie": "^4.1.2",
-    "tough-cookie-file-store": "^2.0.3",
     "user-agents": "^1.0.1178"
   },
   "devDependencies": {

package/src/CookieStore.ts

@@ -2,13 +2,26 @@ import { env } from "./global";
 import { parsedArgs } from "./argv";
 import { CookieJar, MemoryCookieStore, Store } from "tough-cookie";
 
-const { FileCookieStore } = require("tough-cookie-file-store");
+import { FileCookieStore } from "./FileCookieStore";
 
-export let cookieStore: Store;
-if (parsedArgs["cs"] == "memory") {
-  cookieStore = new MemoryCookieStore();
-} else {
-  cookieStore = new FileCookieStore(`${env["HOME"]}/cookie-star.json`);
+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 cookieJar = new CookieJar(cookieStore);
+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/FileCookieStore.ts

@@ -0,0 +1,170 @@
+import { Cookie, MemoryCookieStore, Store } from "tough-cookie";
+import { existsSync, readFileSync, writeFile } from "fs";
+import destr from "destr";
+import { merge } from "lodash";
+
+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();
+
+    console.log("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 = readFileSync(filePath, "utf8");
+      const cookies: any[] = Object.values(destr(data))
+        .flatMap((domainCookies: any) => Object.values(domainCookies))
+        .flatMap((domainCookies: any) => Object.values(domainCookies));
+      console.log("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(console.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/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 { cookieJar, cookieStore } from "../CookieStore";
+import { Cookie, Store } from "tough-cookie";
+import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
 import { stringToRegex } from "../StringToRegex";
 
 export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
@@ -66,29 +66,34 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
     };
   }
 
-  #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 ?? []);
+          }
         }
-      });
+      );
     });
   }
 }

package/src/fetchWithCookies.ts

@@ -4,10 +4,10 @@ import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
-import { cookieJar } from "./CookieStore";
+import { cookieJarPromise } from "./CookieStore";
 import UserAgent from "user-agents";
 import { parsedArgs } from "./argv";
-import { blue, yellow } from "colorette";
+import { blue, redBright, yellow } from "colorette";
 import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
 import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 import CookieSpec from "./CookieSpec";
@@ -40,6 +40,7 @@ export async function fetchWithCookies(
     () => ""
   );
   if (parsedArgs["dump-request-headers"]) {
+    console.log(redBright("Request URL:"), url1.href);
     console.log(blue("Request headers:"), headers);
   }
   const newOptions1: RequestInit = merge(defaultOptions, { headers }, options);
@@ -51,7 +52,8 @@ export async function fetchWithCookies(
     });
     for (const [key, value] of headers) {
       if (key === "set-cookie") {
-        await cookieJar.setCookie(value, url2);
+        const cookieJar1 = await cookieJarPromise;
+        await cookieJar1.setCookie(value, url2);
         if (parsedArgs.verbose) {
           console.log(blue(`Set-Cookie:`), yellow(value), yellow(url2));
         }
@@ -59,11 +61,11 @@ export async function fetchWithCookies(
     }
 
     const newUrl: string = res.headers.get("location") ?? res.url;
-    const sameHost = new URL(newUrl).host === url1.host;
+    // const sameHost = new URL(newUrl).host === url1.host;
     if (res.status == 301 || res.status == 302) {
       // follow the redirect
       if (newUrl && newUrl !== url2) {
-        if (parsedArgs.verbose) {
+        if (parsedArgs.verbose || parsedArgs["dump-response-headers"]) {
           console.log(blue(`Redirected to `), yellow(newUrl));
         }
         return fetchWithCookies(

package/tsconfig.json

@@ -1,23 +1,17 @@
 {
-  "include": [
-    "src/**.ts",
-    "src/**.tsx",
-    "src/**.js",
-    "src/**.jsx"
-  ],
+  "include": ["src/**.ts", "src/**.tsx", "src/**.js", "src/**.jsx"],
   "compilerOptions": {
     "moduleResolution": "node",
     "target": "es2021",
-    "types": [
-      "node"
-    ],
-    "lib": [
-      "es2015",
-      "es2017",
-      "es2021",
-      "dom"
-    ],
+    "types": ["node"],
+    "lib": ["es2015", "es2017", "es2021", "dom"],
     "strict": true,
     "allowSyntheticDefaultImports": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "module": "commonjs",
+    "outDir": "dist",
+    "outFile": "dist/types.d.ts"
   }
 }