@mherod/get-cookie 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/index.js

@@ -6,8 +6,8 @@ var $7oI3p$colorette = require("colorette");
 var $7oI3p$fs = require("fs");
 var $7oI3p$crypto = require("crypto");
 var $7oI3p$path = require("path");
-var $7oI3p$child_process = require("child_process");
 var $7oI3p$sqlite3 = require("sqlite3");
+var $7oI3p$child_process = require("child_process");
 var $7oI3p$toughcookie = require("tough-cookie");
 var $7oI3p$toughcookiefilestore = require("tough-cookie-file-store");
 var $7oI3p$jsonwebtoken = require("jsonwebtoken");
@@ -41,6 +41,7 @@ function $parcel$interopDefault(a) {
 $parcel$export(module.exports, "getCookie", () => $8481e2034946cc4b$export$4be65e66cfa2648a);
 $parcel$export(module.exports, "getChromeCookie", () => $1a92ef2038b55530$export$e5637297e9eb6f2e);
 $parcel$export(module.exports, "getFirefoxCookie", () => $f9b70200901ad17d$export$c44c5fdef43f0941);
+$parcel$export(module.exports, "getMergedRenderedCookies", () => $4ffeaeb7bb3c0319$export$cfc0723de5712e57);
 $parcel$export(module.exports, "getGroupedRenderedCookies", () => $300d8b33187a203c$export$4d2e9997e2c23417);
 $parcel$export(module.exports, "fetchWithCookies", () => $cfc07ae4aa2c7e44$export$b24a545a0b39f491);
 
@@ -125,46 +126,6 @@ async function $e62c2c56eb720f29$export$2c9faf86071156ae({ path: path , name: na
 
 
 
-
-
-
-async function $a085b524d8ee9fce$export$f19f611d1fa7c6f3({ file: file , sql: sql , rowTransform: rowTransform  }) {
-    if (!file || file && !$7oI3p$fs.existsSync(file)) throw new Error(`doSqliteQuery1: file ${file} does not exist`);
-    const db = new $7oI3p$sqlite3.Database(file);
-    return new Promise((resolve, reject)=>{
-        db.all(sql, (err, rows)=>{
-            if (err) {
-                reject(err);
-                return;
-            }
-            const rows1 = rows;
-            if (rows1 == null || rows1.length === 0) {
-                resolve([]);
-                return;
-            }
-            if (Array.isArray(rows1)) {
-                const cookieRows = rows1.map((row)=>{
-                    const newVar = {
-                        meta: {
-                            file: file
-                        }
-                    };
-                    const cookieRow = rowTransform(row);
-                    return (0, $7oI3p$lodash.merge)(newVar, cookieRow);
-                });
-                resolve(cookieRows);
-                return;
-            }
-            if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-            resolve([
-                rows1
-            ]);
-        });
-    });
-}
-
-
-
 function $af69dfb8766652d8$export$bc926c43858bd3cb(obj) {
     return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
 }
@@ -184,6 +145,8 @@ function $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb(s) {
 
 
 
+
+
 class $269fe42bfd555305$export$2e2bcd8739ae039 {
     browserName = "Chrome";
     async queryCookies(name, domain) {
@@ -240,12 +203,17 @@ async function $269fe42bfd555305$var$getChromeCookies({ name: name , domain: dom
         const decryptedValue = await $269fe42bfd555305$var$decryptValue(password, encryptedValue);
         const meta = {};
         (0, $7oI3p$lodash.merge)(meta, cookieRow.meta ?? {});
-        return {
+        const exportedCookie = {
             domain: cookieRow.domain,
             name: cookieRow.name,
             value: decryptedValue,
             meta: meta
         };
+        const expiry = cookieRow.expiry;
+        if (expiry) (0, $7oI3p$lodash.merge)(exportedCookie, {
+            expiry: new Date(expiry)
+        });
+        return exportedCookie;
     });
     const results = (await Promise.all(decrypted)).filter((0, $d66f40b581ba8bfa$export$963c8d651337e4a4));
     if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log("results", results);
@@ -260,7 +228,8 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
     }
     let sql;
     //language=SQL
-    sql = "SELECT encrypted_value, name, host_key FROM cookies";
+    sql = "SELECT * FROM cookies";
+    // sql = "SELECT encrypted_value, name, host_key FROM cookies";
     const wildcardRegexp = /^([*%])$/i;
     const specifiedName = name.match(wildcardRegexp) == null;
     const specifiedDomain = domain.match(wildcardRegexp) == null;
@@ -279,15 +248,18 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
             sql += `host_key LIKE '${sqlEmbedDomain}';`;
         }
     }
-    const sqliteQuery1 = await (0, $a085b524d8ee9fce$export$f19f611d1fa7c6f3)({
+    const sqliteQuery1 = await $269fe42bfd555305$export$bd52b72df8d0d261({
         file: file,
         sql: sql,
         rowTransform: (row)=>{
-            return {
+            const cookieRow = {
+                expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
                 domain: row["host_key"],
                 name: row["name"],
                 value: row["encrypted_value"]
             };
+            if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log("CookieRow", cookieRow);
+            return cookieRow;
         }
     });
     return sqliteQuery1.filter((row)=>{
@@ -352,6 +324,42 @@ async function $269fe42bfd555305$var$decrypt(password, encryptedData) {
         });
     });
 }
+async function $269fe42bfd555305$export$bd52b72df8d0d261({ file: file , sql: sql , rowTransform: rowTransform  }) {
+    if (!file || file && !(0, ($parcel$interopDefault($7oI3p$fs))).existsSync(file)) throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+    const db = new $7oI3p$sqlite3.Database(file);
+    return new Promise((resolve, reject)=>{
+        db.all(sql, (err, rows)=>{
+            if (err) {
+                reject(err);
+                return;
+            }
+            const rows1 = rows;
+            if (rows1 == null || rows1.length === 0) {
+                resolve([]);
+                return;
+            }
+            if (Array.isArray(rows1)) {
+                const cookieRows = rows1.map((row)=>{
+                    const newVar = {
+                        meta: {
+                            file: file
+                        }
+                    };
+                    const cookieRow = rowTransform(row);
+                    return (0, $7oI3p$lodash.merge)(newVar, cookieRow);
+                });
+                resolve(cookieRows);
+                return;
+            }
+            if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+            resolve([
+                rows1
+            ]);
+        });
+    });
+}
+
+
 
 
 
@@ -359,6 +367,43 @@ async function $269fe42bfd555305$var$decrypt(password, encryptedData) {
 
 
 
+
+async function $a085b524d8ee9fce$export$f19f611d1fa7c6f3({ file: file , sql: sql , rowTransform: rowTransform  }) {
+    if (!file || file && !$7oI3p$fs.existsSync(file)) throw new Error(`doSqliteQuery1: file ${file} does not exist`);
+    const db = new $7oI3p$sqlite3.Database(file);
+    return new Promise((resolve, reject)=>{
+        db.all(sql, (err, rows)=>{
+            if (err) {
+                reject(err);
+                return;
+            }
+            const rows1 = rows;
+            if (rows1 == null || rows1.length === 0) {
+                resolve([]);
+                return;
+            }
+            if (Array.isArray(rows1)) {
+                const cookieRows = rows1.map((row)=>{
+                    const newVar = {
+                        meta: {
+                            file: file
+                        }
+                    };
+                    const cookieRow = rowTransform(row);
+                    return (0, $7oI3p$lodash.merge)(newVar, cookieRow);
+                });
+                resolve(cookieRows);
+                return;
+            }
+            if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+            resolve([
+                rows1
+            ]);
+        });
+    });
+}
+
+
 function $b744d19cc39f964e$export$da22813e5a2ec500({ name: name , domain: domain  }) {
     const wildcardRegexp = /^([*%])$/i;
     return {
@@ -496,8 +541,9 @@ class $e4efb16e005540de$export$2e2bcd8739ae039 {
             domain: cookie.domain ?? cookieSpec.domain,
             name: cookie.key ?? cookieSpec.name,
             value: cookie.value,
+            expiry: cookie.expires ?? Infinity,
             meta: {
-                file: "memory"
+                file: "tough-cookie"
             }
         };
     }
@@ -642,7 +688,16 @@ async function $f9b70200901ad17d$export$c44c5fdef43f0941(params) {
 
 
 function $9c43c2ed82e63570$export$9abc0a414b0d8b8f(results) {
-    return (0, $7oI3p$lodash.uniqBy)(results, (r)=>r.name).map((r)=>r.name + "=" + r.value).join("; ");
+    // sort by name and expiry descending
+    // takes the latest expiry for each name
+    const orderedResults = (0, $7oI3p$lodash.orderBy)(results, [
+        "name",
+        "expiry"
+    ], [
+        "asc",
+        "desc"
+    ]);
+    return (0, $7oI3p$lodash.uniqBy)(orderedResults, (r)=>r.name).map((r)=>r.name + "=" + r.value).join("; ");
 }
 
 
@@ -668,6 +723,23 @@ async function $300d8b33187a203c$export$4d2e9997e2c23417({ name: name , domain:
 
 
 
+async function $4ffeaeb7bb3c0319$export$cfc0723de5712e57({ name: name , domain: domain  }) {
+    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
+        name: name,
+        domain: domain
+    }, new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)());
+    if (cookies.length == 0) throw new Error("Cookie not found");
+    const results = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
+        name: name,
+        domain: domain
+    });
+    return (0, $9c43c2ed82e63570$export$9abc0a414b0d8b8f)(results);
+}
+
+
+
+
+
 
 
 
@@ -689,23 +761,28 @@ async function $cfc07ae4aa2c7e44$export$b24a545a0b39f491(url, options = {}, fetc
         name: "%",
         domain: domain
     };
-    const cookies = await (0, $300d8b33187a203c$export$4d2e9997e2c23417)(cookieSpec).catch(()=>[]);
-    const cookie = cookies.pop();
+    // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
+    //   () => []
+    // );
+    // const cookie = cookies.pop();
+    const cookie = await (0, $4ffeaeb7bb3c0319$export$cfc0723de5712e57)(cookieSpec).catch(()=>"");
+    const headers = {};
+    if (cookie.length > 0) (0, $7oI3p$lodash.merge)(headers, {
+        Cookie: cookie
+    });
     const newOptions1 = (0, $7oI3p$lodash.merge)(defaultOptions, options, {
-        headers: {
-            Cookie: cookie
-        }
+        headers: headers
     });
     try {
         const res = await fetch(url2, newOptions1);
-        const headers = [];
+        const headers1 = [];
         res.headers.forEach((value, key)=>{
-            headers.push([
+            headers1.push([
                 key,
                 value
             ]);
         });
-        for (const [key, value] of headers)if (key === "set-cookie") {
+        for (const [key, value] of headers1)if (key === "set-cookie") {
             await (0, $53a3bcc99a05dfcf$export$928a906645f9d018).setCookie(value, url2);
             if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log((0, $7oI3p$colorette.blue)(`Set-Cookie: ${(0, $7oI3p$colorette.yellow)(value)} ${(0, $7oI3p$colorette.yellow)(url2)}`));
         // const cookie = tough.parse(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.7",
+  "version": "2.0.0-rc.9",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -11,7 +11,7 @@
     "access": "public"
   },
   "scripts": {
-    "clean": "git clean -fXd && yarn",
+    "clean": "git clean -fdX && rm -rf node_modules dist && yarn install",
     "build": "parcel build",
     "prepare": "npm run build && npm run prettier",
     "test": "jest",

package/src/CookieRow.ts

@@ -1,4 +1,5 @@
 export default interface CookieRow {
+  expiry?: number;
   domain: string;
   name: string;
   value: Buffer;

package/src/ExportedCookie.ts

@@ -2,5 +2,6 @@ export default interface ExportedCookie {
   domain: string;
   name: string;
   value: string;
+  expiry?: Date | "Infinity";
   meta?: any;
 }

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -13,6 +13,9 @@ import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
 import { stringToRegex } from "../StringToRegex";
 import { parsedArgs } from "../argv";
+import fs from "fs";
+import * as sqlite3 from "sqlite3";
+import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
   browserName = "Chrome";
@@ -103,12 +106,19 @@ Promise<ExportedCookie[]> {
       const decryptedValue = await decryptValue(password, encryptedValue);
       const meta = {};
       merge(meta, cookieRow.meta ?? {});
-      return {
+      const exportedCookie: ExportedCookie = {
         domain: cookieRow.domain,
         name: cookieRow.name,
         value: decryptedValue,
         meta: meta,
       };
+      const expiry = cookieRow.expiry;
+      if (expiry) {
+        merge(exportedCookie, {
+          expiry: new Date(expiry),
+        });
+      }
+      return exportedCookie;
     });
   const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
     isExportedCookie
@@ -146,7 +156,8 @@ async function getEncryptedChromeCookie({
   }
   let sql;
   //language=SQL
-  sql = "SELECT encrypted_value, name, host_key FROM cookies";
+  sql = "SELECT * FROM cookies";
+  // sql = "SELECT encrypted_value, name, host_key FROM cookies";
 
   const wildcardRegexp = /^([*%])$/i;
   const specifiedName = name.match(wildcardRegexp) == null;
@@ -168,15 +179,20 @@ async function getEncryptedChromeCookie({
       sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
-  const sqliteQuery1: CookieRow[] = await doSqliteQuery1({
+  const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
     file: file,
     sql: sql,
     rowTransform: (row) => {
-      return {
+      const cookieRow = {
+        expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
         domain: row["host_key"],
         name: row["name"],
         value: row["encrypted_value"],
       };
+      if (parsedArgs.verbose) {
+        console.log("CookieRow", cookieRow);
+      }
+      return cookieRow;
     },
   });
   return sqliteQuery1.filter((row) => {
@@ -284,3 +300,44 @@ async function decrypt(
     });
   });
 }
+
+export async function doChromeSqliteQuery1({
+  file,
+  sql,
+  rowTransform,
+}: DoSqliteQuery1Params): Promise<CookieRow[]> {
+  if (!file || (file && !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: any) => {
+          const newVar = {
+            meta: {
+              file: file,
+            },
+          };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
+        });
+        resolve(cookieRows);
+        return;
+      }
+      if (parsedArgs.verbose) {
+        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+      }
+      resolve([rows1]);
+    });
+  });
+}

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -57,8 +57,9 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
       domain: cookie.domain ?? cookieSpec.domain,
       name: cookie.key ?? cookieSpec.name,
       value: cookie.value,
+      expiry: cookie.expires ?? Infinity,
       meta: {
-        file: "memory",
+        file: "tough-cookie",
       },
     };
   }

package/src/doSqliteQuery1.ts

@@ -3,12 +3,7 @@ import * as sqlite3 from "sqlite3";
 import CookieRow from "./CookieRow";
 import { merge } from "lodash";
 import { parsedArgs } from "./argv";
-
-interface DoSqliteQuery1Params {
-  file: string;
-  sql: string;
-  rowTransform: (row: any) => CookieRow;
-}
+import { DoSqliteQuery1Params } from "./doSqliteQuery1Params";
 
 export async function doSqliteQuery1({
   file,

package/src/doSqliteQuery1Params.ts

@@ -0,0 +1,7 @@
+import CookieRow from "./CookieRow";
+
+export interface DoSqliteQuery1Params {
+  file: string;
+  sql: string;
+  rowTransform: (row: any) => CookieRow;
+}

package/src/fetchWithCookies.ts

@@ -5,11 +5,11 @@ import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
 import CookieSpec from "./CookieSpec";
-import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
 import { cookieJar } from "./CookieStore";
 import UserAgent from "user-agents";
 import { parsedArgs } from "./argv";
 import { blue, yellow } from "colorette";
+import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
 
 export async function fetchWithCookies(
   url: RequestInfo | URL,
@@ -31,15 +31,18 @@ export async function fetchWithCookies(
     name: "%",
     domain: domain,
   };
-  const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
-    () => []
-  );
-  const cookie = cookies.pop();
-  const newOptions1: RequestInit = merge(defaultOptions, options, {
-    headers: {
+  // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
+  //   () => []
+  // );
+  // const cookie = cookies.pop();
+  const cookie = await getMergedRenderedCookies(cookieSpec).catch(() => "");
+  const headers = {};
+  if (cookie.length > 0) {
+    merge(headers, {
       Cookie: cookie,
-    },
-  });
+    });
+  }
+  const newOptions1: RequestInit = merge(defaultOptions, options, { headers });
   try {
     const res: Response = await fetch(url2, newOptions1);
     const headers: [string, string][] = [];

package/src/findAllFiles.ts

@@ -1,4 +1,3 @@
-import { env } from "./global";
 import * as fs from "fs";
 import { parsedArgs } from "./argv";
 

package/src/getMergedRenderedCookies.ts

@@ -0,0 +1,25 @@
+import { groupBy } from "lodash";
+import { queryCookies } from "./queryCookies";
+import { resultsRendered } from "./resultsRendered";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+
+export async function getMergedRenderedCookies({
+  name,
+  domain,
+}: CookieSpec): Promise<string> {
+  const cookies: ExportedCookie[] = await queryCookies(
+    {
+      name,
+      domain,
+    },
+    new CompositeCookieQueryStrategy()
+    //
+  );
+  if (cookies.length == 0) {
+    throw new Error("Cookie not found");
+  }
+  const results: ExportedCookie[] = await queryCookies({ name, domain });
+  return resultsRendered(results);
+}

package/src/index.ts

@@ -5,12 +5,14 @@ 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 {
   getCookie,
   getChromeCookie,
   getFirefoxCookie,
+  getMergedRenderedCookies,
   getGroupedRenderedCookies,
   fetchWithCookies,
   //

package/src/resultsRendered.ts

@@ -1,8 +1,11 @@
-import { uniqBy } from "lodash";
+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/utils.ts

@@ -1,7 +1,6 @@
 // noinspection JSUnusedGlobalSymbols
 
 import { exec, ExecException } from "child_process";
-import { parsedArgs } from "./argv";
 
 export async function execSimple(command: string): Promise<string> {
   return new Promise((resolve, reject) => {