@djrcx/raindrop-mcp 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# Raindrop MCP Server
+
+Search and retrieve your curated bookmarks from [Raindrop.io](https://raindrop.io) directly in your AI-powered IDE (Antigravity, Cursor, VS Code, etc.).
+
+## Features
+
+- 🔍 Search your bookmarked tools, components, and resources
+- 📋 List all bookmarks in a collection
+- 📦 **New:** `search_bookmark_components` - Search UI/component libraries in your bookmarks for specific components and return deep links directly.
+- 🎨 **New:** `extract_design_system` - Fetch any URL (or bookmark) and parse CSS variables, custom colors, fonts, and layout metadata to automatically map out its design system.
+- 🌧️ Auto-updates when you add new bookmarks via browser extension
+- 🔐 Secure credential storage
+- 🚀 Works cross-platform (Linux, macOS, Windows)
+- ⚡ Automatic IDE configuration
+
+## Tools
+
+### 1. `search_raindrop`
+Search bookmarks in your Raindrop collection.
+* **Arguments:** `query` (string)
+
+### 2. `list_raindrop`
+List all bookmarks in your Raindrop collection.
+* **Arguments:** None
+
+### 3. `search_bookmark_components`
+Deep search matching component keywords (like "navbar", "carousel") inside your bookmarked UI libraries.
+* **Arguments:**
+  * `query` (string): The UI component name to find.
+  * `collectionId` (string, optional): Raindrop collection ID (defaults to configured collection). Use `"0"` to search all collections.
+
+### 4. `extract_design_system`
+Extract colors, custom variables, fonts, and structural layout indicators from a website URL.
+* **Arguments:**
+  * `url` (string): The URL of the website to analyze.
+
+## Quick Start
+
+### 1. Install and Setup (Automatic)
+
+```bash
+npx raindrop-mcp-setup
+```
+

package/dist/config.js

@@ -0,0 +1,75 @@
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { fileURLToPath } from "url";
+// Get package name dynamically from package.json
+export let packageName = "raindrop-mcp";
+try {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(currentDir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    packageName = pkg.name || packageName;
+}
+catch { }
+const CONFIG_DIR = join(homedir(), ".raindrop-mcp");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const data = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export function getConfig() {
+    // Priority: 1. Env vars, 2. Config file
+    const token = process.env.RAINDROP_TOKEN;
+    const collectionId = process.env.RAINDROP_COLLECTION_ID;
+    if (token) {
+        return { token, collectionId: collectionId || "0" };
+    }
+    const config = loadConfig();
+    if (!config) {
+        console.error("❌ No configuration found.");
+        console.error("Run: npx raindrop-mcp-setup");
+        process.exit(1);
+    }
+    return config;
+}
+// Generate Antigravity-specific format
+export function generateAntigravityRaindropConfig() {
+    const config = getConfig();
+    return {
+        "$typeName": "exa.cascade_plugins_pb.CascadePluginCommandTemplate",
+        "command": "npx",
+        "args": ["-y", packageName],
+        "env": {
+            "RAINDROP_TOKEN": config.token,
+            "RAINDROP_COLLECTION_ID": config.collectionId,
+        },
+    };
+}
+// Generate standard MCP format (for Cursor, VS Code, etc.)
+export function generateStandardRaindropConfig() {
+    const config = getConfig();
+    return {
+        command: "npx",
+        args: ["-y", packageName],
+        env: {
+            RAINDROP_TOKEN: config.token,
+            RAINDROP_COLLECTION_ID: config.collectionId,
+        },
+    };
+}

package/dist/index.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as cheerio from "cheerio";
+import { getConfig } from "./config.js";
+const config = getConfig();
+const API_BASE = "https://api.raindrop.io/rest/v1";
+const server = new McpServer({
+    name: "Raindrop MCP",
+    version: "1.0.0",
+});
+async function fetchRaindrop(endpoint) {
+    const res = await fetch(`${API_BASE}${endpoint}`, {
+        headers: { Authorization: `Bearer ${config.token}` },
+    });
+    if (!res.ok) {
+        let errMsg = res.statusText;
+        try {
+            const errJson = await res.json();
+            errMsg = errJson.errorMessage || errJson.message || JSON.stringify(errJson);
+        }
+        catch {
+            try {
+                const text = await res.text();
+                if (text)
+                    errMsg = text;
+            }
+            catch { }
+        }
+        throw new Error(`Raindrop API error (${res.status}): ${errMsg}`);
+    }
+    return res.json();
+}
+async function postRaindrop(endpoint, body) {
+    const res = await fetch(`${API_BASE}${endpoint}`, {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${config.token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        let errMsg = res.statusText;
+        try {
+            const errJson = await res.json();
+            errMsg = errJson.errorMessage || errJson.message || JSON.stringify(errJson);
+        }
+        catch {
+            try {
+                const text = await res.text();
+                if (text)
+                    errMsg = text;
+            }
+            catch { }
+        }
+        throw new Error(`Raindrop API error (${res.status}): ${errMsg}`);
+    }
+    return res.json();
+}
+async function fetchWithTimeout(url, timeoutMs = 5000) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(id);
+        if (!res.ok)
+            throw new Error(`HTTP error: ${res.status} ${res.statusText}`);
+        return await res.text();
+    }
+    catch (err) {
+        clearTimeout(id);
+        throw err;
+    }
+}
+// 1. search_bookmarks (Full original schema implementation)
+server.tool("search_bookmarks", "Search bookmarks from Raindrop.io", {
+    search: z.string().describe("The search query"),
+    collection_id: z.number().optional().default(0).describe("The collection ID to filter bookmarks, 0 for all, -1 for unsorted, -99 for trash, others for specific collection"),
+    page: z.number().optional().default(0).describe("The page number"),
+    perpage: z.number().optional().default(50).describe("The number of bookmarks per page"),
+    sort: z.enum(["-created", "created"]).optional().describe("Sort bookmarks"),
+}, async ({ search, collection_id, page, perpage, sort }) => {
+    try {
+        const activeCollection = collection_id !== undefined ? collection_id : parseInt(config.collectionId, 10);
+        let endpoint = `/raindrops/${activeCollection}?search=${encodeURIComponent(search)}&perpage=${perpage}&page=${page}`;
+        if (sort) {
+            endpoint += `&sort=${sort}`;
+        }
+        const data = await fetchRaindrop(endpoint);
+        if (!data.items || data.items.length === 0) {
+            return { content: [{ type: "text", text: "No bookmarks found for that query." }] };
+        }
+        const formatted = data.items
+            .map((item) => `### ${item.title}\n` +
+            `- **URL:** ${item.link}\n` +
+            `- **Tags:** ${item.tags.join(", ") || "None"}\n` +
+            `- **Excerpt:** ${item.excerpt || "No description."}\n`)
+            .join("\n---\n");
+        return {
+            content: [{ type: "text", text: `Found ${data.items.length} bookmarks:\n\n${formatted}` }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+});
+// 2. create_bookmarks (Full original schema implementation)
+server.tool("create_bookmarks", "Create bookmarks on Raindrop.io", {
+    items: z.array(z.object({
+        link: z.string().url().describe("The URL of this bookmark"),
+        title: z.string().optional().describe("The bookmark title"),
+        excerpt: z.string().optional().describe("The excerpt"),
+    })).describe("The bookmarks to create"),
+}, async ({ items }) => {
+    try {
+        const collectionIdNum = parseInt(config.collectionId, 10) || 0;
+        const body = {
+            items: items.map((item) => {
+                const itemBody = {
+                    link: item.link,
+                    collection: {
+                        $id: collectionIdNum,
+                    },
+                    pleaseParse: {}, // Tell Raindrop to crawl title/excerpt/cover if empty
+                };
+                if (item.title)
+                    itemBody.title = item.title;
+                if (item.excerpt)
+                    itemBody.excerpt = item.excerpt;
+                return itemBody;
+            }),
+        };
+        const res = await postRaindrop("/raindrops", body);
+        if (!res.items || res.items.length === 0) {
+            return { content: [{ type: "text", text: "Failed to create bookmarks." }] };
+        }
+        const formatted = res.items
+            .map((item) => `- **${item.title || item.link}** (${item.link})`)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: `✅ Created ${res.items.length} bookmark(s) successfully:\n\n${formatted}` }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error creating bookmarks: ${error.message}` }] };
+    }
+});
+// 3. get_collections (Full original schema implementation)
+server.tool("get_collections", "Get collections from Raindrop.io", {}, async () => {
+    try {
+        const data = await fetchRaindrop("/collections");
+        if (!data.items || data.items.length === 0) {
+            return { content: [{ type: "text", text: "No collections found." }] };
+        }
+        const formatted = data.items
+            .map((item) => `- **${item.title}** (ID: \`${item._id}\`, Count: ${item.count})`)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: `Found ${data.items.length} collections:\n\n${formatted}` }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+});
+// 4. search_raindrop (Legacy alias support)
+server.tool("search_raindrop", "Search bookmarks in your Raindrop collection. Use this to find curated tools, resources, and references.", { query: z.string().describe("Search term (searches title, description, tags, URL)") }, async ({ query }) => {
+    try {
+        const data = await fetchRaindrop(`/raindrops/${config.collectionId}?search=${encodeURIComponent(query)}&perpage=10`);
+        if (!data.items || data.items.length === 0) {
+            return { content: [{ type: "text", text: "No bookmarks found for that query." }] };
+        }
+        const formatted = data.items
+            .map((item) => `### ${item.title}\n` +
+            `- **URL:** ${item.link}\n` +
+            `- **Tags:** ${item.tags.join(", ") || "None"}\n` +
+            `- **Excerpt:** ${item.excerpt || "No description."}\n`)
+            .join("\n---\n");
+        return {
+            content: [{ type: "text", text: `Found ${data.items.length} bookmarks:\n\n${formatted}` }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+});
+// 5. list_raindrop (Legacy support)
+server.tool("list_raindrop", "List all bookmarks in your Raindrop collection.", {}, async () => {
+    try {
+        const data = await fetchRaindrop(`/raindrops/${config.collectionId}?perpage=50`);
+        const formatted = data.items
+            .map((item) => `- **${item.title}** (${item.tags.join(", ") || "untagged"}): ${item.link}`)
+            .join("\n");
+        return { content: [{ type: "text", text: `Bookmarks:\n${formatted}` }] };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+});
+// 6. extract_design_system
+server.tool("extract_design_system", "Extract the design system (colors, typography, CSS variables, and layout patterns) from a bookmarked URL or any website.", { url: z.string().url().describe("The URL of the website to analyze") }, async ({ url }) => {
+    try {
+        const html = await fetchWithTimeout(url, 6000);
+        const $ = cheerio.load(html);
+        const designSystem = {
+            title: $("title").text().trim() || url,
+            fonts: [],
+            cssVariables: {},
+            colors: [],
+            tailwindDetected: false,
+            layoutElements: [],
+        };
+        // Detect Google Fonts or other font imports
+        $('link[href*="fonts.googleapis.com"], link[href*="fonts.gstatic.com"]').each((_, el) => {
+            const href = $(el).attr("href");
+            if (href)
+                designSystem.fonts.push(href);
+        });
+        // Detect Tailwind CSS
+        $('link[href*="tailwind"], script[src*="tailwind"]').each((_, el) => {
+            designSystem.tailwindDetected = true;
+        });
+        if (html.includes("tailwindcss") || html.includes("tailwind.config")) {
+            designSystem.tailwindDetected = true;
+        }
+        // Check common layout structures
+        const layoutTags = ["nav", "header", "footer", "main", "aside", "section"];
+        layoutTags.forEach(tag => {
+            if ($(tag).length > 0) {
+                designSystem.layoutElements.push(`${tag} (${$(tag).length} instances)`);
+            }
+        });
+        // Extract inline style variables and style tag content
+        let cssText = "";
+        $("style").each((_, el) => {
+            cssText += $(el).text() + "\n";
+        });
+        $("[style]").each((_, el) => {
+            cssText += $(el).attr("style") + "\n";
+        });
+        // Fetch external stylesheets (max 2 to avoid blocking/timeouts)
+        const stylesheetUrls = [];
+        $('link[rel="stylesheet"]').each((_, el) => {
+            const href = $(el).attr("href");
+            if (href && stylesheetUrls.length < 2) {
+                try {
+                    stylesheetUrls.push(new URL(href, url).toString());
+                }
+                catch { }
+            }
+        });
+        for (const sheetUrl of stylesheetUrls) {
+            try {
+                if (!sheetUrl.includes("font-awesome") && !sheetUrl.includes("bootstrap")) {
+                    const sheetText = await fetchWithTimeout(sheetUrl, 3000);
+                    cssText += sheetText + "\n";
+                }
+            }
+            catch (e) {
+                // Continue silently
+            }
+        }
+        // Parse CSS Variables
+        const varRegex = /(--[\w-]+)\s*:\s*([^;}]+)/g;
+        let match;
+        while ((match = varRegex.exec(cssText)) !== null) {
+            const key = match[1].trim();
+            const value = match[2].trim();
+            if (Object.keys(designSystem.cssVariables).length < 60) {
+                designSystem.cssVariables[key] = value;
+            }
+        }
+        // Parse colors (hex, rgb, hsl)
+        const hexRegex = /#([0-9a-fA-F]{3,8})\b/g;
+        const rgbRegex = /rgb\([^)]+\)/g;
+        const hslRegex = /hsl\([^)]+\)/g;
+        const foundColors = new Set();
+        let colMatch;
+        while ((colMatch = hexRegex.exec(cssText)) !== null) {
+            foundColors.add(colMatch[0]);
+            if (foundColors.size >= 25)
+                break;
+        }
+        if (foundColors.size < 25) {
+            while ((colMatch = rgbRegex.exec(cssText)) !== null) {
+                foundColors.add(colMatch[0]);
+                if (foundColors.size >= 25)
+                    break;
+            }
+        }
+        if (foundColors.size < 25) {
+            while ((colMatch = hslRegex.exec(cssText)) !== null) {
+                foundColors.add(colMatch[0]);
+                if (foundColors.size >= 25)
+                    break;
+            }
+        }
+        designSystem.colors = Array.from(foundColors);
+        let md = `## Design System for: [${designSystem.title}](${url})\n\n`;
+        md += `### 🎨 Color Palette (Extracted Colors)\n`;
+        if (designSystem.colors.length > 0) {
+            md += designSystem.colors.map((c) => `- \`${c}\``).join("\n") + "\n\n";
+        }
+        else {
+            md += `- None directly identified.\n\n`;
+        }
+        md += `### ⚙️ CSS Custom Variables\n`;
+        const variableEntries = Object.entries(designSystem.cssVariables);
+        if (variableEntries.length > 0) {
+            md += variableEntries.map(([k, v]) => `- \`${k}\`: \`${v}\``).join("\n") + "\n\n";
+        }
+        else {
+            md += `- No CSS variables found.\n\n`;
+        }
+        md += `### 🅰️ Typography & Fonts\n`;
+        if (designSystem.fonts.length > 0) {
+            md += designSystem.fonts.map((f) => `- Google Fonts/external font import: [Font Link](${f})`).join("\n") + "\n\n";
+        }
+        else {
+            md += `- No external font libraries detected. Standard system fonts or custom @font-face are likely used.\n\n`;
+        }
+        md += `### 📐 Layout & Frameworks\n`;
+        md += `- **Tailwind CSS Detected:** ${designSystem.tailwindDetected ? "Yes" : "No"}\n`;
+        if (designSystem.layoutElements.length > 0) {
+            md += `- **Semantic Elements:**\n` + designSystem.layoutElements.map((el) => `  - ${el}`).join("\n") + "\n";
+        }
+        return {
+            content: [{ type: "text", text: md }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error extracting design system from ${url}: ${error.message}` }] };
+    }
+});
+// 7. search_bookmark_components
+server.tool("search_bookmark_components", "Search UI/component libraries in your bookmarks for specific components and return direct links.", {
+    query: z.string().describe("The component to search for (e.g. 'navbar', 'hero', 'carousel')"),
+    collectionId: z.string().optional().describe("Raindrop collection ID (defaults to configured collection)"),
+}, async ({ query, collectionId }) => {
+    try {
+        const activeCollection = collectionId || config.collectionId;
+        const data = await fetchRaindrop(`/raindrops/${activeCollection}?perpage=50`);
+        if (data.items.length === 0) {
+            return { content: [{ type: "text", text: "No bookmarks found to search components in." }] };
+        }
+        const results = [];
+        // Filter bookmarks that look like UI/component libraries
+        const targets = data.items.filter((item) => {
+            const title = item.title.toLowerCase();
+            const excerpt = (item.excerpt || "").toLowerCase();
+            const tags = item.tags.map((t) => t.toLowerCase());
+            const link = item.link.toLowerCase();
+            return (title.includes("ui") ||
+                title.includes("component") ||
+                title.includes("library") ||
+                title.includes("kit") ||
+                title.includes("template") ||
+                excerpt.includes("ui") ||
+                excerpt.includes("component") ||
+                tags.includes("ui") ||
+                tags.includes("components") ||
+                tags.includes("ui-library") ||
+                link.includes("ui") ||
+                link.includes("component"));
+        });
+        const itemsToSearch = targets.length > 0 ? targets : data.items.slice(0, 5);
+        const fetchPromises = itemsToSearch.slice(0, 8).map(async (item) => {
+            try {
+                const html = await fetchWithTimeout(item.link, 4500);
+                const $ = cheerio.load(html);
+                const matches = [];
+                $("a").each((_, el) => {
+                    const href = $(el).attr("href");
+                    const text = $(el).text().trim().toLowerCase();
+                    if (href && (text.includes(query.toLowerCase()) || href.toLowerCase().includes(query.toLowerCase()))) {
+                        try {
+                            const absoluteUrl = new URL(href, item.link).toString();
+                            if (!matches.some(m => m.href === absoluteUrl)) {
+                                matches.push({ text: $(el).text().trim() || href, href: absoluteUrl });
+                            }
+                        }
+                        catch { }
+                    }
+                });
+                return {
+                    title: item.title,
+                    baseUrl: item.link,
+                    matches: matches.slice(0, 8),
+                };
+            }
+            catch (e) {
+                return {
+                    title: item.title,
+                    baseUrl: item.link,
+                    matches: [],
+                    error: e.message,
+                };
+            }
+        });
+        const fetchResults = await Promise.all(fetchPromises);
+        let output = `## Component Matches for "${query}" in Bookmarked Libraries:\n\n`;
+        let foundAny = false;
+        for (const res of fetchResults) {
+            if (res.matches.length > 0) {
+                foundAny = true;
+                output += `### 📁 [${res.title}](${res.baseUrl})\n`;
+                res.matches.forEach((m) => {
+                    output += `- [${m.text}](${m.href})\n`;
+                });
+                output += "\n";
+            }
+        }
+        if (!foundAny) {
+            output += `No specific component links matching "${query}" were found on the homepages of the following searched libraries:\n`;
+            itemsToSearch.forEach((item) => {
+                output += `- [${item.title}](${item.link})\n`;
+            });
+        }
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: `Error searching component bookmarks: ${error.message}` }] };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`✅ Raindrop MCP running (collection: ${config.collectionId})`);
+}
+main().catch((error) => {
+    console.error("Fatal:", error);
+    process.exit(1);
+});

package/dist/setup.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { saveConfig, generateAntigravityRaindropConfig, generateStandardRaindropConfig, packageName } from "./config.js";
+async function main() {
+    if (!process.stdin.isTTY) {
+        console.log("⚠️ Non-interactive terminal detected. Skipping automatic Raindrop MCP configuration.");
+        console.log(`You can configure it manually later by running: npx ${packageName}-setup`);
+        process.exit(0);
+    }
+    console.log(chalk.bold.cyan("\n🌧️  Raindrop MCP Setup\n"));
+    // Step 1: Get credentials
+    const answers = await inquirer.prompt([
+        {
+            type: "password",
+            name: "token",
+            message: "Enter your Raindrop API token:",
+            validate: (input) => (input.length > 0 ? true : "Token is required"),
+        },
+        {
+            type: "input",
+            name: "collectionId",
+            message: "Enter your Raindrop Collection ID (or '0' for all bookmarks):",
+            default: "0",
+            validate: (input) => (/^\d+$/.test(input) ? true : "Must be a number"),
+        },
+    ]);
+    const spinner = ora("Saving configuration...").start();
+    try {
+        // Save credentials
+        saveConfig({
+            token: answers.token,
+            collectionId: answers.collectionId,
+        });
+        spinner.succeed(chalk.green("Configuration saved to ~/.raindrop-mcp/config.json"));
+        // Step 2: Ask about auto-configuring IDE
+        const ideChoice = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "autoConfig",
+                message: "Would you like to automatically add this to your IDE's MCP config?",
+                default: true,
+            },
+            {
+                type: "list",
+                name: "ide",
+                message: "Which IDE are you using?",
+                choices: ["Antigravity", "Cursor", "VS Code", "Manual (show me the config)"],
+                when: (ans) => ans.autoConfig,
+            },
+        ]);
+        if (ideChoice.autoConfig && ideChoice.ide !== "Manual (show me the config)") {
+            const configPath = await getConfigPath(ideChoice.ide);
+            if (configPath) {
+                const updateSpinner = ora(`Updating ${configPath}...`).start();
+                try {
+                    await updateMCPConfig(configPath, ideChoice.ide);
+                    updateSpinner.succeed(chalk.green(`✅ Updated ${configPath}`));
+                    console.log(chalk.bold.green("\n🎉 Setup complete! Restart your IDE to use Raindrop MCP.\n"));
+                }
+                catch (error) {
+                    updateSpinner.fail(chalk.red(`Failed to update config: ${error.message}`));
+                    console.log(chalk.yellow("\nYou can manually add this to your config:\n"));
+                    console.log(JSON.stringify({ raindrop: generateAntigravityRaindropConfig() }, null, 1));
+                }
+            }
+        }
+        else {
+            // Manual mode - just show the config
+            console.log(chalk.bold("\n📋 Add this to your IDE's MCP config:\n"));
+            console.log(chalk.gray("─".repeat(60)));
+            console.log(JSON.stringify({ raindrop: generateStandardRaindropConfig() }, null, 2));
+            console.log(chalk.gray("─".repeat(60)));
+            console.log(chalk.bold.green("\n✅ Setup complete!\n"));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Setup failed"));
+        console.error(error);
+        process.exit(1);
+    }
+}
+async function getConfigPath(ide) {
+    const commonPaths = {
+        Antigravity: [
+            join(homedir(), ".gemini", "config", "mcp_config.json"),
+            join(homedir(), ".config", "antigravity", "mcp_config.json"),
+            join(homedir(), ".antigravity", "mcp_config.json"),
+            join(homedir(), "Library", "Application Support", "Antigravity", "mcp_config.json"),
+        ],
+        Cursor: [
+            join(homedir(), ".config", "Cursor", "User", "globalStorage", "mcp.json"),
+            join(homedir(), ".cursor", "mcp.json"),
+        ],
+        "VS Code": [
+            join(homedir(), ".config", "Code", "User", "globalStorage", "mcp.json"),
+        ],
+    };
+    const paths = commonPaths[ide] || [];
+    for (const path of paths) {
+        if (existsSync(path)) {
+            const { usePath } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "usePath",
+                    message: `Found config at ${path}. Use this?`,
+                    default: true,
+                },
+            ]);
+            if (usePath)
+                return path;
+        }
+    }
+    const { customPath } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "customPath",
+            message: `Enter the path to your ${ide} MCP config file:`,
+            validate: (input) => (input ? true : "Path is required"),
+        },
+    ]);
+    return customPath;
+}
+async function updateMCPConfig(configPath, ide) {
+    let config = {};
+    // Read existing config if it exists
+    if (existsSync(configPath)) {
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            config = JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse existing config: ${error}`);
+        }
+    }
+    // Find the mcpServers key (with or without trailing space)
+    const mcpServersKey = Object.keys(config).find((key) => key.trim() === "mcpServers") || "mcpServers ";
+    if (!config[mcpServersKey]) {
+        config[mcpServersKey] = {};
+    }
+    // Add raindrop config in the appropriate format
+    if (ide === "Antigravity") {
+        config[mcpServersKey]["raindrop "] = generateAntigravityRaindropConfig();
+    }
+    else {
+        config[mcpServersKey]["raindrop"] = generateStandardRaindropConfig();
+    }
+    // Write back with proper formatting
+    writeFileSync(configPath, JSON.stringify(config, null, 1));
+}
+main().catch((error) => {
+    console.error(chalk.red("Fatal error:"), error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@djrcx/raindrop-mcp",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "MCP server to search Raindrop.io bookmarks from AI IDEs",
+  "type": "module",
+  "bin": {
+    "raindrop-mcp": "dist/index.js",
+    "raindrop-mcp-setup": "dist/setup.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js && chmod +x dist/setup.js",
+    "start": "node dist/index.js",
+    "setup": "node dist/setup.js",
+    "postinstall": "node dist/setup.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "raindrop",
+    "bookmarks",
+    "ai",
+    "cursor",
+    "vscode",
+    "antigravity"
+  ],
+  "author": "djrcx",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "chalk": "^5.3.0",
+    "cheerio": "^1.2.0",
+    "inquirer": "^9.2.15",
+    "ora": "^8.0.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.12.7",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}