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

package/src/cli.js

@@ -2,57 +2,89 @@
 
 import { version } from "../package.json";
 import { env } from "./global";
-const { getCookie } = require("./index");
-
-const argv = process.argv;
-if (argv) {
-  if (argv.length > 2) {
-    if (argv.includes("--version") || argv.includes("-v")) {
-      console.log(version);
-      return;
-    }
+import { queryCookies } from "./queryCookies";
+import { argv } from "./argv";
+import { groupBy, uniqBy } from "lodash";
+import { blue, green } from "colorette";
 
-    const name = argv[2];
+function combinedString(results) {
+  return blue(
+    uniqBy(results, (r) => r.name)
+      .map((r) => r.name + "=" + r.value)
+      .join("; ")
+  );
+}
 
-    let domain;
-    if (argv[3] != null && argv[3].indexOf(".") > -1) {
-      domain = argv[3];
+async function cliQueryCookies(name, domain) {
+  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);
+        }
+      }
     } else {
-      domain = "%";
+      console.error("No results");
     }
+  } catch (e) {
+    console.error(e);
+  }
+}
 
-    if (argv.includes("--require-jwt")) {
-      env.REQUIRE_JWT = "true";
-    }
-    if (argv.includes("--verbose")) {
-      env.VERBOSE = "true";
-    }
-    if (argv.includes("--chrome-only")) {
-      env.CHROME_ONLY = "true";
-    }
-    if (argv.includes("--firefox-only")) {
-      env.FIREFOX_ONLY = "true";
-    }
-    if (argv.includes("--ignore-expired")) {
-      env.IGNORE_EXPIRED = "true";
-    }
+if (argv && argv.length > 2) {
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(version);
+    return;
+  }
 
-    if (env.VERBOSE) {
-      console.log("Verbose mode", argv);
-    }
+  const name = argv[2];
 
-    getCookie({
-      name: name,
-      domain: domain,
-      requireJwt: env.REQUIRE_JWT === "true",
-    })
-      .then((cookie) => {
-        if (typeof cookie === "string") {
-          console.log(cookie);
-        }
-      })
-      .catch((err) => {
-        console.error(err);
-      });
+  let domain;
+  if (argv[3] != null && argv[3].indexOf(".") > -1) {
+    domain = argv[3];
+  } 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;
+  }
+
+  if (env.VERBOSE) {
+    console.log("Verbose mode", argv);
+  }
+
+  cliQueryCookies(name, domain).catch(console.error);
 }

package/src/doSqliteQuery1.ts

@@ -0,0 +1,47 @@
+import * as fs from "fs";
+import * as sqlite3 from "sqlite3";
+import {CookieRow} from "./CookieRow";
+
+export async function doSqliteQuery1(file: string, sql: string): Promise<CookieRow[]> {
+    if (!fs.existsSync(file)) {
+        throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+    }
+    const db = new sqlite3.Database(file);
+    return new Promise((resolve, reject) => {
+        db.all(sql, (err: Error, rows: any[]) => {
+            if (err) {
+                if (process.env.VERBOSE) {
+                    console.log(`doSqliteQuery1: error ${err}`);
+                }
+                reject(err);
+                return;
+            }
+            const rows1: any[] = rows;
+            if (rows1 == null || rows1.length === 0) {
+                if (process.env.VERBOSE) {
+                    console.log(`doSqliteQuery1: no rows`);
+                }
+                resolve([]);
+                return;
+            }
+            if (Array.isArray(rows1)) {
+                const cookieRows: CookieRow[] = rows1.map((row) => {
+                    return {
+                        domain: row["host_key"],
+                        name: row["name"],
+                        value: row["encrypted_value"],
+                        meta: {
+                            file: file
+                        }
+                    }
+                })
+                resolve(cookieRows);
+                return;
+            }
+            if (process.env.VERBOSE) {
+                console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+            }
+            resolve([rows1]);
+        });
+    });
+}

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/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");
+}