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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.4",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -66,7 +66,9 @@
     "lodash": "^4.17.21",
     "lru-cache": "^7.14.0",
     "minimist": "^1.2.6",
-    "sqlite3": "^5.1.1"
+    "sqlite3": "^5.1.1",
+    "tough-cookie": "^4.1.2",
+    "tough-cookie-file-store": "^2.0.3"
   },
   "devDependencies": {
     "@parcel/packager-ts": "^2.7.0",
@@ -75,6 +77,7 @@
     "@types/lodash": "^4.14.186",
     "@types/minimist": "^1.2.2",
     "@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",

package/src/CookieRow.ts

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

package/src/CookieSpec.ts

@@ -1,4 +1,4 @@
-export interface CookieSpec {
-  name: string;
+export default interface CookieSpec {
   domain: string;
+  name: string;
 }

package/src/CookieStore.ts

@@ -0,0 +1,10 @@
+import { CookieJar } from "tough-cookie";
+import { env } from "./global";
+const { FileCookieStore } = require("tough-cookie-file-store");
+
+export const cookieStore = new FileCookieStore(
+  `${env["HOME"]}/cookie-star.json`
+);
+// export const cookieStore = new MemoryCookieStore();
+
+export const cookieJar = new CookieJar(cookieStore);

package/src/ExportedCookie.ts

@@ -1,4 +1,4 @@
-export interface ExportedCookie {
+export default interface ExportedCookie {
   domain: string;
   name: string;
   value: string;

package/src/FetchResponse.ts

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols
+
 import { Response } from "cross-fetch";
 
 export default interface FetchResponse extends Response {

package/src/IsCookieRow.ts

@@ -1,4 +1,4 @@
-import { CookieRow } from "./CookieRow";
+import CookieRow from "./CookieRow";
 
 export function isCookieRow(obj: any): obj is CookieRow {
   return (

package/src/IsExportedCookie.ts

@@ -1,4 +1,4 @@
-import { ExportedCookie } from "./ExportedCookie";
+import ExportedCookie from "./ExportedCookie";
 
 export function isExportedCookie(obj: any): obj is ExportedCookie {
   return (

package/src/SpecialCases.ts

@@ -1,4 +1,4 @@
-import { CookieSpec } from "./CookieSpec";
+import CookieSpec from "./CookieSpec";
 
 export function specialCases({ name, domain }: CookieSpec): {
   specifiedName: boolean;

package/src/StringToRegex.ts

@@ -0,0 +1,6 @@
+export function stringToRegex(s: string): RegExp {
+  const s1 = s.replaceAll(/\./gi, ".");
+  const s2 = s1.replace(/%/g, ".*");
+  const s3 = s2.replace(/\*/g, ".*");
+  return new RegExp(s3);
+}

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -9,10 +9,13 @@ import { doSqliteQuery1 } from "../doSqliteQuery1";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
 import { isExportedCookie } from "../IsExportedCookie";
-import { CookieRow } from "../CookieRow";
-import { ExportedCookie } from "../ExportedCookie";
+import CookieRow from "../CookieRow";
+import ExportedCookie from "../ExportedCookie";
+import { stringToRegex } from "../StringToRegex";
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Chrome";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
       throw new Error("This only works on macOS");
@@ -56,7 +59,7 @@ async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
     const promises: Promise<CookieRow[]>[] = files.map((file) =>
       getPromise1(name, domain, file)
     );
-    const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
+    const results1: CookieRow[][] = await Promise.all(promises);
     return results1.flat().filter(isCookieRow);
   } catch (error) {
     if (env.VERBOSE) {
@@ -146,19 +149,22 @@ async function getEncryptedChromeCookie({
   const wildcardRegexp = /^([*%])$/i;
   const specifiedName = name.match(wildcardRegexp) == null;
   const specifiedDomain = domain.match(wildcardRegexp) == null;
-  if (specifiedName || specifiedDomain) {
+  const wildcardDomain = domain.match(/[%*]/) != null;
+  const queryDomain = specifiedDomain && !wildcardDomain;
+  // if we have a wildcard domain, we need to use a regexp
+  if (specifiedName || queryDomain) {
     sql += ` WHERE `;
     if (specifiedName) {
       sql += `name = '${name}'`;
-      if (specifiedDomain) {
+      if (queryDomain) {
         sql += ` AND `;
       }
     }
-    if (specifiedDomain) {
+    if (queryDomain) {
       sql += `host_key LIKE '${domain}';`;
     }
   }
-  return doSqliteQuery1({
+  const sqliteQuery1: CookieRow[] = await doSqliteQuery1({
     file: file,
     sql: sql,
     rowTransform: (row) => {
@@ -169,6 +175,9 @@ async function getEncryptedChromeCookie({
       };
     },
   });
+  return sqliteQuery1.filter((row) => {
+    return row.domain.match(stringToRegex(domain)) != null;
+  });
 }
 
 async function getChromePassword(): Promise<string> {

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -2,8 +2,10 @@ 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";
 
 const cache = new LRUCache<string, ExportedCookie[]>({
   ttl: 1000 * 2,
@@ -13,10 +15,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 +31,24 @@ 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) => {
+    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 cookies.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,6 @@
-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,88 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import CookieSpec from "../CookieSpec";
+import ExportedCookie from "../ExportedCookie";
+import { Cookie } from "tough-cookie";
+import { cookieStore, cookieJar } 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);
+    }
+
+    if (name == "%" && domain == "%") {
+      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 cookieJar.getCookies(url.href);
+      const domainCookies = cookies.map((cookie: Cookie) => {
+        return this.#extracted(cookie, {
+          domain,
+          name,
+        });
+      });
+      exportedCookies.push(...domainCookies);
+    }
+
+    if (name == "%") {
+      return exportedCookies;
+    }
+
+    const cookie: Cookie | null = await cookieStore.findCookie(
+      domain,
+      path,
+      name
+    );
+
+    if (cookie) {
+      const singleCookie = this.#extracted(cookie, { name, domain });
+      return [singleCookie];
+    }
+
+    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,
+      meta: {
+        file: "memory",
+      },
+    };
+  }
+
+  #getAllCookies(): Promise<Cookie[]> {
+    return new Promise((resolve, reject) => {
+      // @ts-ignore
+      return cookieStore.getAllCookies((err, cookies) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cookies ?? []);
+        }
+      });
+    });
+  }
+}

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -4,12 +4,14 @@ import { env, HOME } from "../global";
 import { 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";
 
 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");

package/src/browsers/SafariCookieQueryStrategy.ts

@@ -1,7 +1,9 @@
 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[]> {
     return [];
   }

package/src/cli.ts

@@ -2,42 +2,50 @@
 
 import minimist from "minimist";
 import { argv } from "./argv";
-import { env } from "./global";
 import { queryCookies } from "./queryCookies";
 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";
 
-const parsedArgs: minimist.ParsedArgs = minimist(argv);
+const parsedArgs: minimist.ParsedArgs = minimist(argv.slice(2));
 
-async function cliQueryCookies(name: string, domain: string) {
+async function cliQueryCookies({ name, domain }: 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);
-        }
+    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);
@@ -45,74 +53,62 @@ async function cliQueryCookies(name: string, domain: string) {
 }
 
 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;
+  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;
+  }
+
+  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 cookieSpec: CookieSpec = {
+    name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
+    domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
+  };
 
-    cliQueryCookies(arg2, domain).catch(console.error);
-  }
+  cliQueryCookies(cookieSpec).catch(console.error);
 }
 
 main();

package/src/doSqliteQuery1.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as sqlite3 from "sqlite3";
-import { CookieRow } from "./CookieRow";
+import CookieRow from "./CookieRow";
 import { merge } from "lodash";
 
 interface DoSqliteQuery1Params {

package/src/fetchWithCookies.ts

@@ -1,16 +1,18 @@
 // noinspection JSUnusedGlobalSymbols
 
-import { fetch } from "cross-fetch";
+import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
-import FetchResponse from "./FetchResponse";
+import CookieSpec from "./CookieSpec";
 import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+import { cookieJar } from "./CookieStore";
 
 export async function fetchWithCookies(
   url: RequestInfo | URL,
-  options: RequestInit | undefined = {}
-): Promise<FetchResponse> {
+  options: RequestInit | undefined = {},
+  fetch: Function = fetchImpl
+): Promise<Response> {
   const defaultOptions: RequestInit = {
     headers: {
       "User-Agent":
@@ -23,10 +25,13 @@ export async function fetchWithCookies(
   const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
     return `%${p1}`;
   });
-  const cookies: string[] = await getGroupedRenderedCookies({
+  const cookieSpec: CookieSpec = {
     name: "%",
     domain: domain,
-  }).catch(() => []);
+  };
+  const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
+    () => []
+  );
   const cookie = cookies.pop();
   const newOptions1: RequestInit = merge(defaultOptions, options, {
     headers: {
@@ -35,29 +40,64 @@ export async function fetchWithCookies(
   });
   try {
     const res: Response = await fetch(url2, newOptions1);
-    const newUrl = res.headers.get("location") as string;
+    const headers: [string, string][] = [];
+    res.headers.forEach((value, key) => {
+      headers.push([key, value]);
+    });
+    for (const [key, value] of headers) {
+      if (key === "set-cookie") {
+        await cookieJar.setCookie(value, url2);
+        // const cookie = tough.parse(value);
+        // if (cookie instanceof Cookie) {
+        //   await memoryCookieStore.putCookie(cookie);
+        // }
+      }
+    }
+
+    const newUrl: string = res.headers.get("location") as string;
     if (res.redirected || (newUrl && newUrl !== url2)) {
       return fetchWithCookies(newUrl, newOptions1);
     }
-    const arrayBuffer1 = res.arrayBuffer();
-    const arrayBuffer = async () => arrayBuffer1;
-    const buffer = async () => arrayBuffer().then(Buffer.from);
-    const text = async () => buffer().then((buffer) => buffer.toString("utf8"));
-    const json = async () => text().then(destr);
-    const formData = async () =>
-      text().then((text) => new URLSearchParams(text));
+
+    const arrayBuffer1: Promise<ArrayBuffer> = res.arrayBuffer();
+
+    async function arrayBuffer(): Promise<ArrayBuffer> {
+      return arrayBuffer1;
+    }
+
+    async function buffer(): Promise<Buffer> {
+      return arrayBuffer().then(Buffer.from);
+    }
+
+    async function text(): Promise<string> {
+      return buffer().then((buffer) => buffer.toString("utf8"));
+    }
+
+    async function json(): Promise<any> {
+      return text().then((text) => destr(text));
+    }
+
+    async function formData(): Promise<FormData> {
+      const urlSearchParams: URLSearchParams = await text().then(
+        (text) => new URLSearchParams(text)
+      );
+      const formData = new FormData();
+      for (const [key, value] of urlSearchParams.entries()) {
+        formData.append(key, value);
+      }
+      return formData;
+    }
+
+    const res1: Response = res;
     const source2 = {
-      status: res.status,
-      statusText: res.statusText,
-      headers: res.headers,
       arrayBuffer,
-      buffer,
       text,
       json,
+      buffer,
       formData,
       //
     };
-    return merge({}, res, source2);
+    return merge(res1, source2);
   } catch (e) {
     throw e;
   }