@mherod/get-cookie 1.2.0 → 2.0.0-beta.1

package/src/global.js

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

package/src/index.js

@@ -0,0 +1,61 @@
+#!/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";
+
+/**
+ *
+ * @param params
+ * @returns {Promise<string>}
+ */
+export async function getCookie(params) {
+  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");
+  }
+}
+
+/**
+ *
+ * @param params
+ * @returns {Promise<*>}
+ */
+export async function getFirefoxCookie(params) {
+  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");
+  }
+}
+
+/**
+ *
+ * @param params
+ * @returns {Promise<*>}
+ */
+export async function getChromeCookie(params) {
+  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");
+  }
+}

package/src/isValidJwt.js

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

package/src/queryCookies.js

@@ -0,0 +1,28 @@
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { uniq } from "lodash";
+import { env } from "./global";
+import isValidJwt from "./isValidJwt";
+
+export async function queryCookies(
+  { name, domain },
+  strategy = new CompositeCookieQueryStrategy()
+) {
+  const results = await strategy.queryCookies(name, domain);
+  const results1 = uniq(results).map((cookie) => {
+    return {
+      name: name,
+      domain: domain,
+      value: cookie,
+    };
+  });
+  const jwtCookies = [];
+  for (const result of results1) {
+    const value = result.value;
+    if (isValidJwt(value)) {
+      jwtCookies.push(result);
+    }
+  }
+  const results2 = env.REQUIRE_JWT ? jwtCookies : results1;
+  const resultsUniq = uniq(results2).map((cookie) => cookie.value);
+  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
+}

package/src/utils.js

@@ -0,0 +1,181 @@
+// noinspection JSUnusedGlobalSymbols
+
+import { exec } from "child_process";
+
+import fs from "fs";
+
+export async function execSimple(command) {
+  if (typeof command !== "string") {
+    throw new TypeError("execSimple: command must be a string");
+  }
+  if (process.env.VERBOSE) {
+    console.log(command);
+  }
+  return new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        if (stdout) {
+          resolve(stdout.toString("utf8").trim());
+        }
+      }
+    );
+  });
+}
+
+export async function execAsBuffer(command) {
+  if (typeof command !== "string") {
+    throw new TypeError("execAsBuffer: command must be a string");
+  }
+  if (process.env.VERBOSE) {
+    console.log(command);
+  }
+  return await new Promise((resolve, reject) => {
+    exec(
+      command,
+      { encoding: "binary", maxBuffer: 5 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          reject(error);
+          return;
+        }
+        let stdoutAsBuffer = stdout;
+        if (typeof stdoutAsBuffer === "string" && stdoutAsBuffer.length > 0) {
+          // noinspection JSCheckFunctionSignatures
+          stdoutAsBuffer = Buffer.from(stdoutAsBuffer, "binary").slice(0, -1);
+        }
+        if (stdoutAsBuffer && stdoutAsBuffer.length > 0) {
+          resolve(stdoutAsBuffer);
+        }
+      }
+    );
+  });
+}
+
+export function toStringValue(r) {
+  if (process.env.VERBOSE) {
+    console.log("Printing value", r);
+  }
+  if (r) {
+    if (typeof r === "string") {
+      return r;
+    } else if (r.toString) {
+      // noinspection JSCheckFunctionSignatures
+      return r.toString("utf8");
+    }
+  }
+}
+
+export function printStringValue(r) {
+  if (process.env.VERBOSE) {
+    console.log("Printing value", r);
+  }
+  if (r) {
+    if (typeof r === "string") {
+      console.log(r);
+    } else if (r.toString) {
+      // noinspection JSCheckFunctionSignatures
+      console.log(r.toString("utf8"));
+    }
+  }
+}
+
+/**
+ *
+ * @param result
+ * @returns {string|null}
+ */
+export function toStringOrNull(result) {
+  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;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {string} sql
+ * @returns {Promise<Buffer[]>}
+ */
+export async function doSqliteQuery1(file, sql) {
+  if (typeof sql !== "string") {
+    throw new TypeError("doSqliteQuery1: sql must be a string");
+  }
+  if (typeof file !== "string") {
+    throw new TypeError("doSqliteQuery1: file must be a string");
+  }
+  if (!fs.existsSync(file)) {
+    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+  }
+  if (process.env.VERBOSE) {
+    console.log(`doSqliteQuery1: file ${file}`);
+    console.log(`doSqliteQuery1: sql ${sql}`);
+  }
+  const sqlite3 = require("sqlite3");
+  const db = new sqlite3.Database(file);
+  return new Promise((resolve, reject) => {
+    db.all(sql, (err, rows) => {
+      if (err) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: error ${err}`);
+        }
+        reject(err);
+        return;
+      }
+      const rows1 = rows;
+      if (rows1 == null || rows1.length === 0) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: no rows`);
+        }
+        resolve([]);
+        return;
+      }
+      if (Array.isArray(rows1)) {
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: ${rows1.length} rows`);
+        }
+        // noinspection JSCheckFunctionSignatures
+        const buffers = rows1
+          .flatMap((row) => Object.values(row))
+          .map((v) => Buffer.from(v, "binary"));
+        if (process.env.VERBOSE) {
+          console.log(`doSqliteQuery1: ${buffers.length} buffers`);
+        }
+        resolve(buffers);
+        return;
+      }
+      if (process.env.VERBOSE) {
+        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+      }
+      resolve([rows1]);
+    });
+  });
+}
+
+export function invalidString(input) {
+  return typeof input !== "string" || input.length === 0;
+}

package/cli.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-const {getCookie} = require("./index");
-
-if (process.argv) {
-    if (process.argv.length > 2) {
-        const name = process.argv[2];
-
-        let domain;
-        if (process.argv[3] != null && process.argv[3].indexOf(".") > -1) {
-            domain = process.argv[3];
-        } else {
-            domain = '%';
-        }
-
-        if (process.argv.includes("--require-jwt")) {
-            process.env.REQUIRE_JWT = "true";
-        }
-        if (process.argv.includes('--verbose')) {
-            process.env.VERBOSE = "true";
-        }
-        if (process.argv.includes("--chrome-only")) {
-            process.env.CHROME_ONLY = "true";
-        }
-        if (process.argv.includes("--firefox-only")) {
-            process.env.FIREFOX_ONLY = "true";
-        }
-        if (process.argv.includes("--ignore-expired")) {
-            process.env.IGNORE_EXPIRED = "true";
-        }
-
-        if (process.env.VERBOSE) {
-            console.log("Verbose mode", process.argv);
-        }
-
-        getCookie({
-            name: name,
-            domain: domain,
-            requireJwt: (process.env.REQUIRE_JWT === "true"),
-        }).then(cookie => {
-            if (typeof cookie === "string") {
-                console.log(cookie);
-            }
-        }).catch(err => {
-            console.error(err);
-        });
-    }
-}