ai-chat-export 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "ai-chat-export",
+  "description": "Export AI chat conversations (Gemini, ChatGPT, Copilot, DeepSeek) to Markdown and JSON using AppleScript + Chrome",
+  "version": "1.0.0",
+  "author": {
+    "name": "Kapil Tundwal"
+  },
+  "homepage": "https://github.com/ktundwal/ai-chat-export",
+  "repository": "https://github.com/ktundwal/ai-chat-export",
+  "license": "MIT"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kapil Tundwal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# ai-chat-export
+
+Export your AI chat conversations to Markdown and JSON files — for backup, analysis, or feeding to other AI tools.
+
+**Supported providers:**
+
+| Provider | Status |
+|----------|--------|
+| Google Gemini | Available |
+| ChatGPT | Coming soon |
+| Microsoft Copilot | Coming soon |
+| DeepSeek | Coming soon |
+
+Most AI chat platforms don't offer full conversation export. Google Takeout doesn't support Gemini chats at all. This tool fills that gap.
+
+## Why AppleScript?
+
+We tried every reasonable approach before landing on AppleScript:
+
+| Approach | Result |
+|---|---|
+| Playwright `launchPersistentContext` | Chrome blocks `--remote-debugging-pipe` on its default user data directory |
+| Copy Chrome profile to temp dir | Cookies are encrypted via macOS Keychain — copied profile loses authentication |
+| `--remote-debugging-port` on default profile | Same restriction — Chrome refuses remote debugging on its standard data directory |
+| Symlink trick | Chrome resolves symlinks, still detects the default directory |
+| Copy profile + `--user-data-dir` | CDP works, but cookies can't be decrypted in the new location |
+
+**AppleScript controls the real Chrome process with real cookies** — no profile copying, no CDP, no authentication issues. The tradeoff is macOS-only.
+
+## Prerequisites
+
+- **macOS** (AppleScript requirement)
+- **Google Chrome** open and signed in to your AI provider
+- **Allow JavaScript from Apple Events** — in Chrome: `View > Developer > Allow JavaScript from Apple Events`
+
+## Quick Start
+
+```bash
+npx ai-chat-export
+```
+
+This exports all your Gemini conversations as Markdown files to `./ai-chats/`.
+
+## CLI Options
+
+| Option | Short | Default | Description |
+|---|---|---|---|
+| `--provider <name>` | `-p` | `gemini` | AI provider to export from |
+| `--output <dir>` | `-o` | `./ai-chats` | Output directory |
+| `--format <type>` | `-f` | `markdown` | Output format: `markdown`, `json`, or `both` |
+| `--delay <ms>` | `-d` | `3000` | Delay between chat exports (ms) |
+| `--verbose` | `-v` | `false` | Enable debug logging |
+| `--help` | `-h` | | Show help message |
+
+## Examples
+
+```bash
+# Export Gemini chats as JSON (for programmatic analysis)
+npx ai-chat-export --format json
+
+# Export both Markdown and JSON
+npx ai-chat-export --format both --output ~/my-exports
+
+# Slower export (for rate limiting concerns)
+npx ai-chat-export --delay 5000
+
+# Debug mode
+npx ai-chat-export --verbose
+```
+
+## Output Formats
+
+### Markdown (default)
+
+```markdown
+# How to make sourdough bread
+
+## User
+
+How do I make sourdough bread from scratch?
+
+---
+
+## Gemini
+
+Here's a step-by-step guide to making sourdough bread...
+
+---
+```
+
+### JSON
+
+```json
+{
+  "title": "How to make sourdough bread",
+  "url": "https://gemini.google.com/app/abc123",
+  "exportedAt": "2025-01-15T10:30:00.000Z",
+  "messages": [
+    { "role": "User", "content": "How do I make sourdough bread from scratch?" },
+    { "role": "Gemini", "content": "Here's a step-by-step guide to making sourdough bread..." }
+  ]
+}
+```
+
+## How It Works
+
+1. **AppleScript bridge** — Executes JavaScript in Chrome's active tab via `osascript`
+2. **Sidebar scanning** — Opens the sidebar and scrolls to load all lazy-loaded conversations
+3. **Link collection** — Extracts all chat URLs, filtering out non-chat links
+4. **Message extraction** — Navigates to each chat and extracts messages using multiple fallback DOM strategies
+5. **Formatting** — Converts extracted messages to Markdown and/or JSON
+
+## Adding a New Provider
+
+Each provider is a single file in `src/providers/` that exports:
+
+```js
+export const name = "provider-id";
+export const displayName = "Provider Name";
+export const url = "https://provider.example.com";
+export function checkSignedIn() { /* ... */ }
+export async function collectChats({ verbose }) { /* ... */ }
+export async function extractMessages() { /* ... */ }
+```
+
+See `src/providers/gemini.mjs` for a complete example.
+
+## Limitations
+
+- **macOS only** — AppleScript is a macOS technology
+- **Chrome only** — Uses Chrome-specific AppleScript commands
+- **DOM-dependent** — Message extraction relies on each provider's DOM structure, which may change
+- **Sequential** — Exports one chat at a time (no parallel extraction)
+- **No retry** — Failed chats are skipped without retry
+
+## Future Work
+
+- [ ] **More providers** — ChatGPT, Microsoft Copilot, DeepSeek
+- [ ] **Windows/Linux support** — CDP-based approach where user launches Chrome with `--remote-debugging-port` on a separate `--user-data-dir`, signs in once, then tool connects via CDP
+- [ ] **Retry logic** — Retry failed chat exports
+- [ ] **Incremental export** — Skip chats already exported (by checking existing files)
+
+## Use with Claude Code
+
+This repo is a [Claude Code plugin](https://docs.anthropic.com/en/docs/claude-code/plugins). Install it and get the `/ai-chat-export` slash command:
+
+```
+/plugin install https://github.com/ktundwal/ai-chat-export
+```
+
+Then use it:
+
+```
+/ai-chat-export
+/ai-chat-export --provider gemini --format json --output ~/exports
+```
+
+## Contributing
+
+Contributions welcome — especially new providers! See [CLAUDE.md](CLAUDE.md) for development guidelines.
+
+## License
+
+[MIT](LICENSE)

package/bin/ai-chat-export.mjs

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+/**
+ * ai-chat-export — CLI entry point
+ *
+ * Exports AI chat conversations to Markdown and/or JSON files.
+ * Uses AppleScript to control Chrome with your real authenticated session.
+ */
+
+import { parseArgs } from "node:util";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { chromeJS, navigateTo, sleep } from "../src/browser.mjs";
+import { getProvider, listProviders } from "../src/providers/index.mjs";
+import { formatAsMarkdown, formatAsJSON } from "../src/formatter.mjs";
+
+// ─── CLI argument parsing ───────────────────────────────────────────────────
+
+const { values: args } = parseArgs({
+  options: {
+    provider: { type: "string", short: "p", default: "gemini" },
+    output: { type: "string", short: "o", default: "./ai-chats" },
+    format: { type: "string", short: "f", default: "markdown" },
+    delay: { type: "string", short: "d", default: "3000" },
+    verbose: { type: "boolean", short: "v", default: false },
+    help: { type: "boolean", short: "h", default: false },
+  },
+  strict: true,
+});
+
+if (args.help) {
+  const providers = listProviders();
+  console.log(`
+ai-chat-export — Export AI chat conversations to Markdown/JSON
+
+USAGE
+  npx ai-chat-export [options]
+
+OPTIONS
+  -p, --provider <name>  AI provider: ${providers.join(", ")} (default: gemini)
+  -o, --output <dir>     Output directory (default: ./ai-chats)
+  -f, --format <type>    Output format: markdown, json, or both (default: markdown)
+  -d, --delay <ms>       Delay between chats in ms (default: 3000)
+  -v, --verbose          Enable verbose/debug logging
+  -h, --help             Show this help message
+
+PREREQUISITES
+  1. macOS (AppleScript requirement)
+  2. Google Chrome open and signed in to the AI provider
+  3. Chrome > View > Developer > Allow JavaScript from Apple Events (enabled)
+
+EXAMPLES
+  npx ai-chat-export
+  npx ai-chat-export --provider gemini --format json
+  npx ai-chat-export --format both --output ~/my-exports
+  npx ai-chat-export --delay 5000 --verbose
+`);
+  process.exit(0);
+}
+
+const FORMAT = args.format;
+const DELAY = parseInt(args.delay, 10) || 3000;
+const VERBOSE = args.verbose;
+
+if (!["markdown", "json", "both"].includes(FORMAT)) {
+  console.error(`Invalid format "${FORMAT}". Use: markdown, json, or both`);
+  process.exit(1);
+}
+
+if (VERBOSE) {
+  process.env.GEMINI_VERBOSE = "1";
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function sanitizeFilename(name) {
+  return name
+    .replace(/[/\\?%*:|"<>]/g, "-")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 200);
+}
+
+function log(msg) {
+  if (VERBOSE) console.log(msg);
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  const provider = getProvider(args.provider);
+
+  console.log(`ai-chat-export (${provider.displayName})`);
+  console.log("==================\n");
+
+  if (process.platform !== "darwin") {
+    console.error(
+      "Error: This tool requires macOS (AppleScript). See README for details."
+    );
+    process.exit(1);
+  }
+
+  const OUTPUT_DIR = join(process.cwd(), args.output);
+  await mkdir(OUTPUT_DIR, { recursive: true });
+  console.log(`Provider: ${provider.displayName}`);
+  console.log(`Output:   ${OUTPUT_DIR}`);
+  console.log(`Format:   ${FORMAT}`);
+  console.log(`Delay:    ${DELAY}ms\n`);
+
+  // Navigate to provider if needed
+  const currentURL = chromeJS("window.location.href");
+  log(`Current URL: ${currentURL}`);
+
+  if (!currentURL.includes(new URL(provider.url).hostname)) {
+    console.log(`Navigating to ${provider.displayName}...`);
+    await navigateTo(provider.url);
+  }
+
+  // Verify authentication
+  if (!provider.checkSignedIn()) {
+    console.error(
+      `Error: Not signed in to ${provider.displayName}. Please sign in first.`
+    );
+    process.exit(1);
+  }
+  console.log(`Signed in to ${provider.displayName}.\n`);
+
+  // Collect chats
+  console.log("Collecting chat links...");
+  const chats = await provider.collectChats({ verbose: VERBOSE });
+
+  console.log(`Found ${chats.length} conversations to export.\n`);
+
+  if (chats.length === 0) {
+    console.log("No conversations found. Exiting.");
+    process.exit(0);
+  }
+
+  // Export each chat
+  let exported = 0;
+  let failed = 0;
+
+  for (let i = 0; i < chats.length; i++) {
+    const chat = chats[i];
+    const progress = `[${i + 1}/${chats.length}]`;
+    const title = chat.text || `Chat ${i + 1}`;
+
+    console.log(`${progress} ${title}`);
+    log(`  URL: ${chat.href}`);
+
+    try {
+      await navigateTo(chat.href);
+      const messages = await provider.extractMessages();
+
+      if (messages.length === 0) {
+        console.log(`  ⚠ No messages extracted, skipping`);
+        failed++;
+        continue;
+      }
+
+      log(`  ${messages.length} messages extracted`);
+
+      const filename = sanitizeFilename(title) || `chat-${i + 1}`;
+
+      if (FORMAT === "markdown" || FORMAT === "both") {
+        const md = formatAsMarkdown(title, chat.href, messages);
+        await writeFile(join(OUTPUT_DIR, `${filename}.md`), md, "utf-8");
+        log(`  Saved ${filename}.md`);
+      }
+
+      if (FORMAT === "json" || FORMAT === "both") {
+        const json = formatAsJSON(title, chat.href, messages);
+        await writeFile(join(OUTPUT_DIR, `${filename}.json`), json, "utf-8");
+        log(`  Saved ${filename}.json`);
+      }
+
+      exported++;
+    } catch (err) {
+      console.error(`  ✗ ${err.message}`);
+      failed++;
+    }
+
+    if (i < chats.length - 1) await sleep(DELAY);
+  }
+
+  console.log("\n==================");
+  console.log(`Export complete!`);
+  console.log(`  Exported: ${exported}`);
+  console.log(`  Failed:   ${failed}`);
+  console.log(`  Output:   ${OUTPUT_DIR}`);
+}
+
+main().catch((err) => {
+  console.error(`\nFatal error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "ai-chat-export",
+  "version": "1.0.0",
+  "description": "Export AI chat conversations (Gemini, ChatGPT, Copilot, DeepSeek) to Markdown and JSON. Uses AppleScript to control Chrome — no API keys needed.",
+  "type": "module",
+  "bin": {
+    "ai-chat-export": "bin/ai-chat-export.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    ".claude-plugin/",
+    "skills/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/ai-chat-export.mjs"
+  },
+  "keywords": [
+    "ai-chat-export",
+    "gemini",
+    "chatgpt",
+    "copilot",
+    "deepseek",
+    "chat-export",
+    "conversation-export",
+    "applescript",
+    "chrome",
+    "markdown"
+  ],
+  "author": "Kapil Tundwal",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ktundwal/ai-chat-export.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ktundwal/ai-chat-export/issues"
+  },
+  "homepage": "https://github.com/ktundwal/ai-chat-export#readme"
+}

package/skills/ai-chat-export/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ai-chat-export
+description: Export AI chat conversations to Markdown and/or JSON. Use when the user wants to save, export, or backup their chats from Gemini, ChatGPT, Copilot, or DeepSeek.
+argument-hint: "[--provider gemini] [--format markdown|json|both] [--output dir]"
+allowed-tools: Bash, Read
+---
+
+Export AI chat conversations from Chrome using the `ai-chat-export` CLI tool.
+
+## Prerequisites
+
+Before running, verify with the user:
+1. We're on macOS (AppleScript requirement)
+2. Google Chrome is open and signed in to the relevant AI provider
+3. Chrome > View > Developer > Allow JavaScript from Apple Events is enabled
+
+If any prerequisite is missing, guide the user through setup.
+
+## Running the Export
+
+Install and run the tool. Pass through any arguments the user provided:
+
+```bash
+npx ai-chat-export $ARGUMENTS
+```
+
+If no arguments were provided, run with defaults (exports Gemini chats):
+
+```bash
+npx ai-chat-export
+```
+
+### Available Options
+
+| Option | Short | Default | Description |
+|--------|-------|---------|-------------|
+| `--provider <name>` | `-p` | `gemini` | AI provider to export from |
+| `--output <dir>` | `-o` | `./ai-chats` | Output directory |
+| `--format <type>` | `-f` | `markdown` | `markdown`, `json`, or `both` |
+| `--delay <ms>` | `-d` | `3000` | Delay between chats in ms |
+| `--verbose` | `-v` | | Debug logging |
+| `--help` | `-h` | | Show help |
+
+### Supported Providers
+
+| Provider | Status |
+|----------|--------|
+| `gemini` | Available |
+| `chatgpt` | Coming soon |
+| `copilot` | Coming soon |
+| `deepseek` | Coming soon |
+
+## After Export
+
+Once complete, summarize:
+- Which provider was exported
+- How many chats were exported
+- Where the output files are located
+- Any failures that occurred

package/src/browser.mjs

@@ -0,0 +1,64 @@
+/**
+ * browser.mjs — AppleScript ↔ Chrome bridge
+ *
+ * Controls Google Chrome via AppleScript to execute JavaScript
+ * in the active tab. This is the core mechanism that lets us
+ * interact with Gemini using the user's real authenticated session.
+ */
+
+import { execSync } from "child_process";
+
+/**
+ * Execute JavaScript in Chrome's active tab via AppleScript.
+ * Returns the string result.
+ */
+export function chromeJS(js) {
+  const escaped = js.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const script = `tell application "Google Chrome" to execute active tab of front window javascript "${escaped}"`;
+  try {
+    const result = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, {
+      encoding: "utf-8",
+      timeout: 30000,
+      maxBuffer: 50 * 1024 * 1024,
+    });
+    return result.trim();
+  } catch (err) {
+    if (process.env.GEMINI_VERBOSE) {
+      console.error(`  JS execution error: ${err.message.slice(0, 200)}`);
+    }
+    return "";
+  }
+}
+
+/**
+ * Navigate Chrome's active tab to a URL and wait for it to load.
+ */
+export async function navigateTo(url) {
+  const escaped = url.replace(/"/g, '\\"');
+  execSync(
+    `osascript -e 'tell application "Google Chrome" to set URL of active tab of front window to "${escaped}"'`,
+    { encoding: "utf-8", timeout: 10000 }
+  );
+  await sleep(3000);
+  for (let i = 0; i < 10; i++) {
+    const loading = chromeJS("document.readyState");
+    if (loading === "complete") break;
+    await sleep(1000);
+  }
+  await sleep(2000);
+}
+
+/**
+ * Check if the user is signed in to Gemini.
+ * Returns true if signed in, false otherwise.
+ */
+export function checkSignedIn() {
+  const result = chromeJS(
+    `document.querySelector('a[aria-label="Sign in"]') === null ? 'yes' : 'no'`
+  );
+  return result === "yes";
+}
+
+export function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/formatter.mjs

@@ -0,0 +1,45 @@
+/**
+ * formatter.mjs — Output formatting for exported chats
+ *
+ * Converts extracted messages into Markdown or JSON format.
+ */
+
+/**
+ * Format messages as a Markdown document.
+ *
+ * @param {string} title - Chat title
+ * @param {string} url - Original Gemini URL
+ * @param {Array<{role: string, content: string}>} messages
+ * @returns {string} Markdown content
+ */
+export function formatAsMarkdown(title, url, messages) {
+  let md = `# ${title}\n\n`;
+  for (const msg of messages) {
+    if (!msg.content) continue;
+    md += `## ${msg.role}\n\n${msg.content}\n\n---\n\n`;
+  }
+  return md;
+}
+
+/**
+ * Format messages as a JSON document.
+ *
+ * @param {string} title - Chat title
+ * @param {string} url - Original Gemini URL
+ * @param {Array<{role: string, content: string}>} messages
+ * @returns {string} Pretty-printed JSON
+ */
+export function formatAsJSON(title, url, messages) {
+  return JSON.stringify(
+    {
+      title,
+      url,
+      exportedAt: new Date().toISOString(),
+      messages: messages
+        .filter((m) => m.content)
+        .map(({ role, content }) => ({ role, content })),
+    },
+    null,
+    2
+  );
+}

package/src/providers/gemini.mjs

@@ -0,0 +1,254 @@
+/**
+ * gemini.mjs — Google Gemini provider
+ *
+ * Implements chat discovery and message extraction for gemini.google.com.
+ * Uses AppleScript to control Chrome via the shared browser bridge.
+ */
+
+import { chromeJS } from "../browser.mjs";
+import { sleep } from "../browser.mjs";
+
+export const name = "gemini";
+export const displayName = "Google Gemini";
+export const url = "https://gemini.google.com/app";
+
+/**
+ * Check if the user is signed in to Gemini.
+ */
+export function checkSignedIn() {
+  const result = chromeJS(
+    `document.querySelector('a[aria-label="Sign in"]') === null ? 'yes' : 'no'`
+  );
+  return result === "yes";
+}
+
+/**
+ * Open the sidebar menu.
+ */
+async function ensureSidebarOpen() {
+  chromeJS(`
+    (function() {
+      const btn = document.querySelector('button[aria-label="Main menu"]');
+      if (btn) btn.click();
+    })()
+  `);
+  await sleep(2000);
+}
+
+/**
+ * Scroll the sidebar to load all lazy-loaded conversations.
+ * Gemini only renders chats as you scroll.
+ */
+async function scrollSidebarToLoadAll({ verbose = false } = {}) {
+  if (verbose) console.log("Scrolling sidebar to load all conversations...");
+
+  let stableRounds = 0;
+  for (let i = 0; i < 100; i++) {
+    const countBefore = chromeJS(
+      `document.querySelectorAll('a[href*="/app/"]').length`
+    );
+
+    chromeJS(`
+      (function() {
+        const candidates = [
+          document.querySelector('side-navigation-content'),
+          document.querySelector('bard-sidenav'),
+          document.querySelector('[role="navigation"]'),
+          document.querySelector('.side-nav-container'),
+          document.querySelector('mat-sidenav'),
+        ];
+        for (const el of candidates) {
+          if (el && el.scrollHeight > el.clientHeight) {
+            el.scrollTop = el.scrollHeight;
+            return;
+          }
+        }
+        const container = document.querySelector('bard-sidenav-container');
+        if (container) {
+          for (const child of container.querySelectorAll('*')) {
+            if (child.scrollHeight > child.clientHeight + 10) {
+              child.scrollTop = child.scrollHeight;
+              return;
+            }
+          }
+        }
+      })()
+    `);
+    await sleep(1500);
+
+    const countAfter = chromeJS(
+      `document.querySelectorAll('a[href*="/app/"]').length`
+    );
+
+    if (countAfter === countBefore) {
+      stableRounds++;
+      if (stableRounds >= 5) {
+        if (verbose) console.log(`  Sidebar fully loaded — ${countAfter} links found`);
+        break;
+      }
+    } else {
+      stableRounds = 0;
+      if (verbose) console.log(`  Scrolling... ${countAfter} links so far`);
+    }
+  }
+}
+
+/**
+ * Collect all chat links from the sidebar.
+ * Filters out non-chat links and deduplicates.
+ *
+ * @returns {Promise<Array<{href: string, text: string}>>}
+ */
+export async function collectChats({ verbose = false } = {}) {
+  await ensureSidebarOpen();
+  await scrollSidebarToLoadAll({ verbose });
+
+  const linksJSON = chromeJS(`
+    JSON.stringify(
+      Array.from(document.querySelectorAll('a[href*="/app/"]'))
+        .map(a => ({ href: a.href, text: (a.textContent || '').trim().split('\\n')[0].trim() }))
+        .filter(l =>
+          !l.href.endsWith('/app') &&
+          !l.href.endsWith('/app/') &&
+          !l.href.includes('/download') &&
+          !l.href.includes('/settings') &&
+          !l.href.includes('/extensions') &&
+          !l.href.includes('accounts.google.com')
+        )
+    )
+  `);
+
+  try {
+    const links = JSON.parse(linksJSON);
+    const seen = new Set();
+    return links.filter((l) => {
+      if (seen.has(l.href)) return false;
+      seen.add(l.href);
+      return true;
+    });
+  } catch {
+    console.error("Failed to parse chat links from sidebar");
+    return [];
+  }
+}
+
+/**
+ * Extract messages from the currently loaded chat page.
+ * Tries 4 strategies in order — Gemini's DOM changes over time.
+ *
+ * @returns {Promise<Array<{role: string, content: string}>>}
+ */
+export async function extractMessages() {
+  await sleep(2000);
+
+  // Scroll conversation to load all messages
+  chromeJS(`
+    (function() {
+      const main = document.querySelector('.conversation-container') ||
+                   document.querySelector('main') ||
+                   document.scrollingElement;
+      if (main) {
+        let lastH = 0;
+        function scrollDown() {
+          main.scrollTop = main.scrollHeight;
+          if (main.scrollHeight !== lastH) {
+            lastH = main.scrollHeight;
+            setTimeout(scrollDown, 500);
+          } else {
+            main.scrollTop = 0;
+          }
+        }
+        scrollDown();
+      }
+    })()
+  `);
+  await sleep(3000);
+
+  const messagesJSON = chromeJS(`
+    JSON.stringify((function() {
+      const results = [];
+
+      // Strategy 1: Custom elements (user-query / model-response)
+      const turns = document.querySelectorAll(
+        'user-query, model-response, .conversation-turn, [class*="turn-container"]'
+      );
+      if (turns.length > 0) {
+        for (const turn of turns) {
+          const tag = turn.tagName.toLowerCase();
+          const isUser = tag === 'user-query' ||
+            turn.classList.contains('user-turn') ||
+            turn.querySelector('[class*="user"]') !== null;
+          const text = turn.innerText?.trim();
+          if (text && text.length > 1) {
+            results.push({ role: isUser ? 'User' : 'Gemini', content: text });
+          }
+        }
+        if (results.length > 0) return results;
+      }
+
+      // Strategy 2: Query text + response container patterns
+      const queryEls = document.querySelectorAll(
+        '.query-text, [class*="query-content"], [class*="user-query"], user-query'
+      );
+      const responseEls = document.querySelectorAll(
+        '.response-container, .model-response-text, [class*="model-response"], model-response, message-content'
+      );
+      if (queryEls.length > 0 || responseEls.length > 0) {
+        const allTurns = [];
+        queryEls.forEach(el => allTurns.push({
+          role: 'User', content: el.innerText?.trim(),
+          y: el.getBoundingClientRect().top
+        }));
+        responseEls.forEach(el => allTurns.push({
+          role: 'Gemini', content: el.innerText?.trim(),
+          y: el.getBoundingClientRect().top
+        }));
+        allTurns.sort((a, b) => a.y - b.y);
+        const cleaned = allTurns
+          .filter(t => t.content && t.content.length > 1)
+          .map(({role, content}) => ({role, content}));
+        if (cleaned.length > 0) return cleaned;
+      }
+
+      // Strategy 3: data-message-author-role attributes
+      const dataEls = document.querySelectorAll('[data-message-author-role]');
+      if (dataEls.length > 0) {
+        for (const el of dataEls) {
+          const role = el.getAttribute('data-message-author-role');
+          const text = el.innerText?.trim();
+          if (text) results.push({ role: role === 'user' ? 'User' : 'Gemini', content: text });
+        }
+        if (results.length > 0) return results;
+      }
+
+      // Strategy 4: Conversation container children
+      const container = document.querySelector('.conversation-container') ||
+        document.querySelector('[class*="conversation"]') ||
+        document.querySelector('main');
+      if (container) {
+        const children = Array.from(container.children);
+        for (let i = 0; i < children.length; i++) {
+          const el = children[i];
+          const text = el.innerText?.trim();
+          if (!text || text.length < 2) continue;
+          const cls = (el.className || '') + ' ' + (el.tagName || '');
+          const isUser = /user|query|human|prompt|request/i.test(cls);
+          results.push({ role: isUser ? 'User' : 'Gemini', content: text });
+        }
+        if (results.length > 0) return results;
+
+        // Last resort: grab all text
+        const text = container.innerText?.trim();
+        if (text) return [{ role: 'Unknown', content: text }];
+      }
+
+      return results;
+    })())
+  `);
+
+  try {
+    return JSON.parse(messagesJSON);
+  } catch {
+    return [];
+  }
+}

package/src/providers/index.mjs

@@ -0,0 +1,33 @@
+/**
+ * providers/index.mjs — Provider registry
+ *
+ * Each provider exports: { name, displayName, url, checkSignedIn, collectChats, extractMessages }
+ */
+
+import * as gemini from "./gemini.mjs";
+
+const providers = {
+  gemini,
+};
+
+/**
+ * Get a provider by name.
+ * @param {string} name
+ * @returns {object} provider module
+ */
+export function getProvider(name) {
+  const provider = providers[name];
+  if (!provider) {
+    const available = Object.keys(providers).join(", ");
+    throw new Error(`Unknown provider "${name}". Available: ${available}`);
+  }
+  return provider;
+}
+
+/**
+ * List all available provider names.
+ * @returns {string[]}
+ */
+export function listProviders() {
+  return Object.keys(providers);
+}