redash-mcp 3.0.3 → 3.1.0

package/dist/query-cache.js

@@ -25,6 +25,17 @@ function makeCacheKey(dataSourceId, sql) {
 function roughSize(obj) {
     return JSON.stringify(obj).length * 2;
 }
+function purgeExpired(ttl) {
+    if (ttl === 0)
+        return;
+    const now = Date.now();
+    for (const [key, entry] of cache) {
+        if (now - entry.ts > ttl) {
+            totalSizeBytes -= entry.size;
+            cache.delete(key);
+        }
+    }
+}
 export function getCached(dataSourceId, sql) {
     const ttl = getCacheTtlMs();
     if (ttl === 0)
@@ -38,6 +49,9 @@ export function getCached(dataSourceId, sql) {
         cache.delete(key);
         return null;
     }
+    // Touch entry to maintain LRU order via insertion-order Map semantics.
+    cache.delete(key);
+    cache.set(key, entry);
     return entry.result;
 }
 export function setCached(dataSourceId, sql, result) {
@@ -48,6 +62,7 @@ export function setCached(dataSourceId, sql, result) {
     const size = roughSize(result);
     if (size > maxSize * 0.2)
         return;
+    purgeExpired(ttl);
     while (totalSizeBytes + size > maxSize && cache.size > 0) {
         const oldestKey = cache.keys().next().value;
         if (!oldestKey)

package/dist/redash-client.js

@@ -1,15 +1,58 @@
-const REDASH_URL = process.env.REDASH_URL?.replace(/\/$/, "");
+function validateRedashUrl(raw) {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    if (/[\n\r]/.test(raw)) {
+        throw new Error("REDASH_URL must not contain newlines");
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error(`REDASH_URL is not a valid URL: ${raw}`);
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error("REDASH_URL must not contain credentials");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`REDASH_URL must use http or https scheme, got: ${parsed.protocol}`);
+    }
+    return trimmed.replace(/\/$/, "");
+}
+const REDASH_URL = validateRedashUrl(process.env.REDASH_URL);
 const REDASH_API_KEY = process.env.REDASH_API_KEY;
+const HTTP_TIMEOUT_MS = (() => {
+    const raw = parseInt(process.env.REDASH_HTTP_TIMEOUT_SECS ?? "30", 10);
+    return (isNaN(raw) || raw <= 0 ? 30 : raw) * 1000;
+})();
 export { REDASH_URL, REDASH_API_KEY };
 export async function redashFetch(path, options) {
-    const res = await fetch(`${REDASH_URL}/api${path}`, {
-        ...options,
-        headers: {
-            "Authorization": `Key ${REDASH_API_KEY}`,
-            "Content-Type": "application/json",
-            ...options?.headers,
-        },
-    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
+    let res;
+    try {
+        res = await fetch(`${REDASH_URL}/api${path}`, {
+            ...options,
+            signal: options?.signal ?? controller.signal,
+            headers: {
+                "Authorization": `Key ${REDASH_API_KEY}`,
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+        });
+    }
+    catch (err) {
+        if (err?.name === "AbortError") {
+            throw new Error(`Redash request timed out after ${HTTP_TIMEOUT_MS / 1000}s`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
     if (!res.ok) {
         let hint = "";
         if (res.status === 401)
@@ -26,7 +69,9 @@ export async function redashFetch(path, options) {
     return res.json();
 }
 export async function pollQueryResult(jobId, timeoutSecs = 30) {
-    for (let i = 0; i < timeoutSecs; i++) {
+    const deadline = Date.now() + timeoutSecs * 1000;
+    let delayMs = 250;
+    while (Date.now() < deadline) {
         const job = await redashFetch(`/jobs/${jobId}`);
         if (job.job.status === 3) {
             return await redashFetch(`/query_results/${job.job.query_result_id}`);
@@ -34,7 +79,11 @@ export async function pollQueryResult(jobId, timeoutSecs = 30) {
         if (job.job.status === 4) {
             throw new Error(`Query failed: ${job.job.error}`);
         }
-        await new Promise((r) => setTimeout(r, 1000));
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            break;
+        await new Promise((r) => setTimeout(r, Math.min(delayMs, remaining)));
+        delayMs = Math.min(delayMs * 2, 2000);
     }
     throw new Error(`Query timed out after ${timeoutSecs}s`);
 }
@@ -49,16 +98,27 @@ export function formatAsMarkdownTable(columns, rows) {
 }
 const schemaCache = new Map();
 const CACHE_TTL_MS = 10 * 60 * 1000;
+const SCHEMA_CACHE_MAX_ENTRIES = 32;
 export async function fetchSchema(dataSourceId) {
     const cached = schemaCache.get(dataSourceId);
     if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
+        schemaCache.delete(dataSourceId);
+        schemaCache.set(dataSourceId, cached);
         return cached.schema;
     }
+    if (cached)
+        schemaCache.delete(dataSourceId);
     const result = await redashFetch(`/data_sources/${dataSourceId}/schema`);
     const schema = (result.schema ?? []).map((table) => ({
         ...table,
         columns: (table.columns ?? []).map((c) => typeof c === "string" ? { name: c, type: "unknown" } : c),
     }));
+    while (schemaCache.size >= SCHEMA_CACHE_MAX_ENTRIES) {
+        const oldest = schemaCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        schemaCache.delete(oldest);
+    }
     schemaCache.set(dataSourceId, { schema, ts: Date.now() });
     return schema;
 }

package/dist/tool-error.js

@@ -0,0 +1,40 @@
+/**
+ * Shared error handler for MCP tool callbacks.
+ * Logs the full error to stderr for debugging, then returns a
+ * user-friendly MCP error response without leaking internal details.
+ */
+export function handleToolError(toolName, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    // Log full detail to stderr so operators can debug.
+    console.error(`[${toolName}] ${detail}`);
+    // Derive a safe, user-facing message.
+    let userMessage;
+    if (detail.includes("Query timed out")) {
+        userMessage = "The query timed out. Try simplifying the query or increasing timeout_secs.";
+    }
+    else if (detail.includes("Query failed")) {
+        userMessage = "The query execution failed. Please check the SQL syntax and try again.";
+    }
+    else if (detail.includes("401") || detail.includes("Check your REDASH_API_KEY")) {
+        userMessage = "Authentication failed. Please verify your Redash API key.";
+    }
+    else if (detail.includes("403") || detail.includes("Access denied")) {
+        userMessage = "Access denied. You do not have permission for this resource.";
+    }
+    else if (/\b404\b/.test(detail) || detail.includes("Redash API error (404)")) {
+        userMessage = "The requested resource was not found. Please check the ID and try again.";
+    }
+    else if (detail.includes("Redash API error")) {
+        userMessage = "The Redash API returned an error. Please try again later.";
+    }
+    else if (detail.includes("fetch failed") || detail.includes("ECONNREFUSED") || detail.includes("ENOTFOUND")) {
+        userMessage = "Unable to connect to the Redash server. Please check REDASH_URL and network connectivity.";
+    }
+    else {
+        userMessage = "An unexpected error occurred. Please try again or check the server logs.";
+    }
+    return {
+        content: [{ type: "text", text: userMessage }],
+        isError: true,
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "redash-mcp",
   "mcpName": "io.github.seob717/redash-mcp",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "description": "MCP server for Redash",
   "license": "MIT",
   "author": "seob717",
@@ -32,17 +32,20 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
-    "@clack/prompts": "^1.1.0",
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.0.0"
+    "@anthropic-ai/sdk": "^0.95.2",
+    "@clack/prompts": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.6"
   }
 }