@mherod/get-cookie 2.0.0-beta.9 → 2.0.0-rc.10

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -0,0 +1,94 @@
+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);
+    // }
+
+    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",
+      },
+    };
+  }
+
+  #getCookies(url: string): Promise<Cookie[]> {
+    return new Promise((resolve, reject) => {
+      // @ts-ignore
+      return cookieJar.getCookies(url, (err, cookies) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cookies ?? []);
+        }
+      });
+    });
+  }
+
+  #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

@@ -1,13 +1,17 @@
+import * as path from "path";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { env, HOME } from "../global";
 import { existsSync } from "fs";
-import { toStringOrNull } from "../utils";
 import { findAllFiles } from "../findAllFiles";
-import * as path from "path";
 import { doSqliteQuery1 } from "../doSqliteQuery1";
-import { ExportedCookie } from "../ExportedCookie";
+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");
@@ -16,26 +20,21 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
       return [];
     }
     const cookies = await this.#getFirefoxCookie({ name, domain });
-    return Array.isArray(cookies) ? cookies.map(toStringOrNull) : [];
+    if (Array.isArray(cookies)) {
+      return cookies.map((cookie: CookieRow) => {
+        return {
+          domain: cookie.domain,
+          name: cookie.name,
+          value: cookie.value.toString("utf8"),
+        };
+      });
+    } else {
+      return [];
+    }
   }
 
-  /**
-   *
-   * @param name
-   * @param domain
-   * @returns {Promise<Buffer>}
-   */
   async #getFirefoxCookie(
-    //
-    {
-      name,
-      domain
-    }: {
-      name: string,
-      domain: string
-      //
-    }
-    //
+    { name, domain }: CookieSpec //
   ) {
     const files: string[] = await findAllFiles({
       path: path.join(
@@ -45,48 +44,57 @@ export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
         "Firefox",
         "Profiles"
       ),
-      name: "cookies.sqlite"
+      name: "cookies.sqlite",
     });
-    const all = await Promise.all(
-      files.map((file) => {
-        return this.#queryCookiesDb(file, name, domain);
-      })
-    );
+    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));
     return all.flat();
   }
 
-  #queryCookiesDb(file: string, name: string, domain: string) {
+  async #queryCookiesDb(
+    file: string,
+    name: string,
+    domain: string
+  ): Promise<CookieRow[]> {
     if (file && !existsSync(file)) {
       throw new Error(`File ${file} does not exist`);
     }
-    if (env.VERBOSE) {
-      console.log(`Trying Firefox cookie ${name} for domain ${domain}`);
-    }
     let sql;
     //language=SQL
-    sql = "SELECT value FROM moz_cookies";
-    if (typeof name === "string" || typeof domain === "string") {
+    sql = "SELECT value, name, host FROM moz_cookies";
+    const { specifiedName, specifiedDomain } = specialCases({ name, domain });
+    if (specifiedName || specifiedDomain) {
       sql += ` WHERE `;
-      if (typeof name === "string") {
+      if (specifiedName) {
         sql += `name = '${name}'`;
-        if (typeof domain === "string") {
+        if (specifiedDomain) {
           sql += ` AND `;
         }
       }
-      if (typeof domain === "string") {
+      if (specifiedDomain) {
         sql += `host LIKE '${domain}';`;
       }
     }
-    return doSqliteQuery1(file, sql)
-      .then((rows) => {
-        return rows.map((row) => {
-          return {
-            domain: row.domain,
-            name: row.name,
-            value: row.value.toString("utf8")
-          };
-        });
-      })
-      .catch(() => []);
+    const rowTransform = (row: any) => {
+      // row is object key by column name
+      const value = row.value as string;
+      return {
+        domain: row.domain as string,
+        name: row.name as string,
+        value: Buffer.from(value, "utf8"),
+      };
+    };
+    try {
+      return await doSqliteQuery1({
+        file,
+        sql,
+        rowTransform,
+      });
+    } catch (e) {
+      console.error(`Error querying ${file}`, e);
+      return [];
+    }
   }
 }

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

@@ -1,82 +1,111 @@
 #!/usr/bin/env node
 
-import { env } from "./global";
+import { argv, parsedArgs } from "./argv";
 import { queryCookies } from "./queryCookies";
-import { argv } from "./argv";
 import { groupBy } from "lodash";
-import { blue, green } from "colorette";
+import { green, red, yellow } from "colorette";
 import { resultsRendered } from "./resultsRendered";
-import { ExportedCookie } from "./ExportedCookie";
+import { fetchWithCookies } from "./fetchWithCookies";
+import { unpackHeaders } from "./unpackHeaders";
+import CookieSpec from "./CookieSpec";
 
-function combinedString(results: ExportedCookie[]) {
-  return blue(resultsRendered(results));
-}
-
-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(combinedString(results));
-      } else if (argv.includes("--dump")) {
-        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) + ": ", combinedString(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);
   }
 }
 
-if (argv && argv.length > 2) {
-  const name = argv[2];
-
-  let domain;
-  if (argv[3] != null && argv[3].indexOf(".") > -1) {
-    domain = argv[3];
-  } else {
-    domain = "%";
+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;
   }
 
-  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;
+  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}`);
+        });
+      }
+      if (parsedArgs["dump-response-body"]) {
+        res.text().then((r) => {
+          console.log(r);
+        });
+      }
+      return;
+    };
+    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(name, domain).catch(console.error);
+  cliQueryCookies(cookieSpec).catch(console.error);
 }
+
+main();

package/src/doSqliteQuery1.ts

@@ -1,9 +1,16 @@
 import * as fs from "fs";
 import * as sqlite3 from "sqlite3";
-import { CookieRow } from "./CookieRow";
+import CookieRow from "./CookieRow";
+import { merge } from "lodash";
+import { parsedArgs } from "./argv";
+import { DoSqliteQuery1Params } from "./doSqliteQuery1Params";
 
-export async function doSqliteQuery1(file: string, sql: string): Promise<CookieRow[]> {
-  if (!fs.existsSync(file)) {
+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);
@@ -19,20 +26,19 @@ export async function doSqliteQuery1(file: string, sql: string): Promise<CookieR
         return;
       }
       if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row) => {
-          return {
-            domain: row["host_key"],
-            name: row["name"],
-            value: row["encrypted_value"],
+        const cookieRows: CookieRow[] = rows1.map((row: any) => {
+          const newVar = {
             meta: {
-              file: file
-            }
+              file: file,
+            },
           };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
         });
         resolve(cookieRows);
         return;
       }
-      if (process.env.VERBOSE) {
+      if (parsedArgs.verbose) {
         console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
       }
       resolve([rows1]);

package/src/doSqliteQuery1Params.ts

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

package/src/fetchWithCookies.ts

@@ -1,61 +1,114 @@
 // 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 { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+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";
 
 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": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
+      "User-Agent": new UserAgent().toString(),
     },
-    redirect: "manual"
+    redirect: "manual",
   };
   const url2: string = `${url}`;
   const url1: URL = new URL(url2);
   const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
     return `%${p1}`;
   });
-  const cookies: string[] = await getGroupedRenderedCookies({
+  const cookieSpec: CookieSpec = {
     name: "%",
-    domain: domain
-  });
-  const cookie = cookies.pop();
-  const newOptions1: RequestInit = merge(defaultOptions, options, {
-    headers: {
-      Cookie: cookie
-    }
-  });
+    domain: domain,
+  };
+  // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
+  //   () => []
+  // );
+  // const cookie = cookies.pop();
+  const cookie = await getMergedRenderedCookies(cookieSpec).catch(() => "");
+  const headers = {};
+  if (cookie.length > 0) {
+    merge(headers, {
+      Cookie: cookie,
+    });
+  }
+  const newOptions1: RequestInit = merge(defaultOptions, options, { headers });
   try {
-    const res = await fetch(url2, newOptions1);
-    const newUrl = res.headers.get("location") as string;
-    if (res.redirected || newUrl && newUrl !== url2) {
+    const res: Response = await fetch(url2, newOptions1);
+    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);
+        if (parsedArgs.verbose) {
+          console.log(blue(`Set-Cookie: ${yellow(value)} ${yellow(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)) {
+      if (parsedArgs.verbose) {
+        console.log(blue(`Redirected to `), yellow(newUrl));
+      }
       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,
-      formData
+      buffer,
+      formData,
       //
     };
-    return merge({}, res, source2);
+    return merge(res1, source2);
   } catch (e) {
     throw e;
   }