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

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"mappings":";ACAA;IACE,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AILD;IACE,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;ASLD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AGID,0CAEE,EACE,IAAI,EACJ,MAAM,EAEP,EAAE,aAAa,GAEf,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB;AC/BD;IACE,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,QAAQ,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;IACzC,WAAW,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IACxC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/B;ACDD,iCACE,GAAG,EAAE,WAAW,GAAG,GAAG,EACtB,OAAO,GAAE,WAAW,GAAG,SAAc,GACpC,OAAO,CAAC,aAAa,CAAC,CAiDxB;ACjDD,0BAAgC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAW1F;AAED,iCAAuC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAWjG;AAED,gCAAsC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAWhG","sources":["src/src/global.ts","src/src/ExportedCookie.ts","src/src/browsers/CookieQueryStrategy.ts","src/src/utils.ts","src/src/findAllFiles.ts","src/src/CookieRow.ts","src/src/doSqliteQuery1.ts","src/src/IsCookieRow.ts","src/src/IsExportedCookie.ts","src/src/browsers/ChromeCookieQueryStrategy.ts","src/src/browsers/FirefoxCookieQueryStrategy.ts","src/src/browsers/SafariCookieQueryStrategy.ts","src/src/browsers/CompositeCookieQueryStrategy.ts","src/src/isValidJwt.ts","src/src/CookieRequest.ts","src/src/queryCookies.ts","src/src/resultsRendered.ts","src/src/getGroupedRenderedCookies.ts","src/src/fetchResponse.ts","src/src/fetchWithCookies.ts","src/src/index.ts","src/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"#!/usr/bin/env node\n// noinspection JSUnusedGlobalSymbols\n\nimport { queryCookies } from \"./queryCookies\";\nimport FirefoxCookieQueryStrategy from \"./browsers/FirefoxCookieQueryStrategy\";\nimport ChromeCookieQueryStrategy from \"./browsers/ChromeCookieQueryStrategy\";\nimport CompositeCookieQueryStrategy from \"./browsers/CompositeCookieQueryStrategy\";\nimport { CookieRequest } from \"./CookieRequest\";\nimport { ExportedCookie } from \"./ExportedCookie\";\nimport { getGroupedRenderedCookies } from \"./getGroupedRenderedCookies\";\nimport { fetchWithCookies } from \"./fetchWithCookies\";\n\nexport async function getCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {\n  const cookies = await queryCookies(\n    params,\n    new CompositeCookieQueryStrategy()\n    //\n  );\n  if (Array.isArray(cookies) && cookies.length > 0) {\n    return cookies.find((cookie) => cookie != null);\n  } else {\n    throw new Error(\"Cookie not found\");\n  }\n}\n\nexport async function getFirefoxCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {\n  const cookies = await queryCookies(\n    params,\n    new FirefoxCookieQueryStrategy()\n    //\n  );\n  if (Array.isArray(cookies) && cookies.length > 0) {\n    return cookies.find((cookie) => cookie != null);\n  } else {\n    throw new Error(\"Cookie not found\");\n  }\n}\n\nexport async function getChromeCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {\n  const cookies = await queryCookies(\n    params,\n    new ChromeCookieQueryStrategy()\n    //\n  );\n  if (Array.isArray(cookies) && cookies.length > 0) {\n    return cookies.find((cookie) => cookie != null);\n  } else {\n    throw new Error(\"Cookie not found\");\n  }\n}\n\nexport {\n  getGroupedRenderedCookies,\n  fetchWithCookies,\n};\n\nexport * from \"./CookieRequest\";\nexport * from \"./CookieRow\";\nexport * from \"./ExportedCookie\";\n"],"names":[],"version":3,"file":"types.d.ts.map","sourceRoot":"../"}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "1.3.0",
+  "version": "2.0.0-beta.10",
   "description": "Node.js module for querying a local user's Chrome cookie",
-  "source": "src/index.js",
+  "source": "src/index.ts",
   "bin": "dist/cli.js",
-  "main": "dist/main.js",
+  "main": "dist/index.js",
   "module": "dist/module.js",
+  "types": "dist/types.d.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -13,30 +14,41 @@
     "clean": "git clean -fXd",
     "build": "parcel build",
     "test": "jest",
-    "postbuild": "npm run install:global",
+    "postbuild": "npm run check && npm run install:global",
+    "prepublish": "npm run build",
     "install:global": "npm install --force --global .",
     "postinstall:global": "find $NVM_BIN -exec chmod +x {} \\; || true",
-    "prettier": "prettier --write 'src/{**/*,*}.{js,json}'"
+    "prettier": "prettier --write 'src/{**/*,*}.{js,json,ts}'",
+    "check": "tsc --noEmit"
   },
   "targets": {
-    "main": {
-      "source": "src/index.js",
+    "main": {},
+    "types": {},
+    "library": {
+      "source": [
+        "src/index.ts"
+      ],
       "distDir": "dist",
+      "isLibrary": true,
       "engines": {
         "node": "16"
       }
     },
     "cli": {
-      "source": "src/cli.js",
+      "source": "src/cli.ts",
       "distDir": "dist",
+      "isLibrary": false,
       "engines": {
         "node": "16"
-      }
+      },
+      "includeNodeModules": [
+        "colorette"
+      ]
     }
   },
   "@parcel/transformer-js": {
     "inlineFS": false,
-    "inlineEnvironment": false
+    "inlineEnvironment": true
   },
   "engines": {
     "node": "16"
@@ -45,12 +57,25 @@
   "author": "Matthew Herod",
   "license": "ISC",
   "dependencies": {
+    "colorette": "^2.0.19",
+    "cross-fetch": "^3.1.5",
+    "destr": "^1.1.1",
     "jsonwebtoken": "^8.5.1",
     "lodash": "^4.17.21",
-    "sqlite3": "^5.0.8"
+    "sqlite3": "^5.1.1",
+    "user-agents": "^1.0.1163"
   },
   "devDependencies": {
-    "jest": "^28.1.0",
-    "prettier": "^2.7.1"
+    "@parcel/packager-ts": "^2.7.0",
+    "@parcel/transformer-typescript-types": "^2.7.0",
+    "@types/jsonwebtoken": "^8.5.9",
+    "@types/lodash": "^4.14.186",
+    "@types/node": "^18.8.2",
+    "@types/user-agents": "^1.0.2",
+    "jest": "^29.0.3",
+    "parcel": "^2.7.0",
+    "prettier": "^2.7.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.4"
   }
 }

package/src/CookieRequest.ts

@@ -0,0 +1,4 @@
+export interface CookieRequest {
+  name: string;
+  domain: string;
+}

package/src/CookieRow.ts

@@ -0,0 +1,6 @@
+export interface CookieRow {
+  domain: string;
+  name: string;
+  value: Buffer;
+  meta?: any;
+}

package/src/ExportedCookie.ts

@@ -0,0 +1,6 @@
+export interface ExportedCookie {
+  domain: string;
+  name: string;
+  value: string;
+  meta?: any;
+}

package/src/IsCookieRow.ts

@@ -0,0 +1,5 @@
+import { CookieRow } from "./CookieRow";
+
+export function isCookieRow(obj: any): obj is CookieRow {
+  return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+}

package/src/IsExportedCookie.ts

@@ -0,0 +1,5 @@
+import { ExportedCookie } from "./ExportedCookie";
+
+export function isExportedCookie(obj: any): obj is ExportedCookie {
+  return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+}

package/src/argv.ts

@@ -0,0 +1 @@
+export const argv: string[] = process.argv ?? [];

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -0,0 +1,259 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import { execSimple } from "../utils";
+import { env, HOME } from "../global";
+import { existsSync } from "fs";
+import { findAllFiles } from "../findAllFiles";
+import * as crypto from "crypto";
+import * as path from "path";
+import { doSqliteQuery1 } from "../doSqliteQuery1";
+import { merge } from "lodash";
+import { isCookieRow } from "../IsCookieRow";
+import { isExportedCookie } from "../IsExportedCookie";
+import { CookieRow } from "../CookieRow";
+import { ExportedCookie } from "../ExportedCookie";
+
+export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    if (process.platform !== "darwin") {
+      throw new Error("This only works on macOS");
+    }
+    if (env.FIREFOX_ONLY) {
+      return [];
+    }
+    return getChromeCookies({
+      requireJwt: false,
+      name,
+      domain
+    });
+  }
+}
+
+async function getPromise1(name: string, domain: string, file: string): Promise<CookieRow[]> {
+  try {
+    return await getEncryptedChromeCookie({
+      name: name,
+      domain: domain,
+      file: file
+    });
+  } catch (e) {
+    if (env.VERBOSE) {
+      console.log("Error getting encrypted cookie", e);
+    }
+    return [];
+  }
+}
+
+async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
+  try {
+    const files: string[] = await findAllFiles({
+      path: chromeLocal,
+      name: "Cookies"
+    });
+    const promises: Promise<CookieRow[]>[] = files.map((file) => getPromise1(name, domain, file));
+    const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
+    return results1.flat().filter(isCookieRow);
+  } catch (error) {
+    if (env.VERBOSE) {
+      console.log("error", error);
+    }
+    return [];
+  }
+}
+
+async function decryptValue(password: string, encryptedValue: Buffer) {
+  let d: string | null;
+  try {
+    d = await decrypt(password, encryptedValue);
+  } catch (e) {
+    if (env.VERBOSE) {
+      console.log("Error decrypting cookie", e);
+    }
+    d = null;
+  }
+  return d ?? encryptedValue.toString("utf-8");
+}
+
+async function getChromeCookies(
+  {
+    name,
+    domain = "%",
+    requireJwt = false
+  }: {
+    name: string;
+    domain: string;
+    requireJwt: boolean | undefined;
+    //
+  }
+  //
+): Promise<ExportedCookie[]> {
+  const encryptedDataItems: CookieRow[] = await getPromise(name, domain);
+  const password: string = await getChromePassword();
+  const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
+    .filter(({ value }) => value != null && value.length > 0)
+    .map(async (cookieRow: CookieRow) => {
+      const encryptedValue: Buffer = cookieRow.value;
+      const decryptedValue = await decryptValue(password, encryptedValue);
+      const meta = {};
+      merge(meta, cookieRow.meta ?? {});
+      return {
+        domain: cookieRow.domain,
+        name: cookieRow.name,
+        value: decryptedValue,
+        meta: meta
+      };
+    });
+  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(isExportedCookie);
+  if (env.VERBOSE) {
+    console.log("results", results);
+  }
+  return results;
+}
+
+const chromeLocal = path.join(
+  HOME,
+  "Library",
+  "Application Support",
+  "Google",
+  "Chrome"
+);
+
+async function getEncryptedChromeCookie(
+  {
+    name,
+    domain,
+    file = path.join(chromeLocal, "Default", "Cookies")
+    //
+  }: {
+    name: string;
+    domain: string;
+    file: string;
+  }): Promise<CookieRow[]> {
+  if (!existsSync(file)) {
+    throw new Error(`File ${file} does not exist`);
+  }
+  if (env.VERBOSE) {
+    const s = file.split("/").slice(-3).join("/");
+    console.log(`Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`);
+  }
+  let sql;
+  sql = `SELECT encrypted_value, name, host_key FROM cookies`;
+  const wildcardRegexp = /^([*%])$/i;
+  const specifiedName = name.match(wildcardRegexp) == null;
+  const specifiedDomain = domain.match(wildcardRegexp) == null;
+  if (specifiedName || specifiedDomain) {
+    sql += ` WHERE `;
+    if (specifiedName) {
+      sql += `name = '${name}'`;
+      if (specifiedDomain) {
+        sql += ` AND `;
+      }
+    }
+    if (specifiedDomain) {
+      sql += `host_key LIKE '${domain}';`;
+    }
+  }
+  return doSqliteQuery1(file, sql);
+}
+
+async function getChromePassword(): Promise<string> {
+  return execSimple(
+    "security find-generic-password -w -s \"Chrome Safe Storage\""
+  );
+}
+
+async function decrypt(password: crypto.BinaryLike, encryptedData: Buffer): Promise<string> {
+  if (typeof password !== "string") {
+    throw new Error("password must be a string: " + password);
+  }
+  let encryptedData1: any;
+  encryptedData1 = encryptedData;
+  if (encryptedData1 == null || typeof encryptedData1 !== "object") {
+    throw new Error("encryptedData must be a object: " + encryptedData1);
+  }
+  if (!(encryptedData1 instanceof Buffer)) {
+    if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
+      [encryptedData1] = encryptedData1;
+      if (env.VERBOSE) {
+        console.log(
+          `encryptedData is an array of buffers, selected first: ${encryptedData1}`
+        );
+      }
+    } else {
+      throw new Error("encryptedData must be a Buffer: " + encryptedData1);
+    }
+    encryptedData1 = Buffer.from(encryptedData1);
+  }
+  if (env.VERBOSE) {
+    console.log(`Trying to decrypt with password ${password}`);
+  }
+  return new Promise((resolve, reject) => {
+    crypto.pbkdf2(password,
+      "saltysalt",
+      1003,
+      16,
+      "sha1",
+      (error, buffer) => {
+        try {
+          if (error) {
+            if (env.VERBOSE) {
+              console.log("Error doing pbkdf2", error);
+            }
+            reject(error);
+            return;
+          }
+
+          if (buffer.length !== 16) {
+            if (env.VERBOSE) {
+              console.log(
+                "Error doing pbkdf2, buffer length is not 16",
+                buffer.length
+              );
+            }
+            reject(new Error("Buffer length is not 16"));
+            return;
+          }
+
+          const str = new Array(17).join(" ");
+          const iv = Buffer.from(str, "binary");
+          const decipher = crypto.createDecipheriv("aes-128-cbc", buffer, iv);
+          decipher.setAutoPadding(false);
+
+          if (encryptedData1 && encryptedData1.slice) {
+            encryptedData1 = encryptedData1.slice(3);
+          }
+
+          if (encryptedData1.length % 16 !== 0) {
+            if (env.VERBOSE) {
+              console.log(
+                "Error doing pbkdf2, encryptedData length is not a multiple of 16",
+                encryptedData1.length
+              );
+            }
+            reject(new Error("encryptedData length is not a multiple of 16"));
+            return;
+          }
+
+          let decoded = decipher.update(encryptedData1);
+          try {
+            decipher.final("utf-8");
+          } catch (e) {
+            if (env.VERBOSE) {
+              console.log("Error doing decipher.final()", e);
+            }
+            reject(e);
+            return;
+          }
+
+          const padding = decoded[decoded.length - 1];
+          if (padding) {
+            decoded = decoded.slice(0, 0 - padding);
+          }
+          // noinspection JSCheckFunctionSignatures
+          const decodedString = decoded.toString("utf8");
+          resolve(decodedString);
+        } catch (e) {
+          reject(e);
+        }
+      });
+  });
+}

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -0,0 +1,30 @@
+import ChromeCookieQueryStrategy from "./ChromeCookieQueryStrategy";
+import FirefoxCookieQueryStrategy from "./FirefoxCookieQueryStrategy";
+import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import { ExportedCookie } from "../ExportedCookie";
+
+export default class CompositeCookieQueryStrategy implements CookieQueryStrategy {
+  #strategies;
+
+  constructor() {
+    this.#strategies = [
+      ChromeCookieQueryStrategy,
+      FirefoxCookieQueryStrategy,
+      SafariCookieQueryStrategy,
+    ].map((strategy) => {
+      return new strategy();
+    });
+  }
+
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    const results = await Promise.all(
+      this.#strategies.map(async (strategy) => {
+        // @ts-ignore
+        const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(name, domain);
+        return cookies.catch(() => []);
+      })
+    );
+    return results.flat();
+  }
+}

package/src/browsers/CookieQueryStrategy.ts

@@ -0,0 +1,5 @@
+import { ExportedCookie } from "../ExportedCookie";
+
+export default interface CookieQueryStrategy {
+  queryCookies(name: string, domain: string): Promise<ExportedCookie[]>
+}

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -0,0 +1,92 @@
+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";
+
+export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    if (process.platform !== "darwin") {
+      throw new Error("This only works on macOS");
+    }
+    if (env.CHROME_ONLY) {
+      return [];
+    }
+    const cookies = await this.#getFirefoxCookie({ name, domain });
+    return Array.isArray(cookies) ? cookies.map(toStringOrNull) : [];
+  }
+
+  /**
+   *
+   * @param name
+   * @param domain
+   * @returns {Promise<Buffer>}
+   */
+  async #getFirefoxCookie(
+    //
+    {
+      name,
+      domain
+    }: {
+      name: string,
+      domain: string
+      //
+    }
+    //
+  ) {
+    const files: string[] = await findAllFiles({
+      path: path.join(
+        HOME,
+        "Library",
+        "Application Support",
+        "Firefox",
+        "Profiles"
+      ),
+      name: "cookies.sqlite"
+    });
+    const all = await Promise.all(
+      files.map((file) => {
+        return this.#queryCookiesDb(file, name, domain);
+      })
+    );
+    return all.flat();
+  }
+
+  #queryCookiesDb(file: string, name: string, domain: string) {
+    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 += ` WHERE `;
+      if (typeof name === "string") {
+        sql += `name = '${name}'`;
+        if (typeof domain === "string") {
+          sql += ` AND `;
+        }
+      }
+      if (typeof domain === "string") {
+        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(() => []);
+  }
+}

package/src/browsers/SafariCookieQueryStrategy.ts

@@ -0,0 +1,8 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import { ExportedCookie } from "../ExportedCookie";
+
+export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    return [];
+  }
+}

package/src/cli.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import { env } from "./global";
+import { queryCookies } from "./queryCookies";
+import { argv } from "./argv";
+import { groupBy } from "lodash";
+import { blue, green } from "colorette";
+import { resultsRendered } from "./resultsRendered";
+import { ExportedCookie } from "./ExportedCookie";
+
+function combinedString(results: ExportedCookie[]) {
+  return blue(resultsRendered(results));
+}
+
+async function cliQueryCookies(name: string, domain: string) {
+  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 {
+      console.error("No results");
+    }
+  } 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 = "%";
+  }
+
+  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,41 @@
+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) {
+        reject(err);
+        return;
+      }
+      const rows1: any[] = rows;
+      if (rows1 == null || rows1.length === 0) {
+        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/fetchResponse.ts

@@ -0,0 +1,11 @@
+export default interface FetchResponse {
+  status: number;
+  statusText: string;
+  headers: Headers;
+  url: string;
+  text: () => Promise<string>;
+  json: () => Promise<any>;
+  formData: () => Promise<URLSearchParams>;
+  arrayBuffer: () => Promise<ArrayBuffer>;
+  buffer: () => Promise<Buffer>;
+}