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

package/src/fetchWithCookies.ts

@@ -1,63 +1,154 @@
-// noinspection JSUnusedGlobalSymbols
+// noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
 
-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 { cookieJarPromise } from "./CookieStore";
+import UserAgent from "user-agents";
+import { parsedArgs } from "./argv";
+import { blue, redBright, yellow } from "colorette";
+import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
+import CookieSpec from "./CookieSpec";
+
+const userAgent = new UserAgent().toString();
+
+interface FetchRequestInit {
+  url: RequestInfo | URL | string;
+  options?: RequestInit;
+}
 
 export async function fetchWithCookies(
-  url: RequestInfo | URL,
-  options: RequestInit | undefined = {}
-): Promise<FetchResponse> {
+  url: RequestInfo | URL | string,
+  options: RequestInit | undefined = {},
+  fetch: Function = fetchImpl,
+  originalRequest: FetchRequestInit | undefined = undefined
+): Promise<Response> {
+  const originalRequest1 = originalRequest || { url, options };
+  const headers: HeadersInit = {
+    "User-Agent": userAgent,
+  };
   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",
-    },
+    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 cookies: string[] = await getGroupedRenderedCookies({
-    name: "%",
-    domain: domain,
-  }).catch(() => []);
-  const cookie = cookies.pop();
-  const newOptions1: RequestInit = merge(defaultOptions, options, {
-    headers: {
-      Cookie: cookie,
-    },
-  });
+  const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url1);
+  headers["Cookie"] = await getMergedRenderedCookies(cookieSpecs).catch(
+    () => ""
+  );
+  if (parsedArgs["dump-request-headers"]) {
+    console.log(redBright("Request URL:"), url1.href);
+    console.log(blue("Request headers:"), headers);
+  }
+  const newOptions1: RequestInit = merge(defaultOptions, { headers }, options);
   try {
-    const res: Response = await fetch(url2, newOptions1);
-    const newUrl = res.headers.get("location") as string;
-    if (res.redirected || (newUrl && newUrl !== url2)) {
-      return fetchWithCookies(newUrl, newOptions1);
+    const res: Response = await fetch(url1, newOptions1);
+    const headers: [string, string][] = [];
+    res.headers.forEach((value, key) => {
+      headers.push([key, value]);
+    });
+    for (const [key, value] of headers) {
+      if (key === "set-cookie") {
+        const cookieJar1 = await cookieJarPromise;
+        await cookieJar1.setCookie(value, url2);
+        if (parsedArgs.verbose) {
+          console.log(blue(`Set-Cookie:`), yellow(value), yellow(url2));
+        }
+      }
+    }
+
+    const newUrl: string = res.headers.get("location") ?? res.url;
+    // const sameHost = new URL(newUrl).host === url1.host;
+    if (res.status == 301 || res.status == 302) {
+      // follow the redirect
+      if (newUrl && newUrl !== url2) {
+        if (parsedArgs.verbose || parsedArgs["dump-response-headers"]) {
+          console.log(blue(`Redirected to `), yellow(newUrl));
+        }
+        return fetchWithCookies(
+          //
+          newUrl,
+          newOptions1,
+          fetch,
+          originalRequest1
+          //
+        );
+      }
+    }
+    if (res.status == 303 && newUrl && newUrl !== url2) {
+      // follow the redirect with GET
+      let newOptions2: RequestInit = {};
+      switch (newOptions1.method) {
+        case "POST":
+        case "PUT":
+        case "DELETE":
+          merge(newOptions2, newOptions1, { method: "GET" });
+          newOptions2.body = undefined; // TODO: is this needed?
+          break;
+        case "HEAD":
+        case "GET":
+          merge(newOptions2, newOptions1);
+          newOptions2.body = undefined; // TODO: is this needed?
+          break;
+        default:
+          merge(newOptions2, newOptions1);
+          break;
+      }
+      if (parsedArgs.verbose) {
+        console.log(blue(`Redirected to `), yellow(newUrl));
+      }
+      return fetchWithCookies(
+        //
+        newUrl,
+        newOptions2,
+        fetch,
+        originalRequest1
+        //
+      );
+    }
+
+    const arrayBuffer1: Promise<ArrayBuffer> = res.arrayBuffer();
+
+    async function arrayBuffer(): Promise<ArrayBuffer> {
+      return arrayBuffer1;
     }
-    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));
+
+    async function buffer(): Promise<Buffer> {
+      return arrayBuffer().then(Buffer.from);
+    }
+
+    async function text(): Promise<string> {
+      return buffer().then((buffer: Buffer) => buffer.toString("utf8"));
+    }
+
+    async function json(): Promise<any> {
+      return text().then((text: string) => 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;
   }

package/src/findAllFiles.ts

@@ -1,5 +1,5 @@
-import { env } from "./global";
 import * as fs from "fs";
+import { parsedArgs } from "./argv";
 
 export async function findAllFiles({
   path,
@@ -12,16 +12,12 @@ export async function findAllFiles({
   maxDepth?: number;
 }): Promise<string[]> {
   const rootSegments = path.split("/").length;
-
-  if (env.VERBOSE) {
-    console.log(`Searching for ${name} in ${path}`);
-  }
   const files: string[] = [];
   let readdirSync;
   try {
     readdirSync = fs.readdirSync(path);
   } catch (e) {
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose) {
       console.log(`Error reading ${path}`, e);
     }
     return [];
@@ -32,7 +28,7 @@ export async function findAllFiles({
     try {
       stat = fs.statSync(filePath);
     } catch (e) {
-      if (env.VERBOSE) {
+      if (parsedArgs.verbose) {
         console.error(`Error getting stat for ${filePath}`, e);
       }
       continue;
@@ -47,7 +43,7 @@ export async function findAllFiles({
           });
           files.push(...subFiles);
         } catch (e) {
-          if (env.VERBOSE) {
+          if (parsedArgs.verbose) {
             console.error(e);
           }
         }
@@ -56,7 +52,7 @@ export async function findAllFiles({
       files.push(filePath);
     }
   }
-  if (env.VERBOSE) {
+  if (parsedArgs.verbose) {
     if (files.length > 0) {
       console.log(`Found ${files.length} ${name} files`);
       console.log(files);

package/src/getChromeCookie.ts

@@ -0,0 +1,19 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
+import { isExportedCookie } from "./IsExportedCookie";
+
+export async function getChromeCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  const cookies = await queryCookies(
+    params,
+    new ChromeCookieQueryStrategy()
+    //
+  );
+  if (cookies.length == 0) {
+    throw new Error("Cookie not found");
+  }
+  return cookies.find(isExportedCookie);
+}

package/src/getCookie.ts

@@ -0,0 +1,19 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+
+export async function getCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  const cookies = await queryCookies(
+    params,
+    new CompositeCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
+  } else {
+    throw new Error("Cookie not found");
+  }
+}

package/src/getFirefoxCookie.ts

@@ -0,0 +1,19 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
+
+export async function getFirefoxCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  const cookies = await queryCookies(
+    params,
+    new FirefoxCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    return cookies.find((cookie) => cookie != null);
+  } else {
+    throw new Error("Cookie not found");
+  }
+}

package/src/getGroupedRenderedCookies.ts

@@ -1,32 +1,19 @@
-import { queryCookies } from "./queryCookies";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import { groupBy } from "lodash";
 import { resultsRendered } from "./resultsRendered";
-import { CookieSpec } from "./CookieSpec";
-import { ExportedCookie } from "./ExportedCookie";
+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()
-    //
-  );
-  if (Array.isArray(cookies) && cookies.length > 0) {
-    const results: ExportedCookie[] = await queryCookies({ name, domain });
-    const groupedByFile = groupBy(results, (r) => r.meta?.file);
-    return Object.keys(groupedByFile).map((file: string) => {
-      const results: ExportedCookie[] = groupedByFile[file];
-      return resultsRendered(results);
-    });
-  } else {
+  cookieSpec: MultiCookieSpec
+): Promise<string[]> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  if (cookies.length == 0) {
     throw new Error("Cookie not found");
   }
+  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

@@ -0,0 +1,14 @@
+import { resultsRendered } from "./resultsRendered";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+
+export async function getMergedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  if (cookies.length > 0) {
+    return resultsRendered(cookies);
+  }
+  return "";
+}

package/src/index.ts

@@ -1,61 +1,22 @@
 #!/usr/bin/env node
 // noinspection JSUnusedGlobalSymbols
 
-import { queryCookies } from "./queryCookies";
-import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
-import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import { CookieSpec } from "./CookieSpec";
-import { ExportedCookie } from "./ExportedCookie";
+import { getCookie } from "./getCookie";
+import { getChromeCookie } from "./getChromeCookie";
+import { getFirefoxCookie } from "./getFirefoxCookie";
 import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
 import { fetchWithCookies } from "./fetchWithCookies";
 
-export async function getCookie(
-  params: CookieSpec
-): Promise<ExportedCookie | undefined> {
-  const cookies = await queryCookies(
-    params,
-    new CompositeCookieQueryStrategy()
-    //
-  );
-  if (Array.isArray(cookies) && cookies.length > 0) {
-    return cookies.find((cookie) => cookie != null);
-  } else {
-    throw new Error("Cookie not found");
-  }
-}
-
-export async function getFirefoxCookie(
-  params: CookieSpec
-): Promise<ExportedCookie | undefined> {
-  const cookies = await queryCookies(
-    params,
-    new FirefoxCookieQueryStrategy()
-    //
-  );
-  if (Array.isArray(cookies) && cookies.length > 0) {
-    return cookies.find((cookie) => cookie != null);
-  } else {
-    throw new Error("Cookie not found");
-  }
-}
-
-export async function getChromeCookie(
-  params: CookieSpec
-): Promise<ExportedCookie | undefined> {
-  const cookies = await queryCookies(
-    params,
-    new ChromeCookieQueryStrategy()
-    //
-  );
-  if (Array.isArray(cookies) && cookies.length > 0) {
-    return cookies.find((cookie) => cookie != null);
-  } else {
-    throw new Error("Cookie not found");
-  }
-}
-
-export { getGroupedRenderedCookies, fetchWithCookies };
+export {
+  getCookie,
+  getChromeCookie,
+  getFirefoxCookie,
+  getMergedRenderedCookies,
+  getGroupedRenderedCookies,
+  fetchWithCookies,
+  //
+};
 
 export * from "./CookieSpec";
 export * from "./CookieRow";

package/src/isValidJwt.ts

@@ -1,10 +1,10 @@
 import jsonwebtoken, { JwtPayload } from "jsonwebtoken";
-import { env } from "./global";
+import { parsedArgs } from "./argv";
 
 export default function isValidJwt(token: any) {
   try {
     const result = jsonwebtoken.decode(token, { complete: true });
-    if (env.VERBOSE) {
+    if (parsedArgs.verbose && result) {
       console.log(result);
     }
     const payload: JwtPayload = result?.payload as JwtPayload;

package/src/queryCookies.ts

@@ -1,24 +1,28 @@
-import { env } from "./global";
 import { uniqBy } from "lodash";
+import { parsedArgs } from "./argv";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
 import isValidJwt from "./isValidJwt";
-import { CookieSpec } from "./CookieSpec";
-import { ExportedCookie } from "./ExportedCookie";
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
 
 export async function queryCookies(
   { name, domain }: CookieSpec,
   strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy()
-) {
+): Promise<ExportedCookie[]> {
   const results: ExportedCookie[] = await strategy.queryCookies(name, domain);
-  const results1: ExportedCookie[] = uniqBy(results, JSON.stringify);
-  const jwtCookies = [];
-  for (const result of results1) {
-    const value = result.value;
-    if (isValidJwt(value)) {
-      jwtCookies.push(result);
+  const allCookies: ExportedCookie[] = uniqBy(results, JSON.stringify);
+
+  if (parsedArgs["require-jwt"]) {
+    const jwtCookies = [];
+    for (const result of allCookies) {
+      const value: string = result.value;
+      if (isValidJwt(value)) {
+        jwtCookies.push(result);
+      }
     }
+    return parsedArgs["single"] ? [jwtCookies[0]] : jwtCookies;
+  } else {
+    return parsedArgs["single"] ? [allCookies[0]] : allCookies;
   }
-  const resultsUniq = env.REQUIRE_JWT ? jwtCookies : results1;
-  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
 }

package/src/resultsRendered.ts

@@ -1,8 +1,11 @@
-import { uniqBy } from "lodash";
-import { ExportedCookie } from "./ExportedCookie";
+import { orderBy, uniqBy } from "lodash";
+import ExportedCookie from "./ExportedCookie";
 
 export function resultsRendered(results: ExportedCookie[]) {
-  return uniqBy(results, (r) => r.name)
-    .map((r) => r.name + "=" + r.value)
+  // sort by name and expiry descending
+  // takes the latest expiry for each name
+  const orderedResults = orderBy(results, ["name", "expiry"], ["asc", "desc"]);
+  return uniqBy(orderedResults, (r: ExportedCookie) => r.name)
+    .map((r: ExportedCookie) => r.name + "=" + r.value)
     .join("; ");
 }

package/src/unpackHeaders.ts

@@ -1,13 +1,16 @@
-export function unpackHeaders(headerArgs: string[] | string) {
+export function unpackHeaders(headerArgs: string[] | string | null) {
   const headers: any = {};
+  if (headerArgs == null) {
+    return headers;
+  }
   if (Array.isArray(headerArgs)) {
     for (const h of headerArgs) {
       const [key, value] = h.split("=");
       headers[key] = value;
     }
-  } else {
-    const [key, value] = headerArgs.split("=");
-    headers[key] = value;
+    return headers;
   }
+  const [key, value] = headerArgs.split("=");
+  headers[key] = value;
   return headers;
 }

package/src/utils.ts

@@ -23,28 +23,3 @@ export async function execSimple(command: string): Promise<string> {
     );
   });
 }
-
-export function toStringOrNull(result: any) {
-  if (result == null) {
-    return null;
-  }
-  if (process.env.VERBOSE) {
-    console.log("result", result);
-  }
-  if (typeof result === "string" && result.length > 0) {
-    return result;
-  }
-  if (result.slice && result.toString) {
-    // noinspection JSCheckFunctionSignatures
-    return result.toString("utf8");
-  }
-  return null;
-}
-
-export function invalidString(input: any): boolean {
-  return typeof input !== "string" || input.length === 0;
-}
-
-export function validString(input: any): input is string {
-  return typeof input == "string" && input.length > 0;
-}

package/tsconfig.json

@@ -1,23 +1,19 @@
 {
-  "include": [
-    "src/**.ts",
-    "src/**.tsx",
-    "src/**.js",
-    "src/**.jsx"
-  ],
+  "include": ["src/**.ts", "src/**.tsx", "src/**.js", "src/**.jsx"],
   "compilerOptions": {
     "moduleResolution": "node",
     "target": "es2021",
-    "types": [
-      "node"
-    ],
-    "lib": [
-      "es2015",
-      "es2017",
-      "es2021",
-      "dom"
-    ],
+    "types": ["node"],
+    "lib": ["es2015", "es2017", "es2021", "dom"],
     "strict": true,
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
     "allowSyntheticDefaultImports": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "module": "commonjs",
+    "outDir": "dist",
+    "outFile": "dist/types.d.ts"
   }
 }

package/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"