@mherod/get-cookie 2.0.0-rc.2 → 2.0.0-rc.21

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -2,8 +2,12 @@ import ChromeCookieQueryStrategy from "./ChromeCookieQueryStrategy";
 import FirefoxCookieQueryStrategy from "./FirefoxCookieQueryStrategy";
 import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { ExportedCookie } from "../ExportedCookie";
+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";
 
 const cache = new LRUCache<string, ExportedCookie[]>({
   ttl: 1000 * 2,
@@ -13,10 +17,13 @@ const cache = new LRUCache<string, ExportedCookie[]>({
 export default class CompositeCookieQueryStrategy
   implements CookieQueryStrategy
 {
+  browserName = "all";
+
   #strategies;
 
   constructor() {
     this.#strategies = [
+      CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
@@ -26,19 +33,36 @@ 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;
     }
-    const results = await Promise.all(
-      this.#strategies.map(async (strategy) => {
+    if (parsedArgs.verbose) {
+      console.log("Querying cookies:", name, domain);
+    }
+    const results: ExportedCookie[][] = await Promise.all(
+      this.#strategies.map(async (strategy: CookieQueryStrategy) => {
         // @ts-ignore
-        const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(
-          name,
-          domain
-        );
-        return cookies.catch(() => []);
+        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();

package/src/browsers/CookieQueryStrategy.ts

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

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -0,0 +1,99 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import CookieSpec from "../CookieSpec";
+import ExportedCookie from "../ExportedCookie";
+import { Cookie, Store } from "tough-cookie";
+import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
+import { stringToRegex } from "../StringToRegex";
+
+export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
+  browserName = "internal";
+
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    const exportedCookies: ExportedCookie[] = [];
+
+    // if (name.match(/[%*]/) || domain.match(/[%*]/)) {
+    const cookies: Cookie[] = await this.#getAllCookies();
+    const allExportedCookies = cookies.map((cookie: Cookie) => {
+      return this.#extracted(cookie, { name, domain });
+    });
+    exportedCookies.push(...allExportedCookies);
+    // }
+
+    const wildcardRegexp = /^([*%])$/i;
+    if (name.match(wildcardRegexp) && domain.match(wildcardRegexp)) {
+      return exportedCookies;
+    }
+
+    const path = "/";
+
+    if (domain != "%") {
+      const domain1 = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+      const url = new URL("https://" + domain1);
+      url.pathname = path;
+      const cookies: Cookie[] = await this.#getCookies(url.href);
+      const domainCookies = cookies.map((cookie: Cookie) => {
+        return this.#extracted(cookie, {
+          domain,
+          name,
+        });
+      });
+      exportedCookies.push(...domainCookies);
+    }
+
+    if (name == "%") {
+      return exportedCookies.filter((cookie: ExportedCookie) => {
+        return cookie.domain.match(stringToRegex(domain));
+      });
+    }
+
+    return exportedCookies.filter((cookie: ExportedCookie) => {
+      return (
+        cookie.name.match(stringToRegex(name)) &&
+        cookie.domain.match(stringToRegex(domain))
+      );
+    });
+  }
+
+  #extracted(cookie: Cookie, cookieSpec: CookieSpec): ExportedCookie {
+    return {
+      domain: cookie.domain ?? cookieSpec.domain,
+      name: cookie.key ?? cookieSpec.name,
+      value: cookie.value,
+      expiry: cookie.expires ?? "Infinity",
+      meta: {
+        file: "tough-cookie",
+      },
+    };
+  }
+
+  async #getCookies(url: string): Promise<Cookie[]> {
+    const cookieJar = await cookieJarPromise;
+    return new Promise((resolve, reject) => {
+      return cookieJar.getCookies(
+        url,
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        }
+      );
+    });
+  }
+
+  async #getAllCookies(): Promise<Cookie[]> {
+    const cookieStore: Store = await cookieStorePromise;
+    return new Promise((resolve, reject) => {
+      return cookieStore.getAllCookies(
+        (err: Error | null, cookies: Cookie[]) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(cookies ?? []);
+          }
+        }
+      );
+    });
+  }
+}

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -1,20 +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 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 });
@@ -47,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

@@ -1,8 +1,11 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
-import { ExportedCookie } from "../ExportedCookie";
+import ExportedCookie from "../ExportedCookie";
 
 export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Safari";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    // TODO: implement
     return [];
   }
 }

package/src/cli.ts

@@ -1,118 +1,126 @@
 #!/usr/bin/env node
 
-import minimist from "minimist";
-import { argv } from "./argv";
-import { env } from "./global";
-import { queryCookies } from "./queryCookies";
+import { argv, parsedArgs } from "./argv";
 import { groupBy } from "lodash";
-import { green, yellow } from "colorette";
+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";
 
-const parsedArgs: minimist.ParsedArgs = minimist(argv);
-
-async function cliQueryCookies(name: string, domain: string) {
+async function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[]) {
   try {
-    const results = await queryCookies({ name, domain });
-    if (results.length > 0) {
-      if (argv.includes("--combined-string")) {
-        console.log(yellow(resultsRendered(results)));
-      } else if (argv.includes("--render") || argv.includes("-r")) {
-        console.log(yellow(resultsRendered(results)));
-      } else if (argv.includes("--dump") || argv.includes("-d")) {
-        console.log(results);
-      } else if (argv.includes("--dump-grouped")) {
-        const groupedByFile = groupBy(results, (r) => r.meta?.file);
-        console.log(green(JSON.stringify(groupedByFile, null, 2)));
-      } else if (argv.includes("--combined-string-grouped")) {
-        const groupedByFile = groupBy(results, (r) => r.meta?.file);
-        for (const file of Object.keys(groupedByFile)) {
-          let results = groupedByFile[file];
-          console.log(green(file) + ": ", yellow(resultsRendered(results)));
-        }
-      } else {
-        for (const result of results) {
-          console.log(result.value);
-        }
+    const results = await comboQueryCookieSpec(cookieSpec);
+    if (results == null || results.length == 0) {
+      console.error(red("No results"));
+      return;
+    }
+    if (parsedArgs["dump"] || parsedArgs["d"]) {
+      console.log(results);
+      return;
+    }
+    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      console.log(green(JSON.stringify(groupedByFile, null, 2)));
+      return;
+    }
+    if (
+      parsedArgs["render"] ||
+      parsedArgs["render-merged"] ||
+      parsedArgs["r"]
+    ) {
+      console.log(yellow(resultsRendered(results)));
+      return;
+    }
+    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      for (const file of Object.keys(groupedByFile)) {
+        let results = groupedByFile[file];
+        console.log(green(file) + ": ", yellow(resultsRendered(results)));
       }
-    } else {
-      console.error("No results");
+      return;
+    }
+    for (const result of results) {
+      console.log(result.value);
     }
   } catch (e) {
     console.error(e);
   }
 }
 
-function main() {
-  if (argv && argv.length > 2) {
-    const arg2 = argv[2];
-    const arg3 = argv[3];
-    if (arg2 == "--fetch" || arg2 == "-f") {
-      const f = parsedArgs["f"];
-      let url: URL;
-      try {
-        url = new URL(f);
-      } catch (e) {
-        console.error("Invalid URL", arg3);
-        return;
+async function main() {
+  if (parsedArgs["help"] || parsedArgs["h"]) {
+    console.log(`Usage: ${argv[1]} [name] [domain] [options] `);
+    console.log(`Options:`);
+    console.log(`  -h, --help: Show this help`);
+    console.log(`  -v, --verbose: Show verbose output`);
+    console.log(`  -d, --dump: Dump all results`);
+    console.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
+    console.log(`  -r, --render: Render all results`);
+    return;
+  }
+
+  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
+
+  const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
+  if (fetchUrl) {
+    let url: URL;
+    try {
+      url = new URL(<string>fetchUrl);
+    } catch (e) {
+      console.error("Invalid URL", fetchUrl);
+      return;
+    }
+    const headerArgs: string[] | string = parsedArgs["H"];
+    const headers = unpackHeaders(headerArgs);
+    const onfulfilled = (res: Response) => {
+      if (parsedArgs["dump-response-headers"]) {
+        res.headers.forEach((value: string, key: string) => {
+          console.log(`${key}: ${value}`);
+        });
       }
-      const headerArgs: string[] | string = parsedArgs["H"];
-      const headers = unpackHeaders(headerArgs);
-      const onfulfilled = (res: Response) => {
-        return res.text().then((r) => {
+      if (parsedArgs["dump-response-body"]) {
+        res.text().then((r) => {
           console.log(r);
         });
-      };
-      fetchWithCookies(
-        url,
-        {
-          //
-          headers,
-        }
-        //
-      ).then(
-        onfulfilled,
-        console.error
-        //
-      );
+      }
       return;
-    }
-    let domain;
-    if (arg3 != null && arg3.indexOf(".") > -1) {
-      domain = arg3;
-    } else {
-      domain = "%";
-    }
-
-    const tru = `${true}`;
-
-    if (argv.includes("--require-jwt")) {
-      env.REQUIRE_JWT = tru;
-    }
-    if (argv.includes("--verbose")) {
-      env.VERBOSE = tru;
-    }
-    if (argv.includes("--chrome-only")) {
-      env.CHROME_ONLY = tru;
-    }
-    if (argv.includes("--firefox-only")) {
-      env.FIREFOX_ONLY = tru;
-    }
-    if (argv.includes("--ignore-expired")) {
-      env.IGNORE_EXPIRED = tru;
-    }
-
-    if (argv.includes("--single")) {
-      env.SINGLE = tru;
-    }
+    };
+    fetchWithCookies(
+      url,
+      {
+        //
+        headers,
+      }
+      //
+    ).then(
+      onfulfilled,
+      console.error
+      //
+    );
+    return;
+  }
 
-    if (env.VERBOSE) {
-      console.log("Verbose mode", argv);
+  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] || "%",
+    });
+  }
 
-    cliQueryCookies(arg2, domain).catch(console.error);
+  if (parsedArgs.verbose) {
+    console.log("cookieSpecs", cookieSpecs);
   }
+
+  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

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