@mherod/get-cookie 2.0.0-rc.10 → 2.0.0-rc.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.10",
+  "version": "2.0.0-rc.12",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -13,19 +13,16 @@
   "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"
   },
   "targets": {
     "main": {},
-    "types": {},
     "library": {
       "source": "src/index.ts",
       "distDir": "dist",
@@ -33,6 +30,7 @@
       "engines": {
         "node": "16"
       },
+      "sourceMap": true,
       "includeNodeModules": false
     },
     "cli": {
@@ -42,6 +40,7 @@
       "engines": {
         "node": "16"
       },
+      "sourceMap": false,
       "includeNodeModules": [
         "colorette"
       ]
@@ -79,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/CookieSpec.ts

@@ -2,3 +2,5 @@ export default interface CookieSpec {
   domain: string;
   name: string;
 }
+
+export type MultiCookieSpec = CookieSpec | CookieSpec[];

package/src/CookieStore.ts

@@ -1,10 +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/ChromeCookieQueryStrategy.ts

@@ -1,11 +1,10 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { execSimple } from "../utils";
 import { env, HOME } from "../global";
-import { existsSync } from "fs";
+import fs, { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
 import * as crypto from "crypto";
 import * as path from "path";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
 import { isExportedCookie } from "../IsExportedCookie";
@@ -13,7 +12,6 @@ import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
 import { stringToRegex } from "../StringToRegex";
 import { parsedArgs } from "../argv";
-import fs from "fs";
 import * as sqlite3 from "sqlite3";
 import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
 
@@ -113,11 +111,15 @@ Promise<ExportedCookie[]> {
         meta: meta,
       };
       const expiry = cookieRow.expiry;
-      if (expiry) {
-        merge(exportedCookie, {
-          expiry: new Date(expiry),
-        });
-      }
+      const mergeExpiry =
+        expiry != null && expiry > 0
+          ? {
+              expiry: new Date(expiry),
+            }
+          : {
+              expiry: "Infinity",
+            };
+      merge(exportedCookie, mergeExpiry);
       return exportedCookie;
     });
   const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
@@ -179,9 +181,16 @@ async function getEncryptedChromeCookie({
       sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
+  if (parsedArgs.verbose) {
+    console.log("sql", sql);
+  }
+  const domainRegexp: RegExp = stringToRegex(domain);
   const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
     file: file,
     sql: sql,
+    rowFilter: (row) => {
+      return row["host_key"].match(domainRegexp) != null;
+    },
     rowTransform: (row) => {
       const cookieRow = {
         expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
@@ -196,7 +205,7 @@ async function getEncryptedChromeCookie({
     },
   });
   return sqliteQuery1.filter((row) => {
-    return row.domain.match(stringToRegex(domain)) != null;
+    return row.domain.match(domainRegexp) != null;
   });
 }
 
@@ -304,6 +313,7 @@ async function decrypt(
 export async function doChromeSqliteQuery1({
   file,
   sql,
+  rowFilter = () => true,
   rowTransform,
 }: DoSqliteQuery1Params): Promise<CookieRow[]> {
   if (!file || (file && !fs.existsSync(file))) {
@@ -322,15 +332,17 @@ export async function doChromeSqliteQuery1({
         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);
-        });
+        const cookieRows: CookieRow[] = rows1
+          .filter(rowFilter)
+          .map((row: any) => {
+            const newVar = {
+              meta: {
+                file: file,
+              },
+            };
+            const cookieRow: CookieRow = rowTransform(row);
+            return merge(newVar, cookieRow);
+          });
         resolve(cookieRows);
         return;
       }

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

@@ -2,7 +2,7 @@ import CookieQueryStrategy from "./CookieQueryStrategy";
 import CookieSpec from "../CookieSpec";
 import ExportedCookie from "../ExportedCookie";
 import { Cookie } from "tough-cookie";
-import { cookieStore, cookieJar } from "../CookieStore";
+import { cookieJar, cookieStore } from "../CookieStore";
 import { stringToRegex } from "../StringToRegex";
 
 export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
@@ -59,7 +59,7 @@ 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",
       },

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/cli.ts

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 
 import { argv, parsedArgs } from "./argv";
-import { queryCookies } from "./queryCookies";
 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";
 
-async function cliQueryCookies({ name, domain }: CookieSpec) {
+async function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[]) {
   try {
-    const results = await queryCookies({ name, domain });
+    const results = await comboQueryCookieSpec(cookieSpec);
     if (results == null || results.length == 0) {
       console.error(red("No results"));
       return;
@@ -49,7 +50,7 @@ async function cliQueryCookies({ name, domain }: CookieSpec) {
   }
 }
 
-function main() {
+async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
     console.log(`Usage: ${argv[1]} [name] [domain] [options] `);
     console.log(`Options:`);
@@ -61,6 +62,8 @@ function main() {
     return;
   }
 
+  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
+
   const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
   if (fetchUrl) {
     let url: URL;
@@ -100,12 +103,24 @@ function main() {
     return;
   }
 
-  const cookieSpec: CookieSpec = {
-    name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
-    domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
-  };
+  const cookieSpecs: CookieSpec[] = [];
+  const argUrl: string = parsedArgs["url"] || parsedArgs["u"];
+  if (argUrl) {
+    for (const cookieSpec of cookieSpecsFromUrl(argUrl)) {
+      cookieSpecs.push(cookieSpec);
+    }
+  } else {
+    cookieSpecs.push({
+      name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
+      domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
+    });
+  }
+
+  if (parsedArgs.verbose) {
+    console.log("cookieSpecs", cookieSpecs);
+  }
 
-  cliQueryCookies(cookieSpec).catch(console.error);
+  await cliQueryCookies(cookieSpecs).catch(console.error);
 }
 
-main();
+main().then((r) => r, console.error);

package/src/comboQueryCookieSpec.ts

@@ -0,0 +1,24 @@
+import CookieSpec, { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import { uniqBy } from "lodash";
+
+export async function comboQueryCookieSpec(
+  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);
+    }
+  } else {
+    const singleQuery: ExportedCookie[] = await queryCookies(cookieSpec);
+    cookies.push(...singleQuery);
+  }
+  return uniqBy(cookies, JSON.stringify);
+}

package/src/cookieSpecsFromUrl.ts

@@ -0,0 +1,26 @@
+import CookieSpec from "./CookieSpec";
+import { uniqBy } from "lodash";
+
+export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
+  const url1 = typeof url == "string" ? new URL(url) : url;
+  const cookieSpecs = [];
+  const splits = url1.hostname.split(".");
+  const tld = splits.slice(-2).join(".");
+  const cookieSpec: CookieSpec = {
+    name: "%",
+    domain: "%." + tld,
+  };
+  cookieSpecs.push(cookieSpec);
+  const cookieSpec1: CookieSpec = {
+    name: "%",
+    domain: url1.hostname,
+  };
+  cookieSpecs.push(cookieSpec1);
+  // const isWww = splits.slice(-3)[0] === "www";
+  const cookieSpec2: CookieSpec = {
+    name: "%",
+    domain: tld,
+  };
+  cookieSpecs.push(cookieSpec2);
+  return uniqBy(cookieSpecs, JSON.stringify);
+}

package/src/doSqliteQuery1Params.ts

@@ -3,5 +3,6 @@ import CookieRow from "./CookieRow";
 export interface DoSqliteQuery1Params {
   file: string;
   sql: string;
+  rowFilter?: (row: any) => boolean;
   rowTransform: (row: any) => CookieRow;
 }

package/src/fetchWithCookies.ts

@@ -1,47 +1,43 @@
-// noinspection JSUnusedGlobalSymbols
+// noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
 
 import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
-import CookieSpec from "./CookieSpec";
 import { cookieJar } from "./CookieStore";
 import UserAgent from "user-agents";
 import { parsedArgs } from "./argv";
 import { blue, yellow } from "colorette";
 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": userAgent,
+  };
   const defaultOptions: RequestInit = {
-    headers: {
-      "User-Agent": new UserAgent().toString(),
-    },
+    headers,
     redirect: "manual",
   };
   const url2: string = `${url}`;
   const url1: URL = new URL(url2);
-  const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
-    return `%${p1}`;
-  });
-  const cookieSpec: CookieSpec = {
-    name: "%",
-    domain: domain,
-  };
-  // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
-  //   () => []
-  // );
-  // const cookie = cookies.pop();
-  const cookie = await getMergedRenderedCookies(cookieSpec).catch(() => "");
-  const headers = {};
+  const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url1);
+  const cookie = await getMergedRenderedCookies(cookieSpecs).catch(() => "");
   if (cookie.length > 0) {
     merge(headers, {
       Cookie: cookie,
     });
   }
+  if (parsedArgs["dump-request-headers"]) {
+    console.log(blue("Request headers:"), headers);
+  }
   const newOptions1: RequestInit = merge(defaultOptions, options, { headers });
   try {
     const res: Response = await fetch(url2, newOptions1);
@@ -63,11 +59,15 @@ 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);
+      } else {
+        throw new Error("Redirected but no new location");
       }
-      return fetchWithCookies(newUrl, newOptions1);
     }
 
     const arrayBuffer1: Promise<ArrayBuffer> = res.arrayBuffer();

package/src/getGroupedRenderedCookies.ts

@@ -1,27 +1,17 @@
 import { groupBy } from "lodash";
-import { queryCookies } from "./queryCookies";
 import { resultsRendered } from "./resultsRendered";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieSpec from "./CookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 
-export async function getGroupedRenderedCookies({
-  name,
-  domain,
-}: CookieSpec): Promise<string[]> {
-  const cookies: ExportedCookie[] = await queryCookies(
-    {
-      name,
-      domain,
-    },
-    new CompositeCookieQueryStrategy()
-    //
-  );
+export async function getGroupedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string[]> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
   if (cookies.length == 0) {
     throw new Error("Cookie not found");
   }
-  const results: ExportedCookie[] = await queryCookies({ name, domain });
-  const groupedByFile = groupBy(results, (r: ExportedCookie) => r.meta?.file);
+  const groupedByFile = groupBy(cookies, (r: ExportedCookie) => r.meta?.file);
   return Object.keys(groupedByFile).map((file: string) => {
     const results: ExportedCookie[] = groupedByFile[file];
     return resultsRendered(results);

package/src/getMergedRenderedCookies.ts

@@ -1,25 +1,14 @@
-import { groupBy } from "lodash";
-import { queryCookies } from "./queryCookies";
 import { resultsRendered } from "./resultsRendered";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieSpec from "./CookieSpec";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 
-export async function getMergedRenderedCookies({
-  name,
-  domain,
-}: CookieSpec): Promise<string> {
-  const cookies: ExportedCookie[] = await queryCookies(
-    {
-      name,
-      domain,
-    },
-    new CompositeCookieQueryStrategy()
-    //
-  );
-  if (cookies.length == 0) {
-    throw new Error("Cookie not found");
+export async function getMergedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  if (cookies.length > 0) {
+    return resultsRendered(cookies);
   }
-  const results: ExportedCookie[] = await queryCookies({ name, domain });
-  return resultsRendered(results);
+  return "";
 }

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]);
-    });
-  });
-}