context-shuttle-mcp 0.0.1

package/README.md

@@ -0,0 +1,103 @@
+# Context Shuttle MCP Server
+
+这是 **Context Shuttle** 系统的 MCP 服务端组件。它充当 Chrome 插件 / Desktop 应用与 AI IDE (Cursor/Gemini) 之间的桥梁。
+
+## 🚀 快速开始
+
+### 方式一：使用 npx（推荐）
+
+无需安装，直接运行：
+
+```bash
+npx -y context-shuttle-mcp
+```
+
+### 方式二：Smithery (Claude Desktop 推荐)
+
+如果你使用 Claude Desktop，可以通过 Smithery 自动安装和配置：
+
+```bash
+npx -y @smithery/cli install context-shuttle-mcp --client claude
+```
+
+### 方式二：全局安装
+
+```bash
+npm install -g context-shuttle-mcp
+context-shuttle-mcp
+```
+
+### 方式三：从源码运行
+
+```bash
+git clone https://github.com/julyCodeGo/context-shuttle.git
+cd context-shuttle/mcp-server
+npm install
+node index.js
+```
+
+## ⚙️ 在 AI IDE 中配置
+
+### Cursor / Windsurf 配置
+
+编辑 `~/.cursor/mcp.json` 或 `~/.codeium/windsurf/mcp_config.json`：
+
+```json
+{
+  "mcpServers": {
+    "context-shuttle": {
+      "command": "npx",
+      "args": ["-y", "context-shuttle-mcp"]
+    }
+  }
+}
+```
+
+### Gemini 配置
+
+在 Settings -> Features -> MCP 中添加：
+- **Type**: `command`
+- **Name**: `context-shuttle`
+- **Command**: `npx -y context-shuttle-mcp`
+
+## 核心职责
+
+1.  **HTTP 服务器 (Express)**:
+    *   监听 `http://localhost:3333`
+    *   接收来自 Chrome 插件或 Desktop 应用的 POST 请求 (`/api/sync`)
+    *   将 Base64 图片数据写入本地临时文件系统
+    *   维护一个基于文件的 JSON 队列 (`queue.json`)
+
+2.  **MCP 服务器 (Model Context Protocol)**:
+    *   通过标准输入输出 (Stdio) 与 AI IDE 通信
+    *   提供 `get_context_queue` 工具，供 AI 读取当前采集到的上下文信息
+    *   提供 `list_history_batches` 工具，查看历史批次
+    *   提供 `read_batch` 工具，读取指定批次的完整内容
+
+## API 接口
+
+### `GET /api/status`
+检查服务是否存活，返回当前队列状态。
+
+### `POST /api/sync`
+接收从浏览器或桌面端采集的数据批次。
+
+**请求体示例**:
+```json
+{
+  "batch_title": "登录页 Bug",
+  "batch_notes": "按钮颜色不对",
+  "items": [
+    {
+      "type": "image",
+      "base64": "data:image/png;base64,...",
+      "url": "http://...",
+      "title": "Page Title"
+    }
+  ]
+}
+```
+
+## 许可证
+
+MIT License

package/index.js

@@ -0,0 +1,730 @@
+#!/usr/bin/env node
+const express = require('express');
+const cors = require('cors');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { v4: uuidv4 } = require('uuid');
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+
+// --- Configuration ---
+// --- Configuration ---
+const PORT = 3333;
+const TMP_DIR = path.join(os.tmpdir(), 'mcp_kopiki_captures');
+const QUEUE_FILE = path.join(TMP_DIR, 'queue.json');
+const BATCHES_DIR = path.join(TMP_DIR, 'batches');
+const ASSETS_DIR = path.join(TMP_DIR, 'assets');
+
+// --- Initialization ---
+fs.ensureDirSync(TMP_DIR);
+fs.ensureDirSync(BATCHES_DIR);
+fs.ensureDirSync(ASSETS_DIR);
+
+if (!fs.existsSync(QUEUE_FILE)) {
+    fs.writeJsonSync(QUEUE_FILE, []); // Stores list of Batch IDs
+}
+console.error(`[MCP Server] Root Dir: ${TMP_DIR}`);
+console.error(`[MCP Server] Batches Dir: ${BATCHES_DIR}`);
+
+// --- In-Memory Cache ---
+let queueCache = [];
+
+function loadQueueFromCache() {
+    try {
+        if (fs.existsSync(QUEUE_FILE)) {
+            return fs.readJsonSync(QUEUE_FILE);
+        }
+    } catch (e) {
+        console.error('[MCP Server] Failed to load queue from disk:', e);
+    }
+    return [];
+}
+
+// Initialize Cache
+queueCache = loadQueueFromCache();
+
+// --- Initial Cleanup ---
+// Moved here to ensure queueCache is initialized
+cleanupData();
+
+// --- Helper Functions ---
+function getQueue() {
+    return queueCache;
+}
+
+function saveQueue(queue) {
+    queueCache = queue;
+    try {
+        fs.writeJsonSync(QUEUE_FILE, queue);
+    } catch (e) {
+        console.error('[MCP Server] Failed to save queue to disk:', e);
+    }
+}
+
+function saveBatch(batch) {
+    const filepath = path.join(BATCHES_DIR, `batch_${batch.id}.json`);
+    fs.writeJsonSync(filepath, batch);
+    return filepath;
+}
+
+function getBatch(batchId) {
+    try {
+        const filepath = path.join(BATCHES_DIR, `batch_${batchId}.json`);
+        if (fs.existsSync(filepath)) {
+            return fs.readJsonSync(filepath);
+        }
+    } catch (e) {
+        console.error(`[MCP Server] Failed to load batch ${batchId}:`, e);
+    }
+    return null;
+}
+
+function getAllBatches() {
+    try {
+        const files = fs.readdirSync(BATCHES_DIR).filter(f => f.endsWith('.json'));
+        // Sort by time (newest first), assuming filename format batch_{id}.json isn't enough, 
+        // we might need to read content or rely on file stats. 
+        // For simplicity, we'll read them to get timestamps.
+        const batches = files.map(f => {
+            try {
+                return fs.readJsonSync(path.join(BATCHES_DIR, f));
+            } catch (e) { return null; }
+        }).filter(b => b !== null);
+
+        return batches.sort((a, b) => b.created_at - a.created_at);
+    } catch (e) {
+        return [];
+    }
+}
+
+function cleanupData() {
+    console.error('[MCP Server] Running cleanup (Policy: Delete processed & >24h old)...');
+    const queue = getQueue();
+    const now = Date.now();
+    const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+    let queueChanged = false;
+    const newQueue = [...queue];
+
+    try {
+        if (!fs.existsSync(BATCHES_DIR)) return;
+
+        const files = fs.readdirSync(BATCHES_DIR).filter(f => f.endsWith('.json'));
+
+        for (const file of files) {
+            const filepath = path.join(BATCHES_DIR, file);
+            let batch = null;
+            try {
+                batch = fs.readJsonSync(filepath);
+            } catch (e) {
+                // Corrupt file, delete it
+                try { fs.unlinkSync(filepath); } catch (e) { }
+                continue;
+            }
+
+            const isQueued = queue.includes(batch.id);
+            const isExpired = (now - batch.created_at) > ONE_DAY_MS;
+
+            // Delete if:
+            // 1. Not in queue (already processed)
+            // 2. OR Expired (older than 24h)
+            if (!isQueued || isExpired) {
+                // Delete associated images
+                const contexts = batch.contexts || [{ items: batch.items || [] }];
+                for (const context of contexts) {
+                    if (context.items) {
+                        for (const item of context.items) {
+                            if (item.type === 'image' && item.filepath) {
+                                try {
+                                    if (fs.existsSync(item.filepath)) {
+                                        fs.unlinkSync(item.filepath);
+                                    }
+                                } catch (e) {
+                                    // Ignore missing images
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Delete batch file
+                try {
+                    fs.unlinkSync(filepath);
+                    console.error(`[MCP Server] Deleted batch: ${batch.title} (ID: ${batch.id}). Reason: ${isExpired ? 'Expired' : 'Already Processed'}`);
+                } catch (e) {
+                    console.error(`[MCP Server] Failed to delete batch file ${filepath}:`, e);
+                }
+
+                // If it was queued but expired, remove from queue
+                if (isQueued && isExpired) {
+                    const idx = newQueue.indexOf(batch.id);
+                    if (idx > -1) {
+                        newQueue.splice(idx, 1);
+                        queueChanged = true;
+                    }
+                }
+            }
+        }
+
+        if (queueChanged) {
+            saveQueue(newQueue);
+        }
+
+    } catch (e) {
+        console.error('[MCP Server] Error during cleanup:', e);
+    }
+}
+
+// --- Express App (HTTP Server) ---
+const app = express();
+
+// Middleware
+app.use(cors()); // Allow all origins for now
+app.use(express.json({ limit: '50mb' })); // Support large payloads (images)
+
+// Routes
+app.get('/api/status', (req, res) => {
+    const queue = getQueue();
+    res.json({
+        status: 'running',
+        port: PORT,
+        version: '1.0.0',
+        queue_length: queue.length,
+        tools: [
+            { name: "get_context_queue", description: "获取最新未处理的采集内容。" },
+            { name: "list_history_batches", description: "列出所有历史采集批次。" },
+            { name: "read_batch", description: "读取指定历史批次的完整内容。" },
+            { name: "read_local_file", description: "读取扩展引用的本地文件。" },
+            { name: "clear_context_queue", description: "手动清空待处理队列。" }
+        ],
+        prompts: [
+            { name: "organize_requirements", description: "将采集的需求整理为结构化的 Markdown 规范文档。" },
+            { name: "analyze_bugs", description: "分析采集的 Bug 报告并制定修复计划。" }
+        ]
+    });
+});
+
+app.post('/api/sync', async (req, res) => {
+    try {
+        // Run cleanup before processing new data
+        cleanupData();
+
+        // v1.0: Extract batch info (supports both contexts and items)
+        const { contexts, items, batch_id, batch_title, batch_notes, intent } = req.body;
+
+        const batchId = batch_id || uuidv4();
+        const now = Date.now();
+        let processedCount = 0;
+        let finalContexts = [];
+
+        if (contexts && Array.isArray(contexts)) {
+            // --- New Path: Context-based ---
+            for (const ctx of contexts) {
+                // Ensure metadata
+                if (!ctx.metadata) ctx.metadata = {};
+                ctx.source_id = uuidv4();
+
+                // Process items
+                if (ctx.items && Array.isArray(ctx.items)) {
+                    for (const item of ctx.items) {
+                        item.id = uuidv4(); // Assign ID
+
+                        if (item.type === 'image' && item.base64) {
+                            // Save image to disk
+                            const buffer = Buffer.from(item.base64.replace(/^data:image\/\w+;base64,/, ""), 'base64');
+                            const filename = `capture_${now}_${item.id}.png`;
+                            const filepath = path.join(ASSETS_DIR, filename);
+
+                            await fs.writeFile(filepath, buffer);
+
+                            item.uri = `file://${filepath}`;
+                            item.filepath = filepath;
+                            delete item.base64; // Remove base64 to save space
+                        }
+                        processedCount++;
+                    }
+                }
+            }
+            finalContexts = contexts;
+
+        } else if (items && Array.isArray(items)) {
+            // --- Legacy Path: Flat Items (Auto-Group) ---
+            const contextsMap = {};
+
+            for (const item of items) {
+                const itemId = uuidv4();
+                const url = item.url || 'unknown';
+
+                // Create Context if not exists
+                if (!contextsMap[url]) {
+                    contextsMap[url] = {
+                        source_id: uuidv4(),
+                        metadata: {
+                            url: item.url,
+                            title: item.title,
+                            fixVersion: item.fixVersion
+                        },
+                        items: []
+                    };
+                }
+
+                const batchItem = {
+                    id: itemId,
+                    type: item.type,
+                    notes: item.notes || '',
+                };
+
+                if (item.type === 'image' && item.base64) {
+                    const buffer = Buffer.from(item.base64.replace(/^data:image\/\w+;base64,/, ""), 'base64');
+                    const filename = `capture_${now}_${itemId}.png`;
+                    const filepath = path.join(ASSETS_DIR, filename);
+
+                    await fs.writeFile(filepath, buffer);
+
+                    batchItem.uri = `file://${filepath}`;
+                    batchItem.filepath = filepath;
+                } else if (item.type === 'text') {
+                    batchItem.content = item.content;
+                }
+
+                contextsMap[url].items.push(batchItem);
+                processedCount++;
+            }
+            finalContexts = Object.values(contextsMap);
+        } else {
+            return res.status(400).json({ error: 'Invalid format: must provide contexts or items' });
+        }
+
+        const newBatch = {
+            id: batchId,
+            title: batch_title || 'Untitled Batch',
+            notes: batch_notes || '',
+            intent: intent || 'requirement',
+            created_at: now,
+            contexts: finalContexts // New Structure
+        };
+
+        // 1. Save Batch to Disk (Persistence)
+        saveBatch(newBatch);
+
+        // 2. Add Batch ID to Queue (for immediate consumption)
+        const currentQueue = getQueue();
+        if (!currentQueue.includes(batchId)) {
+            currentQueue.push(batchId);
+            saveQueue(currentQueue);
+        }
+
+        console.error(`[MCP Server] Saved Batch '${newBatch.title}' (${processedCount} items in ${finalContexts.length} contexts). Queue size: ${currentQueue.length}`);
+        res.json({ status: 'success', processed_count: processedCount, message: 'Batch saved and queued' });
+
+    } catch (error) {
+        console.error('[MCP Server] Error processing sync:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+app.post('/api/clear', (req, res) => {
+    saveQueue([]); // Only clears the queue, not the batches!
+    console.error('[MCP Server] Queue cleared via HTTP (Batches remain on disk)');
+    res.json({ status: 'success', message: 'Queue cleared' });
+});
+
+// Start HTTP Server
+const httpServer = app.listen(PORT, () => {
+    console.error(`[MCP Server] HTTP Server listening on port ${PORT}`);
+});
+
+// Fix for "frequently disconnects" (ECONNRESET) issue
+// Node.js default keepAliveTimeout is 5s, which often races with Chrome's usage of Keep-Alive connections.
+// We increase it to 60s to ensure the server doesn't close the connection while Chrome might try to reuse it.
+httpServer.keepAliveTimeout = 60000;
+httpServer.headersTimeout = 61000;
+
+httpServer.on('error', (e) => {
+    if (e.code === 'EADDRINUSE') {
+        console.error(`[MCP Server] Port ${PORT} is already in use.`);
+    } else {
+        console.error('[MCP Server] HTTP Server error:', e);
+    }
+});
+
+
+// --- MCP Server (Stdio) ---
+const server = new Server(
+    {
+        name: "context-shuttle",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+            prompts: {},
+        },
+    }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "get_context_queue",
+                description: "Retrieve the *latest unprocessed* captured items from the Chrome extension. Use this to get what the user just sent you. Reading this will remove items from the 'pending' queue, but they are saved in history.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "list_history_batches",
+                description: "List all historical batches of captured data. Use this to see what the user has captured in the past.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "read_batch",
+                description: "Read the full content of a specific historical batch.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        batchId: { type: "string", description: "The ID of the batch to read" }
+                    },
+                    required: ["batchId"]
+                },
+            },
+            {
+                name: "read_local_file",
+                description: "Read a local file referenced by the Chrome extension. The file path should be provided in the captured items' metadata.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "Absolute path to the local file to read"
+                        }
+                    },
+                    required: ["filePath"]
+                },
+            },
+            {
+                name: "clear_context_queue",
+                description: "Clear the pending queue manually.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+        prompts: [
+            {
+                name: "organize_requirements",
+                description: "Compile captured requirements into a structured Markdown specification document.",
+            },
+            {
+                name: "analyze_bugs",
+                description: "Analyze captured bug reports and prepare a fix plan.",
+            }
+        ]
+    };
+});
+
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const promptName = request.params.name;
+
+    if (promptName === "organize_requirements") {
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: "Please retrieve the latest captured context using `get_context_queue`. Identify items that are Requirements. Format them into a clean Markdown document titled 'Requirement Specification'. For each item, list:\n1. Title\n2. Source URL\n3. Fix Version\n4. Detailed Description (from content/notes)\n5. Attached Images (if any)."
+                    }
+                }
+            ]
+        };
+    }
+
+    if (promptName === "analyze_bugs") {
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: "Please retrieve the latest captured context using `get_context_queue`. Identify items that are Bugs. For each bug, generate a 'Bug Analysis' section containing:\n1. Bug Title & URL\n2. Fix Version\n3. Reproduction Steps (parsed from content)\n4. Visual Analysis (if images are present)\n5. Suggested Fix Approach (based on your knowledge of the codebase)."
+                    }
+                }
+            ]
+        };
+    }
+
+
+
+    throw new Error("Prompt not found");
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    switch (request.params.name) {
+        case "get_context_queue": {
+            const queueIds = getQueue();
+            const content = [];
+
+            if (queueIds.length === 0) {
+                return {
+                    content: [{ type: "text", text: "The context queue is empty." }],
+                };
+            }
+
+            // Load Batches
+            for (const batchId of queueIds) {
+                const batch = getBatch(batchId);
+                if (!batch) continue;
+
+                // Render Batch
+                let batchHeader = `\n=== BATCH: ${batch.title} (ID: ${batch.id}) ===\n`;
+                batchHeader += `Intent: ${batch.intent || 'requirement'}\n`;
+                if (batch.notes) batchHeader += `Batch Notes: ${batch.notes}\n`;
+                batchHeader += `Time: ${new Date(batch.created_at).toLocaleString()}\n`;
+                batchHeader += `--------------------------------------------------\n`;
+
+                content.push({ type: "text", text: batchHeader });
+
+                // Handle both old (flat) and new (grouped) structures
+                const contexts = batch.contexts || [{ metadata: {}, items: batch.items || [] }];
+
+                for (const context of contexts) {
+                    if (batch.contexts) {
+                        // Only render context header if it's the new structure
+                        let contextHeader = `\n### Source: ${context.metadata.title || 'Unknown'}\n`;
+                        if (context.metadata.url) contextHeader += `URL: ${context.metadata.url}\n`;
+                        if (context.metadata.fixVersion) contextHeader += `Fix Version: ${context.metadata.fixVersion}\n`;
+                        contextHeader += `\n`;
+                        content.push({ type: "text", text: contextHeader });
+                    }
+
+                    for (const item of context.items) {
+                        let itemHeader = `- [${item.type}]`;
+                        if (item.notes) itemHeader += ` Notes: ${item.notes}`;
+                        itemHeader += `\n`;
+
+                        // For old structure compatibility
+                        if (!batch.contexts && item.metadata) {
+                            if (item.metadata.title) itemHeader += `  Source: ${item.metadata.title}\n`;
+                            if (item.metadata.url) itemHeader += `  URL: ${item.metadata.url}\n`;
+                        }
+
+                        content.push({ type: "text", text: itemHeader });
+
+                        if (item.type === 'image' && item.filepath) {
+                            try {
+                                content.push({
+                                    type: "image",
+                                    data: fs.readFileSync(item.filepath).toString('base64'),
+                                    mimeType: "image/png"
+                                });
+                            } catch (e) {
+                                content.push({ type: "text", text: `  [Error loading image: ${e.message}]\n` });
+                            }
+                        } else if (item.type === 'text') {
+                            content.push({ type: "text", text: `  Content:\n${item.content}\n` });
+                        }
+
+                        content.push({ type: "text", text: "\n" });
+                    }
+                }
+                content.push({ type: "text", text: "==================================================\n\n" });
+            }
+
+            // Auto-Clear Queue (but keep files!)
+            saveQueue([]);
+            console.error(`[MCP Server] Queue processed and cleared. (${queueIds.length} batches archived)`);
+
+            return { content };
+        }
+
+        case "list_history_batches": {
+            const batches = getAllBatches();
+            let text = "Here are the historical batches:\n\n";
+            batches.forEach(b => {
+                let itemCount = 0;
+                if (b.contexts) {
+                    itemCount = b.contexts.reduce((acc, ctx) => acc + (ctx.items ? ctx.items.length : 0), 0);
+                } else if (b.items) {
+                    itemCount = b.items.length;
+                }
+                text += `- [${new Date(b.created_at).toLocaleString()}] **${b.title}** (ID: \`${b.id}\`) - ${itemCount} items\n`;
+                if (b.notes) text += `  Notes: ${b.notes}\n`;
+            });
+            return { content: [{ type: "text", text }] };
+        }
+
+        case "read_batch": {
+            const { batchId } = request.params.arguments;
+            const batch = getBatch(batchId);
+            if (!batch) {
+                return { content: [{ type: "text", text: `Batch not found: ${batchId}` }] };
+            }
+
+            // Reuse rendering logic? For simplicity, just JSON dump or simple text for now.
+            // Better to reuse the rendering logic from get_context_queue but without clearing.
+            // Let's do a simple render here.
+            const content = [];
+            content.push({ type: "text", text: `Reading Batch: ${batch.title}\n\n` });
+
+            // Handle both old (flat) and new (grouped) structures
+            const contexts = batch.contexts || [{ metadata: {}, items: batch.items || [] }];
+
+            for (const context of contexts) {
+                if (batch.contexts) {
+                    let contextHeader = `\n### Source: ${context.metadata.title || 'Unknown'}\n`;
+                    if (context.metadata.url) contextHeader += `URL: ${context.metadata.url}\n`;
+                    content.push({ type: "text", text: contextHeader });
+                }
+
+                for (const item of context.items) {
+                    let itemText = `--- Item (${item.type}) ---\n`;
+                    if (item.notes) itemText += `Notes: ${item.notes}\n`;
+                    if (item.content) itemText += `Content: ${item.content.substring(0, 200)}...\n`;
+
+                    // Old structure compatibility
+                    if (!batch.contexts && item.metadata) {
+                        if (item.metadata.title) itemText += `Title: ${item.metadata.title}\n`;
+                    }
+
+                    content.push({ type: "text", text: itemText });
+
+                    if (item.type === 'image' && item.filepath) {
+                        try {
+                            content.push({
+                                type: "image",
+                                data: fs.readFileSync(item.filepath).toString('base64'),
+                                mimeType: "image/png"
+                            });
+                        } catch (e) { }
+                    }
+                }
+            }
+
+            return { content };
+        }
+
+        case "clear_context_queue": {
+            saveQueue([]);
+            return {
+                content: [{ type: "text", text: `Queue cleared.` }],
+            };
+        }
+
+        case "read_local_file": {
+            const { filePath } = request.params.arguments;
+
+            try {
+                // 安全检查:确保文件存在
+                if (!fs.existsSync(filePath)) {
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `❌ 文件不存在: ${filePath}`
+                        }]
+                    };
+                }
+
+                const stats = fs.statSync(filePath);
+                const ext = path.extname(filePath).toLowerCase();
+                const fileName = path.basename(filePath);
+
+                // 图片文件
+                const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'];
+                if (imageExts.includes(ext)) {
+                    const buffer = fs.readFileSync(filePath);
+                    const base64 = buffer.toString('base64');
+                    const mimeType = ext === '.jpg' || ext === '.jpeg' ? 'image/jpeg' :
+                        ext === '.png' ? 'image/png' :
+                            ext === '.gif' ? 'image/gif' :
+                                ext === '.webp' ? 'image/webp' : 'image/png';
+
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `📷 读取图片文件: ${fileName}\n文件大小: ${(stats.size / 1024).toFixed(2)} KB\n修改时间: ${stats.mtime.toLocaleString()}\n\n`
+                            },
+                            {
+                                type: "image",
+                                data: base64,
+                                mimeType: mimeType
+                            }
+                        ]
+                    };
+                }
+
+                // 文本文件
+                const textExts = ['.txt', '.md', '.json', '.js', '.ts', '.html', '.css', '.xml', '.log', '.csv'];
+                if (textExts.includes(ext) || stats.size < 1024 * 1024) { // 小于 1MB 尝试作为文本读取
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📄 读取文本文件: ${fileName}\n文件大小: ${(stats.size / 1024).toFixed(2)} KB\n修改时间: ${stats.mtime.toLocaleString()}\n\n--- 文件内容 ---\n${content}\n--- 结束 ---`
+                            }]
+                        };
+                    } catch (e) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `⚠️ 文件可能不是文本格式或编码不支持: ${fileName}`
+                            }]
+                        };
+                    }
+                }
+
+                // 其他文件类型
+                return {
+                    content: [{
+                        type: "text",
+                        text: `ℹ️ 文件信息: ${fileName}\n类型: ${ext || '未知'}\n大小: ${(stats.size / 1024).toFixed(2)} KB\n修改时间: ${stats.mtime.toLocaleString()}\n\n⚠️ 该文件类型暂不支持直接读取。`
+                    }]
+                };
+
+            } catch (error) {
+                console.error(`[MCP Server] Error reading local file ${filePath}:`, error);
+                return {
+                    content: [{
+                        type: "text",
+                        text: `❌ 读取文件失败: ${error.message}`
+                    }]
+                };
+            }
+        }
+
+        default:
+            throw new Error("Unknown tool");
+    }
+});
+
+// Start MCP Server
+async function runMcp() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[MCP Server] MCP Server connected via Stdio");
+}
+
+runMcp().catch((error) => {
+    console.error("[MCP Server] Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "context-shuttle-mcp",
+  "version": "0.0.1",
+  "description": "MCP Server for Context Shuttle - Bridge between browser extension and AI IDE (Cursor/Gemini)",
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "smithery.yaml"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.js",
+  "bin": {
+    "context-shuttle-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "mcp",
+    "context-shuttle",
+    "ai",
+    "cursor",
+    "gemini",
+    "chrome-extension",
+    "model-context-protocol"
+  ],
+  "author": "Context Shuttle Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/julyCodeGo/context-shuttle.git"
+  },
+  "homepage": "https://contextshuttle.com",
+  "bugs": {
+    "url": "https://github.com/julyCodeGo/context-shuttle/issues"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.22.0",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "fs-extra": "^11.3.2",
+    "uuid": "^13.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/smithery.yaml

@@ -0,0 +1,7 @@
+startCommand:
+  type: stdio
+  command: node
+  args:
+    - index.js
+
+docUrl: https://github.com/julyCodeGo/context-shuttle/blob/main/mcp-server/README.md