@mherod/get-cookie 2.1.3 → 4.0.2

package/src/CookieRow.ts

@@ -1,43 +0,0 @@
-import consola from "./logger";
-
-/**
- * The CookieRow interface represents the structure of a cookie row object.
- */
-export default interface CookieRow {
-  expiry?: number;
-  domain: string;
-  name: string;
-  value: Uint8Array | Buffer;
-  meta?: Record<string, unknown>;
-}
-
-/**
- * Type guard to check if an object is a CookieRow.
- * @param obj - The object to check.
- * @returns True if the object is a CookieRow, false otherwise.
- */
-export function isCookieRow(obj: any): obj is CookieRow {
-  if (typeof obj !== "object" || obj === null) {
-    consola.warn("Object is not an object or is null:", obj);
-    return false;
-  }
-
-  const { domain, name, value } = obj as CookieRow;
-
-  if (typeof domain !== "string") {
-    consola.warn("Domain is not a string:", domain);
-    return false;
-  }
-
-  if (typeof name !== "string") {
-    consola.warn("Name is not a string:", name);
-    return false;
-  }
-
-  if (!(value instanceof Uint8Array) && !Buffer.isBuffer(value)) {
-    consola.warn("Value is not a Uint8Array or Buffer:", value);
-    return false;
-  }
-
-  return true;
-}

package/src/CookieSpec.ts

@@ -1,42 +0,0 @@
-/**
- * Define the CookieSpec interface with domain and name properties
- */
-export default interface CookieSpec {
-  domain: string;
-  name: string;
-}
-
-/**
- * Function to check if an object is of type CookieSpec
- * @param obj - The object to check
- * @returns True if the object is of type CookieSpec, otherwise false
- */
-export function isCookieSpec(obj: unknown): obj is CookieSpec {
-  const cookie = obj as CookieSpec;
-  return typeof cookie.domain === "string" && typeof cookie.name === "string";
-}
-
-/**
- * Define a type that can be either a single CookieSpec or an array of CookieSpecs
- */
-export type MultiCookieSpec = CookieSpec | CookieSpec[];
-
-/**
- * Function to check if an object is of type MultiCookieSpec
- * @param obj - The object to check
- * @returns True if the object is of type MultiCookieSpec, otherwise false
- */
-export function isMultiCookieSpec(obj: unknown): obj is MultiCookieSpec {
-  if (isCookieSpec(obj)) {
-    return true;
-  }
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      if (!isCookieSpec(obj[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}

package/src/ExportedCookie.ts

@@ -1,19 +0,0 @@
-export default interface ExportedCookie {
-  domain: string;
-  name: string;
-  value: string;
-  expiry?: Date | "Infinity";
-  meta?: any;
-}
-
-export function isExportedCookie(obj: any): obj is ExportedCookie {
-  return (
-    typeof obj.domain === "string" &&
-    typeof obj.name === "string" &&
-    typeof obj.value === "string" &&
-    (obj.expiry === undefined ||
-      obj.expiry instanceof Date ||
-      obj.expiry === "Infinity") &&
-    (obj.meta === undefined || typeof obj.meta === "object")
-  );
-}

package/src/FetchResponse.ts

@@ -1,13 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-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>;
-}

package/src/SpecialCases.ts

@@ -1,15 +0,0 @@
-import CookieSpec from "./CookieSpec";
-
-export function specialCases({ name, domain }: CookieSpec): {
-  specifiedName: boolean;
-  specifiedDomain: boolean;
-} {
-  const wildcardRegexp: RegExp = /^([*%])$/i;
-  const specifiedName: boolean = name.match(wildcardRegexp) == null;
-  const specifiedDomain: boolean = domain.match(wildcardRegexp) == null;
-
-  return {
-    specifiedName,
-    specifiedDomain,
-  };
-}

package/src/StringToRegex.ts

@@ -1,16 +0,0 @@
-// This function converts a string into a regular expression
-export function stringToRegex(s: string): RegExp {
-  // Replace all occurrences of '.' with a literal '\.'
-  let s1: string = s.replace(/\./g, "\\.");
-  // Replace all occurrences of '%' with '.*' to match any number of any characters
-  let s2: string = s1.replace(/%/g, ".*");
-  // Replace all occurrences of '*' with '.*' to match any number of any characters
-  let s3: string = s2.replace(/\*/g, ".*");
-  // Return the new string as a RegExp object
-  return new RegExp(s3);
-}
-
-/*
-%.example.com -> .*\.example\.com
-example.com -> example\.com
-*/

package/src/argv.ts

@@ -1,30 +0,0 @@
-import minimist from "minimist";
-import { merge } from "lodash";
-
-export interface MyParsedArgs extends minimist.ParsedArgs {
-  verbose: boolean;
-  render?: string;
-  fetch?: string;
-  cs?: string;
-  dump?: string;
-  "dump-request-headers"?: string;
-  "dump-response-headers"?: string;
-  "dump-response-body"?: string;
-}
-
-/*
-Usage: get-cookie [name] [domain] [options]
-Options:
-  -h, --help: Show this help
-  -v, --verbose: Show verbose output
-  -d, --dump: Dump all results
-  -D, --dump-grouped: Dump all results, grouped by profile
-  -r, --render: Render all results
- */
-
-export const argv: string[] = process.argv ?? [];
-const minimistArgs: minimist.ParsedArgs = minimist(argv.slice(2));
-const defaultOptions = {
-  verbose: false,
-};
-export const parsedArgs: MyParsedArgs = merge(defaultOptions, minimistArgs);

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -1,76 +0,0 @@
-import ChromeCookieQueryStrategy from "./chrome/ChromeCookieQueryStrategy";
-import FirefoxCookieQueryStrategy from "./firefox/FirefoxCookieQueryStrategy";
-import SafariCookieQueryStrategy from "./safari/SafariCookieQueryStrategy";
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import ExportedCookie from "../ExportedCookie";
-import LRUCache from "lru-cache";
-import { merge } from "lodash";
-import { flatMapAsync } from "../util/flatMapAsync";
-import consola from "../logger";
-
-const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
-  string,
-  ExportedCookie[]
->({
-  ttl: 1000 * 10, // 10 seconds
-  max: 10,
-});
-
-export default class CompositeCookieQueryStrategy
-  implements CookieQueryStrategy
-{
-  browserName: string = "all";
-
-  private readonly strategies: CookieQueryStrategy[];
-
-  constructor() {
-    this.strategies = [
-      ChromeCookieQueryStrategy,
-      FirefoxCookieQueryStrategy,
-      SafariCookieQueryStrategy,
-    ].map((Strategy) => new Strategy());
-  }
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    const key: string = `${name}:${domain}`;
-    consola.info(`Querying cookies for name: ${name}, domain: ${domain}`);
-    if (cache.has(key)) {
-      const cached: ExportedCookie[] | undefined = cache.get(key);
-      if (cached) {
-        consola.info(
-          `Cache hit for key: ${key}, returning ${cached.length} cookies`,
-        );
-        return cached;
-      }
-    }
-    const results: ExportedCookie[] = await flatMapAsync(
-      this.strategies,
-      async (strategy) => {
-        try {
-          const cookies: ExportedCookie[] = await strategy.queryCookies(
-            name,
-            domain,
-          );
-          return cookies.map((cookie: ExportedCookie) =>
-            merge(cookie, {
-              meta: {
-                browser: strategy.browserName,
-              },
-            }),
-          );
-        } catch (e) {
-          consola.error(
-            `Error querying cookies for ${name} on ${domain} using ${strategy.browserName}`,
-            e,
-          );
-          return [];
-        }
-      },
-    );
-    cache.set(key, results);
-    consola.info(
-      `Query result size for key: ${key} is ${results.length} cookies`,
-    );
-    return results;
-  }
-}

package/src/browsers/CookieQueryStrategy.ts

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

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -1,115 +0,0 @@
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import CookieSpec from "../CookieSpec";
-import ExportedCookie from "../ExportedCookie";
-import { Cookie, Store } from "tough-cookie";
-import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
-import { stringToRegex } from "../StringToRegex";
-
-export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
-  browserName: string = "internal";
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    const exportedCookies: ExportedCookie[] = await this.getAllExportedCookies(
-      name,
-      domain,
-    );
-
-    const wildcardRegexp: RegExp = /^([*%])$/i;
-    if (name.match(wildcardRegexp) && domain.match(wildcardRegexp)) {
-      return exportedCookies;
-    }
-
-    if (domain !== "%") {
-      const domainCookies: ExportedCookie[] = await this.getDomainCookies(
-        name,
-        domain,
-      );
-      exportedCookies.push(...domainCookies);
-    }
-
-    return this.filterCookies(exportedCookies, name, domain);
-  }
-
-  private async getAllExportedCookies(
-    name: string,
-    domain: string,
-  ): Promise<ExportedCookie[]> {
-    const cookies: Cookie[] = await this.getAllCookies();
-    return cookies.map((cookie: Cookie) =>
-      this.extractCookie(cookie, { name, domain }),
-    );
-  }
-
-  private async getDomainCookies(
-    name: string,
-    domain: string,
-  ): Promise<ExportedCookie[]> {
-    const path: string = "/";
-    const domain1: string = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
-    const url: URL = new URL("https://" + domain1);
-    url.pathname = path;
-    const cookies: Cookie[] = await this.getCookies(url.href);
-    return cookies.map((cookie: Cookie) =>
-      this.extractCookie(cookie, { domain, name }),
-    );
-  }
-
-  private filterCookies(
-    exportedCookies: ExportedCookie[],
-    name: string,
-    domain: string,
-  ): ExportedCookie[] {
-    if (name === "%") {
-      return exportedCookies.filter((cookie: ExportedCookie) =>
-        cookie.domain.match(stringToRegex(domain)),
-      );
-    }
-
-    return exportedCookies.filter(
-      (cookie: ExportedCookie) =>
-        cookie.name.match(stringToRegex(name)) &&
-        cookie.domain.match(stringToRegex(domain)),
-    );
-  }
-
-  private extractCookie(
-    cookie: Cookie,
-    cookieSpec: CookieSpec,
-  ): ExportedCookie {
-    return {
-      domain: cookie.domain ?? cookieSpec.domain,
-      name: cookie.key ?? cookieSpec.name,
-      value: cookie.value,
-      expiry: cookie.expires ?? "Infinity",
-      meta: {
-        file: "tough-cookie",
-      },
-    };
-  }
-
-  private async getCookies(url: string): Promise<Cookie[]> {
-    const cookieJar = await cookieJarPromise;
-    return new Promise((resolve, reject) => {
-      cookieJar.getCookies(url, (err: Error | null, cookies: Cookie[]) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(cookies ?? []);
-        }
-      });
-    });
-  }
-
-  private async getAllCookies(): Promise<Cookie[]> {
-    const cookieStore: Store = await cookieStorePromise;
-    return new Promise((resolve, reject) => {
-      cookieStore.getAllCookies((err: Error | null, cookies: Cookie[]) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(cookies ?? []);
-        }
-      });
-    });
-  }
-}

package/src/browsers/QuerySqliteThenTransform.ts

@@ -1,48 +0,0 @@
-import CookieRow from "../CookieRow";
-import fs from "fs";
-import { merge } from "lodash";
-import { Database } from "bun:sqlite";
-
-interface FnOptions {
-  file: string;
-  sql: string;
-  rowFilter?: (row: any) => boolean;
-  rowTransform: (row: any) => CookieRow;
-}
-
-async function checkFileExistence(file: string): Promise<void> {
-  if (!file || !fs.existsSync(file))
-    throw new Error(`File ${file} does not exist`);
-}
-
-async function transformRows(
-  rows: any[],
-  rowFilter: (row: any) => boolean,
-  rowTransform: (row: any) => CookieRow,
-  file: string,
-): Promise<CookieRow[]> {
-  const filteredRows = rows.filter(rowFilter);
-  const transformedRows = filteredRows.map((row) =>
-    merge({ meta: { file } }, rowTransform(row)),
-  );
-  return transformedRows;
-}
-
-export async function querySqliteThenTransform({
-  file,
-  sql,
-  rowFilter = () => true,
-  rowTransform,
-}: FnOptions): Promise<CookieRow[]> {
-  await checkFileExistence(file);
-  const db = new Database(file);
-
-  try {
-    const rows: any[] = db.query(sql).all();
-    if (!rows || rows.length === 0) return [];
-
-    return await transformRows(rows, rowFilter, rowTransform, file);
-  } catch (err: any) {
-    throw err;
-  }
-}

package/src/browsers/chrome/ChromeApplicationSupport.ts

@@ -1,14 +0,0 @@
-import { join } from "path";
-import { HOME } from "../../global";
-
-if (HOME === undefined) {
-  throw new Error("HOME environment variable is not defined");
-}
-
-export const chromeApplicationSupport: string = join(
-  HOME,
-  "Library",
-  "Application Support",
-  "Google",
-  "Chrome",
-);

package/src/browsers/chrome/ChromeCookieQueryStrategy.ts

@@ -1,158 +0,0 @@
-import CookieQueryStrategy from "../CookieQueryStrategy";
-import CookieRow, { isCookieRow } from "../../CookieRow";
-import ExportedCookie from "../../ExportedCookie";
-import { chromeApplicationSupport } from "./ChromeApplicationSupport";
-import { decrypt } from "./decrypt";
-import { env } from "../../global";
-import { findAllFiles } from "../../findAllFiles";
-import { getChromePassword } from "./getChromePassword";
-import { isExportedCookie } from "../../ExportedCookie";
-import { merge } from "lodash";
-import { parsedArgs } from "../../argv";
-import { flatMapAsync } from "../../util/flatMapAsync";
-import { getEncryptedChromeCookie } from "../getEncryptedChromeCookie";
-import logger from "../../logger";
-
-export const consola = logger.withTag("ChromeCookieQueryStrategy");
-
-export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
-  browserName: string = "Chrome";
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    this.ensurePlatformIsMacOS();
-    if (env.FIREFOX_ONLY) {
-      return [];
-    }
-    return this.getChromeCookies({
-      requireJwt: false,
-      name,
-      domain,
-    });
-  }
-
-  private ensurePlatformIsMacOS(): void {
-    if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
-    }
-  }
-
-  private async getChromeCookies({
-    name,
-    domain = "%",
-    requireJwt = false,
-  }: {
-    name: string;
-    domain: string;
-    requireJwt: boolean | undefined;
-  }): Promise<ExportedCookie[]> {
-    const encryptedDataItems: CookieRow[] = await this.getEncryptedCookies(
-      name,
-      domain,
-    );
-
-    const password: string = await getChromePassword();
-    const decryptedCookies: ExportedCookie[] = await this.decryptCookies(
-      encryptedDataItems,
-      password,
-    );
-
-    return decryptedCookies;
-  }
-
-  private async getEncryptedCookies(
-    name: string,
-    domain: string,
-  ): Promise<CookieRow[]> {
-    try {
-      const files: string[] = findAllFiles({
-        path: chromeApplicationSupport,
-        name: "Cookies",
-      });
-
-      const results: CookieRow[] = await flatMapAsync(files, async (file) => {
-        return await this.getCookiesFromFile(name, domain, file);
-      });
-
-      return results.filter(isCookieRow);
-    } catch (error) {
-      consola.warn("Error finding encrypted cookies", error);
-      return [];
-    }
-  }
-
-  private async getCookiesFromFile(
-    name: string,
-    domain: string,
-    file: string,
-  ): Promise<CookieRow[]> {
-    try {
-      return await getEncryptedChromeCookie({
-        name: name,
-        domain: domain,
-        file: file,
-      });
-    } catch (e) {
-      consola.warn("Error getting encrypted cookie from file", e);
-      return [];
-    }
-  }
-
-  private async decryptCookies(
-    encryptedDataItems: CookieRow[],
-    password: string,
-  ): Promise<ExportedCookie[]> {
-    const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
-      .filter(({ value }) => value != null && value.length > 0)
-      .map(async (cookieRow: CookieRow) => {
-        const encryptedValue: Uint8Array | Buffer = cookieRow.value;
-        const decryptedValue = await this.decryptValue(
-          password,
-          encryptedValue,
-        );
-        return this.createExportedCookie(cookieRow, decryptedValue);
-      });
-    return (await Promise.all(decrypted)).filter(isExportedCookie);
-  }
-
-  private async decryptValue(
-    password: string,
-    encryptedValue: Uint8Array | Buffer,
-  ): Promise<string> {
-    let decrypted: string | null;
-    try {
-      const bufferValue = Buffer.isBuffer(encryptedValue)
-        ? encryptedValue
-        : Buffer.from(encryptedValue);
-      decrypted = await decrypt(password, bufferValue);
-    } catch (e) {
-      consola.warn("Error decrypting cookie", e);
-      decrypted = null;
-    }
-    return decrypted ?? encryptedValue.toString("utf-8");
-  }
-
-  private createExportedCookie(
-    cookieRow: CookieRow,
-    decryptedValue: string,
-  ): ExportedCookie {
-    const meta = {};
-    merge(meta, cookieRow.meta ?? {});
-    const exportedCookie: ExportedCookie = {
-      domain: cookieRow.domain,
-      name: cookieRow.name,
-      value: decryptedValue,
-      meta: meta,
-    };
-    const expiry = cookieRow.expiry;
-    const mergeExpiry =
-      expiry != null && expiry > 0
-        ? {
-            expiry: new Date(expiry),
-          }
-        : {
-            expiry: "Infinity",
-          };
-    merge(exportedCookie, mergeExpiry);
-    return exportedCookie;
-  }
-}