redash-mcp 3.1.3 → 3.1.5

package/dist/bird/tools.js

@@ -1,319 +0,0 @@
-import { z } from "zod";
-import { handleSmartQuery } from "./smart-query.js";
-import { loadExamples, addExample, removeExample } from "./few-shot.js";
-import { recordFeedback } from "./feedback.js";
-import { loadTestSuite, addTestCase, removeTestCase, runEvaluation, formatEvalResults } from "./evaluation.js";
-import { loadConfig, getConfigDir } from "./config.js";
-import { getEffectiveMap, addMappings, removeMappings, resetMappings, loadKeywordMap, DEFAULT_KEYWORD_MAP } from "./keyword-map.js";
-import { handleToolError } from "../tool-error.js";
-export function registerBirdTools(server) {
-    if (process.env.REDASH_BIRD_ENABLED === "false")
-        return;
-    server.tool("smart_query", "BIRD SQL-based intelligent query tool. Analyzes natural-language questions to (1) extract relevant schema, (2) match similar few-shot examples, (3) assess complexity, (4) request clarification for ambiguous questions. Call this tool before run_query. For a new data source, first inspect the schema with list_tables, then register keyword-to-table mappings via manage_keyword_map to significantly improve accuracy.", {
-        data_source_id: z.number().describe("Data source ID (from list_data_sources)"),
-        question: z.string().describe("Natural-language question (e.g., 'How many payments were completed last month?')"),
-        context: z.string().optional().describe("User's answer to a previous clarification question (for multi-turn)"),
-    }, { readOnlyHint: true }, async ({ data_source_id, question, context }) => {
-        try {
-            const result = await handleSmartQuery({ question, data_source_id, context });
-            if (result.action === "clarify") {
-                const text = [
-                    "## Clarification needed\n",
-                    "Before generating SQL, I need more information:\n",
-                    ...(result.clarificationQuestions?.map((q, i) => `${i + 1}. ${q}`) ?? []),
-                    "\nPlease provide answers, then call smart_query again with the `context` parameter containing your answers.",
-                ].join("\n");
-                return { content: [{ type: "text", text }] };
-            }
-            if (result.action === "explain") {
-                return {
-                    content: [{ type: "text", text: result.explanation ?? "Cannot generate SQL for this question." }],
-                };
-            }
-            const parts = [];
-            if (result.schema) {
-                parts.push(result.schema);
-            }
-            if (result.fewShotExamples) {
-                parts.push(result.fewShotExamples);
-            }
-            if (result.complexity) {
-                parts.push(`## Complexity: ${result.complexity.level}\n`);
-            }
-            if (result.guidance) {
-                parts.push(`## Guidance\n${result.guidance}`);
-            }
-            parts.push("\n---\nUse the schema and examples above to generate SQL, then execute with `run_query`.");
-            return { content: [{ type: "text", text: parts.join("\n") }] };
-        }
-        catch (error) {
-            return handleToolError("smart_query", error);
-        }
-    });
-    server.tool("manage_few_shot_examples", "Manage few-shot examples (list/add/remove). Register domain-specific examples to improve SQL accuracy.", {
-        data_source_id: z.number().describe("Data source ID"),
-        action: z.enum(["list", "add", "remove"]).describe("Action to perform"),
-        example: z
-            .object({
-            question: z.string().describe("Natural-language question"),
-            sql: z.string().describe("Correct SQL"),
-            tables: z.array(z.string()).describe("List of table names used"),
-            tags: z.array(z.string()).optional().describe("Tags (e.g., payments, date-filter)"),
-            notes: z.string().optional().describe("Domain knowledge notes (e.g., payment status values are paid, pending...)"),
-        })
-            .optional()
-            .describe("Example to add (required when action=add)"),
-        example_id: z.string().optional().describe("Example ID to remove (required when action=remove)"),
-    }, {}, async ({ data_source_id, action, example, example_id }) => {
-        try {
-            if (action === "list") {
-                const examples = await loadExamples(data_source_id);
-                if (examples.length === 0) {
-                    return { content: [{ type: "text", text: "No few-shot examples registered." }] };
-                }
-                const text = examples
-                    .map((e) => `**[${e.id}]** ${e.question}\n\`\`\`sql\n${e.sql}\n\`\`\`\nTables: ${e.tables.join(", ")} | Tags: ${e.tags.join(", ")} | Source: ${e.source}`)
-                    .join("\n\n---\n\n");
-                return { content: [{ type: "text", text: `Total ${examples.length} example(s):\n\n${text}` }] };
-            }
-            if (action === "add") {
-                if (!example) {
-                    return { content: [{ type: "text", text: "The example parameter is required." }] };
-                }
-                const added = await addExample(data_source_id, {
-                    question: example.question,
-                    sql: example.sql,
-                    tables: example.tables,
-                    tags: example.tags ?? [],
-                    notes: example.notes ?? "",
-                    source: "manual",
-                });
-                return {
-                    content: [{ type: "text", text: `Few-shot example added. (ID: ${added.id})` }],
-                };
-            }
-            if (action === "remove") {
-                if (!example_id) {
-                    return { content: [{ type: "text", text: "The example_id parameter is required." }] };
-                }
-                const removed = await removeExample(data_source_id, example_id);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: removed ? `Example ${example_id} has been removed.` : `Example ${example_id} not found.`,
-                        },
-                    ],
-                };
-            }
-            return { content: [{ type: "text", text: "Invalid action" }] };
-        }
-        catch (error) {
-            return handleToolError("manage_few_shot_examples", error);
-        }
-    });
-    server.tool("submit_query_feedback", "Submit feedback on generated SQL. Incorrect SQL is automatically classified and may be promoted to a few-shot example.", {
-        data_source_id: z.number().describe("Data source ID"),
-        question: z.string().describe("Original natural-language question"),
-        generated_sql: z.string().describe("Generated SQL"),
-        correct_sql: z.string().optional().describe("Correct SQL (provide when rating=down for automatic learning)"),
-        rating: z.enum(["up", "down"]).describe("Rating: up (correct) or down (incorrect)"),
-    }, {}, async ({ data_source_id, question, generated_sql, correct_sql, rating }) => {
-        try {
-            const entry = await recordFeedback(data_source_id, {
-                question,
-                generatedSql: generated_sql,
-                correctSql: correct_sql,
-                rating,
-            });
-            const parts = [`Feedback recorded. (ID: ${entry.id})`];
-            if (entry.errorType) {
-                parts.push(`Error type: ${entry.errorType}`);
-            }
-            if (entry.promotedToFewShot) {
-                parts.push("Repeated errors of the same type — auto-promoted to few-shot example.");
-            }
-            return { content: [{ type: "text", text: parts.join("\n") }] };
-        }
-        catch (error) {
-            return handleToolError("submit_query_feedback", error);
-        }
-    });
-    server.tool("evaluate_queries", "Manage SQL accuracy evaluation. Add/list test cases, run evaluations, and view results.", {
-        data_source_id: z.number().describe("Data source ID"),
-        action: z.enum(["list_tests", "add_test", "remove_test", "run", "results"]).describe("Action to perform"),
-        test_case: z
-            .object({
-            question: z.string().describe("Natural-language question"),
-            ground_truth_sql: z.string().describe("Ground-truth SQL"),
-            difficulty: z.enum(["simple", "medium", "complex"]).describe("Difficulty level"),
-            tags: z.array(z.string()).optional().describe("Tags"),
-        })
-            .optional()
-            .describe("Test case to add (required when action=add_test)"),
-        test_case_id: z.string().optional().describe("Test case ID to remove (required when action=remove_test)"),
-        generated_sqls: z
-            .array(z.object({
-            test_case_id: z.string().describe("Test case ID"),
-            generated_sql: z.string().describe("Generated SQL"),
-        }))
-            .optional()
-            .describe("List of SQL to evaluate (required when action=run)"),
-    }, {}, async ({ data_source_id, action, test_case, test_case_id, generated_sqls }) => {
-        try {
-            if (action === "list_tests") {
-                const store = await loadTestSuite(data_source_id);
-                if (store.testCases.length === 0) {
-                    return { content: [{ type: "text", text: "No test cases registered." }] };
-                }
-                const text = store.testCases
-                    .map((tc) => `**[${tc.id}]** ${tc.question}\nDifficulty: ${tc.difficulty} | Tags: ${tc.tags.join(", ")}\n\`\`\`sql\n${tc.groundTruthSql}\n\`\`\``)
-                    .join("\n\n---\n\n");
-                return { content: [{ type: "text", text: `Total ${store.testCases.length} test case(s):\n\n${text}` }] };
-            }
-            if (action === "add_test") {
-                if (!test_case) {
-                    return { content: [{ type: "text", text: "The test_case parameter is required." }] };
-                }
-                const added = await addTestCase(data_source_id, {
-                    question: test_case.question,
-                    groundTruthSql: test_case.ground_truth_sql,
-                    difficulty: test_case.difficulty,
-                    tags: test_case.tags ?? [],
-                });
-                return {
-                    content: [{ type: "text", text: `Test case added. (ID: ${added.id})` }],
-                };
-            }
-            if (action === "remove_test") {
-                if (!test_case_id) {
-                    return { content: [{ type: "text", text: "The test_case_id parameter is required." }] };
-                }
-                const removed = await removeTestCase(data_source_id, test_case_id);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: removed ? `Test case ${test_case_id} has been removed.` : `Test case ${test_case_id} not found.`,
-                        },
-                    ],
-                };
-            }
-            if (action === "run") {
-                if (!generated_sqls || generated_sqls.length === 0) {
-                    return { content: [{ type: "text", text: "The generated_sqls parameter is required." }] };
-                }
-                const run = await runEvaluation(data_source_id, generated_sqls.map((gs) => ({
-                    testCaseId: gs.test_case_id,
-                    generatedSql: gs.generated_sql,
-                })));
-                return { content: [{ type: "text", text: formatEvalResults(run) }] };
-            }
-            if (action === "results") {
-                const store = await loadTestSuite(data_source_id);
-                if (store.runs.length === 0) {
-                    return { content: [{ type: "text", text: "No evaluation runs found." }] };
-                }
-                const lastRun = store.runs[store.runs.length - 1];
-                return { content: [{ type: "text", text: formatEvalResults(lastRun) }] };
-            }
-            return { content: [{ type: "text", text: "Invalid action" }] };
-        }
-        catch (error) {
-            return handleToolError("evaluate_queries", error);
-        }
-    });
-    server.tool("manage_keyword_map", "Manage keyword-to-table-name mappings. After inspecting the schema with list_tables, register domain-specific mappings to improve smart_query table-matching accuracy. e.g., {\"revenue\": [\"payment\"], \"creator\": [\"creator\"]}", {
-        data_source_id: z.number().describe("Data source ID"),
-        action: z.enum(["list", "add", "remove", "reset"]).describe("Action to perform"),
-        mappings: z
-            .record(z.string(), z.array(z.string()))
-            .optional()
-            .describe("Mappings to add (required when action=add). e.g., {\"revenue\": [\"payment\", \"billing\"]}"),
-        keywords: z
-            .array(z.string())
-            .optional()
-            .describe("Keywords to remove (required when action=remove). e.g., [\"revenue\", \"order\"]"),
-    }, {}, async ({ data_source_id, action, mappings, keywords }) => {
-        try {
-            if (action === "list") {
-                const effective = await getEffectiveMap(data_source_id);
-                const custom = await loadKeywordMap(data_source_id);
-                const defaultCount = Object.keys(DEFAULT_KEYWORD_MAP).length;
-                const customCount = Object.keys(custom).length;
-                const lines = [
-                    `## Keyword Map (Data Source ${data_source_id})\n`,
-                    `Default: ${defaultCount} | Custom: ${customCount} | Total: ${Object.keys(effective).length}\n`,
-                ];
-                if (customCount > 0) {
-                    lines.push("### Custom mappings:");
-                    for (const [ko, en] of Object.entries(custom)) {
-                        lines.push(`- **${ko}** → ${en.join(", ")}`);
-                    }
-                    lines.push("");
-                }
-                lines.push("### All effective mappings:");
-                for (const [ko, en] of Object.entries(effective)) {
-                    const isCustom = ko in custom;
-                    lines.push(`- ${isCustom ? "**" : ""}${ko}${isCustom ? "** (custom)" : ""} → ${en.join(", ")}`);
-                }
-                return { content: [{ type: "text", text: lines.join("\n") }] };
-            }
-            if (action === "add") {
-                if (!mappings || Object.keys(mappings).length === 0) {
-                    return { content: [{ type: "text", text: "The mappings parameter is required. e.g., {\"revenue\": [\"payment\"]}" }] };
-                }
-                const updated = await addMappings(data_source_id, mappings);
-                const added = Object.keys(mappings);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `${added.length} keyword mapping(s) added/updated: ${added.join(", ")}`,
-                        },
-                    ],
-                };
-            }
-            if (action === "remove") {
-                if (!keywords || keywords.length === 0) {
-                    return { content: [{ type: "text", text: "The keywords parameter is required." }] };
-                }
-                await removeMappings(data_source_id, keywords);
-                return {
-                    content: [{ type: "text", text: `${keywords.length} custom keyword(s) removed: ${keywords.join(", ")}` }],
-                };
-            }
-            if (action === "reset") {
-                await resetMappings(data_source_id);
-                return {
-                    content: [{ type: "text", text: "Custom mappings have been reset. Only default mappings will be used." }],
-                };
-            }
-            return { content: [{ type: "text", text: "Invalid action" }] };
-        }
-        catch (error) {
-            return handleToolError("manage_keyword_map", error);
-        }
-    });
-    server.tool("get_bird_config", "View BIRD SQL configuration and status.", {}, { readOnlyHint: true }, async () => {
-        try {
-            const config = await loadConfig();
-            const configDir = getConfigDir();
-            const lines = [
-                "## BIRD SQL Configuration\n",
-                `Config directory: \`${configDir}\`\n`,
-                "### Settings:",
-                `- Schema Pruning: ${config.bird.schemaPruning.enabled ? "ON" : "OFF"} (Top-K: ${config.bird.schemaPruning.topK})`,
-                `- Few-shot Examples: ${config.bird.fewShot.enabled ? "ON" : "OFF"} (Max per query: ${config.bird.fewShot.maxExamplesPerQuery})`,
-                `- Feedback Loop: ${config.bird.feedback.enabled ? "ON" : "OFF"} (Auto-promote threshold: ${config.bird.feedback.autoPromoteThreshold})`,
-                `- Complexity Assessment: ${config.bird.complexity.enabled ? "ON" : "OFF"}`,
-                "",
-                `Edit \`${configDir}/config.json\` to customize settings.`,
-            ];
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-        }
-        catch (error) {
-            return handleToolError("get_bird_config", error);
-        }
-    });
-}

package/dist/bird/types.js

@@ -1 +0,0 @@
-export {};

package/dist/query-cache.js

@@ -1,87 +0,0 @@
-import { createHash } from "crypto";
-const cache = new Map();
-let totalSizeBytes = 0;
-function getCacheTtlMs() {
-    const ttl = parseInt(process.env.REDASH_MCP_CACHE_TTL ?? "300", 10);
-    return (isNaN(ttl) ? 300 : ttl) * 1000;
-}
-function getMaxSizeBytes() {
-    const mb = parseInt(process.env.REDASH_MCP_CACHE_MAX_MB ?? "50", 10);
-    return (isNaN(mb) ? 50 : mb) * 1024 * 1024;
-}
-function normalizeSQL(sql) {
-    return sql
-        .replace(/--[^\n]*/g, " ")
-        .replace(/\/\*[\s\S]*?\*\//g, " ")
-        .replace(/\s+/g, " ")
-        .trim()
-        .toLowerCase();
-}
-function makeCacheKey(dataSourceId, sql) {
-    return createHash("sha256")
-        .update(`${dataSourceId}:${normalizeSQL(sql)}`)
-        .digest("hex");
-}
-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)
-        return null;
-    const key = makeCacheKey(dataSourceId, sql);
-    const entry = cache.get(key);
-    if (!entry)
-        return null;
-    if (Date.now() - entry.ts > ttl) {
-        totalSizeBytes -= entry.size;
-        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) {
-    const ttl = getCacheTtlMs();
-    if (ttl === 0)
-        return;
-    const maxSize = getMaxSizeBytes();
-    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)
-            break;
-        const old = cache.get(oldestKey);
-        totalSizeBytes -= old.size;
-        cache.delete(oldestKey);
-    }
-    const key = makeCacheKey(dataSourceId, sql);
-    const existing = cache.get(key);
-    if (existing)
-        totalSizeBytes -= existing.size;
-    cache.set(key, { result, ts: Date.now(), size });
-    totalSizeBytes += size;
-}
-export function getCacheStats() {
-    return {
-        entries: cache.size,
-        sizeMb: (totalSizeBytes / 1024 / 1024).toFixed(2),
-        ttlSecs: getCacheTtlMs() / 1000,
-    };
-}

package/dist/redash-client.js

@@ -1,124 +0,0 @@
-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 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)
-            hint = " (Check your REDASH_API_KEY)";
-        else if (res.status === 403)
-            hint = " (Access denied for this resource)";
-        else if (res.status === 404)
-            hint = " (Resource not found. Check the ID)";
-        throw new Error(`Redash API error: ${res.status} ${res.statusText}${hint}`);
-    }
-    if (res.status === 204 || res.headers.get("content-length") === "0") {
-        return null;
-    }
-    return res.json();
-}
-export async function pollQueryResult(jobId, timeoutSecs = 30) {
-    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}`);
-        }
-        if (job.job.status === 4) {
-            throw new Error(`Query failed: ${job.job.error}`);
-        }
-        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`);
-}
-export function formatAsMarkdownTable(columns, rows) {
-    const escape = (s) => s.replace(/\|/g, "\\|");
-    const header = `| ${columns.map(escape).join(" | ")} |`;
-    const separator = `| ${columns.map(() => "---").join(" | ")} |`;
-    const body = rows
-        .map((row) => `| ${columns.map((c) => escape(String(row[c] ?? ""))).join(" | ")} |`)
-        .join("\n");
-    return `${header}\n${separator}\n${body}`;
-}
-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/setup.js

@@ -1,137 +0,0 @@
-#!/usr/bin/env node
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { execSync } from "child_process";
-import * as p from "@clack/prompts";
-function findNpxPath() {
-    try {
-        const result = execSync("which npx", { encoding: "utf8" }).trim();
-        if (result)
-            return result;
-    }
-    catch { }
-    const candidates = [
-        "/usr/local/bin/npx",
-        "/opt/homebrew/bin/npx",
-        "/usr/bin/npx",
-    ];
-    for (const c of candidates) {
-        if (fs.existsSync(c))
-            return c;
-    }
-    return "npx";
-}
-function getDesktopConfigPath() {
-    const platform = os.platform();
-    if (platform === "darwin") {
-        return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-    }
-    else if (platform === "win32") {
-        return path.join(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
-    }
-    else {
-        return path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
-    }
-}
-function getClaudeCodeConfigPath() {
-    return path.join(os.homedir(), ".claude", "settings.json");
-}
-export async function main() {
-    p.intro("redash-mcp setup wizard");
-    const targets = await p.multiselect({
-        message: "Select installation targets (space to select, enter to confirm)",
-        options: [
-            { value: "desktop", label: "Claude Desktop" },
-            { value: "cli", label: "Claude Code (CLI)" },
-        ],
-        required: true,
-    });
-    if (p.isCancel(targets)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const redashUrl = await p.text({
-        message: "Enter your Redash URL",
-        placeholder: "https://redash.example.com",
-        validate(value) {
-            if (!value)
-                return "URL is required.";
-            if (!value.startsWith("http://") && !value.startsWith("https://"))
-                return "Must start with http:// or https://";
-        },
-    });
-    if (p.isCancel(redashUrl)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const apiKey = await p.text({
-        message: "Enter your Redash API key",
-        validate(value) {
-            if (!value)
-                return "API key is required.";
-        },
-    });
-    if (p.isCancel(apiKey)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const url = redashUrl.replace(/\/$/, "");
-    const npxPath = findNpxPath();
-    const mcpEntry = {
-        command: npxPath,
-        args: ["-y", "redash-mcp"],
-        env: {
-            REDASH_URL: url,
-            REDASH_API_KEY: apiKey,
-        },
-    };
-    const s = p.spinner();
-    if (targets.includes("desktop")) {
-        s.start("Configuring Claude Desktop...");
-        setupDesktop(mcpEntry);
-        s.stop("Claude Desktop configured");
-    }
-    if (targets.includes("cli")) {
-        s.start("Configuring Claude Code (CLI)...");
-        setupClaudeCode(mcpEntry);
-        s.stop("Claude Code (CLI) configured");
-    }
-    p.outro("Setup complete. Restart to start using redash-mcp.");
-}
-function setupDesktop(mcpEntry) {
-    const configPath = getDesktopConfigPath();
-    let config = { mcpServers: {} };
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            config.mcpServers ??= {};
-        }
-        catch {
-            throw new Error(`Failed to read claude_desktop_config.json: ${configPath}`);
-        }
-    }
-    else {
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    }
-    config.mcpServers["redash-mcp"] = mcpEntry;
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
-}
-function setupClaudeCode(mcpEntry) {
-    const configPath = getClaudeCodeConfigPath();
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        }
-        catch {
-            throw new Error(`Failed to read Claude Code settings.json: ${configPath}`);
-        }
-    }
-    else {
-        fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    }
-    config.mcpServers ??= {};
-    config.mcpServers["redash-mcp"] = mcpEntry;
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
-}