sessionsnap 0.0.1

package/README.md

@@ -0,0 +1,325 @@
+# sessionsnap
+
+> **KISS — Keep It Simple, Stupid.**
+>
+> Authenticated browser sessions shouldn't require complex auth flows, token management, cookie injection hacks, or custom login scripts per site. Just open a browser, log in like a human, and let the tool save & reuse that session. That's it.
+
+Capture and reuse authenticated browser sessions using **manual login**. Supports both Puppeteer and Playwright.
+
+Designed for test automation, internal tooling, and any workflow that requires persistent authenticated sessions — without scraping, bot detection bypass, or fingerprint spoofing.
+
+## Features
+
+- **Human-in-the-loop** — You log in manually (CAPTCHA / 2FA friendly)
+- **Persistent profiles** — Sessions saved to disk and reusable across runs
+- **Auto-detect login completion** — URL and cookie heuristics
+- **Session auto-update** — Session snapshot is refreshed when the browser closes
+- **Automatic screenshots** — Captures a PNG after login and on session open
+- **Action recording** — Inject a recorder to capture clicks, inputs, navigations
+- **Action replay** — Replay recorded actions with configurable speed
+- **Desktop viewport** — 1440×900 default for realistic rendering
+- **Dual runner support** — Puppeteer (bundled) and Playwright (optional)
+- **Works for any website** — SaaS dashboards, admin panels, internal tools
+
+## Install
+
+```bash
+npm install
+```
+
+Puppeteer is included as a direct dependency. For Playwright support, install it separately:
+
+```bash
+npm install playwright
+```
+
+## CLI Usage
+
+### Capture a session
+
+Launch a headed browser, log in manually, and save the session:
+
+```bash
+sessionsnap capture <url> \
+  --profile <name> \
+  [--runner puppeteer|playwright] \
+  [--out <file>] \
+  [--wait <minutes>] \
+  [--record]
+```
+
+`--runner` defaults to `puppeteer` since it is bundled as a direct dependency.
+
+**Example:**
+
+```bash
+sessionsnap capture https://app.acmecorp.io/login --profile acme
+```
+
+The tool will:
+1. Open a headed browser (1440×900 viewport)
+2. Navigate to the URL
+3. Wait for you to log in manually
+4. Detect login completion (URL no longer contains `login`/`signin`/`auth`, or cookie count increases)
+5. Take a screenshot of the post-login state
+6. Capture cookies and save a session snapshot
+
+### Open a URL with a saved session
+
+```bash
+sessionsnap open <url> \
+  --profile <name> \
+  [--runner puppeteer|playwright] \
+  [--record]
+```
+
+**Example:**
+
+```bash
+sessionsnap open https://app.acmecorp.io/dashboard --profile acme
+```
+
+When you close the browser, the session snapshot is automatically updated with the latest cookies.
+
+### List all profiles
+
+```bash
+sessionsnap list [--json]
+```
+
+Shows all saved profiles with a summary: runner, URL, relative date, screenshot/recording counts.
+
+**Example output:**
+
+```
+[sessionsnap] 2 profile(s) found:
+
+  acme     [puppeteer]  https://app.acmecorp.io/dashboard  (2h ago)  📸 3  🔴 2
+  staging  [playwright]  https://staging.acmecorp.io/home   (1d ago)  📸 1
+```
+
+Use `--json` for machine-readable output (useful for scripting).
+
+### Show profile status
+
+```bash
+sessionsnap status --profile <name>
+```
+
+Prints profile details including directory path, session metadata, cookie/origin counts, and a list of saved screenshots and recordings.
+
+**Example output:**
+
+```
+Profile:      acme
+Directory:    /Users/you/.sessionsnap/profiles/acme
+Runner:       puppeteer
+Captured at:  2026-02-09T12:00:00.000Z
+Updated at:   2026-02-09T12:05:00.000Z
+Start URL:    https://app.acmecorp.io/login
+Final URL:    https://app.acmecorp.io/dashboard
+Cookies:      12
+Origins:      0
+Screenshots:
+  - capture-2026-02-09T12-00-00-000Z.png
+  - open-2026-02-09T12-05-00-000Z.png
+Recordings:
+  - actions-capture-2026-02-09T12-00-00-000Z.json
+```
+
+## Snapshot Format
+
+```json
+{
+  "meta": {
+    "runner": "puppeteer",
+    "profile": "acme",
+    "capturedAt": "2026-02-09T12:00:00.000Z",
+    "startUrl": "https://app.acmecorp.io/login",
+    "finalUrl": "https://app.acmecorp.io/dashboard"
+  },
+  "cookies": [
+    {
+      "name": "session_token",
+      "value": "abc123",
+      "domain": ".acmecorp.io",
+      "path": "/",
+      "expires": 1700000000,
+      "httpOnly": true,
+      "secure": true,
+      "sameSite": "Lax"
+    }
+  ],
+  "origins": []
+}
+```
+
+After using `open`, an `updatedAt` field is added to `meta`.
+
+## Screenshots
+
+Screenshots are automatically saved to the profile directory on every `capture` and `open` command:
+
+```
+~/.sessionsnap/profiles/acme/
+  snapshot.json
+  capture-2026-02-09T12-00-00-000Z.png
+  open-2026-02-09T12-05-00-000Z.png
+```
+
+- **capture** — taken right after login is detected
+- **open** — taken after the page loads with the saved session
+
+## Action Recording
+
+Use `--record` on `capture` or `open` to inject a lightweight recorder into the page. It captures 11 action types:
+
+| Action | What it records | Replay |
+|--------|----------------|--------|
+| **click** | selector, tag, text, coordinates | CSS selector → text → coordinates fallback |
+| **dblclick** | selector, tag, text, coordinates | Same 3-tier fallback as click |
+| **hover** | selector, tag, text | `page.hover(selector)` with text fallback |
+| **input** | selector, value (passwords masked) | Clear + type / fill |
+| **select** | selector, selected value & text | `page.select` / `selectOption` |
+| **checkbox** | selector, checked state, type (checkbox/radio) | Smart toggle (checks current state) |
+| **keydown** | key, combo (Ctrl/Meta/Alt+key), selector | `page.keyboard.press` with modifiers |
+| **submit** | form selector, action, method | `form.requestSubmit()` / Enter fallback |
+| **scroll** | scrollX, scrollY, scrollHeight, viewportHeight | `window.scrollTo(x, y)` |
+| **file** | selector, file names, file count | Log only (cannot replay file selection) |
+| **navigation** | from/to URLs (SPA & traditional) | `page.goto(url)` |
+
+Noise reduction: hover is debounced (200ms, interactive elements only), scroll is debounced (400ms), keydown only captures special keys (Enter/Escape/Tab/arrows/F-keys) and modifier combos (Ctrl+key, Meta+key).
+
+Recorded actions are saved as timestamped JSON files in the profile directory:
+
+```
+~/.sessionsnap/profiles/acme/
+  actions-capture-2026-02-09T12-00-00-000Z.json
+  actions-open-2026-02-09T12-05-00-000Z.json
+```
+
+**Example:**
+
+```bash
+sessionsnap capture https://app.acmecorp.io/login --profile acme --record
+```
+
+### Replaying actions
+
+Replay a previously recorded session:
+
+```bash
+sessionsnap replay \
+  --profile <name> \
+  [--runner puppeteer|playwright] \
+  [--file <actions-file>] \
+  [--speed <multiplier>] \
+  [--headless] \
+  [--bail]
+```
+
+**Examples:**
+
+```bash
+# Replay the latest recording at normal speed
+sessionsnap replay --profile acme
+
+# Replay at 2x speed
+sessionsnap replay --profile acme --speed 2
+
+# Replay a specific recording file
+sessionsnap replay --profile acme --file actions-capture-2026-02-09T12-00-00-000Z.json
+
+# Replay in headless mode (no visible browser)
+sessionsnap replay --profile acme --headless
+
+# Fail fast — stop on first failure (exit code 1)
+sessionsnap replay --profile acme --bail
+```
+
+The replayer:
+1. Launches a browser with the saved session profile
+2. Navigates to the starting URL from the recording
+3. Executes each action in order (click, dblclick, hover, type, select, checkbox, keydown, submit, scroll, navigate)
+4. Uses real timing from the recording (clamped to 50ms–5s per action)
+5. Takes a screenshot after replay completes
+6. Password fields are skipped during replay for security
+
+#### Error handling
+
+By default, replay is **fault-tolerant**. If an individual action fails (element not found, timeout, etc.), it is logged as `FAILED` and the replay **continues with the next action** — the whole flow does not crash.
+
+Use `--bail` for **fail-fast** mode: the replay stops immediately on the first failure and exits with code `1`. This is useful in CI/CD pipelines or when you need strict action accuracy.
+
+For click actions, there is a 3-step fallback strategy:
+1. **CSS selector** — tries the recorded selector (2s timeout)
+2. **Text content** — searches all visible elements for matching text
+3. **Coordinates** — clicks at the recorded x/y position
+
+If all three strategies fail, the action is logged as `FAILED` and skipped.
+
+```
+[sessionsnap] [1/5] click: #submit-btn "Submit"
+[sessionsnap] [2/5] click FAILED: Element not found: #old-selector (text: "Gone")
+[sessionsnap] [3/5] input: input[name="email"] → "user@example.com"
+[sessionsnap] [4/5] navigation: /login → /dashboard
+[sessionsnap] [5/5] click: a[href="/settings"] "Settings"
+[sessionsnap] Replay complete.
+```
+
+Each action entry includes a `type`, `timestamp`, `url`, and type-specific fields:
+
+```json
+[
+  { "type": "click", "selector": "#login-button", "tag": "button", "text": "Sign In", "x": 720, "y": 450 },
+  { "type": "dblclick", "selector": ".cell", "tag": "td", "text": "Edit me", "x": 300, "y": 200 },
+  { "type": "hover", "selector": "nav > .dropdown", "tag": "button", "text": "Menu" },
+  { "type": "input", "selector": "input[name=\"email\"]", "tag": "input", "inputType": "email", "value": "user@example.com" },
+  { "type": "checkbox", "selector": "input[name=\"remember\"]", "inputType": "checkbox", "checked": true },
+  { "type": "keydown", "key": "Escape", "combo": "Escape", "selector": ".modal", "tag": "div" },
+  { "type": "scroll", "scrollX": 0, "scrollY": 800, "scrollHeight": 3200, "viewportHeight": 900 },
+  { "type": "file", "selector": "input[type=\"file\"]", "fileNames": ["photo.jpg"], "fileCount": 1 },
+  { "type": "navigation", "from": "/login", "to": "/dashboard" }
+]
+```
+
+## Project Structure
+
+```
+sessionsnap/
+  bin/
+    sessionsnap.js          # CLI entry point
+  src/
+    core/
+      snapshot.js           # Canonical session format & normalization
+      heuristics.js         # Login detection logic (URL + cookie polling)
+      recorder.js           # Injected script for recording user actions
+      replayer.js           # Replay engine for recorded actions
+    puppeteer/
+      capture.js            # Capture session via CDP
+      open.js               # Open URL with saved profile + update on close
+      replay.js             # Replay recorded actions via Puppeteer
+    playwright/
+      capture.js            # Capture session via storageState
+      open.js               # Open URL with saved profile + update on close
+      replay.js             # Replay recorded actions via Playwright
+    store.js                # Profile directory & JSON I/O
+  test/
+    store.test.js
+    snapshot.test.js
+    heuristics.test.js
+    cli.test.js
+  package.json
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+Uses the Node.js built-in test runner (`node:test`). No additional test dependencies required.
+
+## License
+
+MIT

package/bin/sessionsnap.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProfileDir, loadSnapshot, loadActions, listProfiles, listActionFiles } from '../src/store.js';
+
+const program = new Command();
+
+program
+  .name('sessionsnap')
+  .description('Capture and reuse authenticated browser sessions')
+  .version('1.0.0');
+
+program
+  .command('capture <url>')
+  .description('Launch a browser, login manually, and capture the session')
+  .option('--runner <runner>', 'Browser runner: puppeteer or playwright', 'puppeteer')
+  .requiredOption('--profile <name>', 'Profile name to save the session under')
+  .option('--out <file>', 'Custom output path for the snapshot JSON')
+  .option('--wait <minutes>', 'Max minutes to wait for login', parseFloat)
+  .option('--record', 'Record user actions (clicks, inputs, navigations)')
+  .action(async (url, opts) => {
+    validateRunner(opts.runner);
+    try {
+      if (opts.runner === 'puppeteer') {
+        const { capture } = await import('../src/puppeteer/capture.js');
+        await capture(url, { profile: opts.profile, out: opts.out, waitMinutes: opts.wait, record: opts.record });
+      } else {
+        const { capture } = await import('../src/playwright/capture.js');
+        await capture(url, { profile: opts.profile, out: opts.out, waitMinutes: opts.wait, record: opts.record });
+      }
+    } catch (err) {
+      console.error(`[sessionsnap] Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('open <url>')
+  .description('Open a URL using a previously captured session profile')
+  .option('--runner <runner>', 'Browser runner: puppeteer or playwright', 'puppeteer')
+  .requiredOption('--profile <name>', 'Profile name to load')
+  .option('--record', 'Record user actions (clicks, inputs, navigations)')
+  .action(async (url, opts) => {
+    validateRunner(opts.runner);
+    try {
+      if (opts.runner === 'puppeteer') {
+        const { open } = await import('../src/puppeteer/open.js');
+        await open(url, { profile: opts.profile, record: opts.record });
+      } else {
+        const { open } = await import('../src/playwright/open.js');
+        await open(url, { profile: opts.profile, record: opts.record });
+      }
+    } catch (err) {
+      console.error(`[sessionsnap] Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .description('List all saved profiles')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const profiles = await listProfiles();
+    if (profiles.length === 0) {
+      console.log('[sessionsnap] No profiles found.');
+      return;
+    }
+
+    if (opts.json) {
+      const result = [];
+      for (const name of profiles) {
+        const entry = { name };
+        try {
+          const snap = await loadSnapshot(name);
+          entry.runner = snap.meta.runner;
+          entry.capturedAt = snap.meta.capturedAt;
+          entry.updatedAt = snap.meta.updatedAt || null;
+          entry.startUrl = snap.meta.startUrl;
+          entry.finalUrl = snap.meta.finalUrl;
+          entry.cookies = snap.cookies.length;
+        } catch { entry.snapshot = null; }
+        try {
+          const dir = getProfileDir(name);
+          const files = await readdir(dir);
+          entry.screenshots = files.filter((f) => f.endsWith('.png')).length;
+          const actionFiles = files.filter((f) => f.startsWith('actions-') && f.endsWith('.json'));
+          entry.recordings = actionFiles.length;
+        } catch { entry.screenshots = 0; entry.recordings = 0; }
+        result.push(entry);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // ANSI color helpers
+    const c = {
+      bold:    (s) => `\x1b[1m${s}\x1b[0m`,
+      green:   (s) => `\x1b[32m${s}\x1b[0m`,
+      cyan:    (s) => `\x1b[36m${s}\x1b[0m`,
+      yellow:  (s) => `\x1b[33m${s}\x1b[0m`,
+      magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+      dim:     (s) => `\x1b[2m${s}\x1b[0m`,
+      red:     (s) => `\x1b[31m${s}\x1b[0m`,
+    };
+
+    console.log(`\n${c.bold(`[sessionsnap] ${profiles.length} profile(s) found:`)}\n`);
+    for (const name of profiles) {
+      let line = `  ${c.bold(c.green(name))}`;
+      try {
+        const snap = await loadSnapshot(name);
+        const runner = snap.meta.runner;
+        const date = snap.meta.updatedAt || snap.meta.capturedAt;
+        const relDate = timeSince(date);
+        const url = snap.meta.finalUrl || snap.meta.startUrl;
+        line += `  ${c.cyan(`[${runner}]`)}  ${c.dim(url)}  ${c.yellow(`(${relDate})`)}`;
+      } catch {
+        line += `  ${c.red('(no snapshot)')}`;
+      }
+      try {
+        const dir = getProfileDir(name);
+        const files = await readdir(dir);
+        const screenshots = files.filter((f) => f.endsWith('.png')).length;
+        const recordings = files.filter((f) => f.startsWith('actions-') && f.endsWith('.json')).length;
+        const extras = [];
+        if (screenshots > 0) extras.push(`📸 ${screenshots}`);
+        if (recordings > 0) extras.push(`🔴 ${recordings}`);
+        if (extras.length > 0) line += `  ${c.magenta(extras.join('  '))}`;
+      } catch { /* no dir */ }
+      console.log(line);
+    }
+    console.log();
+  });
+
+function timeSince(dateStr) {
+  const seconds = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1000);
+  if (seconds < 60) return 'just now';
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  return `${months}mo ago`;
+}
+
+program
+  .command('recordings')
+  .description('List recorded action files for a profile')
+  .requiredOption('--profile <name>', 'Profile name')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const c = {
+      bold:    (s) => `\x1b[1m${s}\x1b[0m`,
+      green:   (s) => `\x1b[32m${s}\x1b[0m`,
+      cyan:    (s) => `\x1b[36m${s}\x1b[0m`,
+      yellow:  (s) => `\x1b[33m${s}\x1b[0m`,
+      magenta: (s) => `\x1b[35m${s}\x1b[0m`,
+      dim:     (s) => `\x1b[2m${s}\x1b[0m`,
+      red:     (s) => `\x1b[31m${s}\x1b[0m`,
+    };
+
+    const files = await listActionFiles(opts.profile);
+    if (files.length === 0) {
+      console.log(`[sessionsnap] No recordings found for profile "${opts.profile}".`);
+      return;
+    }
+
+    const dir = getProfileDir(opts.profile);
+    const entries = [];
+
+    for (const file of files) {
+      const raw = await readFile(join(dir, file), 'utf-8');
+      const actions = JSON.parse(raw);
+      const count = Array.isArray(actions) ? actions.length : 0;
+
+      // Extract label and timestamp from filename: actions-<label>-<timestamp>.json
+      const match = file.match(/^actions-(.+?)-(\d{4}-\d{2}-\d{2}T.+)\.json$/);
+      const label = match ? match[1] : '?';
+      const tsRaw = match ? match[2].replace(/-/g, (m, offset) => {
+        // Restore ISO date: first 10 chars use '-', rest use ':' and '.'
+        return offset < 10 ? '-' : offset === 19 ? '.' : ':';
+      }) : '';
+
+      let dateStr = '';
+      let relDate = '';
+      if (count > 0 && actions[0].timestamp) {
+        dateStr = new Date(actions[0].timestamp).toISOString();
+        relDate = timeSince(dateStr);
+      } else if (tsRaw) {
+        try {
+          dateStr = new Date(tsRaw).toISOString();
+          relDate = timeSince(dateStr);
+        } catch { /* invalid date */ }
+      }
+
+      // Summarize action types
+      const types = {};
+      if (Array.isArray(actions)) {
+        for (const a of actions) {
+          types[a.type] = (types[a.type] || 0) + 1;
+        }
+      }
+
+      entries.push({ file, label, count, date: dateStr, relDate, types });
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(entries, null, 2));
+      return;
+    }
+
+    console.log(`\n${c.bold(`[sessionsnap] ${entries.length} recording(s) for profile "${opts.profile}":`)}\n`);
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      const num = c.dim(`${i + 1}.`);
+      const name = c.bold(c.green(e.file));
+      const countStr = e.count > 0 ? c.cyan(`${e.count} actions`) : c.red('empty');
+      const labelStr = c.magenta(`[${e.label}]`);
+      const dateInfo = e.relDate ? c.yellow(`(${e.relDate})`) : '';
+
+      console.log(`  ${num} ${name}`);
+      console.log(`     ${labelStr}  ${countStr}  ${dateInfo}`);
+
+      if (e.count > 0) {
+        const typeSummary = Object.entries(e.types)
+          .map(([t, n]) => `${t}:${n}`)
+          .join('  ');
+        console.log(`     ${c.dim(typeSummary)}`);
+      }
+      console.log();
+    }
+  });
+
+program
+  .command('status')
+  .description('Show profile details: path, session info, and screenshots')
+  .requiredOption('--profile <name>', 'Profile name')
+  .action(async (opts) => {
+    const dir = getProfileDir(opts.profile);
+    console.log(`Profile:      ${opts.profile}`);
+    console.log(`Directory:    ${dir}`);
+
+    try {
+      const snap = await loadSnapshot(opts.profile);
+      console.log(`Runner:       ${snap.meta.runner}`);
+      console.log(`Captured at:  ${snap.meta.capturedAt}`);
+      if (snap.meta.updatedAt) {
+        console.log(`Updated at:   ${snap.meta.updatedAt}`);
+      }
+      console.log(`Start URL:    ${snap.meta.startUrl}`);
+      console.log(`Final URL:    ${snap.meta.finalUrl}`);
+      console.log(`Cookies:      ${snap.cookies.length}`);
+      console.log(`Origins:      ${snap.origins.length}`);
+    } catch {
+      console.log(`Snapshot:     (not yet captured)`);
+    }
+
+    try {
+      const files = await readdir(dir);
+      const screenshots = files.filter((f) => f.endsWith('.png')).sort();
+      if (screenshots.length > 0) {
+        console.log(`Screenshots:`);
+        for (const s of screenshots) {
+          console.log(`  - ${s}`);
+        }
+      } else {
+        console.log(`Screenshots:  (none)`);
+      }
+
+      const recordings = files.filter((f) => f.startsWith('actions-') && f.endsWith('.json')).sort();
+      if (recordings.length > 0) {
+        console.log(`Recordings:`);
+        for (const r of recordings) {
+          console.log(`  - ${r}`);
+        }
+      } else {
+        console.log(`Recordings:   (none)`);
+      }
+    } catch {
+      console.log(`Screenshots:  (directory not found)`);
+      console.log(`Recordings:   (directory not found)`);
+    }
+  });
+
+program
+  .command('replay')
+  .description('Replay previously recorded actions on a saved session')
+  .option('--runner <runner>', 'Browser runner: puppeteer or playwright', 'puppeteer')
+  .requiredOption('--profile <name>', 'Profile name to load')
+  .option('--file <name>', 'Specific actions JSON file to replay (defaults to latest)')
+  .option('--speed <multiplier>', 'Playback speed multiplier (default: 1)', parseFloat, 1)
+  .option('--headless', 'Run in headless mode')
+  .option('--bail', 'Stop replay immediately on first failure (fail fast)')
+  .option('--visual', 'Show a visual mouse cursor during replay')
+  .action(async (opts) => {
+    validateRunner(opts.runner);
+    try {
+      const actions = await loadActions(opts.profile, opts.file);
+      console.log(`[sessionsnap] Loaded ${actions.length} actions.`);
+
+      const replayOpts = {
+        profile: opts.profile,
+        speed: opts.speed,
+        headed: !opts.headless,
+        bail: opts.bail || false,
+        visual: opts.visual || false,
+      };
+
+      if (opts.runner === 'puppeteer') {
+        const { replay } = await import('../src/puppeteer/replay.js');
+        await replay(actions, replayOpts);
+      } else {
+        const { replay } = await import('../src/playwright/replay.js');
+        await replay(actions, replayOpts);
+      }
+    } catch (err) {
+      console.error(`[sessionsnap] Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+function validateRunner(runner) {
+  if (!['puppeteer', 'playwright'].includes(runner)) {
+    console.error(`[sessionsnap] Invalid runner: "${runner}". Use puppeteer or playwright.`);
+    process.exit(1);
+  }
+}
+
+program.parse();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "sessionsnap",
+  "version": "0.0.1",
+  "description": "Capture and reuse authenticated browser sessions (Puppeteer + Playwright)",
+  "type": "module",
+  "bin": {
+    "sessionsnap": "./bin/sessionsnap.js"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "css-selector-generator": "^3.8.0",
+    "puppeteer": "^24.2.1"
+  },
+  "peerDependencies": {
+    "playwright": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}