readdit-later-mcp 1.0.0

package/bin/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { execSync } from 'child_process';
+
+const args = process.argv.slice(2);
+
+if (args[0] === 'setup') {
+  setup();
+} else {
+  // Default: run the MCP server
+  await import('../src/index.js');
+}
+
+function setup() {
+  console.log('\n  Readdit Later MCP — Setup\n');
+
+  const configs = getConfigPaths();
+  let configured = false;
+
+  for (const { name, path, key } of configs) {
+    if (!path) continue;
+
+    try {
+      const dir = join(path, '..');
+      if (!existsSync(dir)) continue;
+
+      if (!existsSync(path)) writeFileSync(path, '{}');
+
+      const raw = readFileSync(path, 'utf8');
+      const config = JSON.parse(raw || '{}');
+
+      if (!config.mcpServers) config.mcpServers = {};
+
+      if (config.mcpServers['readdit-later']) {
+        console.log(`  ✓ ${name} — already configured`);
+        configured = true;
+        continue;
+      }
+
+      // Find npx path
+      const npxCmd = platform() === 'win32' ? 'npx.cmd' : 'npx';
+      let npxPath;
+      try {
+        npxPath = execSync(`${platform() === 'win32' ? 'where' : 'which'} npx`, { encoding: 'utf8' }).trim().split('\n')[0].trim();
+      } catch {
+        npxPath = npxCmd;
+      }
+
+      config.mcpServers['readdit-later'] = {
+        command: npxPath,
+        args: ['readdit-later-mcp']
+      };
+
+      writeFileSync(path, JSON.stringify(config, null, 2));
+      console.log(`  ✓ ${name} — configured at ${path}`);
+      configured = true;
+    } catch (err) {
+      console.log(`  ✗ ${name} — failed: ${err.message}`);
+    }
+  }
+
+  if (!configured) {
+    console.log('  No AI tool config files found. Add this manually:\n');
+    printManualConfig();
+  }
+
+  console.log('\n  Next steps:');
+  console.log('  1. Restart your AI tool (Claude Desktop, Cursor, etc.)');
+  console.log('  2. Open Chrome — the Readdit Later extension connects automatically');
+  console.log('  3. Ask Claude: "Search my saved Reddit posts about TypeScript"\n');
+}
+
+function getConfigPaths() {
+  const home = homedir();
+  const p = platform();
+
+  let claudeDir;
+  if (p === 'win32') claudeDir = join(process.env.APPDATA || '', 'Claude');
+  else if (p === 'darwin') claudeDir = join(home, 'Library', 'Application Support', 'Claude');
+  else claudeDir = join(home, '.config', 'Claude');
+
+  return [
+    { name: 'Claude Desktop', path: join(claudeDir, 'claude_desktop_config.json'), key: 'mcpServers' },
+    { name: 'Cursor', path: join(home, '.cursor', 'mcp.json'), key: 'mcpServers' },
+    { name: 'Windsurf', path: join(home, '.windsurf', 'mcp.json'), key: 'mcpServers' }
+  ];
+}
+
+function printManualConfig() {
+  console.log(`    {
+      "mcpServers": {
+        "readdit-later": {
+          "command": "npx",
+          "args": ["readdit-later-mcp"]
+        }
+      }
+    }`);
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "readdit-later-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Readdit Later — manage your Reddit saves from Claude, Cursor, and other AI tools",
+  "type": "module",
+  "bin": {
+    "readdit-later-mcp": "./bin/cli.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "ws": "^8.18.0"
+  },
+  "keywords": ["mcp", "readdit-later", "reddit", "bookmarks", "claude", "cursor"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/bridge.js

@@ -0,0 +1,135 @@
+import { WebSocketServer } from 'ws';
+
+const PORT = 52849;
+const COMMAND_TIMEOUT = 15000;
+
+export class Bridge {
+  constructor(store) {
+    this.store = store;
+    this.wss = null;
+    this.extension = null;
+    this.pendingCommands = new Map();
+    this._commandId = 0;
+  }
+
+  start() {
+    this.wss = new WebSocketServer({ port: PORT, host: '127.0.0.1' });
+
+    this.wss.on('connection', (ws) => {
+      this.extension = ws;
+      this._log('Extension connected');
+
+      ws.on('message', (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          this._handleMessage(msg);
+        } catch {
+          // Ignore malformed messages
+        }
+      });
+
+      ws.on('close', () => {
+        this._log('Extension disconnected');
+        this.extension = null;
+        this._rejectAllPending('Extension disconnected');
+      });
+
+      ws.on('error', () => {
+        this.extension = null;
+        this._rejectAllPending('Extension connection error');
+      });
+
+      this._send({ type: 'request_sync' });
+    });
+
+    this.wss.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        this._log(`Port ${PORT} in use — another instance may be running`);
+      }
+    });
+
+    this._log(`Bridge listening on ws://127.0.0.1:${PORT}`);
+  }
+
+  get isConnected() {
+    return this.extension !== null && this.extension.readyState === 1;
+  }
+
+  async sendCommand(action, params) {
+    if (!this.isConnected) {
+      throw new Error('Extension not connected. Open Chrome with Readdit Later installed.');
+    }
+
+    const id = String(++this._commandId);
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCommands.delete(id);
+        reject(new Error('Command timed out — extension did not respond'));
+      }, COMMAND_TIMEOUT);
+
+      this.pendingCommands.set(id, { resolve, reject, timer });
+      this._send({ type: 'command', id, action, params });
+    });
+  }
+
+  _handleMessage(msg) {
+    switch (msg.type) {
+      case 'sync':
+        this.store.sync(msg.posts, msg.collections);
+        this._log(`Synced ${this.store.posts.length} posts, ${this.store.collections.length} collections`);
+        break;
+
+      case 'post_updated':
+        if (msg.post) this.store.updatePost(msg.post);
+        break;
+
+      case 'post_deleted':
+        if (msg.postId) this.store.removePost(msg.postId);
+        break;
+
+      case 'collections_updated':
+        if (msg.collections) this.store.updateCollections(msg.collections);
+        break;
+
+      case 'command_result': {
+        const pending = this.pendingCommands.get(msg.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingCommands.delete(msg.id);
+          if (msg.success) {
+            pending.resolve(msg.data);
+          } else {
+            pending.reject(new Error(msg.error || 'Command failed'));
+          }
+        }
+        break;
+      }
+
+      case 'pong':
+        break;
+    }
+  }
+
+  _send(msg) {
+    if (this.isConnected) {
+      this.extension.send(JSON.stringify(msg));
+    }
+  }
+
+  _rejectAllPending(reason) {
+    for (const [id, { reject, timer }] of this.pendingCommands) {
+      clearTimeout(timer);
+      reject(new Error(reason));
+    }
+    this.pendingCommands.clear();
+  }
+
+  _log(msg) {
+    process.stderr.write(`[readdit-mcp] ${msg}\n`);
+  }
+
+  stop() {
+    if (this.wss) this.wss.close();
+  }
+}

package/src/index.js

@@ -0,0 +1,22 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Store } from './store.js';
+import { Bridge } from './bridge.js';
+import { registerTools } from './tools.js';
+
+const store = new Store();
+const bridge = new Bridge(store);
+
+const server = new McpServer({
+  name: 'readdit-later',
+  version: '1.0.0'
+});
+
+registerTools(server, store, bridge);
+
+bridge.start();
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+
+process.stderr.write('[readdit-mcp] MCP server running — waiting for extension connection\n');

package/src/store.js

@@ -0,0 +1,206 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DATA_DIR = join(homedir(), '.readdit-later');
+const DATA_FILE = join(DATA_DIR, 'data.json');
+
+export class Store {
+  constructor() {
+    this.posts = [];
+    this.collections = [];
+    this.postIndex = new Map();
+    this.lastSyncTime = null;
+    this._load();
+  }
+
+  _load() {
+    try {
+      if (existsSync(DATA_FILE)) {
+        const raw = readFileSync(DATA_FILE, 'utf8');
+        const data = JSON.parse(raw);
+        this.posts = data.posts || [];
+        this.collections = data.collections || [];
+        this.lastSyncTime = data.lastSyncTime || null;
+        this._rebuildIndex();
+      }
+    } catch {
+      // Start fresh if file is corrupt
+    }
+  }
+
+  _save() {
+    try {
+      if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+      writeFileSync(DATA_FILE, JSON.stringify({
+        posts: this.posts,
+        collections: this.collections,
+        lastSyncTime: this.lastSyncTime
+      }));
+    } catch {
+      // Non-critical — data will be re-synced from extension
+    }
+  }
+
+  _rebuildIndex() {
+    this.postIndex.clear();
+    for (const post of this.posts) {
+      this.postIndex.set(post.id, post);
+    }
+  }
+
+  sync(posts, collections) {
+    this.posts = posts || [];
+    this.collections = collections || [];
+    this.lastSyncTime = new Date().toISOString();
+    this._rebuildIndex();
+    this._save();
+  }
+
+  updatePost(post) {
+    const idx = this.posts.findIndex(p => p.id === post.id);
+    if (idx !== -1) {
+      this.posts[idx] = { ...this.posts[idx], ...post };
+      this.postIndex.set(post.id, this.posts[idx]);
+    } else {
+      this.posts.push(post);
+      this.postIndex.set(post.id, post);
+    }
+    this._save();
+  }
+
+  removePost(postId) {
+    this.posts = this.posts.filter(p => p.id !== postId);
+    this.postIndex.delete(postId);
+    this._save();
+  }
+
+  getPost(id) {
+    return this.postIndex.get(id) || null;
+  }
+
+  searchPosts({ query, subreddit, tag, content_type, read_status, author, min_score, min_comments, time_filter, item_type, sort_by, limit }) {
+    let results = [...this.posts];
+
+    if (query) {
+      const q = query.toLowerCase();
+      const terms = q.split(/\s+/);
+      results = results.filter(p => {
+        const text = `${p.title || ''} ${p.subreddit || ''} ${p.selftext || ''} ${p.comment_body || ''} ${p.author || ''} ${p.note || ''} ${(p.tags || p.labels || []).join(' ')} ${p.source_post_title || ''}`.toLowerCase();
+        return terms.every(t => text.includes(t));
+      });
+    }
+
+    if (subreddit) {
+      const sub = subreddit.toLowerCase().replace(/^r\//, '');
+      results = results.filter(p => (p.subreddit || '').toLowerCase() === sub);
+    }
+
+    if (tag) {
+      results = results.filter(p => {
+        const tags = p.tags || p.labels || [];
+        return tags.some(t => t.toLowerCase() === tag.toLowerCase());
+      });
+    }
+
+    if (content_type) {
+      results = results.filter(p => this._matchesType(p, content_type));
+    }
+
+    if (read_status === 'read') results = results.filter(p => p.is_read === true);
+    if (read_status === 'unread') results = results.filter(p => p.is_read !== true);
+
+    if (author) {
+      const a = author.toLowerCase().replace(/^u\//, '');
+      results = results.filter(p => (p.author || '').toLowerCase() === a);
+    }
+
+    if (min_score) results = results.filter(p => (p.score || 0) >= min_score);
+    if (min_comments) results = results.filter(p => (p.num_comments || 0) >= min_comments);
+
+    if (item_type === 'comment') results = results.filter(p => p.is_comment || p.item_type === 'comment' || p.kind === 't1');
+    if (item_type === 'post') results = results.filter(p => !p.is_comment && p.item_type !== 'comment' && p.kind !== 't1');
+
+    if (time_filter) {
+      const now = Date.now() / 1000;
+      const limits = { day: 86400, week: 604800, month: 2592000, year: 31536000 };
+      const secs = limits[time_filter];
+      if (secs) results = results.filter(p => (p.created_utc || 0) >= now - secs);
+    }
+
+    switch (sort_by) {
+      case 'oldest': results.sort((a, b) => (a.created_utc || 0) - (b.created_utc || 0)); break;
+      case 'most_upvoted': results.sort((a, b) => (b.score || 0) - (a.score || 0)); break;
+      case 'most_commented': results.sort((a, b) => (b.num_comments || 0) - (a.num_comments || 0)); break;
+      case 'alphabetical': results.sort((a, b) => (a.title || '').localeCompare(b.title || '')); break;
+      default: results.sort((a, b) => (b.created_utc || 0) - (a.created_utc || 0));
+    }
+
+    if (limit && limit > 0) results = results.slice(0, limit);
+
+    return results;
+  }
+
+  getStats() {
+    const subredditCounts = {};
+    const tagCounts = {};
+    let readCount = 0;
+    let commentCount = 0;
+
+    for (const p of this.posts) {
+      subredditCounts[p.subreddit] = (subredditCounts[p.subreddit] || 0) + 1;
+      if (p.is_read) readCount++;
+      if (p.is_comment || p.item_type === 'comment') commentCount++;
+      for (const t of (p.tags || p.labels || [])) {
+        tagCounts[t] = (tagCounts[t] || 0) + 1;
+      }
+    }
+
+    return {
+      total_posts: this.posts.length,
+      total_comments: commentCount,
+      read: readCount,
+      unread: this.posts.length - readCount,
+      subreddits: Object.keys(subredditCounts).length,
+      labels: Object.keys(tagCounts).length,
+      collections: this.collections.length,
+      last_sync: this.lastSyncTime,
+      top_subreddits: Object.entries(subredditCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count })),
+      top_labels: Object.entries(tagCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count }))
+    };
+  }
+
+  getSubreddits() {
+    const counts = {};
+    for (const p of this.posts) {
+      counts[p.subreddit] = (counts[p.subreddit] || 0) + 1;
+    }
+    return Object.entries(counts).sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
+  }
+
+  getLabels() {
+    const counts = {};
+    for (const p of this.posts) {
+      for (const t of (p.tags || p.labels || [])) {
+        counts[t] = (counts[t] || 0) + 1;
+      }
+    }
+    return Object.entries(counts).sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
+  }
+
+  updateCollections(collections) {
+    this.collections = collections || [];
+    this._save();
+  }
+
+  _matchesType(post, type) {
+    const url = post.url || '';
+    switch (type) {
+      case 'image': return /i\.redd\.it|imgur\.com|\.(jpg|jpeg|png|gif|webp)$/i.test(url);
+      case 'video': return /v\.redd\.it|youtube\.com|youtu\.be|\.(mp4|webm)$/i.test(url);
+      case 'text': return post.is_self && (post.selftext || '').trim().length > 0;
+      case 'link': return !post.is_self && !this._matchesType(post, 'image') && !this._matchesType(post, 'video');
+      default: return true;
+    }
+  }
+}

package/src/tools.js

@@ -0,0 +1,364 @@
+import { z } from 'zod';
+
+export function registerTools(server, store, bridge) {
+
+  // ── Read Tools (work from cached data) ─────────────────────────
+
+  server.tool(
+    'search_posts',
+    'Search saved Reddit posts by keyword, subreddit, tag, author, content type, read status, or date range',
+    {
+      query: z.string().optional().describe('Search keywords (matches title, body, subreddit, author, notes, labels)'),
+      subreddit: z.string().optional().describe('Filter by subreddit name (without r/ prefix)'),
+      tag: z.string().optional().describe('Filter by label/tag name'),
+      content_type: z.enum(['image', 'video', 'text', 'link']).optional().describe('Filter by post type'),
+      read_status: z.enum(['read', 'unread']).optional().describe('Filter by read/unread status'),
+      author: z.string().optional().describe('Filter by Reddit username (without u/ prefix)'),
+      item_type: z.enum(['post', 'comment']).optional().describe('Filter posts vs saved comments'),
+      min_score: z.number().optional().describe('Minimum upvote score'),
+      min_comments: z.number().optional().describe('Minimum comment count'),
+      time_filter: z.enum(['day', 'week', 'month', 'year']).optional().describe('Filter by age'),
+      sort_by: z.enum(['newest', 'oldest', 'most_upvoted', 'most_commented', 'alphabetical']).optional().describe('Sort order (default: newest)'),
+      limit: z.number().optional().describe('Max results to return')
+    },
+    async (params) => {
+      const results = store.searchPosts(params);
+      const summaries = results.map(formatPost);
+      return {
+        content: [{
+          type: 'text',
+          text: results.length === 0
+            ? 'No saved posts match that query.'
+            : `Found ${results.length} post${results.length === 1 ? '' : 's'}:\n\n${summaries.join('\n\n')}`
+        }]
+      };
+    }
+  );
+
+  server.tool(
+    'get_post',
+    'Get full details of a specific saved post by its ID',
+    { post_id: z.string().describe('The post ID') },
+    async ({ post_id }) => {
+      const post = store.getPost(post_id);
+      if (!post) return { content: [{ type: 'text', text: 'Post not found.' }] };
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            id: post.id,
+            title: post.title,
+            subreddit: post.subreddit,
+            author: post.author,
+            url: post.url,
+            score: post.score,
+            num_comments: post.num_comments,
+            content: post.selftext || post.comment_body || '',
+            labels: post.tags || post.labels || [],
+            note: post.note || '',
+            ai_summary: post.ai_summary || '',
+            is_read: post.is_read || false,
+            saved_date: post.saved_date,
+            created_utc: post.created_utc,
+            item_type: post.is_comment ? 'comment' : 'post'
+          }, null, 2)
+        }]
+      };
+    }
+  );
+
+  server.tool(
+    'get_stats',
+    'Get library statistics — total posts, subreddits, labels, read/unread counts, top subreddits and labels',
+    {},
+    async () => {
+      const stats = store.getStats();
+      return { content: [{ type: 'text', text: JSON.stringify(stats, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'list_subreddits',
+    'List all subreddits in the saved library with post counts',
+    {},
+    async () => {
+      const subs = store.getSubreddits();
+      return {
+        content: [{
+          type: 'text',
+          text: subs.length === 0
+            ? 'No subreddits found.'
+            : subs.map(s => `r/${s.name}: ${s.count} post${s.count === 1 ? '' : 's'}`).join('\n')
+        }]
+      };
+    }
+  );
+
+  server.tool(
+    'list_labels',
+    'List all labels/tags in the saved library with post counts',
+    {},
+    async () => {
+      const labels = store.getLabels();
+      return {
+        content: [{
+          type: 'text',
+          text: labels.length === 0
+            ? 'No labels found.'
+            : labels.map(l => `${l.name}: ${l.count} post${l.count === 1 ? '' : 's'}`).join('\n')
+        }]
+      };
+    }
+  );
+
+  server.tool(
+    'list_collections',
+    'List all reading collections/lists',
+    {},
+    async () => {
+      if (bridge.isConnected) {
+        try {
+          const result = await bridge.sendCommand('list_collections', {});
+          return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        } catch { /* fall through to cached */ }
+      }
+      const cols = store.collections;
+      return {
+        content: [{
+          type: 'text',
+          text: cols.length === 0
+            ? 'No collections found.'
+            : JSON.stringify(cols, null, 2)
+        }]
+      };
+    }
+  );
+
+  // ── Write Tools (require live extension connection) ────────────
+
+  server.tool(
+    'label_posts',
+    'Add a label/tag to one or more posts. Search first to get post IDs.',
+    {
+      post_ids: z.array(z.string()).describe('Array of post IDs to label'),
+      label: z.string().describe('The label to add')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'label_posts', params);
+    }
+  );
+
+  server.tool(
+    'remove_label',
+    'Remove a label/tag from one or more posts',
+    {
+      post_ids: z.array(z.string()).describe('Array of post IDs'),
+      label: z.string().describe('The label to remove')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'remove_label', params);
+    }
+  );
+
+  server.tool(
+    'mark_read',
+    'Mark one or more posts as read or unread',
+    {
+      post_ids: z.array(z.string()).describe('Array of post IDs'),
+      is_read: z.boolean().describe('true = mark as read, false = mark as unread')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'mark_read', params);
+    }
+  );
+
+  server.tool(
+    'add_note',
+    'Add a personal note to one or more posts',
+    {
+      post_ids: z.array(z.string()).describe('Array of post IDs'),
+      note: z.string().describe('The note text to attach')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'add_note', params);
+    }
+  );
+
+  server.tool(
+    'delete_posts',
+    'Delete one or more saved posts permanently',
+    {
+      post_ids: z.array(z.string()).describe('Array of post IDs to delete')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'delete_posts', params);
+    }
+  );
+
+  server.tool(
+    'create_collection',
+    'Create a new reading collection/list with selected posts',
+    {
+      name: z.string().describe('Collection name'),
+      description: z.string().optional().describe('Collection description'),
+      post_ids: z.array(z.string()).describe('Array of post IDs to include')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'create_collection', params);
+    }
+  );
+
+  server.tool(
+    'add_to_collection',
+    'Add posts to an existing collection',
+    {
+      collection_name: z.string().describe('Name of the collection'),
+      post_ids: z.array(z.string()).describe('Array of post IDs to add')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'add_to_collection', params);
+    }
+  );
+
+  server.tool(
+    'remove_from_collection',
+    'Remove posts from a collection',
+    {
+      collection_name: z.string().describe('Name of the collection'),
+      post_ids: z.array(z.string()).describe('Array of post IDs to remove')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'remove_from_collection', params);
+    }
+  );
+
+  server.tool(
+    'delete_collection',
+    'Delete a collection (posts are not deleted)',
+    {
+      collection_name: z.string().describe('Name of the collection to delete')
+    },
+    async (params) => {
+      return await execCommand(bridge, 'delete_collection', params);
+    }
+  );
+
+  server.tool(
+    'export_posts',
+    'Export posts as JSON, CSV, or Markdown',
+    {
+      post_ids: z.array(z.string()).optional().describe('Specific post IDs to export (omit for all)'),
+      format: z.enum(['json', 'csv', 'markdown']).optional().describe('Export format (default: json)')
+    },
+    async ({ post_ids, format = 'json' }) => {
+      const posts = post_ids
+        ? post_ids.map(id => store.getPost(id)).filter(Boolean)
+        : store.posts;
+
+      if (posts.length === 0) return { content: [{ type: 'text', text: 'No posts to export.' }] };
+
+      let output;
+      switch (format) {
+        case 'csv':
+          output = postsToCSV(posts);
+          break;
+        case 'markdown':
+          output = postsToMarkdown(posts);
+          break;
+        default:
+          output = JSON.stringify(posts.map(p => ({
+            id: p.id, title: p.title, subreddit: p.subreddit, author: p.author,
+            url: p.url, score: p.score, num_comments: p.num_comments,
+            labels: p.tags || p.labels || [], note: p.note || '',
+            ai_summary: p.ai_summary || '', content: p.selftext || p.comment_body || '',
+            is_read: p.is_read || false, saved_date: p.saved_date
+          })), null, 2);
+      }
+
+      return { content: [{ type: 'text', text: output }] };
+    }
+  );
+
+  server.tool(
+    'connection_status',
+    'Check if the Chrome extension is connected and synced',
+    {},
+    async () => {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            extension_connected: bridge.isConnected,
+            posts_in_cache: store.posts.length,
+            last_sync: store.lastSyncTime,
+            collections: store.collections.length
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+async function execCommand(bridge, action, params) {
+  try {
+    const result = await bridge.sendCommand(action, params);
+    return {
+      content: [{
+        type: 'text',
+        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+      }]
+    };
+  } catch (err) {
+    return {
+      content: [{ type: 'text', text: `Error: ${err.message}` }],
+      isError: true
+    };
+  }
+}
+
+function formatPost(p) {
+  const labels = (p.tags || p.labels || []);
+  const parts = [
+    `**${p.title || 'Untitled'}**`,
+    `r/${p.subreddit} · u/${p.author} · ${p.score || 0} pts · ${p.num_comments || 0} comments`,
+    `ID: ${p.id} · ${p.url || ''}`
+  ];
+  if (labels.length) parts.push(`Labels: ${labels.join(', ')}`);
+  if (p.note) parts.push(`Note: ${p.note}`);
+  if (p.ai_summary) parts.push(`Summary: ${p.ai_summary}`);
+  if (p.is_read) parts.push('(Read)');
+  return parts.join('\n');
+}
+
+function postsToCSV(posts) {
+  const esc = (v) => {
+    const s = String(v ?? '');
+    return s.includes(',') || s.includes('"') || s.includes('\n') ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  const headers = ['Title', 'URL', 'Subreddit', 'Author', 'Score', 'Comments', 'Labels', 'Note', 'AI Summary', 'Read'];
+  const rows = posts.map(p => [
+    esc(p.title), esc(p.url), esc(p.subreddit), esc(p.author),
+    p.score || 0, p.num_comments || 0,
+    esc((p.tags || p.labels || []).join('; ')), esc(p.note),
+    esc(p.ai_summary), p.is_read ? 'Yes' : 'No'
+  ].join(','));
+  return [headers.join(','), ...rows].join('\n');
+}
+
+function postsToMarkdown(posts) {
+  return posts.map(p => {
+    const labels = (p.tags || p.labels || []);
+    let md = `## ${p.title || 'Untitled'}\n\n`;
+    md += `- **Subreddit:** r/${p.subreddit}\n`;
+    md += `- **Author:** u/${p.author}\n`;
+    md += `- **Score:** ${p.score || 0} | **Comments:** ${p.num_comments || 0}\n`;
+    md += `- **URL:** ${p.url || 'N/A'}\n`;
+    if (labels.length) md += `- **Labels:** ${labels.join(', ')}\n`;
+    if (p.note) md += `- **Note:** ${p.note}\n`;
+    if (p.ai_summary) md += `- **Summary:** ${p.ai_summary}\n`;
+    if (p.selftext || p.comment_body) md += `\n${(p.selftext || p.comment_body).slice(0, 500)}\n`;
+    return md;
+  }).join('\n---\n\n');
+}