@webeyez/mcp-server 1.0.1

package/README.md

@@ -0,0 +1,72 @@
+# Webeyez Model Context Protocol (MCP) Server
+
+Access Webeyez session replays, JavaScript errors, conversion funnels, and performance diagnostics directly from any MCP-compatible AI client.
+
+## What is Webeyez?
+Webeyez is a comprehensive real-time user experience monitoring and diagnostic platform that helps online businesses detect, investigate, and resolve issues impacting their users. By tracking user friction, client-side errors, and drop-offs, Webeyez pinpoints exact conversion and revenue leaks. 
+
+**All data, insights, and opportunities collected by Webeyez are available through the Model Context Protocol (MCP).** This allows your AI agents and assistants to query live performance data, search session recordings, inspect JavaScript logs, and analyze conversion drop-offs directly within your chat environment.
+
+This server implements the Model Context Protocol (MCP) to seamlessly expose Webeyez's core analytics tools into AI clients such as **Claude (Web App)**, **Claude Desktop**, **Cursor**, **Windsurf**, **Cline**, and any other MCP-compliant interface.
+
+## Installation
+
+```bash
+npm install -g @webeyez/mcp-server
+```
+
+## Connection Setup
+
+The Webeyez MCP server supports both SSE (Server-Sent Events) for web applications and stdio/SSE bridging for local desktop editors.
+
+### Option 1: SSE Configuration (e.g., Claude Web App)
+Register the server as a custom connector in web-based clients:
+1. Go to **Settings > Connectors > Add custom connector** (or equivalent in your AI client).
+2. Enter the connector URL: `https://api.app.webeyez.com/mcp`
+3. Log in with your Webeyez credentials when prompted.
+
+### Option 2: Stdio Bridge Configuration (e.g., Claude Desktop, Cursor, Windsurf)
+Since local editor applications expect local processes, connect them to the remote server using the official `mcp-remote` bridge tool.
+
+#### For Claude Desktop:
+Configure your `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "webeyez": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote@latest",
+        "https://api.app.webeyez.com/mcp"
+      ]
+    }
+  }
+}
+```
+
+#### For Cursor:
+1. Go to **Settings > Features > MCP**.
+2. Click **+ Add New MCP Server**.
+3. Set **Name** to `webeyez`.
+4. Set **Type** to `command`.
+5. Set **Command** to:
+   ```bash
+   npx -y mcp-remote@latest https://api.app.webeyez.com/mcp
+   ```
+
+## Available Tools
+
+All tools require standard authentication (which is handled automatically via OAuth on the connection setup):
+
+* `list_accounts`: List all Webeyez accounts the authenticated user has access to.
+* `list_sites`: List all configured sites under your accounts.
+* `get_site_status`: Check tracking and integration status for a specific site.
+* `get_revenue_loss_estimate`: Retrieve estimated conversion and revenue losses.
+* `get_funnel_summary`: Fetch conversion funnel stages and drops.
+* `get_checkout_dropoffs`: Identify checkout friction points.
+* `get_js_errors`: Fetch javascript console and runtime errors.
+* `get_failed_api_calls`: Retrieve failing HTTP/network requests.
+
+## License
+ISC License

package/dist/claude-proxy.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const { EventSource } = require('eventsource');
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const readline_1 = __importDefault(require("readline"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const zod_1 = require("zod");
+const paths_1 = require("./utils/paths");
+// Retrieve the token and gateway URL from environment variables
+const API_KEY = process.env.WEBEYEZ_API_KEY;
+const GATEWAY_URL = process.env.GATEWAY_URL || 'https://api.app.webeyez.com';
+async function startFallbackServer(errorMsg = "Authentication Required: Your Personal Access Token (PAT) is missing. To get a new PAT, go to https://app.webeyez.com -> click the top right user icon -> Settings -> User Settings tab -> Personal Access Token section. Once the user provides the token, use the `login_webeyez` tool to save it and log in.") {
+    const mcp = new mcp_js_1.McpServer({
+        name: "Webeyez-MCP-Unauthenticated",
+        version: "1.0.0"
+    });
+    mcp.tool("ask_webeyez", "Free text for querying the data webeyez collected for the desired domain in that current organization. Webeyez identifies all JS errors, API failed calls, core web vitals, sessions, page views, frustration clicks, and many more related to client side analytics as webeyez has the tracker on the site. CRITICAL INSTRUCTION FOR CLAUDE: If this tool returns an Authentication error, you MUST copy and paste the EXACT error message to the user word-for-word. Do NOT paraphrase the error message, as it contains precise, technical UI instructions on how the user can generate a new Personal Access Token.", {
+        question: zod_1.z.string().describe("The free text query / question to ask the AI"),
+        domain: zod_1.z.string().optional().describe("The domain context for the question")
+    }, async () => {
+        return {
+            content: [{ type: "text", text: errorMsg }]
+        };
+    });
+    mcp.tool("login_webeyez", "Securely log in to Webeyez. If you do not provide a 'pat' parameter, it will automatically initiate an OAuth 2.1 authentication flow and open your default browser to sign in. CRITICAL: Once you call this tool, the server will restart. You MUST STOP your response immediately after calling this tool. Do NOT call any other tools (like ask_webeyez). Just tell the user to follow the browser login tab, wait a few seconds, and then retry their query.", {
+        pat: zod_1.z.string().optional().describe("Optional: Manually paste a Personal Access Token (PAT) if browser redirect fails.")
+    }, async ({ pat }) => {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const http = await Promise.resolve().then(() => __importStar(require('http')));
+        const crypto = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const { exec } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const configPath = (0, paths_1.getClaudeConfigPath)();
+        if (pat) {
+            try {
+                if (!fs.existsSync(configPath)) {
+                    return {
+                        content: [{ type: "text", text: "Configuration file not found. Please create it manually." }],
+                        isError: true
+                    };
+                }
+                const configData = fs.readFileSync(configPath, 'utf8');
+                const config = JSON.parse(configData);
+                if (!config.mcpServers || !config.mcpServers["wz-mcp-service"]) {
+                    return {
+                        content: [{ type: "text", text: "wz-mcp-service not found in configuration file." }],
+                        isError: true
+                    };
+                }
+                if (!config.mcpServers["wz-mcp-service"].env) {
+                    config.mcpServers["wz-mcp-service"].env = {};
+                }
+                config.mcpServers['wz-mcp-service'].env.WEBEYEZ_API_KEY = String(pat);
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+                setTimeout(() => process.exit(0), 1000);
+                return {
+                    content: [{ type: "text", text: "Successfully saved the PAT to the configuration! Claude Desktop is now restarting the server. Please wait 3 seconds and then retry your query." }]
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: "text", text: `Failed to update configuration: ${err.message}` }],
+                    isError: true
+                };
+            }
+        }
+        // Auto-login OAuth flow
+        try {
+            const codeVerifier = crypto.randomBytes(32).toString('base64url');
+            const codeChallenge = crypto.createHash('sha256').update(codeVerifier).digest().toString('base64url');
+            return new Promise((resolve) => {
+                const server = http.createServer(async (req, res) => {
+                    const reqUrl = new URL(req.url || '', `http://${req.headers.host}`);
+                    if (reqUrl.pathname !== '/callback') {
+                        res.writeHead(404);
+                        res.end('Not Found');
+                        return;
+                    }
+                    const code = reqUrl.searchParams.get('code');
+                    if (!code) {
+                        res.writeHead(400);
+                        res.end('Authorization code not found in request');
+                        server.close();
+                        resolve({
+                            content: [{ type: "text", text: "Authentication failed: No authorization code received." }],
+                            isError: true
+                        });
+                        return;
+                    }
+                    // Exchange code for token
+                    try {
+                        const tokenUrl = `${GATEWAY_URL.replace(/\/$/, '')}/v2/auth/oauth/token`;
+                        const tokenResponse = await (0, node_fetch_1.default)(tokenUrl, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                grant_type: 'authorization_code',
+                                code,
+                                redirect_uri: 'http://localhost:5053/callback',
+                                client_id: 'claude-desktop-client',
+                                code_verifier: codeVerifier
+                            })
+                        });
+                        if (!tokenResponse.ok) {
+                            const errBody = await tokenResponse.text();
+                            res.writeHead(400);
+                            res.end(`Token exchange failed: ${errBody}`);
+                            server.close();
+                            resolve({
+                                content: [{ type: "text", text: `Token exchange failed: ${errBody}` }],
+                                isError: true
+                            });
+                            return;
+                        }
+                        const tokenData = await tokenResponse.json();
+                        const accessToken = tokenData.access_token;
+                        if (!accessToken) {
+                            res.writeHead(400);
+                            res.end('Invalid response from token endpoint');
+                            server.close();
+                            resolve({
+                                content: [{ type: "text", text: "Failed to obtain access token." }],
+                                isError: true
+                            });
+                            return;
+                        }
+                        // Update config
+                        const configData = fs.readFileSync(configPath, 'utf8');
+                        const config = JSON.parse(configData);
+                        if (!config.mcpServers["wz-mcp-service"].env) {
+                            config.mcpServers["wz-mcp-service"].env = {};
+                        }
+                        config.mcpServers['wz-mcp-service'].env.WEBEYEZ_API_KEY = accessToken;
+                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+                        // Success response HTML page
+                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.end(`<!DOCTYPE html>
+<html>
+<head>
+  <title>Login Successful | Webeyez MCP</title>
+  <style>
+    body { background: #09090e; color: #f8fafc; font-family: system-ui, -apple-system, sans-serif; text-align: center; padding-top: 100px; margin: 0; }
+    .card { background: rgba(255,255,255,0.03); border: 1px solid rgba(255,255,255,0.08); border-radius: 20px; display: inline-block; padding: 40px 60px; box-shadow: 0 10px 30px rgba(0,0,0,0.3); backdrop-filter: blur(10px); }
+    h1 { color: #00E08F; font-size: 2.2rem; margin-bottom: 10px; }
+    p { color: #94a3b8; font-size: 1.1rem; line-height: 1.6; }
+    .checkmark { font-size: 4rem; color: #00E08F; margin-bottom: 20px; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="checkmark">✓</div>
+    <h1>Login Successful!</h1>
+    <p>You have successfully logged in to Webeyez MCP.</p>
+    <p>You can close this browser tab and return to Claude Desktop now.</p>
+  </div>
+</body>
+</html>`);
+                        // Gracefully stop server and exit process
+                        setTimeout(() => {
+                            server.close();
+                            process.exit(0);
+                        }, 1000);
+                        resolve({
+                            content: [{ type: "text", text: "Successfully logged in via OAuth! Claude Desktop is restarting the server." }]
+                        });
+                    }
+                    catch (err) {
+                        res.writeHead(500);
+                        res.end(`Internal Server Error: ${err.message}`);
+                        server.close();
+                        resolve({
+                            content: [{ type: "text", text: `Authentication error during exchange: ${err.message}` }],
+                            isError: true
+                        });
+                    }
+                });
+                server.listen(5053, '127.0.0.1', () => {
+                    const authorizeUrl = `${GATEWAY_URL.replace(/\/$/, '')}/v2/auth/oauth/authorize?response_type=code&client_id=claude-desktop-client&redirect_uri=http://localhost:5053/callback&state=state_123&code_challenge=${codeChallenge}&code_challenge_method=S256`;
+                    const startCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+                    exec(`${startCmd} "${authorizeUrl}"`, (err) => {
+                        if (err) {
+                            console.error(`[Proxy] Failed to open browser: ${err.message}`);
+                        }
+                    });
+                });
+                // Set a timeout of 3 minutes for user input
+                setTimeout(() => {
+                    server.close();
+                    resolve({
+                        content: [{ type: "text", text: "Login failed: Authentication timed out after 3 minutes." }],
+                        isError: true
+                    });
+                }, 3 * 60 * 1000);
+            });
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Failed to initiate OAuth login: ${err.message}` }],
+                isError: true
+            };
+        }
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await mcp.connect(transport);
+}
+function isTokenValid(token) {
+    if (!token || token === 'no-pat')
+        return false;
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return false;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString('utf8'));
+        if (payload.exp) {
+            // exp is in seconds, Date.now() is in milliseconds
+            if (payload.exp * 1000 < Date.now()) {
+                console.error("[Proxy] PAT has expired locally.");
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+if (!API_KEY || !isTokenValid(API_KEY)) {
+    // Start a local fallback server that just returns auth instructions
+    startFallbackServer("Authentication Failed: Your Personal Access Token (PAT) is invalid, malformed, or expired. To get a new PAT, go to https://app.webeyez.com -> click the top right user icon -> Settings -> User Settings tab -> Personal Access Token section. Once you provide the new token, use the `login_webeyez` tool to save it and log in.").catch(console.error);
+}
+else {
+    checkConnectionAndStart();
+}
+async function checkConnectionAndStart() {
+    const GATEWAY_ENDPOINT = `${GATEWAY_URL}/mcp/`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15000);
+    try {
+        // Test connection to the /mcp endpoint with a simple invalid message (since we just want to verify HTTP/auth status)
+        const response = await (0, node_fetch_1.default)(GATEWAY_ENDPOINT, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${API_KEY}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json, text/event-stream'
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'ping',
+                id: 'ping-id'
+            }),
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        console.error(`[Proxy] Fetch status: ${response.status} ${response.statusText}`);
+        if (response.status === 401 || response.status === 403) {
+            if (response.body && response.body.destroy)
+                response.body.destroy();
+            await startFallbackServer("Authentication Failed: Your Personal Access Token (PAT) is invalid or expired. To get a new PAT, go to https://app.webeyez.com -> click the top right user icon -> Settings -> User Settings tab -> Personal Access Token section. Once the user provides the new token, use the `login_webeyez` tool to save it and log in.");
+            return;
+        }
+        if (!response.ok && response.status !== 400) {
+            if (response.body && response.body.destroy)
+                response.body.destroy();
+            console.error(`The Webeyez servers are currently not responding (Status: ${response.status}). Exiting so Claude can retry.`);
+            await startFallbackServer(`Connection to Gateway failed with HTTP Status: ${response.status}. Please check if the Gateway is running and the /mcp endpoint is available.`);
+            return;
+        }
+        if (response.body && response.body.destroy)
+            response.body.destroy();
+        startProxyClient();
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        console.error(`The Webeyez servers are currently not responding or unreachable. Error: ${err.message}. Exiting so Claude can retry.`);
+        await startFallbackServer(`Connection to Gateway failed entirely. Error: ${err.message}. Please check if the Gateway is running at ${GATEWAY_URL} and reachable.`);
+    }
+}
+function startProxyClient() {
+    const GATEWAY_ENDPOINT = `${GATEWAY_URL}/mcp/`;
+    // Create StreamableHTTP client transport
+    const clientTransport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(GATEWAY_ENDPOINT), {
+        requestInit: {
+            headers: {
+                'Authorization': `Bearer ${API_KEY}`,
+                'x-api-key': API_KEY || ''
+            }
+        }
+    });
+    clientTransport.onmessage = (message) => {
+        // Write JSON-RPC string back to Claude's stdout
+        process.stdout.write(JSON.stringify(message) + '\n');
+    };
+    clientTransport.onerror = async (err) => {
+        console.error('[Proxy] Client transport error:', err);
+        // If we get an authentication error during active usage, clear the token and exit to fallback
+        if (err?.code === 401 || err?.code === 403 || err?.message?.includes('401') || err?.message?.includes('403')) {
+            console.error('[Proxy] Access token was rejected by server. Clearing token...');
+            try {
+                const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+                const configPath = (0, paths_1.getClaudeConfigPath)();
+                if (fs.existsSync(configPath)) {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                    if (config.mcpServers && config.mcpServers["wz-mcp-service"] && config.mcpServers["wz-mcp-service"].env) {
+                        delete config.mcpServers["wz-mcp-service"].env.WEBEYEZ_API_KEY;
+                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+                    }
+                }
+            }
+            catch (e) {
+                console.error('[Proxy] Failed to clear token:', e);
+            }
+            process.exit(0);
+        }
+    };
+    clientTransport.onclose = () => {
+        console.error('[Proxy] Connection closed.');
+        process.exit(0);
+    };
+    // Forward outgoing messages from Claude's stdin to the remote Server
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+    });
+    rl.on('line', async (line) => {
+        try {
+            const parsed = JSON.parse(line);
+            await clientTransport.send(parsed);
+        }
+        catch (err) {
+            console.error('[Proxy] Failed to parse or send line:', err);
+        }
+    });
+    clientTransport.start().catch((err) => {
+        console.error('[Proxy] Failed to start client transport:', err);
+        process.exit(1);
+    });
+}

package/dist/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const crypto_1 = __importDefault(require("crypto"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const public_1 = require("./tools/public");
+const net_1 = __importDefault(require("net"));
+// Redirect console.log to console.error in stdio mode so random logs don't break JSON-RPC
+if (process.argv.includes('stdio')) {
+    console.log = console.error;
+}
+dotenv_1.default.config();
+const app = (0, express_1.default)();
+app.use((0, cors_1.default)());
+app.use(express_1.default.json()); // Essential for parsing incoming MCP messages
+const transports = new Map();
+// Standardized Streamable HTTP endpoint for remote clients
+app.all(['/mcp', '/mcp/*splat'], async (req, res) => {
+    // 1. Get session ID from headers or query string
+    const sessionId = req.headers['mcp-session-id'] || req.query.sessionId;
+    if (sessionId) {
+        const session = transports.get(sessionId);
+        if (!session) {
+            res.status(404).json({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: `Session not found: ${sessionId}` },
+                id: null
+            });
+            return;
+        }
+        await session.transport.handleRequest(req, res, req.body);
+        return;
+    }
+    // 2. If no session ID, it MUST be a new session POST containing initialization
+    if (req.method !== 'POST') {
+        res.status(400).json({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Bad Request: Session ID required for GET/DELETE" },
+            id: null
+        });
+        return;
+    }
+    const body = req.body;
+    const isInit = Array.isArray(body)
+        ? body.some(msg => msg?.method === 'initialize')
+        : body?.method === 'initialize';
+    if (!isInit) {
+        res.status(400).json({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Bad Request: Session ID required" },
+            id: null
+        });
+        return;
+    }
+    // Extract PAT from Authorization, x-api-key header, or query string token
+    const authHeader = req.headers['authorization'];
+    const pat = authHeader && authHeader.startsWith('Bearer ')
+        ? authHeader.substring(7)
+        : req.headers['x-api-key']
+            || req.query.token;
+    let customerId = req.headers['x-org-id'] ? parseInt(req.headers['x-org-id'], 10) : undefined;
+    const userId = req.headers['x-user-id'];
+    // Try to extract orgId from JWT if x-org-id wasn't provided
+    if (!customerId && pat && pat !== 'no-pat') {
+        try {
+            const parts = pat.split('.');
+            if (parts.length === 3) {
+                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString('utf8'));
+                if (payload?.sub?.orgId) {
+                    customerId = parseInt(payload.sub.orgId, 10);
+                }
+            }
+        }
+        catch (e) { }
+    }
+    // Create a new MCP Server instance per connection session
+    const mcp = new mcp_js_1.McpServer({
+        name: "Webeyez-MCP",
+        version: "1.0.0"
+    });
+    // Setup tools for this instance
+    (0, public_1.setupPublicTools)(mcp, { customerId, userId, pat });
+    // Create a new StreamableHTTPServerTransport
+    let transport;
+    transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto_1.default.randomUUID(),
+        onsessioninitialized: (sid) => {
+            transports.set(sid, { transport, mcp });
+        },
+        onsessionclosed: (sid) => {
+            transports.delete(sid);
+        }
+    });
+    await mcp.connect(transport);
+    // Let the transport handle the request
+    await transport.handleRequest(req, res, req.body);
+});
+// Health check
+app.get('/health-check', (req, res) => {
+    res.json({ status: 'ok' });
+});
+// Function to find a free port
+function getFreePort(startingPort) {
+    return new Promise((resolve) => {
+        const server = net_1.default.createServer();
+        server.listen(startingPort, () => {
+            const port = server.address().port;
+            server.close(() => {
+                resolve(port);
+            });
+        });
+        server.on('error', () => {
+            resolve(getFreePort(startingPort + 1));
+        });
+    });
+}
+async function startServer() {
+    if (process.argv.includes('stdio')) {
+        const mcp = new mcp_js_1.McpServer({
+            name: "Webeyez-MCP",
+            version: "1.0.0"
+        });
+        (0, public_1.setupPublicTools)(mcp, {});
+        const transport = new stdio_js_1.StdioServerTransport();
+        await mcp.connect(transport);
+        console.error("Webeyez MCP Server running on stdio");
+        return;
+    }
+    const requestedPort = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+    const port = await getFreePort(requestedPort);
+    app.listen(port, () => {
+        console.log(`Webeyez MCP Server running on port ${port}`);
+    });
+}
+startServer().catch((err) => {
+    console.error("Failed to start server:", err);
+});
+// Keep process alive explicitly
+setInterval(() => { }, 1000 * 60 * 60);

package/dist/install-env.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./utils/paths");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const args = process.argv.slice(2);
+const targetEnv = args[0] || 'local'; // 'local' or 'production'
+let gatewayUrl = 'http://localhost:5050';
+if (targetEnv === 'local') {
+    gatewayUrl = (process.env.GATEWAY_URL || 'http://localhost:5050');
+}
+else if (targetEnv === 'production') {
+    // You can replace this with the actual production URL or set PROD_GATEWAY_URL in your .env
+    gatewayUrl = (process.env.PROD_GATEWAY_URL || 'https://api.app.webeyez.com');
+}
+const configPath = (0, paths_1.getClaudeConfigPath)();
+try {
+    let config = {};
+    if (fs_1.default.existsSync(configPath)) {
+        config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    if (!config.mcpServers)
+        config.mcpServers = {};
+    if (!config.mcpServers['wz-mcp-service']) {
+        config.mcpServers['wz-mcp-service'] = {
+            command: 'node',
+            args: [path_1.default.resolve(__dirname, '../dist/claude-proxy.js')],
+            env: {}
+        };
+    }
+    const serverConfig = config.mcpServers['wz-mcp-service'];
+    if (!serverConfig.env)
+        serverConfig.env = {};
+    serverConfig.env.GATEWAY_URL = gatewayUrl;
+    // Ensure the command points to the absolute path correctly
+    serverConfig.command = 'node';
+    serverConfig.args = [path_1.default.resolve(__dirname, '../dist/claude-proxy.js')];
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    console.log(`\n✅ Successfully configured Claude Desktop for '${targetEnv}'!`);
+    console.log(`📡 Gateway URL set to: ${gatewayUrl}`);
+    console.log(`\n⚠️  CRITICAL: You MUST fully quit Claude Desktop (Cmd+Q) and reopen it for the changes to apply!\n`);
+}
+catch (error) {
+    console.error(`❌ Failed to configure Claude Desktop: ${error.message}`);
+}