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

package/dist/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 var $7oI3p$lodash = require("lodash");
 var $7oI3p$lrucache = require("lru-cache");
+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$toughcookie = require("tough-cookie");
+var $7oI3p$toughcookiefilestore = require("tough-cookie-file-store");
 var $7oI3p$jsonwebtoken = require("jsonwebtoken");
 var $7oI3p$crossfetch = require("cross-fetch");
 var $7oI3p$destr = require("destr");
@@ -39,6 +41,7 @@ $parcel$export(module.exports, "getFirefoxCookie", () => $cd1ba0160120c006$expor
 $parcel$export(module.exports, "getChromeCookie", () => $cd1ba0160120c006$export$e5637297e9eb6f2e);
 $parcel$export(module.exports, "getGroupedRenderedCookies", () => $300d8b33187a203c$export$4d2e9997e2c23417);
 $parcel$export(module.exports, "fetchWithCookies", () => $cfc07ae4aa2c7e44$export$b24a545a0b39f491);
+$parcel$export(module.exports, "stringToRegex", () => $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb);
 
 const $fac425c10fbbada5$export$a7b6bc01c63cdfc3 = {};
 (0, $7oI3p$lodash.merge)($fac425c10fbbada5$export$a7b6bc01c63cdfc3, process.env);
@@ -181,7 +184,16 @@ function $d66f40b581ba8bfa$export$963c8d651337e4a4(obj) {
 }
 
 
+function $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb(s) {
+    const s1 = s.replaceAll(/\./gi, ".");
+    const s2 = s1.replace(/%/g, ".*");
+    const s3 = s2.replace(/\*/g, ".*");
+    return new RegExp(s3);
+}
+
+
 class $269fe42bfd555305$export$2e2bcd8739ae039 {
+    browserName = "Chrome";
     async queryCookies(name, domain) {
         if (process.platform !== "darwin") throw new Error("This only works on macOS");
         if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).FIREFOX_ONLY) return [];
@@ -260,15 +272,18 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
     const wildcardRegexp = /^([*%])$/i;
     const specifiedName = name.match(wildcardRegexp) == null;
     const specifiedDomain = domain.match(wildcardRegexp) == null;
-    if (specifiedName || specifiedDomain) {
+    const wildcardDomain = domain.match(/[%*]/) != null;
+    const queryDomain = specifiedDomain && !wildcardDomain;
+    // if we have a wildcard domain, we need to use a regexp
+    if (specifiedName || queryDomain) {
         sql += ` WHERE `;
         if (specifiedName) {
             sql += `name = '${name}'`;
-            if (specifiedDomain) sql += ` AND `;
+            if (queryDomain) sql += ` AND `;
         }
-        if (specifiedDomain) sql += `host_key LIKE '${domain}';`;
+        if (queryDomain) sql += `host_key LIKE '${domain}';`;
     }
-    return (0, $a085b524d8ee9fce$export$f19f611d1fa7c6f3)({
+    const sqliteQuery1 = await (0, $a085b524d8ee9fce$export$f19f611d1fa7c6f3)({
         file: file,
         sql: sql,
         rowTransform: (row)=>{
@@ -279,6 +294,9 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
             };
         }
     });
+    return sqliteQuery1.filter((row)=>{
+        return row.domain.match((0, $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb)(domain)) != null;
+    });
 }
 async function $269fe42bfd555305$var$getChromePassword() {
     return (0, $25b78d6746d4ad48$export$8d71c74f97c0202e)('security find-generic-password -w -s "Chrome Safe Storage"');
@@ -355,6 +373,7 @@ function $b744d19cc39f964e$export$da22813e5a2ec500({ name: name , domain: domain
 
 
 class $7bb7da9a77b2fd99$export$2e2bcd8739ae039 {
+    browserName = "Firefox";
     async queryCookies(name, domain) {
         if (process.platform !== "darwin") throw new Error("This only works on macOS");
         if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).CHROME_ONLY) return [];
@@ -424,6 +443,7 @@ class $7bb7da9a77b2fd99$export$2e2bcd8739ae039 {
 
 
 class $fad6f51bd5c7bae2$export$2e2bcd8739ae039 {
+    browserName = "Safari";
     async queryCookies(name, domain) {
         return [];
     }
@@ -432,39 +452,57 @@ class $fad6f51bd5c7bae2$export$2e2bcd8739ae039 {
 
 
 
-const $0fd79d7b9f7bb064$export$231f8b179925e6a5 = new (0, $7oI3p$toughcookie.MemoryCookieStore)();
-const $0fd79d7b9f7bb064$export$928a906645f9d018 = new (0, $7oI3p$toughcookie.CookieJar)($0fd79d7b9f7bb064$export$231f8b179925e6a5);
 
 
-class $0d3ccbe1f68c2e3d$export$2e2bcd8739ae039 {
+var $53a3bcc99a05dfcf$require$FileCookieStore = $7oI3p$toughcookiefilestore.FileCookieStore;
+const $53a3bcc99a05dfcf$export$6c62df16f2e9c7e8 = new $53a3bcc99a05dfcf$require$FileCookieStore(`${(0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3)["HOME"]}/cookie-star.json`);
+const $53a3bcc99a05dfcf$export$928a906645f9d018 = new (0, $7oI3p$toughcookie.CookieJar)($53a3bcc99a05dfcf$export$6c62df16f2e9c7e8);
+
+
+
+class $e4efb16e005540de$export$2e2bcd8739ae039 {
+    browserName = "internal";
     async queryCookies(name, domain) {
-        if (name == "%" && domain == "%") {
-            const cookies = await (0, $0fd79d7b9f7bb064$export$231f8b179925e6a5).getAllCookies();
-            return cookies.map((cookie)=>{
+        const exportedCookies = [];
+        if (name.match(/[%*]/) || domain.match(/[%*]/)) {
+            const cookies = await this.#getAllCookies();
+            const allExportedCookies = cookies.map((cookie)=>{
                 return this.#extracted(cookie, {
                     name: name,
                     domain: domain
                 });
             });
+            exportedCookies.push(...allExportedCookies);
         }
+        if (name == "%" && domain == "%") return exportedCookies;
         const path = "/";
-        if (name == "%") {
-            const cookies1 = await (0, $0fd79d7b9f7bb064$export$231f8b179925e6a5).findCookies(domain, path);
-            return cookies1.map((cookie)=>{
+        if (domain != "%") {
+            const domain1 = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+            const url = new URL("https://" + domain1);
+            url.pathname = path;
+            const cookies1 = await (0, $53a3bcc99a05dfcf$export$928a906645f9d018).getCookies(url.href);
+            const domainCookies = cookies1.map((cookie)=>{
                 return this.#extracted(cookie, {
-                    name: name,
-                    domain: domain
+                    domain: domain,
+                    name: name
                 });
             });
+            exportedCookies.push(...domainCookies);
         }
-        const cookie = await (0, $0fd79d7b9f7bb064$export$231f8b179925e6a5).findCookie(domain, path, name);
-        if (cookie) return [
-            this.#extracted(cookie, {
+        if (name == "%") return exportedCookies;
+        const cookie = await (0, $53a3bcc99a05dfcf$export$6c62df16f2e9c7e8).findCookie(domain, path, name);
+        if (cookie) {
+            const singleCookie = this.#extracted(cookie, {
                 name: name,
                 domain: domain
-            })
-        ];
-        else return [];
+            });
+            return [
+                singleCookie
+            ];
+        }
+        return exportedCookies.filter((cookie)=>{
+            return cookie.name.match((0, $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb)(name)) && cookie.domain.match((0, $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb)(domain));
+        });
     }
      #extracted(cookie, cookieSpec) {
         return {
@@ -476,18 +514,29 @@ class $0d3ccbe1f68c2e3d$export$2e2bcd8739ae039 {
             }
         };
     }
+     #getAllCookies() {
+        return new Promise((resolve, reject)=>{
+            // @ts-ignore
+            return (0, $53a3bcc99a05dfcf$export$6c62df16f2e9c7e8).getAllCookies((err, cookies)=>{
+                if (err) reject(err);
+                else resolve(cookies ?? []);
+            });
+        });
+    }
 }
 
 
+
 const $f72befa528c23ca7$var$cache = new (0, ($parcel$interopDefault($7oI3p$lrucache)))({
     ttl: 2000,
     max: 10
 });
 class $f72befa528c23ca7$export$2e2bcd8739ae039 {
+    browserName = "all";
     #strategies;
     constructor(){
         this.#strategies = [
-            (0, $0d3ccbe1f68c2e3d$export$2e2bcd8739ae039),
+            (0, $e4efb16e005540de$export$2e2bcd8739ae039),
             (0, $269fe42bfd555305$export$2e2bcd8739ae039),
             (0, $7bb7da9a77b2fd99$export$2e2bcd8739ae039),
             (0, $fad6f51bd5c7bae2$export$2e2bcd8739ae039), 
@@ -496,13 +545,18 @@ class $f72befa528c23ca7$export$2e2bcd8739ae039 {
         });
     }
     async queryCookies(name, domain) {
+        // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
         const key = `${name}:${domain}`;
         const cached = $f72befa528c23ca7$var$cache.get(key);
         if (cached) return cached;
+        console.log("Querying cookies:", name, domain);
         const results = await Promise.all(this.#strategies.map(async (strategy)=>{
             // @ts-ignore
             const cookies = strategy.queryCookies(name, domain);
-            return cookies.catch(()=>[]);
+            return cookies.catch((e)=>{
+                console.log((0, $7oI3p$colorette.red)(`Error querying ${strategy.browserName} cookies`), e);
+                return [];
+            });
         }));
         const flat = results.flat();
         $f72befa528c23ca7$var$cache.set(`${name}:${domain}`, flat);
@@ -618,7 +672,7 @@ async function $cfc07ae4aa2c7e44$export$b24a545a0b39f491(url, options = {}, fetc
                 value
             ]);
         });
-        for (const [key, value] of headers)if (key === "set-cookie") await (0, $0fd79d7b9f7bb064$export$928a906645f9d018).setCookie(value, url2);
+        for (const [key, value] of headers)if (key === "set-cookie") await (0, $53a3bcc99a05dfcf$export$928a906645f9d018).setCookie(value, url2);
         const newUrl = res.headers.get("location");
         if (res.redirected || newUrl && newUrl !== url2) return $cfc07ae4aa2c7e44$export$b24a545a0b39f491(newUrl, newOptions1);
         const arrayBuffer1 = res.arrayBuffer();
@@ -664,6 +718,7 @@ var $3d7e27b54f670f46$exports = {};
 var $6c197c88880e045c$exports = {};
 
 
+
 async function $cd1ba0160120c006$export$4be65e66cfa2648a(params) {
     const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(params, new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)());
     if (Array.isArray(cookies) && cookies.length > 0) return cookies.find((cookie)=>cookie != null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.4",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -67,7 +67,8 @@
     "lru-cache": "^7.14.0",
     "minimist": "^1.2.6",
     "sqlite3": "^5.1.1",
-    "tough-cookie": "^4.1.2"
+    "tough-cookie": "^4.1.2",
+    "tough-cookie-file-store": "^2.0.3"
   },
   "devDependencies": {
     "@parcel/packager-ts": "^2.7.0",

package/src/CookieSpec.ts

@@ -1,4 +1,4 @@
 export default interface CookieSpec {
-  name: string;
   domain: string;
+  name: string;
 }

package/src/CookieStore.ts

@@ -0,0 +1,10 @@
+import { CookieJar } from "tough-cookie";
+import { env } from "./global";
+const { FileCookieStore } = require("tough-cookie-file-store");
+
+export const cookieStore = new FileCookieStore(
+  `${env["HOME"]}/cookie-star.json`
+);
+// export const cookieStore = new MemoryCookieStore();
+
+export const cookieJar = new CookieJar(cookieStore);

package/src/StringToRegex.ts

@@ -0,0 +1,6 @@
+export function stringToRegex(s: string): RegExp {
+  const s1 = s.replaceAll(/\./gi, ".");
+  const s2 = s1.replace(/%/g, ".*");
+  const s3 = s2.replace(/\*/g, ".*");
+  return new RegExp(s3);
+}

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -11,8 +11,11 @@ import { isCookieRow } from "../IsCookieRow";
 import { isExportedCookie } from "../IsExportedCookie";
 import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
+import { stringToRegex } from "../StringToRegex";
 
 export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Chrome";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
       throw new Error("This only works on macOS");
@@ -56,7 +59,7 @@ async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
     const promises: Promise<CookieRow[]>[] = files.map((file) =>
       getPromise1(name, domain, file)
     );
-    const results1: Awaited<CookieRow[]>[] = await Promise.all(promises);
+    const results1: CookieRow[][] = await Promise.all(promises);
     return results1.flat().filter(isCookieRow);
   } catch (error) {
     if (env.VERBOSE) {
@@ -146,19 +149,22 @@ async function getEncryptedChromeCookie({
   const wildcardRegexp = /^([*%])$/i;
   const specifiedName = name.match(wildcardRegexp) == null;
   const specifiedDomain = domain.match(wildcardRegexp) == null;
-  if (specifiedName || specifiedDomain) {
+  const wildcardDomain = domain.match(/[%*]/) != null;
+  const queryDomain = specifiedDomain && !wildcardDomain;
+  // if we have a wildcard domain, we need to use a regexp
+  if (specifiedName || queryDomain) {
     sql += ` WHERE `;
     if (specifiedName) {
       sql += `name = '${name}'`;
-      if (specifiedDomain) {
+      if (queryDomain) {
         sql += ` AND `;
       }
     }
-    if (specifiedDomain) {
+    if (queryDomain) {
       sql += `host_key LIKE '${domain}';`;
     }
   }
-  return doSqliteQuery1({
+  const sqliteQuery1: CookieRow[] = await doSqliteQuery1({
     file: file,
     sql: sql,
     rowTransform: (row) => {
@@ -169,6 +175,9 @@ async function getEncryptedChromeCookie({
       };
     },
   });
+  return sqliteQuery1.filter((row) => {
+    return row.domain.match(stringToRegex(domain)) != null;
+  });
 }
 
 async function getChromePassword(): Promise<string> {

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -4,7 +4,8 @@ import SafariCookieQueryStrategy from "./SafariCookieQueryStrategy";
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 import LRUCache from "lru-cache";
-import MemoryCookieStoreQueryStrategy from "./MemoryCookieJarQueryStrategy";
+import CookieStoreQueryStrategy from "./CookieStoreQueryStrategy";
+import { red } from "colorette";
 
 const cache = new LRUCache<string, ExportedCookie[]>({
   ttl: 1000 * 2,
@@ -14,11 +15,13 @@ const cache = new LRUCache<string, ExportedCookie[]>({
 export default class CompositeCookieQueryStrategy
   implements CookieQueryStrategy
 {
+  browserName = "all";
+
   #strategies;
 
   constructor() {
     this.#strategies = [
-      MemoryCookieStoreQueryStrategy,
+      CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
@@ -28,19 +31,24 @@ export default class CompositeCookieQueryStrategy
   }
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
     const key = `${name}:${domain}`;
     const cached = cache.get(key);
     if (cached) {
       return cached;
     }
-    const results = await Promise.all(
-      this.#strategies.map(async (strategy) => {
+    console.log("Querying cookies:", name, domain);
+    const results: ExportedCookie[][] = await Promise.all(
+      this.#strategies.map(async (strategy: CookieQueryStrategy) => {
         // @ts-ignore
         const cookies: Promise<ExportedCookie[]> = strategy.queryCookies(
           name,
           domain
         );
-        return cookies.catch(() => []);
+        return cookies.catch((e) => {
+          console.log(red(`Error querying ${strategy.browserName} cookies`), e);
+          return [];
+        });
       })
     );
     const flat: ExportedCookie[] = results.flat();

package/src/browsers/CookieQueryStrategy.ts

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

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -0,0 +1,88 @@
+import CookieQueryStrategy from "./CookieQueryStrategy";
+import CookieSpec from "../CookieSpec";
+import ExportedCookie from "../ExportedCookie";
+import { Cookie } from "tough-cookie";
+import { cookieStore, cookieJar } from "../CookieStore";
+import { stringToRegex } from "../StringToRegex";
+
+export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
+  browserName = "internal";
+
+  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
+    const exportedCookies: ExportedCookie[] = [];
+
+    if (name.match(/[%*]/) || domain.match(/[%*]/)) {
+      const cookies: Cookie[] = await this.#getAllCookies();
+      const allExportedCookies = cookies.map((cookie: Cookie) => {
+        return this.#extracted(cookie, { name, domain });
+      });
+      exportedCookies.push(...allExportedCookies);
+    }
+
+    if (name == "%" && domain == "%") {
+      return exportedCookies;
+    }
+
+    const path = "/";
+
+    if (domain != "%") {
+      const domain1 = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+      const url = new URL("https://" + domain1);
+      url.pathname = path;
+      const cookies: Cookie[] = await cookieJar.getCookies(url.href);
+      const domainCookies = cookies.map((cookie: Cookie) => {
+        return this.#extracted(cookie, {
+          domain,
+          name,
+        });
+      });
+      exportedCookies.push(...domainCookies);
+    }
+
+    if (name == "%") {
+      return exportedCookies;
+    }
+
+    const cookie: Cookie | null = await cookieStore.findCookie(
+      domain,
+      path,
+      name
+    );
+
+    if (cookie) {
+      const singleCookie = this.#extracted(cookie, { name, domain });
+      return [singleCookie];
+    }
+
+    return exportedCookies.filter((cookie: ExportedCookie) => {
+      return (
+        cookie.name.match(stringToRegex(name)) &&
+        cookie.domain.match(stringToRegex(domain))
+      );
+    });
+  }
+
+  #extracted(cookie: Cookie, cookieSpec: CookieSpec): ExportedCookie {
+    return {
+      domain: cookie.domain ?? cookieSpec.domain,
+      name: cookie.key ?? cookieSpec.name,
+      value: cookie.value,
+      meta: {
+        file: "memory",
+      },
+    };
+  }
+
+  #getAllCookies(): Promise<Cookie[]> {
+    return new Promise((resolve, reject) => {
+      // @ts-ignore
+      return cookieStore.getAllCookies((err, cookies) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cookies ?? []);
+        }
+      });
+    });
+  }
+}

package/src/browsers/FirefoxCookieQueryStrategy.ts

@@ -10,6 +10,8 @@ import CookieSpec from "../CookieSpec";
 import { specialCases } from "../SpecialCases";
 
 export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
+  browserName = "Firefox";
+
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
     if (process.platform !== "darwin") {
       throw new Error("This only works on macOS");

package/src/browsers/SafariCookieQueryStrategy.ts

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

package/src/fetchWithCookies.ts

@@ -6,7 +6,7 @@ import { merge } from "lodash";
 import destr from "destr";
 import CookieSpec from "./CookieSpec";
 import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
-import { cookieJar } from "./MemoryCookieStore";
+import { cookieJar } from "./CookieStore";
 
 export async function fetchWithCookies(
   url: RequestInfo | URL,

package/src/index.ts

@@ -60,3 +60,4 @@ export { getGroupedRenderedCookies, fetchWithCookies };
 export * from "./CookieSpec";
 export * from "./CookieRow";
 export * from "./ExportedCookie";
+export { stringToRegex } from "./StringToRegex";

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",
-      },
-    };
-  }
-}