@mherod/get-cookie 4.3.2 → 4.4.0

package/.claude/settings.local.json

@@ -0,0 +1,3 @@
+{
+  "outputStyle": "Explanatory"
+}

package/.dependency-cruiser.js

@@ -0,0 +1,277 @@
+/** @type {import('dependency-cruiser').IConfiguration} */
+export default {
+  forbidden: [
+    {
+      name: "no-circular",
+      severity: "warn",
+      comment:
+        "This dependency is part of a circular relationship. You might want to revise " +
+        "your solution (i.e. use dependency inversion, make sure the modules have a single responsibility) ",
+      from: {},
+      to: {
+        circular: true,
+      },
+    },
+    {
+      name: "no-orphans",
+      severity: "info",
+      comment:
+        "This is an orphan module - it's likely not used (anymore?). Either use it or " +
+        "remove it. If it's logical this module is an orphan (i.e. it's a config file), " +
+        "add an exception for it in your dependency-cruiser config",
+      from: {
+        orphan: true,
+        pathNot: [
+          "(^|/)\\.[^/]+\\.(js|cjs|mjs|ts|json)$", // dot files
+          "\\.(d\\.ts|test\\.ts|test\\.js|spec\\.ts|spec\\.js)$", // tests
+          "(^|/)__tests__/", // test folders
+          "(^|/)__mocks__/", // mock folders
+          "^src/cli/", // CLI entry points
+        ],
+      },
+      to: {},
+    },
+    {
+      name: "no-deprecated-core",
+      comment:
+        "A module depends on a node core module that has been deprecated. Find an alternative - these are " +
+        "bound to exist - node doesn't deprecate lightly.",
+      severity: "warn",
+      from: {},
+      to: {
+        dependencyTypes: ["core"],
+        path: [
+          "^(v8/tools/codemap)$",
+          "^(v8/tools/consarray)$",
+          "^(v8/tools/csvparser)$",
+          "^(v8/tools/logreader)$",
+          "^(v8/tools/profile_view)$",
+          "^(v8/tools/profile)$",
+          "^(v8/tools/SourceMap)$",
+          "^(v8/tools/splaytree)$",
+          "^(v8/tools/tickprocessor-driver)$",
+          "^(v8/tools/tickprocessor)$",
+          "^(node-inspect/lib/_inspect)$",
+          "^(node-inspect/lib/internal/inspect_client)$",
+          "^(node-inspect/lib/internal/inspect_repl)$",
+          "^(async_hooks)$",
+          "^(punycode)$",
+          "^(domain)$",
+          "^(constants)$",
+          "^(sys)$",
+          "^(_linklist)$",
+          "^(_stream_wrap)$",
+        ],
+      },
+    },
+    {
+      name: "not-to-deprecated",
+      comment:
+        "This module uses a (version of an) npm module that has been deprecated. Either upgrade to a later " +
+        "version of that module, or find an alternative. Check out https://www.npmjs.com/package/[the-module-name] " +
+        "for details.",
+      severity: "warn",
+      from: {},
+      to: {
+        dependencyTypes: ["deprecated"],
+      },
+    },
+    {
+      name: "no-non-package-json",
+      severity: "error",
+      comment:
+        "This module depends on an npm package that isn't in the 'dependencies' section of your package.json. " +
+        "That's problematic as the package either (1) won't be available on live (2 - worse) will be " +
+        "available on live with an non-guaranteed version. Fix it by adding the package to the dependencies " +
+        "in your package.json.",
+      from: {},
+      to: {
+        dependencyTypes: ["npm-no-pkg", "npm-unknown"],
+      },
+    },
+    {
+      name: "not-to-unresolvable",
+      comment:
+        "This module depends on a module that cannot be found ('resolved to disk'). If it's an npm " +
+        "module: add it to your package.json. In all other cases you likely already know what to do.",
+      severity: "error",
+      from: {},
+      to: {
+        couldNotResolve: true,
+      },
+    },
+    {
+      name: "no-duplicate-dep-types",
+      comment:
+        "Likely this module depends on an external ('npm') package that occurs more than once " +
+        "in your package.json i.e. bot as a devDependencies and in dependencies. This will cause " +
+        "maintenance problems later on.",
+      severity: "warn",
+      from: {},
+      to: {
+        moreThanOneDependencyType: true,
+      },
+    },
+
+    /* rules you might want to tweak for your specific situation: */
+    {
+      name: "not-to-test",
+      comment:
+        "This module depends on code within a folder that should only contain tests. As tests don't " +
+        "implement functionality this is odd. Either you're writing a test outside the test folder " +
+        "or there's something in the test folder that isn't a test.",
+      severity: "error",
+      from: {
+        pathNot: "^(src/(__tests__|__mocks__))",
+      },
+      to: {
+        path: "^(src/(__tests__|__mocks__))",
+      },
+    },
+    {
+      name: "not-to-spec",
+      comment:
+        "This module depends on a spec (test) file. The sole responsibility of a spec file is to test code. " +
+        "If there's something in a spec that's of use to other modules, it doesn't have that single " +
+        "responsibility anymore. Factor it out into (e.g.) a separate utility/ helper or a mock.",
+      severity: "error",
+      from: {},
+      to: {
+        path: "\\.(test|spec)\\.(js|mjs|cjs|ts|ls|coffee|litcoffee|coffee\\.md)$",
+      },
+    },
+    {
+      name: "not-to-dev-dep",
+      severity: "error",
+      comment:
+        "This module depends on an npm package from the 'devDependencies' section of your " +
+        "package.json. It looks like something that ships to production, though. To prevent problems " +
+        "with npm packages that aren't there on production declare it (only!) in the 'dependencies'" +
+        "section of your package.json. If this module is development only - add it to the " +
+        "from.pathNot re of the not-to-dev-dep rule in the dependency-cruiser configuration",
+      from: {
+        path: "^(src)",
+        pathNot: [
+          "\\.(test|spec)\\.(js|mjs|cjs|ts|ls|coffee|litcoffee|coffee\\.md)$",
+          "^(src/(__tests__|__mocks__))",
+        ],
+      },
+      to: {
+        dependencyTypes: ["npm-dev"],
+      },
+    },
+    {
+      name: "optional-deps-used",
+      severity: "info",
+      comment:
+        "This module depends on an npm package that is declared as an optional dependency " +
+        "in your package.json. As this makes sense in limited situations only, it's flagged here. " +
+        "If you're using an optional dependency here by design - add an exception to your" +
+        "dependency-cruiser config.",
+      from: {},
+      to: {
+        dependencyTypes: ["npm-optional"],
+      },
+    },
+    {
+      name: "peer-deps-used",
+      comment:
+        "This module depends on an npm package that is declared as a peer dependency " +
+        "in your package.json. This makes sense if your package is e.g. a plugin, but in " +
+        "other cases - maybe not so much. If the use of a peer dependency is intentional " +
+        "add an exception to your dependency-cruiser config.",
+      severity: "warn",
+      from: {},
+      to: {
+        dependencyTypes: ["npm-peer"],
+      },
+    },
+  ],
+  options: {
+    doNotFollow: {
+      path: "node_modules",
+    },
+    tsConfig: {
+      fileName: "tsconfig.json",
+    },
+    tsPreCompilationDeps: true,
+    enhancedResolveOptions: {
+      exportsFields: ["exports"],
+      conditionNames: ["import", "require", "node", "default"],
+      mainFields: ["module", "main", "types", "typings"],
+    },
+    reporterOptions: {
+      dot: {
+        collapsePattern: "node_modules/[^/]+",
+        theme: {
+          graph: {
+            bgcolor: "transparent",
+            color: "#000000",
+            fontcolor: "#000000",
+            fillcolor: "transparent",
+            splines: "ortho",
+          },
+          node: {
+            color: "#000000",
+            fillcolor: "#ffffcc",
+            fontcolor: "#000000",
+          },
+          edge: {
+            arrowhead: "normal",
+            arrowsize: "0.5",
+            penwidth: "1.0",
+            color: "#757575",
+          },
+          modules: [
+            {
+              criteria: { source: "^src/core" },
+              attributes: { fillcolor: "#ffcccc" },
+            },
+            {
+              criteria: { source: "^src/cli" },
+              attributes: { fillcolor: "#ccffcc" },
+            },
+            {
+              criteria: { source: "^src/utils" },
+              attributes: { fillcolor: "#ccccff" },
+            },
+            {
+              criteria: { source: "^src/types" },
+              attributes: { fillcolor: "#ffccff" },
+            },
+          ],
+          dependencies: [
+            {
+              criteria: { resolved: "^src/core" },
+              attributes: { color: "#ff0000" },
+            },
+            {
+              criteria: { resolved: "^src/cli" },
+              attributes: { color: "#00ff00" },
+            },
+            {
+              criteria: { resolved: "^src/utils" },
+              attributes: { color: "#0000ff" },
+            },
+          ],
+        },
+      },
+      archi: {
+        collapsePattern:
+          "^(node_modules|packages|src|lib|app|test(s?)|spec(s?))/[^/]+",
+        theme: {
+          graph: {
+            bgcolor: "transparent",
+            color: "#000000",
+            fontcolor: "#000000",
+            fillcolor: "transparent",
+            splines: "ortho",
+          },
+        },
+      },
+      text: {
+        highlightFocused: true,
+      },
+    },
+  },
+};

package/README.md

@@ -1,39 +1,62 @@
 # get-cookie 🍪
 
-Extract browser cookies programmatically. A command-line tool and library that handles Chrome's encryption, Safari's binary formats, and Firefox's data - all through one command. Perfect for testing, automation, and debugging.
+Extract cookies from your browser's local storage and use them programmatically. This tool reads browser databases directly, handles decryption, and outputs cookies you can use in API calls, testing, or automation.
 
-## Quick Start 🚀
+## What it does
+
+**The Problem**: You're logged into a website in your browser, but you need those same cookies for API testing, automation, or debugging. Manually copying cookies from DevTools is tedious and they expire quickly.
+
+**The Solution**: `get-cookie` reads cookies directly from browser databases (Chrome, Firefox, Safari, etc.), handles all the encryption/decryption, and gives you the cookie values to use programmatically.
+
+## Quick Start
 
 ```bash
+# Install globally
 pnpm add -g @mherod/get-cookie
-get-cookie auth example.com     # Get specific cookie
-get-cookie % example.com        # Get all cookies
+
+# Get a specific cookie
+get-cookie sessionid example.com
+
+# Get all cookies for a domain  
+get-cookie % example.com
+
+# Use in curl/API calls
+curl -H "Cookie: auth=$(get-cookie auth api.example.com)" https://api.example.com/user
 ```
 
 ```typescript
+// Node.js/TypeScript usage
 import { getCookie } from "@mherod/get-cookie";
 
 const cookies = await getCookie({
-  name: "auth",
-  domain: "example.com",
+  name: "auth_token",
+  domain: "api.example.com",
+});
+
+// Use in fetch, axios, etc.
+fetch("https://api.example.com/data", {
+  headers: {
+    Cookie: `auth_token=${cookies[0]?.value}`
+  }
 });
 ```
 
-## Perfect For 🎯
+## Common Use Cases
+
+- **API Testing**: Extract session cookies to test authenticated endpoints
+- **Browser Automation**: Get real cookies instead of managing login flows  
+- **Debugging**: Compare cookies across browsers to troubleshoot auth issues
+- **CI/CD**: Automate authenticated API tests without storing credentials
+- **Development**: Test with production-like authentication locally
 
-- 🔑 **API Testing**: Grab auth cookies directly from your browser for API calls
-- 🐞 **Debugging**: Inspect cookies across browsers to track down session issues
-- 🤖 **Test Automation**: Use real browser cookies in your integration tests
-- 🔄 **CI/CD**: Automate cookie extraction in your testing pipelines
-- 🧪 **Local Development**: Test your apps with production-like authentication
+## How it works
 
-## Why get-cookie? ✨
+1. **Locates browser databases** on your system (Chrome uses SQLite, Safari uses binary files)
+2. **Handles encryption** (Chrome's keychain/DPAPI encryption, etc.) 
+3. **Extracts and parses** cookie data
+4. **Returns usable values** you can immediately use in HTTP requests
 
-- 🔐 **Battle-tested Security**: Handles complex browser encryption with ease
-- 🎯 **Universal Browser Support**: Chrome (all platforms), Firefox, Safari - we've got you covered
-- 🚀 **Developer Experience**: Rich CLI options and type-safe Node.js API
-- ⚡ **Lightning Fast**: Optimised binary parsing and decryption
-- 🛠️ **Production Ready**: Used in critical testing pipelines worldwide
+No browser automation, no complex setup - just direct database access.
 
 ## Installation 📦
 
@@ -58,57 +81,92 @@ nvm use
 
 The project includes an `.nvmrc` file that specifies the required Node.js version, so `nvm use` will automatically switch to the correct version when you're in the project directory.
 
-## Usage Examples 💡
+## More Examples
 
 ### Command Line
 
 ```bash
-get-cookie auth example.com            # Basic extraction
-get-cookie auth example.com --render   # Pretty print
-get-cookie --url https://example.com   # URL-based extraction
+# Basic cookie extraction
+get-cookie sessionid github.com
+
+# Get all cookies for a domain
+get-cookie % api.stripe.com
+
+# Pretty print with metadata
+get-cookie auth example.com --render
+
+# JSON output for scripting
+get-cookie % example.com --output json
+
+# Specific browser/profile
+get-cookie auth example.com --browser chrome --profile "Work"
 ```
 
-### Node.js API
+### API Usage
 
 ```typescript
-import { getCookie } from "@mherod/get-cookie";
+import { getCookie, batchGetCookies } from "@mherod/get-cookie";
 
-// Specific cookie
-const authCookie = await getCookie({
-  name: "auth",
-  domain: "example.com",
+// Single cookie
+const auth = await getCookie({
+  name: "sessionid", 
+  domain: "github.com"
 });
 
-// All cookies
-const cookies = await getCookie({
-  name: "%",
-  domain: "example.com",
+// Multiple cookies efficiently (2-3x faster than individual calls)
+const cookies = await batchGetCookies([
+  { name: "auth", domain: "api.example.com" },
+  { name: "session", domain: "app.example.com" },
+  { name: "csrf", domain: "admin.example.com" }
+]);
+
+// Use in HTTP client
+const response = await fetch("https://api.github.com/user", {
+  headers: {
+    "Cookie": `sessionid=${auth[0]?.value}`
+  }
 });
 ```
 
-## Core Features 🎯
+### Real-world Integration
 
-- 🌐 **Cross-Platform**: Chrome (macOS/Linux/Windows), Firefox (macOS/Linux), Safari (macOS)
-- 🔒 **Enterprise Security**: Browser-native encryption handling
-- 📝 **TypeScript First**: Complete type safety and IntelliSense
-- 🎨 **Flexible Output**: JSON, rendered, or grouped results
-- 👥 **Multi-Profile**: Full support for browser profiles
+```bash
+# Test API endpoint with browser cookies
+AUTH=$(get-cookie connect.sid api.example.com)
+curl -H "Cookie: connect.sid=$AUTH" https://api.example.com/profile
 
-## Documentation 📚
+# Compare session across browsers  
+echo "Chrome:" && get-cookie JSESSIONID app.example.com --browser chrome
+echo "Firefox:" && get-cookie JSESSIONID app.example.com --browser firefox
 
-Explore our comprehensive docs at [mherod.github.io/get-cookie](https://mherod.github.io/get-cookie/)
+# Batch export for migration
+get-cookie % example.com --output json > cookies-backup.json
+```
+
+## Features
 
-## CI/CD Pipeline 🔄
+- **Multiple browsers**: Chrome, Firefox, Safari, Edge, Opera, Arc, Brave - reads from each browser's native storage format
+- **Handles encryption**: Automatically decrypts Chrome's keychain-encrypted cookies (macOS), DPAPI-encrypted cookies (Windows), and keyring encryption (Linux)
+- **Multiple profiles**: Works with all browser profiles (Personal, Work, etc.)
+- **Batch operations**: Get multiple cookies efficiently with built-in SQL optimization (2-3x faster)
+- **Cross-platform**: macOS, Linux, Windows support
+- **Output formats**: Raw values, JSON, pretty-printed tables
 
-Our GitHub Actions workflows ensure quality and reliability:
+## Browser Support 🌐
 
-- **🚀 CI Pipeline**: Automated testing across Node.js 20.x & 22.x on macOS
-- **📖 Documentation**: Auto-generated docs with TypeScript APIs
-- **🧪 Comprehensive Testing**: Swift CookieCreator, binary cookies, and validation scripts
-- **📦 Automated Releases**: NPM publishing with GitHub release creation
-- **✅ Quality Gates**: TypeScript checking, ESLint, Prettier, and link validation
+Supports **11 major browsers** across **macOS, Linux, and Windows**:
 
-Workflows run across macOS, Linux, and Windows to ensure cross-platform compatibility and proper cookie encryption testing.
+- **Chromium-based**: Chrome, Edge, Arc¹, Opera, Opera GX, Chromium, Brave
+- **Firefox-based**: Firefox, Firefox Developer Edition, Firefox ESR  
+- **Safari**: macOS only
+
+¹ *Arc added Windows support in April 2024*
+
+**→ See complete [Browser Support Matrix](docs/guide/browser-support.md) for detailed platform compatibility**
+
+## Documentation 📚
+
+Explore our comprehensive docs at [mherod.github.io/get-cookie](https://mherod.github.io/get-cookie/)
 
 ## Contributing 🤝
 

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.0.6/schema.json",
   "vcs": {
     "enabled": true,
     "clientKind": "git",
@@ -8,13 +8,14 @@
   },
   "files": {
     "ignoreUnknown": false,
-    "ignore": [
-      "dist/**",
-      "node_modules/**",
-      "coverage/**",
-      "docs/.vitepress/cache/**",
-      "**/*.log",
-      ".parcel-cache/**"
+    "includes": [
+      "**",
+      "!**/dist/**",
+      "!**/node_modules/**",
+      "!**/coverage/**",
+      "!**/docs/.vitepress/cache/**",
+      "!**/*.log",
+      "!**/.parcel-cache/**"
     ]
   },
   "formatter": {
@@ -28,25 +29,33 @@
     "attributePosition": "auto",
     "bracketSpacing": true
   },
-  "organizeImports": { "enabled": true },
+  "assist": { "actions": { "source": { "organizeImports": "off" } } },
   "linter": {
     "enabled": true,
     "rules": {
       "recommended": true,
       "correctness": {
         "noUnusedImports": "error",
-        "noUnusedVariables": "error",
-        "useArrayLiterals": "off"
+        "noUnusedVariables": "error"
       },
       "style": {
         "useImportType": "error",
         "noNamespace": "error",
         "noNonNullAssertion": "error",
-        "noVar": "error",
         "useAsConstAssertion": "error",
         "useBlockStatements": "error",
         "useConst": "error",
-        "useLiteralEnumMembers": "error"
+        "useLiteralEnumMembers": "error",
+        "noParameterAssign": "error",
+        "useDefaultParameterLast": "error",
+        "useEnumInitializers": "error",
+        "useSelfClosingElements": "error",
+        "useSingleVarDeclarator": "error",
+        "noUnusedTemplateLiteral": "error",
+        "useNumberNamespace": "error",
+        "noInferrableTypes": "error",
+        "noUselessElse": "error",
+        "useArrayLiterals": "off"
       },
       "complexity": {
         "noStaticOnlyClass": "error",
@@ -63,8 +72,12 @@
         "noMisleadingInstantiator": "error",
         "noPrototypeBuiltins": "error",
         "noUnsafeDeclarationMerging": "error",
-        "useAwait": "error",
-        "useNamespaceKeyword": "error"
+        "useAwait": "off",
+        "useNamespaceKeyword": "error",
+        "noAsyncPromiseExecutor": "error",
+        "noMisleadingCharacterClass": "error",
+        "noThenProperty": "error",
+        "noVar": "error"
       },
       "nursery": {
         "useSortedClasses": "off"
@@ -87,8 +100,18 @@
   },
   "overrides": [
     {
-      "include": [".prettierrc", ".parcelrc"],
+      "includes": ["**/.prettierrc/**", "**/.parcelrc/**"],
       "formatter": { "indentWidth": 2 }
+    },
+    {
+      "includes": ["**/*.test.ts", "**/*.spec.ts", "**/BinaryCodable*.ts"],
+      "linter": {
+        "rules": {
+          "style": {
+            "noNonNullAssertion": "off"
+          }
+        }
+      }
     }
   ]
 }