codemax-mcp 1.0.0 → 1.0.1

package/README.md

@@ -1,63 +1,63 @@
-# codemax-mcp
-
-MCP server for [ClaudeMax](https://codemax.pro) — adds **web search** and **image analysis** tools to your Claude Code session.
-
-## Installation
-
-```bash
-npm install -g codemax-mcp
-```
-
-Or use with npx (no install needed):
-
-```bash
-npx -y codemax-mcp
-```
-
-## Tools
-
-### `web_search`
-Search the web for real-time information — docs, news, APIs, anything.
-
-### `understand_image`
-Analyze images with AI — screenshots, diagrams, UI mockups, error messages.
-
-## Setup
-
-### Automatic (Recommended)
-Run the one-click setup script:
-
-**Windows (PowerShell):**
-```powershell
-Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-irm https://api.claudemax.pro/setup.ps1 | iex
-```
-
-### Manual
-Add to your `~/.claude.json`:
-
-```json
-{
-  "mcpServers": {
-    "ClaudeMax": {
-      "command": "npx",
-      "args": ["-y", "claudemax-mcp"],
-      "env": {
-        "CLAUDEMAX_API_KEY": "YOUR_API_KEY",
-        "CLAUDEMAX_URL": "https://api.claudemax.pro"
-      }
-    }
-  }
-}
-```
-
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `CLAUDEMAX_API_KEY` | Your ClaudeMax API key |
-| `CLAUDEMAX_URL` | API endpoint (default: `https://api.claudemax.pro`) |
-
-## License
-
-MIT
+# codemax-mcp
+
+MCP server for [ClaudeMax](https://codemax.pro) — adds **web search** and **image analysis** tools to your Claude Code session.
+
+## Installation
+
+```bash
+npm install -g codemax-mcp
+```
+
+Or use with npx (no install needed):
+
+```bash
+npx -y codemax-mcp
+```
+
+## Tools
+
+### `web_search`
+Search the web for real-time information — docs, news, APIs, anything.
+
+### `understand_image`
+Analyze images with AI — screenshots, diagrams, UI mockups, error messages.
+
+## Setup
+
+### Automatic (Recommended)
+Run the one-click setup script:
+
+**Windows (PowerShell):**
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+irm https://api.codemax.pro/setup.ps1 | iex
+```
+
+### Manual
+Add to your `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "ClaudeMax": {
+      "command": "npx",
+      "args": ["-y", "claudemax-mcp"],
+      "env": {
+        "CLAUDEMAX_API_KEY": "YOUR_API_KEY",
+        "CLAUDEMAX_URL": "https://api.codemax.pro"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `CLAUDEMAX_API_KEY` | Your ClaudeMax API key |
+| `CLAUDEMAX_URL` | API endpoint (default: `https://api.codemax.pro`) |
+
+## License
+
+MIT

package/index.js

@@ -1,373 +1,373 @@
-#!/usr/bin/env node
-
-/**
- * ClaudeMax MCP Server
- * 
- * Provides MCP tools for Claude Code:
- *   - web_search: Search the web for real-time information
- *   - understand_image: Analyze images with AI
- * 
- * Environment variables:
- *   CLAUDEMAX_API_KEY  — Your ClaudeMax API key
- *   CLAUDEMAX_URL      — ClaudeMax API endpoint (default: https://api.claudemax.pro)
- */
-
-const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
-const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
-const {
-    CallToolRequestSchema,
-    ListToolsRequestSchema,
-} = require("@modelcontextprotocol/sdk/types.js");
-const https = require("https");
-const http = require("http");
-const fs = require("fs");
-const path = require("path");
-
-// ─── Config ───
-const API_KEY = process.env.CLAUDEMAX_API_KEY || process.env.ANTHROPIC_API_KEY || "";
-const BASE_URL = process.env.CLAUDEMAX_URL || "https://api.claudemax.pro";
-const SERPER_URL = "https://google.serper.dev";
-
-// ─── HTTP helper ───
-function httpRequest(url, options, body) {
-    return new Promise((resolve, reject) => {
-        const parsedUrl = new URL(url);
-        const isHttps = parsedUrl.protocol === "https:";
-        const lib = isHttps ? https : http;
-
-        const req = lib.request(
-            {
-                hostname: parsedUrl.hostname,
-                port: parsedUrl.port || (isHttps ? 443 : 80),
-                path: parsedUrl.pathname + parsedUrl.search,
-                method: options.method || "GET",
-                headers: options.headers || {},
-                timeout: 30000,
-            },
-            (res) => {
-                let data = "";
-                res.on("data", (chunk) => (data += chunk));
-                res.on("end", () => {
-                    if (res.statusCode >= 200 && res.statusCode < 300) {
-                        try {
-                            resolve(JSON.parse(data));
-                        } catch {
-                            resolve(data);
-                        }
-                    } else {
-                        reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 500)}`));
-                    }
-                });
-            }
-        );
-
-        req.on("error", reject);
-        req.on("timeout", () => {
-            req.destroy();
-            reject(new Error("Request timeout"));
-        });
-
-        if (body) req.write(typeof body === "string" ? body : JSON.stringify(body));
-        req.end();
-    });
-}
-
-// ─── Web Search via ClaudeMax backend ───
-async function webSearch(query, numResults = 5) {
-    // Try to use the ClaudeMax API's search endpoint
-    // Falls back to direct Serper.dev if available
-    try {
-        const body = JSON.stringify({ q: query, num: numResults });
-
-        const result = await httpRequest(`${SERPER_URL}/search`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                // The API key is forwarded through the ClaudeMax proxy search endpoint
-                "X-API-KEY": process.env.SERPER_API_KEY || "",
-            },
-        }, body);
-
-        const results = [];
-
-        // Knowledge graph
-        if (result.knowledgeGraph) {
-            const kg = result.knowledgeGraph;
-            results.push({
-                title: kg.title || "",
-                snippet: kg.description || "",
-                url: kg.descriptionLink || "",
-                type: "knowledge_graph",
-            });
-        }
-
-        // Answer box
-        if (result.answerBox) {
-            results.push({
-                title: result.answerBox.title || "Answer",
-                snippet: result.answerBox.answer || result.answerBox.snippet || "",
-                url: result.answerBox.link || "",
-                type: "answer_box",
-            });
-        }
-
-        // Organic results
-        if (result.organic) {
-            for (const r of result.organic.slice(0, numResults)) {
-                results.push({
-                    title: r.title || "",
-                    snippet: r.snippet || "",
-                    url: r.link || "",
-                    type: "organic",
-                });
-            }
-        }
-
-        return results;
-    } catch (error) {
-        // Fallback: use ClaudeMax proxy search endpoint
-        try {
-            const result = await httpRequest(`${BASE_URL}/v1/search`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-api-key": API_KEY,
-                },
-            }, JSON.stringify({ query, numResults }));
-
-            return result.results || [];
-        } catch {
-            throw new Error(`Search failed: ${error.message}`);
-        }
-    }
-}
-
-function formatSearchResults(results) {
-    if (!results || results.length === 0) return "No search results found.";
-
-    let text = "";
-    for (let i = 0; i < results.length; i++) {
-        const r = results[i];
-        text += `[${i + 1}] ${r.title}\n`;
-        if (r.snippet) text += `${r.snippet}\n`;
-        if (r.url) text += `Source: ${r.url}\n`;
-        text += "\n";
-    }
-    return text.trim();
-}
-
-// ─── Image Analysis via ClaudeMax API ───
-async function analyzeImage(imageInput, question) {
-    let imageData;
-    let mediaType = "image/jpeg";
-
-    // Check if it's a URL or file path
-    if (imageInput.startsWith("http://") || imageInput.startsWith("https://")) {
-        // Download image from URL
-        const imageBuffer = await httpRequest(imageInput, { method: "GET" }, null);
-        if (typeof imageBuffer === "string") {
-            imageData = Buffer.from(imageBuffer, "binary").toString("base64");
-        } else {
-            imageData = Buffer.from(JSON.stringify(imageBuffer)).toString("base64");
-        }
-
-        // Detect media type from URL
-        const ext = imageInput.split(".").pop()?.toLowerCase()?.split("?")[0];
-        if (ext === "png") mediaType = "image/png";
-        else if (ext === "webp") mediaType = "image/webp";
-        else if (ext === "gif") mediaType = "image/gif";
-    } else {
-        // Read from file path
-        const filePath = path.resolve(imageInput);
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-
-        const buffer = fs.readFileSync(filePath);
-        imageData = buffer.toString("base64");
-
-        // Detect media type from extension
-        const ext = path.extname(filePath).toLowerCase();
-        if (ext === ".png") mediaType = "image/png";
-        else if (ext === ".webp") mediaType = "image/webp";
-        else if (ext === ".gif") mediaType = "image/gif";
-    }
-
-    // Send to ClaudeMax API for analysis
-    const body = {
-        model: "Opus 4.6",
-        max_tokens: 4096,
-        messages: [
-            {
-                role: "user",
-                content: [
-                    {
-                        type: "image",
-                        source: {
-                            type: "base64",
-                            media_type: mediaType,
-                            data: imageData,
-                        },
-                    },
-                    {
-                        type: "text",
-                        text: question || "Describe this image in detail. What do you see?",
-                    },
-                ],
-            },
-        ],
-    };
-
-    const result = await httpRequest(`${BASE_URL}/v1/messages`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "x-api-key": API_KEY,
-            "anthropic-version": "2023-06-01",
-        },
-    }, JSON.stringify(body));
-
-    // Extract text from response
-    if (result.content && Array.isArray(result.content)) {
-        return result.content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("\n");
-    }
-
-    return result.text || JSON.stringify(result);
-}
-
-// ─── MCP Server Setup ───
-const server = new Server(
-    {
-        name: "claudemax-mcp",
-        version: "1.0.0",
-    },
-    {
-        capabilities: {
-            tools: {},
-        },
-    }
-);
-
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                name: "web_search",
-                description:
-                    "Search the web for real-time information — documentation, news, APIs, current events, pricing, anything that requires up-to-date data from the internet.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "The search query to find information on the web",
-                        },
-                        num_results: {
-                            type: "number",
-                            description: "Number of results to return (default: 5, max: 10)",
-                        },
-                    },
-                    required: ["query"],
-                },
-            },
-            {
-                name: "understand_image",
-                description:
-                    "Analyze images with AI — screenshots, diagrams, UI mockups, error messages, charts, photos. Provide a URL or file path to the image.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        image: {
-                            type: "string",
-                            description:
-                                "URL or local file path to the image to analyze (supports JPEG, PNG, WebP, GIF)",
-                        },
-                        question: {
-                            type: "string",
-                            description:
-                                "What to analyze or ask about the image (default: general description)",
-                        },
-                    },
-                    required: ["image"],
-                },
-            },
-        ],
-    };
-});
-
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    try {
-        if (name === "web_search") {
-            const query = args.query;
-            const numResults = Math.min(args.num_results || 5, 10);
-
-            if (!query || typeof query !== "string") {
-                return {
-                    content: [{ type: "text", text: "Error: 'query' parameter is required and must be a string." }],
-                    isError: true,
-                };
-            }
-
-            const results = await webSearch(query, numResults);
-            const formatted = formatSearchResults(results);
-
-            return {
-                content: [{ type: "text", text: formatted }],
-            };
-        }
-
-        if (name === "understand_image") {
-            const image = args.image;
-            const question = args.question;
-
-            if (!image || typeof image !== "string") {
-                return {
-                    content: [{ type: "text", text: "Error: 'image' parameter is required and must be a URL or file path." }],
-                    isError: true,
-                };
-            }
-
-            if (!API_KEY) {
-                return {
-                    content: [{ type: "text", text: "Error: CLAUDEMAX_API_KEY environment variable is not set. Please run the setup script or set it manually." }],
-                    isError: true,
-                };
-            }
-
-            const analysis = await analyzeImage(image, question);
-
-            return {
-                content: [{ type: "text", text: analysis }],
-            };
-        }
-
-        return {
-            content: [{ type: "text", text: `Unknown tool: ${name}` }],
-            isError: true,
-        };
-    } catch (error) {
-        return {
-            content: [{ type: "text", text: `Error: ${error.message}` }],
-            isError: true,
-        };
-    }
-});
-
-// ─── Start Server ───
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("[ClaudeMax MCP] Server started");
-}
-
-main().catch((error) => {
-    console.error("[ClaudeMax MCP] Fatal error:", error);
-    process.exit(1);
-});
+#!/usr/bin/env node
+
+/**
+ * ClaudeMax MCP Server
+ * 
+ * Provides MCP tools for Claude Code:
+ *   - web_search: Search the web for real-time information
+ *   - understand_image: Analyze images with AI
+ * 
+ * Environment variables:
+ *   CLAUDEMAX_API_KEY  — Your ClaudeMax API key
+ *   CLAUDEMAX_URL      — ClaudeMax API endpoint (default: https://api.codemax.pro)
+ */
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} = require("@modelcontextprotocol/sdk/types.js");
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+// ─── Config ───
+const API_KEY = process.env.CLAUDEMAX_API_KEY || process.env.ANTHROPIC_API_KEY || "";
+const BASE_URL = process.env.CLAUDEMAX_URL || "https://api.codemax.pro";
+const SERPER_URL = "https://google.serper.dev";
+
+// ─── HTTP helper ───
+function httpRequest(url, options, body) {
+    return new Promise((resolve, reject) => {
+        const parsedUrl = new URL(url);
+        const isHttps = parsedUrl.protocol === "https:";
+        const lib = isHttps ? https : http;
+
+        const req = lib.request(
+            {
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port || (isHttps ? 443 : 80),
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: options.method || "GET",
+                headers: options.headers || {},
+                timeout: 30000,
+            },
+            (res) => {
+                let data = "";
+                res.on("data", (chunk) => (data += chunk));
+                res.on("end", () => {
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        try {
+                            resolve(JSON.parse(data));
+                        } catch {
+                            resolve(data);
+                        }
+                    } else {
+                        reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 500)}`));
+                    }
+                });
+            }
+        );
+
+        req.on("error", reject);
+        req.on("timeout", () => {
+            req.destroy();
+            reject(new Error("Request timeout"));
+        });
+
+        if (body) req.write(typeof body === "string" ? body : JSON.stringify(body));
+        req.end();
+    });
+}
+
+// ─── Web Search via ClaudeMax backend ───
+async function webSearch(query, numResults = 5) {
+    // Try to use the ClaudeMax API's search endpoint
+    // Falls back to direct Serper.dev if available
+    try {
+        const body = JSON.stringify({ q: query, num: numResults });
+
+        const result = await httpRequest(`${SERPER_URL}/search`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                // The API key is forwarded through the ClaudeMax proxy search endpoint
+                "X-API-KEY": process.env.SERPER_API_KEY || "",
+            },
+        }, body);
+
+        const results = [];
+
+        // Knowledge graph
+        if (result.knowledgeGraph) {
+            const kg = result.knowledgeGraph;
+            results.push({
+                title: kg.title || "",
+                snippet: kg.description || "",
+                url: kg.descriptionLink || "",
+                type: "knowledge_graph",
+            });
+        }
+
+        // Answer box
+        if (result.answerBox) {
+            results.push({
+                title: result.answerBox.title || "Answer",
+                snippet: result.answerBox.answer || result.answerBox.snippet || "",
+                url: result.answerBox.link || "",
+                type: "answer_box",
+            });
+        }
+
+        // Organic results
+        if (result.organic) {
+            for (const r of result.organic.slice(0, numResults)) {
+                results.push({
+                    title: r.title || "",
+                    snippet: r.snippet || "",
+                    url: r.link || "",
+                    type: "organic",
+                });
+            }
+        }
+
+        return results;
+    } catch (error) {
+        // Fallback: use ClaudeMax proxy search endpoint
+        try {
+            const result = await httpRequest(`${BASE_URL}/v1/search`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": API_KEY,
+                },
+            }, JSON.stringify({ query, numResults }));
+
+            return result.results || [];
+        } catch {
+            throw new Error(`Search failed: ${error.message}`);
+        }
+    }
+}
+
+function formatSearchResults(results) {
+    if (!results || results.length === 0) return "No search results found.";
+
+    let text = "";
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        text += `[${i + 1}] ${r.title}\n`;
+        if (r.snippet) text += `${r.snippet}\n`;
+        if (r.url) text += `Source: ${r.url}\n`;
+        text += "\n";
+    }
+    return text.trim();
+}
+
+// ─── Image Analysis via ClaudeMax API ───
+async function analyzeImage(imageInput, question) {
+    let imageData;
+    let mediaType = "image/jpeg";
+
+    // Check if it's a URL or file path
+    if (imageInput.startsWith("http://") || imageInput.startsWith("https://")) {
+        // Download image from URL
+        const imageBuffer = await httpRequest(imageInput, { method: "GET" }, null);
+        if (typeof imageBuffer === "string") {
+            imageData = Buffer.from(imageBuffer, "binary").toString("base64");
+        } else {
+            imageData = Buffer.from(JSON.stringify(imageBuffer)).toString("base64");
+        }
+
+        // Detect media type from URL
+        const ext = imageInput.split(".").pop()?.toLowerCase()?.split("?")[0];
+        if (ext === "png") mediaType = "image/png";
+        else if (ext === "webp") mediaType = "image/webp";
+        else if (ext === "gif") mediaType = "image/gif";
+    } else {
+        // Read from file path
+        const filePath = path.resolve(imageInput);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+
+        const buffer = fs.readFileSync(filePath);
+        imageData = buffer.toString("base64");
+
+        // Detect media type from extension
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === ".png") mediaType = "image/png";
+        else if (ext === ".webp") mediaType = "image/webp";
+        else if (ext === ".gif") mediaType = "image/gif";
+    }
+
+    // Send to ClaudeMax API for analysis
+    const body = {
+        model: "Opus 4.6",
+        max_tokens: 4096,
+        messages: [
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: mediaType,
+                            data: imageData,
+                        },
+                    },
+                    {
+                        type: "text",
+                        text: question || "Describe this image in detail. What do you see?",
+                    },
+                ],
+            },
+        ],
+    };
+
+    const result = await httpRequest(`${BASE_URL}/v1/messages`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": API_KEY,
+            "anthropic-version": "2023-06-01",
+        },
+    }, JSON.stringify(body));
+
+    // Extract text from response
+    if (result.content && Array.isArray(result.content)) {
+        return result.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("\n");
+    }
+
+    return result.text || JSON.stringify(result);
+}
+
+// ─── MCP Server Setup ───
+const server = new Server(
+    {
+        name: "claudemax-mcp",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "web_search",
+                description:
+                    "Search the web for real-time information — documentation, news, APIs, current events, pricing, anything that requires up-to-date data from the internet.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "The search query to find information on the web",
+                        },
+                        num_results: {
+                            type: "number",
+                            description: "Number of results to return (default: 5, max: 10)",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "understand_image",
+                description:
+                    "Analyze images with AI — screenshots, diagrams, UI mockups, error messages, charts, photos. Provide a URL or file path to the image.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        image: {
+                            type: "string",
+                            description:
+                                "URL or local file path to the image to analyze (supports JPEG, PNG, WebP, GIF)",
+                        },
+                        question: {
+                            type: "string",
+                            description:
+                                "What to analyze or ask about the image (default: general description)",
+                        },
+                    },
+                    required: ["image"],
+                },
+            },
+        ],
+    };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        if (name === "web_search") {
+            const query = args.query;
+            const numResults = Math.min(args.num_results || 5, 10);
+
+            if (!query || typeof query !== "string") {
+                return {
+                    content: [{ type: "text", text: "Error: 'query' parameter is required and must be a string." }],
+                    isError: true,
+                };
+            }
+
+            const results = await webSearch(query, numResults);
+            const formatted = formatSearchResults(results);
+
+            return {
+                content: [{ type: "text", text: formatted }],
+            };
+        }
+
+        if (name === "understand_image") {
+            const image = args.image;
+            const question = args.question;
+
+            if (!image || typeof image !== "string") {
+                return {
+                    content: [{ type: "text", text: "Error: 'image' parameter is required and must be a URL or file path." }],
+                    isError: true,
+                };
+            }
+
+            if (!API_KEY) {
+                return {
+                    content: [{ type: "text", text: "Error: CLAUDEMAX_API_KEY environment variable is not set. Please run the setup script or set it manually." }],
+                    isError: true,
+                };
+            }
+
+            const analysis = await analyzeImage(image, question);
+
+            return {
+                content: [{ type: "text", text: analysis }],
+            };
+        }
+
+        return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+
+// ─── Start Server ───
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[ClaudeMax MCP] Server started");
+}
+
+main().catch((error) => {
+    console.error("[ClaudeMax MCP] Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -1,31 +1,31 @@
-{
-    "name": "codemax-mcp",
-    "version": "1.0.0",
-    "description": "ClaudeMax MCP server — web search & image analysis tools for Claude Code",
-    "main": "index.js",
-    "bin": {
-        "codemax-mcp": "index.js"
-    },
-    "keywords": [
-        "mcp",
-        "claude",
-        "claudemax",
-        "claude-code",
-        "web-search",
-        "image-analysis",
-        "anthropic",
-        "model-context-protocol"
-    ],
-    "author": "ClaudeMax",
-    "license": "MIT",
-    "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.0.0"
-    },
-    "engines": {
-        "node": ">=18"
-    },
-    "files": [
-        "index.js",
-        "README.md"
-    ]
-}
+{
+    "name": "codemax-mcp",
+    "version": "1.0.1",
+    "description": "ClaudeMax MCP server — web search & image analysis tools for Claude Code",
+    "main": "index.js",
+    "bin": {
+        "codemax-mcp": "index.js"
+    },
+    "keywords": [
+        "mcp",
+        "claude",
+        "claudemax",
+        "claude-code",
+        "web-search",
+        "image-analysis",
+        "anthropic",
+        "model-context-protocol"
+    ],
+    "author": "ClaudeMax",
+    "license": "MIT",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "files": [
+        "index.js",
+        "README.md"
+    ]
+}