@mherod/get-cookie 1.3.0 → 2.0.0-beta.10

package/src/fetchWithCookies.ts

@@ -0,0 +1,62 @@
+// noinspection JSUnusedGlobalSymbols
+
+import { fetch } from "cross-fetch";
+import { merge } from "lodash";
+// noinspection SpellCheckingInspection
+import destr from "destr";
+import FetchResponse from "./fetchResponse";
+import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+
+export async function fetchWithCookies(
+  url: RequestInfo | URL,
+  options: RequestInit | undefined = {}
+): Promise<FetchResponse> {
+  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"
+    },
+    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
+  });
+  const cookie = cookies.pop();
+  const newOptions1: RequestInit = merge(defaultOptions, options, {
+    headers: {
+      Cookie: cookie
+    }
+  });
+  try {
+    const res = await fetch(url2, newOptions1);
+    const newUrl = 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 source2 = {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers,
+      arrayBuffer,
+      buffer,
+      text,
+      json,
+      formData
+      //
+    };
+    return merge({}, res, source2);
+  } catch (e) {
+    throw e;
+  }
+}

package/src/findAllFiles.ts

@@ -0,0 +1,68 @@
+import { env } from "./global";
+import * as fs from "fs";
+
+export async function findAllFiles(
+  {
+    path,
+    name,
+    maxDepth = 2
+//
+  }: {
+    path: string;
+    name: string;
+    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) {
+      console.log(`Error reading ${path}`, e);
+    }
+    return [];
+  }
+  for (const file of readdirSync) {
+    const filePath = path + "/" + file;
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch (e) {
+      if (env.VERBOSE) {
+        console.error(`Error getting stat for ${filePath}`, e);
+      }
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (filePath.split("/").length < rootSegments + maxDepth) {
+        try {
+          const subFiles = await findAllFiles({
+            path: filePath,
+            name: name,
+            maxDepth: 2
+          });
+          files.push(...subFiles);
+        } catch (e) {
+          if (env.VERBOSE) {
+            console.error(e);
+          }
+        }
+      }
+    } else if (file === name) {
+      files.push(filePath);
+    }
+  }
+  if (env.VERBOSE) {
+    if (files.length > 0) {
+      console.log(`Found ${files.length} ${name} files`);
+      console.log(files);
+    }
+  }
+  return files;
+}

package/src/getGroupedRenderedCookies.ts

@@ -0,0 +1,32 @@
+import { queryCookies } from "./queryCookies";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { groupBy } from "lodash";
+import { resultsRendered } from "./resultsRendered";
+import { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+
+export async function getGroupedRenderedCookies(
+  //
+  {
+    name,
+    domain
+    //
+  }: CookieRequest
+  //
+): 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 {
+    throw new Error("Cookie not found");
+  }
+}

package/src/global.ts

@@ -0,0 +1,7 @@
+const { merge } = require("lodash");
+export const env: any = {};
+merge(env, process.env);
+export const HOME: string = env["HOME"];
+if (!HOME) {
+  throw new Error("HOME environment variable is not set");
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+#!/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 { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+import { fetchWithCookies } from "./fetchWithCookies";
+
+export async function getCookie(params: CookieRequest): 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: CookieRequest): 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: CookieRequest): 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 * from "./CookieRequest";
+export * from "./CookieRow";
+export * from "./ExportedCookie";

package/src/isValidJwt.ts

@@ -0,0 +1,14 @@
+import jsonwebtoken from "jsonwebtoken";
+import { env } from "./global";
+
+export default function isValidJwt(token: any) {
+  try {
+    const result = jsonwebtoken.decode(token, { complete: true });
+    if (env.VERBOSE) {
+      console.log(result);
+    }
+    return true;
+  } catch (err) {
+    return false;
+  }
+}

package/src/queryCookies.ts

@@ -0,0 +1,27 @@
+import { env } from "./global";
+import { uniqBy } from "lodash";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
+import isValidJwt from "./isValidJwt";
+import { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+
+export async function queryCookies(
+  {
+    name,
+    domain
+  }: CookieRequest,
+  strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy()
+) {
+  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 resultsUniq = env.REQUIRE_JWT ? jwtCookies : results1;
+  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
+}

package/src/resultsRendered.ts

@@ -0,0 +1,8 @@
+import { uniqBy } from "lodash";
+import { ExportedCookie } from "./ExportedCookie";
+
+export function resultsRendered(results: ExportedCookie[]) {
+  return uniqBy(results, (r) => r.name)
+    .map((r) => r.name + "=" + r.value)
+    .join("; ");
+}

package/src/utils.ts

@@ -0,0 +1,56 @@
+// noinspection JSUnusedGlobalSymbols
+
+import {exec, ExecException} from "child_process";
+
+export async function execSimple(command: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error: ExecException | null, stdout: string, stderr: string) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        if (stdout) {
+          resolve(stdout.trim());
+        }
+      }
+    );
+  });
+}
+
+/**
+ *
+ * @param result
+ * @returns {string|null}
+ */
+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

@@ -0,0 +1,23 @@
+{
+  "include": [
+    "src/**.ts",
+    "src/**.tsx",
+    "src/**.js",
+    "src/**.jsx"
+  ],
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "target": "es2021",
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "es2015",
+      "es2017",
+      "es2021",
+      "dom"
+    ],
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+  }
+}