@mherod/get-cookie 2.0.0-rc.8 → 2.1.0

package/src/cli.ts

@@ -1,111 +1,87 @@
-#!/usr/bin/env node
+#!/usr/bin/env ts-node
 
 import { argv, parsedArgs } from "./argv";
-import { queryCookies } from "./queryCookies";
-import { groupBy } from "lodash";
-import { green, red, yellow } from "colorette";
-import { resultsRendered } from "./resultsRendered";
 import { fetchWithCookies } from "./fetchWithCookies";
 import { unpackHeaders } from "./unpackHeaders";
 import CookieSpec from "./CookieSpec";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
+import logger from "./logger";
+import { cliQueryCookies } from "./cliQueryCookies";
 
-async function cliQueryCookies({ name, domain }: CookieSpec) {
-  try {
-    const results = await queryCookies({ name, domain });
-    if (results == null || results.length == 0) {
-      console.error(red("No results"));
-      return;
-    }
-    if (parsedArgs["dump"] || parsedArgs["d"]) {
-      console.log(results);
-      return;
-    }
-    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      console.log(green(JSON.stringify(groupedByFile, null, 2)));
-      return;
-    }
-    if (
-      parsedArgs["render"] ||
-      parsedArgs["render-merged"] ||
-      parsedArgs["r"]
-    ) {
-      console.log(yellow(resultsRendered(results)));
-      return;
-    }
-    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
-      const groupedByFile = groupBy(results, (r) => r.meta?.file);
-      for (const file of Object.keys(groupedByFile)) {
-        let results = groupedByFile[file];
-        console.log(green(file) + ": ", yellow(resultsRendered(results)));
-      }
-      return;
-    }
-    for (const result of results) {
-      console.log(result.value);
-    }
-  } catch (e) {
-    console.error(e);
-  }
-}
-
-function main() {
+async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
-    console.log(`Usage: ${argv[1]} [name] [domain] [options] `);
-    console.log(`Options:`);
-    console.log(`  -h, --help: Show this help`);
-    console.log(`  -v, --verbose: Show verbose output`);
-    console.log(`  -d, --dump: Dump all results`);
-    console.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
-    console.log(`  -r, --render: Render all results`);
+    logger.log(`Usage: ${argv[1]} [name] [domain] [options] `);
+    logger.log(`Options:`);
+    logger.log(`  -h, --help: Show this help`);
+    logger.log(`  -v, --verbose: Show verbose output`);
+    logger.log(`  -d, --dump: Dump all results`);
+    logger.log(`  -D, --dump-grouped: Dump all results, grouped by profile`);
+    logger.log(`  -r, --render: Render all results`);
     return;
   }
 
+  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
+
   const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
   if (fetchUrl) {
     let url: URL;
     try {
       url = new URL(<string>fetchUrl);
     } catch (e) {
-      console.error("Invalid URL", fetchUrl);
+      logger.error("Invalid URL", fetchUrl);
       return;
     }
+    logger.start("Fetching", url.href);
     const headerArgs: string[] | string = parsedArgs["H"];
     const headers = unpackHeaders(headerArgs);
     const onfulfilled = (res: Response) => {
       if (parsedArgs["dump-response-headers"]) {
         res.headers.forEach((value: string, key: string) => {
-          console.log(`${key}: ${value}`);
+          logger.log(`${key}: ${value}`);
         });
       }
       if (parsedArgs["dump-response-body"]) {
         res.text().then((r) => {
-          console.log(r);
+          logger.log(r);
         });
       }
       return;
     };
-    fetchWithCookies(
+    return fetchWithCookies(
       url,
       {
         //
         headers,
-      }
+      },
       //
     ).then(
-      onfulfilled,
-      console.error
+      (res) => {
+        logger.debug("Response", res);
+        onfulfilled(res);
+      },
+      logger.error,
       //
     );
-    return;
   }
 
-  const cookieSpec: CookieSpec = {
-    name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
-    domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
-  };
+  const cookieSpecs: CookieSpec[] = [];
+  const argUrl: string = parsedArgs["url"] || parsedArgs["u"];
+  if (argUrl) {
+    for (const cookieSpec of cookieSpecsFromUrl(argUrl)) {
+      cookieSpecs.push(cookieSpec);
+    }
+  } else {
+    cookieSpecs.push({
+      name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
+      domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
+    });
+  }
+
+  if (parsedArgs.verbose) {
+    logger.log("cookieSpecs", cookieSpecs);
+  }
 
-  cliQueryCookies(cookieSpec).catch(console.error);
+  await cliQueryCookies(cookieSpecs).catch(logger.error);
 }
 
-main();
+main().then((r) => r, logger.error);

package/src/cliQueryCookies.ts

@@ -0,0 +1,55 @@
+import CookieSpec from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { groupBy } from "lodash";
+import logger from "./logger";
+import { parsedArgs } from "./argv";
+import { resultsRendered } from "./resultsRendered";
+
+export async function cliQueryCookies(
+  cookieSpec: CookieSpec | CookieSpec[],
+  limit?: number,
+  removeExpired?: boolean,
+  //
+) {
+  try {
+    const results: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec, {
+      limit,
+      removeExpired,
+    });
+    if (results == null || results.length == 0) {
+      logger.error("No results");
+      return;
+    }
+    if (parsedArgs["dump"] || parsedArgs["d"]) {
+      logger.log(results);
+      return;
+    }
+    if (parsedArgs["dump-grouped"] || parsedArgs["D"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      logger.log(JSON.stringify(groupedByFile, null, 2));
+      return;
+    }
+    if (
+      parsedArgs["render"] ||
+      parsedArgs["render-merged"] ||
+      parsedArgs["r"]
+    ) {
+      logger.log(resultsRendered(results));
+      return;
+    }
+    if (parsedArgs["render-grouped"] || parsedArgs["R"]) {
+      const groupedByFile = groupBy(results, (r) => r.meta?.file);
+      for (const file of Object.keys(groupedByFile)) {
+        let results = groupedByFile[file];
+        logger.log(file, ": ", resultsRendered(results));
+      }
+      return;
+    }
+    for (const result of results) {
+      logger.log(result.value);
+    }
+  } catch (e) {
+    logger.error(e);
+  }
+}

package/src/comboQueryCookieSpec.test.ts

@@ -0,0 +1,92 @@
+import { MultiCookieSpec } from "./CookieSpec";
+import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
+import MockCookieQueryStrategy from "./browsers/mock/MockCookieQueryStrategy";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { CookieQueryOptions } from "./cookieQueryOptions";
+
+describe("comboQueryCookieSpec", () => {
+  let cookieSpec: MultiCookieSpec;
+  let options: CookieQueryOptions<CookieQueryStrategy>;
+
+  beforeEach(() => {
+    cookieSpec = {
+      domain: "example.com",
+      name: "test",
+    };
+    options = {
+      strategy: new MockCookieQueryStrategy([
+        // mock available cookies here
+        {
+          name: "test",
+          value: "test",
+          domain: "example.com",
+          expiry: "Infinity",
+        },
+      ]),
+      limit: 10,
+      removeExpired: true,
+    };
+  });
+
+  it("should return an array of cookies", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result).toBeInstanceOf(Array);
+  });
+
+  it("should limit the number of cookies returned", async () => {
+    options.limit = 5;
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result.length).toBeLessThanOrEqual(5);
+  });
+
+  it("should return cookies with the correct domain", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result[0].domain).toBe("example.com");
+  });
+
+  it("should return cookies with the correct name", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result[0].name).toBe("test");
+  });
+
+  it("should return cookies with the correct value", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result[0].value).toBe("test");
+  });
+
+  it("should return cookies with the correct expiry", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result[0].expiry).toBe("Infinity");
+  });
+
+  it("should return cookies with the correct meta", async () => {
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result[0].meta).toBeUndefined();
+  });
+
+  it("should return cookies when limit is undefined", async () => {
+    options.limit = undefined;
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result.length).toBe(1);
+  });
+
+  it("should return cookies when removeExpired is false", async () => {
+    options.removeExpired = false;
+    const result = await comboQueryCookieSpec(cookieSpec, options);
+    expect(result.length).toBe(1);
+  });
+
+  // it('should not return cookies when removeExpired is true and expiry is past', async () => {
+  //     options.removeExpired = true;
+  //     cookieSpec.expiry = new Date('2000-01-01');
+  //     const result = await comboQueryCookieSpec(cookieSpec, options);
+  //     expect(result.length).toBe(0);
+  // });
+
+  // it('should return cookies when removeExpired is true and expiry is future', async () => {
+  //     options.removeExpired = true;
+  //     cookieSpec.expiry = new Date('3000-01-01');
+  //     const result = await comboQueryCookieSpec(cookieSpec, options);
+  //     expect(result.length).toBe(1);
+  // });
+});

package/src/comboQueryCookieSpec.ts

@@ -0,0 +1,29 @@
+import CookieSpec, { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import { flatMapAsync } from "./util";
+import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
+import { CookieQueryOptions, mergedWithDefaults } from "./cookieQueryOptions";
+import { processBeforeReturn } from "./processBeforeReturn";
+
+export async function comboQueryCookieSpec(
+  cookieSpec: MultiCookieSpec,
+  options?: CookieQueryOptions<CookieQueryStrategy>,
+): Promise<ExportedCookie[]> {
+  const optsWithDefaults: CookieQueryOptions<CookieQueryStrategy> =
+    mergedWithDefaults(options);
+  const fn = (cs: CookieSpec) => queryCookies(cs, optsWithDefaults);
+
+  if (Array.isArray(cookieSpec)) {
+    const cookiesForMultiSpec: ExportedCookie[] = await flatMapAsync(
+      cookieSpec,
+      async (cs: CookieSpec) => {
+        return await fn(cs);
+      },
+    );
+    return processBeforeReturn(cookiesForMultiSpec, options);
+  } else {
+    const cookiesForSingleSpec: ExportedCookie[] = await fn(cookieSpec);
+    return processBeforeReturn(cookiesForSingleSpec, options);
+  }
+}

package/src/cookieQueryOptions.ts

@@ -0,0 +1,20 @@
+import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { merge } from "lodash";
+
+export type CookieQueryOptions<T extends CookieQueryStrategy> = {
+  strategy?: T;
+  limit?: number;
+  removeExpired?: boolean;
+};
+
+export const defaultCookieQueryOptions: CookieQueryOptions<CookieQueryStrategy> =
+  {
+    strategy: new CompositeCookieQueryStrategy(),
+  };
+
+export function mergedWithDefaults<T extends CookieQueryStrategy>(
+  options?: CookieQueryOptions<T>,
+): CookieQueryOptions<T> {
+  return merge(defaultCookieQueryOptions, options);
+}

package/src/cookieSpecsFromUrl.test.ts

@@ -0,0 +1,65 @@
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
+import { isCookieSpec } from "./CookieSpec";
+import { uniqBy } from "lodash";
+
+describe("cookieSpecsFromUrl", () => {
+  it("should return an array of cookie specs", () => {
+    const url = "https://example.com/";
+    const result = cookieSpecsFromUrl(url);
+    expect(result).toBeInstanceOf(Array);
+    expect(isCookieSpec(result[0])).toBe(true);
+  });
+
+  it("should handle string URLs", () => {
+    const url = "https://example.com/";
+    const result = cookieSpecsFromUrl(url);
+    expect(result[0].domain).toContain("example.com");
+  });
+
+  it("should handle URL objects", () => {
+    const url = new URL("https://example.com/");
+    const result = cookieSpecsFromUrl(url);
+    expect(result[0].domain).toContain("example.com");
+  });
+
+  it("should handle empty string URL", () => {
+    const url = "";
+    const result = cookieSpecsFromUrl(url);
+    expect(result).toEqual([]);
+  });
+
+  it("should handle invalid URL", () => {
+    const url = "invalid_url";
+    try {
+      const result = cookieSpecsFromUrl(url);
+    } catch (error: any) {
+      expect(error.message).toContain("Invalid URL");
+    }
+  });
+
+  it("should return unique cookie specs", () => {
+    const url = "https://example.com/";
+    const result = cookieSpecsFromUrl(url);
+    const uniqueResults = uniqBy(result, JSON.stringify);
+    expect(result.length).toEqual(uniqueResults.length);
+  });
+
+  it("should return correct cookie specs for URL with subdomain", () => {
+    const url = "https://sub.example.com/";
+    const result = cookieSpecsFromUrl(url);
+    expect(result).toContainEqual({ name: "%", domain: "sub.example.com" });
+    expect(result).toContainEqual({ name: "%", domain: "%.example.com" });
+    expect(result).toContainEqual({ name: "%", domain: "example.com" });
+  });
+
+  it("should return correct cookie specs for URL with multiple subdomains", () => {
+    const url = "https://sub.sub2.example.com/";
+    const result = cookieSpecsFromUrl(url);
+    expect(result).toContainEqual({
+      name: "%",
+      domain: "sub.sub2.example.com",
+    });
+    expect(result).toContainEqual({ name: "%", domain: "%.example.com" });
+    expect(result).toContainEqual({ name: "%", domain: "example.com" });
+  });
+});

package/src/cookieSpecsFromUrl.ts

@@ -0,0 +1,27 @@
+import CookieSpec from "./CookieSpec";
+import { uniqBy } from "lodash";
+
+/**
+ * Generates a list of cookie specifications from a given URL.
+ * Each cookie spec consists of a domain and a name, where the name is a wildcard.
+ * The domain is formatted to enable querying against the cookie store for matching cookies.
+ * @param url - The URL to generate cookie specs from.
+ * @returns An array of unique cookie specifications.
+ */
+export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
+  if (!url || url === "") {
+    return [];
+  }
+
+  const urlObj = typeof url === "string" ? new URL(url) : url;
+  const hostnameParts = urlObj.hostname.split(".");
+  const topLevelDomain = hostnameParts.slice(-2).join(".");
+
+  const cookieSpecs: CookieSpec[] = [
+    { name: "%", domain: `%.${topLevelDomain}` },
+    { name: "%", domain: urlObj.hostname },
+    { name: "%", domain: topLevelDomain },
+  ];
+
+  return uniqBy(cookieSpecs, JSON.stringify);
+}

package/src/execSimple.ts

@@ -0,0 +1,13 @@
+import { execSync } from "child_process";
+
+export async function execSimple(command: string): Promise<string> {
+  try {
+    const stdout = execSync(command, {
+      encoding: "binary",
+      maxBuffer: 5 * 1024,
+    });
+    return stdout.trim();
+  } catch (error) {
+    throw error;
+  }
+}

package/src/fetchWithCookies.test.ts

@@ -0,0 +1,32 @@
+import { fetchWithCookies } from "./fetchWithCookies";
+import { FetchFn } from "./fetchWithCookies";
+
+describe("fetchWithCookies", () => {
+  let mockFetch: FetchFn;
+  let mockResponse: Response;
+
+  beforeEach(() => {
+    mockFetch = jest.fn();
+    mockResponse = new Response("mock body", { status: 200 });
+    (mockFetch as jest.Mock).mockResolvedValue(mockResponse);
+  });
+
+  // it("should call fetch with the correct arguments", async () => {
+  //   const url = "https://example.com/";
+  //   const options: RequestInit = {
+  //     method: "GET",
+  //     headers: { "User-Agent": userAgent },
+  //     redirect: "manual"
+  //     //
+  //   };
+  //   await fetchWithCookies(url, options, mockFetch);
+  //   expect(mockFetch).toBeCalledWith(url, options);
+  // });
+
+  it("should return the response from fetch", async () => {
+    const url = "https://example.com/";
+    const options = { method: "GET" };
+    const response = await fetchWithCookies(url, options, mockFetch);
+    expect(response).toBe(mockResponse);
+  });
+});