@mherod/get-cookie 2.0.0-rc.11 → 2.0.0-rc.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.11",
+  "version": "2.0.0-rc.13",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -13,13 +13,11 @@
   "scripts": {
     "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
     "build": "parcel build",
+    "postbuild": "npm run check",
     "prepare": "npm run build && npm run prettier",
     "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",
+    "install:global": "npm run build && npm install --force --global .",
     "prettier": "prettier --write 'src/{**/*,*}.{js,json,ts}'",
     "check": "tsc --noEmit"
   },
@@ -80,7 +78,6 @@
     "@types/node": "^18.8.2",
     "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
-    "jest": "^29.0.3",
     "parcel": "^2.7.0",
     "prettier": "^2.7.1",
     "ts-node": "^10.9.1",

package/src/CookieStore.ts

@@ -1,11 +1,14 @@
-import { CookieJar } from "tough-cookie";
 import { env } from "./global";
+import { parsedArgs } from "./argv";
+import { CookieJar, MemoryCookieStore, Store } from "tough-cookie";
 
 const { FileCookieStore } = require("tough-cookie-file-store");
 
-export const cookieStore = new FileCookieStore(
-  `${env["HOME"]}/cookie-star.json`
-);
-// export const cookieStore = new MemoryCookieStore();
+export let cookieStore: Store;
+if (parsedArgs["cs"] == "memory") {
+  cookieStore = new MemoryCookieStore();
+} else {
+  cookieStore = new FileCookieStore(`${env["HOME"]}/cookie-star.json`);
+}
 
 export const cookieJar = new CookieJar(cookieStore);

package/src/argv.ts

@@ -1,5 +1,20 @@
 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;
+}
 
-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/FirefoxCookieQueryStrategy.ts

@@ -1,22 +1,67 @@
 import * as path from "path";
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { env, HOME } from "../global";
-import { existsSync } from "fs";
+import { HOME } from "../global";
+import fs, { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
 import ExportedCookie from "../ExportedCookie";
 import CookieRow from "../CookieRow";
 import CookieSpec from "../CookieSpec";
 import { specialCases } from "../SpecialCases";
+import { parsedArgs } from "../argv";
+import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
+import * as sqlite3 from "sqlite3";
+import { merge } from "lodash";
+
+export async function doSqliteQuery1({
+  file,
+  sql,
+  rowTransform,
+}: DoSqliteQuery1Params): Promise<CookieRow[]> {
+  if (!file || (file && !fs.existsSync(file))) {
+    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+  }
+  const db = new sqlite3.Database(file);
+  return new Promise((resolve, reject) => {
+    db.all(sql, (err: Error, rows: any[]) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      const rows1: any[] = rows;
+      if (rows1 == null || rows1.length === 0) {
+        resolve([]);
+        return;
+      }
+      if (Array.isArray(rows1)) {
+        const cookieRows: CookieRow[] = rows1.map((row: any) => {
+          const newVar = {
+            meta: {
+              file: file,
+            },
+          };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
+        });
+        resolve(cookieRows);
+        return;
+      }
+      if (parsedArgs.verbose) {
+        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+      }
+      resolve([rows1]);
+    });
+  });
+}
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
   browserName = "Firefox";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
+      // TODO: implement
+      return [];
     }
-    if (env.CHROME_ONLY) {
+    if (parsedArgs.browser !== "firefox") {
       return [];
     }
     const cookies = await this.#getFirefoxCookie({ name, domain });
@@ -49,7 +94,8 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
     const fn: (file: string) => Promise<CookieRow[]> = async (file: string) => {
       return await this.#queryCookiesDb(file, name, domain);
     };
-    const all: Awaited<CookieRow[]>[] = await Promise.all(files.map(fn));
+    const all: CookieRow[][] = await Promise.all(files.map(fn));
+    // flatten
     return all.flat();
   }
 

package/src/browsers/SafariCookieQueryStrategy.ts

@@ -5,6 +5,7 @@ export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
   browserName = "Safari";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    // TODO: implement
     return [];
   }
 }

package/src/comboQueryCookieSpec.ts

@@ -8,13 +8,16 @@ export async function comboQueryCookieSpec(
 ): Promise<ExportedCookie[]> {
   const cookies: ExportedCookie[] = [];
   if (Array.isArray(cookieSpec)) {
-    const cookieSpecs = <CookieSpec[]>cookieSpec;
-    for (const cookieSpec1 of cookieSpecs) {
-      const cookies1: ExportedCookie[] = await queryCookies(cookieSpec1);
-      cookies.push(...cookies1);
+    const results: Awaited<ExportedCookie[]>[] = await Promise.all(
+      cookieSpec.map((cs) => {
+        return queryCookies(cs);
+      })
+    );
+    for (const exportedCookie of results.flat()) {
+      cookies.push(exportedCookie);
     }
   } else {
-    const singleQuery = await queryCookies(cookieSpec);
+    const singleQuery: ExportedCookie[] = await queryCookies(cookieSpec);
     cookies.push(...singleQuery);
   }
   return uniqBy(cookies, JSON.stringify);

package/src/fetchWithCookies.ts

@@ -1,4 +1,4 @@
-// noinspection JSUnusedGlobalSymbols
+// noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
 
 import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
@@ -12,13 +12,15 @@ import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
 import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 import CookieSpec from "./CookieSpec";
 
+const userAgent = new UserAgent().toString();
+
 export async function fetchWithCookies(
   url: RequestInfo | URL,
   options: RequestInit | undefined = {},
   fetch: Function = fetchImpl
 ): Promise<Response> {
   const headers = {
-    "User-Agent": new UserAgent().toString(),
+    "User-Agent": userAgent,
   };
   const defaultOptions: RequestInit = {
     headers,
@@ -57,11 +59,21 @@ export async function fetchWithCookies(
     }
 
     const newUrl: string = res.headers.get("location") as string;
-    if (res.redirected || (newUrl && newUrl !== url2)) {
-      if (parsedArgs.verbose) {
-        console.log(blue(`Redirected to `), yellow(newUrl));
+    if (res.status >= 300 && res.status < 400) {
+      if (newUrl && newUrl !== url2) {
+        if (parsedArgs.verbose) {
+          console.log(blue(`Redirected to `), yellow(newUrl));
+        }
+        return fetchWithCookies(
+          //
+          newUrl,
+          newOptions1,
+          fetch
+          //
+        );
+      } else {
+        throw new Error("Redirected but no new location");
       }
-      return fetchWithCookies(newUrl, newOptions1);
     }
 
     const arrayBuffer1: Promise<ArrayBuffer> = res.arrayBuffer();

package/src/doSqliteQuery1.ts

@@ -1,47 +0,0 @@
-import * as fs from "fs";
-import * as sqlite3 from "sqlite3";
-import CookieRow from "./CookieRow";
-import { merge } from "lodash";
-import { parsedArgs } from "./argv";
-import { DoSqliteQuery1Params } from "./doSqliteQuery1Params";
-
-export async function doSqliteQuery1({
-  file,
-  sql,
-  rowTransform,
-}: DoSqliteQuery1Params): Promise<CookieRow[]> {
-  if (!file || (file && !fs.existsSync(file))) {
-    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
-  }
-  const db = new sqlite3.Database(file);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const rows1: any[] = rows;
-      if (rows1 == null || rows1.length === 0) {
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row: any) => {
-          const newVar = {
-            meta: {
-              file: file,
-            },
-          };
-          const cookieRow: CookieRow = rowTransform(row);
-          return merge(newVar, cookieRow);
-        });
-        resolve(cookieRows);
-        return;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}