@amplify-studio/open-mcp 0.9.0 → 0.10.0

package/dist/url-reader.js

@@ -1,7 +1,6 @@
-import { createProxyAgent } from "./proxy.js";
 import { logMessage } from "./logging.js";
 import { urlCache } from "./cache.js";
-import { createURLFormatError, createNetworkError, createServerError, createContentError, createTimeoutError, createEmptyContentWarning, createUnexpectedError } from "./error-handler.js";
+import { createURLFormatError, createConfigurationError, createNetworkError, createServerError, createContentError, createTimeoutError, createEmptyContentWarning, createUnexpectedError, GATEWAY_URL_REQUIRED_MESSAGE } from "./error-handler.js";
 function applyCharacterPagination(content, startChar = 0, maxLength) {
     if (startChar >= content.length) {
         return "";
@@ -99,7 +98,8 @@ function applyPaginationOptions(markdownContent, options) {
     }
     return result;
 }
-export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000, paginationOptions = {}) {
+export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 30000, // Increased default from 10s to 30s
+paginationOptions = {}) {
     const startTime = Date.now();
     logMessage(server, "info", `Fetching URL: ${url}`);
     // Check cache first
@@ -112,44 +112,40 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         return result;
     }
     // Validate URL format
-    let parsedUrl;
     try {
-        parsedUrl = new URL(url);
+        new URL(url);
     }
-    catch (error) {
+    catch {
         logMessage(server, "error", `Invalid URL format: ${url}`);
         throw createURLFormatError(url);
     }
     // Build gateway API URL
-    const gatewayUrl = process.env.GATEWAY_URL || "http://115.190.91.253:80";
+    const gatewayUrl = process.env.GATEWAY_URL;
+    if (!gatewayUrl) {
+        throw createConfigurationError(GATEWAY_URL_REQUIRED_MESSAGE);
+    }
     const gatewayApiUrl = `${gatewayUrl}/api/read/${encodeURIComponent(url)}`;
     // Create an AbortController instance
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        // Prepare request options with proxy support
+        // Prepare request options
         const requestOptions = {
             signal: controller.signal,
         };
-        // Add proxy dispatcher if proxy is configured
-        // Node.js fetch uses 'dispatcher' option for proxy, not 'agent'
-        const proxyAgent = createProxyAgent(gatewayApiUrl);
-        if (proxyAgent) {
-            requestOptions.dispatcher = proxyAgent;
-        }
         let response;
         try {
-            // Fetch the URL via gateway API with the abort signal
+            logMessage(server, "info", `Fetching from Gateway: ${gatewayApiUrl}`);
             response = await fetch(gatewayApiUrl, requestOptions);
+            logMessage(server, "info", `Gateway response status: ${response.status}`);
         }
         catch (error) {
-            const context = {
-                url,
-                gatewayUrl,
-                proxyAgent: !!proxyAgent,
-                timeout: timeoutMs
-            };
-            throw createNetworkError(error, context);
+            if (error.name === 'AbortError') {
+                logMessage(server, "error", `Gateway request timeout: ${url} (${timeoutMs}ms)`);
+                throw createTimeoutError(timeoutMs, url);
+            }
+            logMessage(server, "error", `Gateway network error: ${error.message}`, { url, gatewayUrl });
+            throw createNetworkError(error, { url, gatewayUrl, timeout: timeoutMs });
         }
         if (!response.ok) {
             let responseBody;
@@ -159,8 +155,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
             catch {
                 responseBody = '[Could not read response body]';
             }
-            const context = { url, gatewayUrl };
-            throw createServerError(response.status, response.statusText, responseBody, context);
+            throw createServerError(response.status, response.statusText, responseBody, { url, gatewayUrl });
         }
         // Retrieve content from gateway API (JSON response)
         let markdownContent;
@@ -180,7 +175,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         }
         if (!markdownContent || markdownContent.trim().length === 0) {
             logMessage(server, "warning", `Empty content from gateway: ${url}`);
-            return createEmptyContentWarning(url, 0, "");
+            return createEmptyContentWarning(url);
         }
         // Cache the markdown content from gateway
         urlCache.set(url, "", markdownContent);
@@ -209,8 +204,7 @@ export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000,
         }
         // Catch any unexpected errors
         logMessage(server, "error", `Unexpected error fetching URL: ${url}`, error);
-        const context = { url };
-        throw createUnexpectedError(error, context);
+        throw createUnexpectedError(error, { url });
     }
     finally {
         // Clean up the timeout to prevent memory leaks

package/dist/utils/file-helper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect content type based on file extension
+ */
+export declare function detectFileType(filePath: string): 'image' | 'video' | 'file' | null;
+/**
+ * Normalize user input - detect if it's a local path, URL, or base64
+ */
+export declare function normalizeInput(input: string): {
+    type: 'local' | 'url' | 'base64';
+    value: string;
+};
+/**
+ * Read local file and convert to base64
+ */
+export declare function readAsBase64(filePath: string): Promise<string>;
+/**
+ * Get MIME type based on file extension
+ */
+export declare function getMimeType(filePath: string): string;

package/dist/utils/file-helper.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+// MIME type mapping for common extensions
+const MIME_TYPES = {
+    // Images
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    // Videos
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.mkv': 'video/x-matroska',
+    '.webm': 'video/webm',
+    // Documents
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+// Content type mappings by extension
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp']);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.mkv', '.webm']);
+const FILE_EXTENSIONS = new Set(['.pdf', '.txt', '.doc', '.docx', '.xls', '.xlsx']);
+/**
+ * Detect content type based on file extension
+ */
+export function detectFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (IMAGE_EXTENSIONS.has(ext))
+        return 'image';
+    if (VIDEO_EXTENSIONS.has(ext))
+        return 'video';
+    if (FILE_EXTENSIONS.has(ext))
+        return 'file';
+    return null;
+}
+/**
+ * Normalize user input - detect if it's a local path, URL, or base64
+ */
+export function normalizeInput(input) {
+    if (input.startsWith('data:')) {
+        return { type: 'base64', value: input };
+    }
+    if (input.startsWith('http://') || input.startsWith('https://')) {
+        return { type: 'url', value: input };
+    }
+    if (/^[A-Za-z0-9+/=]{20,}$/.test(input) && !input.includes(' ')) {
+        return { type: 'base64', value: input };
+    }
+    return { type: 'local', value: input };
+}
+/**
+ * Read local file and convert to base64
+ */
+export async function readAsBase64(filePath) {
+    try {
+        const buffer = await fs.readFile(filePath);
+        return buffer.toString('base64');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read file: ${filePath}. Error: ${message}`);
+    }
+}
+/**
+ * Get MIME type based on file extension
+ */
+export function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_TYPES[ext] || 'application/octet-stream';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@amplify-studio/open-mcp",
-    "version": "0.9.0",
+    "version": "0.10.0",
     "description": "Open MCP server for web search and URL reading via Gateway API",
     "license": "MIT",
     "author": "Amplify Studio (https://github.com/amplify-studio)",
@@ -39,7 +39,7 @@
         "test": "SEARXNG_URL=https://test-searx.example.com tsx __tests__/run-all.ts",
         "test:coverage": "SEARXNG_URL=https://test-searx.example.com c8 --reporter=text tsx __tests__/run-all.ts",
         "bootstrap": "npm install && npm run build",
-        "inspector": "DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector node dist/index.js",
+        "inspector": "DANGEROUSLY_OMIT_AUTH=true GATEWAY_URL=http://localhost:80 npx @modelcontextprotocol/inspector node dist/index.js",
         "postversion": "TAG=$(node scripts/update-version.js | tail -1) && git add src/index.ts && git commit --amend --no-edit && git tag -f $TAG"
     },
     "dependencies": {
@@ -47,15 +47,16 @@
         "@types/cors": "^2.8.19",
         "@types/express": "^5.0.3",
         "cors": "^2.8.5",
+        "dotenv": "^17.2.3",
         "express": "^5.1.0",
         "node-html-markdown": "^1.3.0",
         "undici": "^6.20.1"
     },
     "devDependencies": {
-        "mcp-evals": "^1.0.18",
         "@types/node": "^22.17.2",
         "@types/supertest": "^6.0.3",
         "c8": "^10.1.3",
+        "mcp-evals": "^1.0.18",
         "shx": "^0.4.0",
         "supertest": "^7.1.4",
         "tsx": "^4.20.5",