@mherod/get-cookie 2.0.0-rc.3 → 2.0.0-rc.30

package/src/getFirefoxCookie.ts

@@ -0,0 +1,19 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
+
+export async function getFirefoxCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
+  const cookies: ExportedCookie[] = 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");
+  }
+}

package/src/getGroupedRenderedCookies.ts

@@ -1,32 +1,19 @@
-import { queryCookies } from "./queryCookies";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import { groupBy } from "lodash";
 import { resultsRendered } from "./resultsRendered";
-import CookieSpec from "./CookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 
 export async function getGroupedRenderedCookies(
-  //
-  {
-    name,
-    domain,
-  }: //
-  CookieSpec
-): //
-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 {
+  cookieSpec: MultiCookieSpec
+): Promise<string[]> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  if (cookies.length == 0) {
     throw new Error("Cookie not found");
   }
+  const groupedByFile = groupBy(cookies, (r: ExportedCookie) => r.meta?.file);
+  return Object.keys(groupedByFile).map((file: string) => {
+    const results: ExportedCookie[] = groupedByFile[file];
+    return resultsRendered(results);
+  });
 }

package/src/getMergedRenderedCookies.ts

@@ -0,0 +1,12 @@
+import { resultsRendered } from "./resultsRendered";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import consola from "consola";
+
+export async function getMergedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  return cookies.length > 0 ? resultsRendered(cookies) : "";
+}

package/src/global.ts

@@ -1,7 +1,7 @@
 import { merge } from "lodash";
 
 export const env: any = {};
-merge(env, process.env);
+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

@@ -1,62 +1,18 @@
-#!/usr/bin/env node
-// noinspection JSUnusedGlobalSymbols
+#!/usr/bin/env bun run
 
-import { queryCookies } from "./queryCookies";
-import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
-import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieSpec from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
+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 async function getCookie(
-  params: CookieSpec
-): 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: CookieSpec
-): 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: CookieSpec
-): 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 "./CookieSpec";
-export * from "./CookieRow";
-export * from "./ExportedCookie";
+export {
+  getCookie,
+  getChromeCookie,
+  getFirefoxCookie,
+  getMergedRenderedCookies,
+  getGroupedRenderedCookies,
+  fetchWithCookies,
+  //
+};

package/src/isValidJwt.ts

@@ -1,11 +1,11 @@
 import jsonwebtoken, { JwtPayload } from "jsonwebtoken";
-import { env } from "./global";
+import { parsedArgs } from "./argv";
 
-export default function isValidJwt(token: any) {
+export default function isValidJwt(token: string) {
   try {
     const result = jsonwebtoken.decode(token, { complete: true });
-    if (env.VERBOSE) {
-      console.log(result);
+    if (parsedArgs.verbose && result) {
+      console.debug(result);
     }
     const payload: JwtPayload = result?.payload as JwtPayload;
     if (payload) {

package/src/listChromeProfiles.ts

@@ -0,0 +1,45 @@
+import { sync } from "fast-glob";
+import { chromeApplicationSupport } from "./browsers/ChromeApplicationSupport";
+import { dirname } from "path";
+import { readFile } from "fs/promises";
+import { flatMapAsync } from "./util/flatMapAsync";
+import destr from "destr";
+
+export async function listChromeProfilePaths(): Promise<string[]> {
+  return sync(`./**/Cookies`, {
+    cwd: chromeApplicationSupport,
+    absolute: true,
+    onlyFiles: true,
+    deep: 2,
+  }).map((f) => {
+    // parent dir
+    return dirname(f);
+  });
+}
+
+export async function listChromeProfiles(): Promise<ChromeProfile[]> {
+  const paths = await listChromeProfilePaths();
+  return await flatMapAsync(paths, async (p) => {
+    const content = await readFile(`${p}/Preferences`, "utf-8");
+    return await destr(content);
+  });
+}
+
+export type ChromeProfileAccountInfo = {
+  account_id: string;
+  accountcapabilities: any;
+  email: string;
+  full_name: string;
+  gaia: string;
+  given_name: string;
+  hd: string;
+  is_supervised_child: number;
+  is_under_advanced_protection: boolean;
+  last_downloaded_image_url_with_size: string;
+  locale: string;
+  picture_url: string;
+};
+
+export type ChromeProfile = {
+  account_info: ChromeProfileAccountInfo[];
+};

package/src/logger.ts

@@ -0,0 +1,3 @@
+import consola from "consola";
+
+export default consola;

package/src/queryCookies.ts

@@ -1,5 +1,5 @@
-import { env } from "./global";
 import { uniqBy } from "lodash";
+import { parsedArgs } from "./argv";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
 import isValidJwt from "./isValidJwt";
@@ -7,18 +7,27 @@ import CookieSpec from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 
 export async function queryCookies(
-  { name, domain }: CookieSpec,
+  {
+    name,
+    domain,
+  }: //
+  CookieSpec,
   strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy()
-) {
+): Promise<ExportedCookie[]> {
+  //
   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 allCookies: ExportedCookie[] = uniqBy(results, JSON.stringify);
+
+  if (parsedArgs["require-jwt"]) {
+    const jwtCookies = [];
+    for (const result of allCookies) {
+      const value: string = result.value;
+      if (isValidJwt(value)) {
+        jwtCookies.push(result);
+      }
     }
+    return parsedArgs["single"] ? [jwtCookies[0]] : jwtCookies;
+  } else {
+    return parsedArgs["single"] ? [allCookies[0]] : allCookies;
   }
-  const resultsUniq = env.REQUIRE_JWT ? jwtCookies : results1;
-  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
 }

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/util/flatMapAsync.test.ts

@@ -0,0 +1,55 @@
+import { flatMapAsync } from "./flatMapAsync";
+
+describe("flatMapAsync", () => {
+  it("should apply async callback to each element, wait for all promises to fulfill and flatten the resulting array", async () => {
+    const array = [1, 2, 3];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 2, 4, 3, 6]);
+  });
+
+  it("should handle errors with the provided error callback", async () => {
+    const array = [1, 2, 3];
+    const callback = async (value: number) => {
+      if (value === 2) {
+        throw new Error("Test error");
+      }
+      return [value, value * 2];
+    };
+    const errorCallback = (error: any) => [0];
+    const result = await flatMapAsync(array, callback, errorCallback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+
+  it("should return an empty array when input array is empty", async () => {
+    const array: number[] = [];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([]);
+  });
+
+  it("should return an array with single element when input array has one element", async () => {
+    const array = [1];
+    const callback = async (value: number) => [value, value * 2];
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2]);
+  });
+
+  it("should handle null values in the array", async () => {
+    const array = [1, null, 3];
+    const callback = async (value: number) =>
+      value ? [value, value * 2] : [0];
+    // @ts-expect-error
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+
+  it("should handle undefined values in the array", async () => {
+    const array = [1, undefined, 3];
+    const callback = async (value: number) =>
+      value ? [value, value * 2] : [0];
+    // @ts-expect-error
+    const result = await flatMapAsync(array, callback);
+    expect(result).toEqual([1, 2, 0, 3, 6]);
+  });
+});

package/src/util/flatMapAsync.ts

@@ -0,0 +1,37 @@
+// This utility function applies an async callback to each element of the input array (just like Array.prototype.map),
+// waits for all resulting promises to fulfill (similar to Promise.all), and then flattens the resulting array (like Array.prototype.flat).
+
+export async function flatMapAsync<T, O>(
+  array: T[], // The input array to transform.
+  callback: (value: T, index: number, array: T[]) => Promise<O[]>, // The async function to apply to each input array element.,
+  or?: O[] | ((error: any) => O[] | Promise<O[]>) // An optional callback to handle errors.
+): Promise<O[]> {
+  if (or) {
+    return flatMapAsync(
+      array,
+      async (value: T, index: number, array: T[]) => {
+        try {
+          return await callback(value, index, array);
+        } catch (error) {
+          return typeof or == "function" ? or(error) : or;
+        }
+      }
+      //
+    );
+  }
+
+  // Step 1: Use Array.prototype.map to transform each element of the input array with the provided callback.
+  // This will result in an array of promises.
+  const ps: Promise<O>[] = array.map(callback) as Promise<O>[];
+
+  // Step 2: Use Promise.all to wait for all promises in the array to fulfill.
+  // This will give us an array of fulfilled promise values.
+  const awaitedAll: Awaited<O>[] = await Promise.all(ps);
+
+  // Step 3: Flatten the array of fulfilled promise values into a single array.
+  // Note: The '@ts-ignore' comment is used to suppress TypeScript compiler warnings, as .flat() method might not be recognized
+  // as a valid method for an array of Awaited<O> instances. However, this code assumes that the result of Promise.all
+  // is indeed an array that can be flattened.
+  // @ts-ignore
+  return awaitedAll.flat() as O[];
+}

package/tsconfig.json

@@ -1,23 +1,19 @@
 {
-  "include": [
-    "src/**.ts",
-    "src/**.tsx",
-    "src/**.js",
-    "src/**.jsx"
-  ],
+  "include": ["src/**.ts", "src/**.tsx", "src/**.js", "src/**.jsx"],
   "compilerOptions": {
     "moduleResolution": "node",
-    "target": "es2021",
-    "types": [
-      "node"
-    ],
-    "lib": [
-      "es2015",
-      "es2017",
-      "es2021",
-      "dom"
-    ],
+    "target": "es6",
+    "types": ["node"],
+    "lib": ["es2015", "es2017", "es2021", "dom"],
     "strict": true,
+    "skipDefaultLibCheck": true,
+    "skipLibCheck": true,
     "allowSyntheticDefaultImports": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "module": "commonjs",
+    "outDir": "dist",
+    "outFile": "dist/types.d.ts"
   }
 }

package/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"

package/.prettierrc.json

@@ -1 +0,0 @@
-{}

package/src/IsExportedCookie.ts

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

package/src/MemoryCookieStore.ts

@@ -1,5 +0,0 @@
-import { CookieJar, MemoryCookieStore } from "tough-cookie";
-
-export const memoryCookieStore = new MemoryCookieStore();
-
-export const cookieJar = new CookieJar(memoryCookieStore);

package/src/browsers/MemoryCookieJarQueryStrategy.ts

@@ -1,53 +0,0 @@
-import ExportedCookie from "../ExportedCookie";
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import { Cookie } from "tough-cookie";
-import CookieSpec from "../CookieSpec";
-import { memoryCookieStore } from "../MemoryCookieStore";
-
-export default class MemoryCookieStoreQueryStrategy
-  implements CookieQueryStrategy
-{
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    if (name == "%" && domain == "%") {
-      const cookies: Cookie[] = await memoryCookieStore.getAllCookies();
-      return cookies.map((cookie) => {
-        return this.#extracted(cookie, { name, domain });
-      });
-    }
-
-    const path = "/";
-
-    if (name == "%") {
-      const cookies: Cookie[] = await memoryCookieStore.findCookies(
-        domain,
-        path
-      );
-      return cookies.map((cookie) => {
-        return this.#extracted(cookie, { name, domain });
-      });
-    }
-
-    const cookie: Cookie | null = await memoryCookieStore.findCookie(
-      domain,
-      path,
-      name
-    );
-
-    if (cookie) {
-      return [this.#extracted(cookie, { name, domain })];
-    } else {
-      return [];
-    }
-  }
-
-  #extracted(cookie: Cookie, cookieSpec: CookieSpec): ExportedCookie {
-    return {
-      domain: cookie.domain ?? cookieSpec.domain,
-      name: cookie.key ?? cookieSpec.name,
-      value: cookie.value,
-      meta: {
-        file: "memory",
-      },
-    };
-  }
-}

package/src/doSqliteQuery1.ts

@@ -1,51 +0,0 @@
-import * as fs from "fs";
-import * as sqlite3 from "sqlite3";
-import CookieRow from "./CookieRow";
-import { merge } from "lodash";
-
-interface DoSqliteQuery1Params {
-  file: string;
-  sql: string;
-  rowTransform: (row: any) => CookieRow;
-}
-
-export async function doSqliteQuery1({
-  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 (process.env.VERBOSE) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}

package/src/utils.ts

@@ -1,50 +0,0 @@
-// 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());
-        }
-      }
-    );
-  });
-}
-
-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;
-}