@havesomecode/kibana-mcp-server 1.1.2 → 1.2.1

package/dist/src/kibana_client.js

@@ -9,6 +9,24 @@ class KibanaHttpError extends Error {
         this.name = "KibanaHttpError";
     }
 }
+export class KibanaRequestError extends Error {
+    code;
+    phase;
+    sourceId;
+    timeoutMs;
+    status;
+    causeCode;
+    constructor(code, phase, sourceId, timeoutMs, message, cause, status, causeCode) {
+        super(message, { cause });
+        this.code = code;
+        this.phase = phase;
+        this.sourceId = sourceId;
+        this.timeoutMs = timeoutMs;
+        this.status = status;
+        this.causeCode = causeCode;
+        this.name = "KibanaRequestError";
+    }
+}
 function joinUrl(baseUrl, path) {
     return path.startsWith("http://") || path.startsWith("https://")
         ? path
@@ -17,6 +35,39 @@ function joinUrl(baseUrl, path) {
 function encodeBasicAuth(username, password) {
     return Buffer.from(`${username}:${password}`).toString("base64");
 }
+function getNetworkCauseCode(error) {
+    if (!(error instanceof Error) || !error.cause || typeof error.cause !== "object") {
+        return undefined;
+    }
+    const code = error.cause.code;
+    return typeof code === "string" ? code : undefined;
+}
+function classifyNetworkError(causeCode) {
+    if (causeCode === "ENOTFOUND" || causeCode === "EAI_AGAIN") {
+        return "KIBANA_DNS";
+    }
+    if (causeCode?.startsWith("CERT_") ||
+        causeCode?.startsWith("ERR_TLS_") ||
+        [
+            "DEPTH_ZERO_SELF_SIGNED_CERT",
+            "SELF_SIGNED_CERT_IN_CHAIN",
+            "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+        ].includes(causeCode ?? "")) {
+        return "KIBANA_TLS";
+    }
+    if ([
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "EHOSTUNREACH",
+        "ENETUNREACH",
+        "ETIMEDOUT",
+        "UND_ERR_CONNECT_TIMEOUT",
+        "UND_ERR_SOCKET",
+    ].includes(causeCode ?? "")) {
+        return "KIBANA_CONNECTION";
+    }
+    return "KIBANA_NETWORK";
+}
 function unwrapSearchResponse(raw) {
     if (!raw || typeof raw !== "object") {
         throw new Error("Unexpected Kibana search response shape");
@@ -46,7 +97,17 @@ function asArray(value) {
     return Array.isArray(value) ? value : [];
 }
 function normalizeFieldCapsResponse(raw) {
-    const fields = asRecord(asRecord(raw).fields);
+    const record = asRecord(raw);
+    if (!raw ||
+        typeof raw !== "object" ||
+        Array.isArray(raw) ||
+        !("fields" in record) ||
+        !record.fields ||
+        typeof record.fields !== "object" ||
+        Array.isArray(record.fields)) {
+        throw new Error("Unexpected Elasticsearch field capabilities response shape");
+    }
+    const fields = asRecord(record.fields);
     return Object.entries(fields)
         .map(([name, typeEntries]) => {
         const typeRecord = asRecord(typeEntries);
@@ -63,13 +124,21 @@ function normalizeFieldCapsResponse(raw) {
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 function normalizeKibanaFieldsResponse(raw) {
-    const rawFields = Array.isArray(raw) ? raw : asArray(asRecord(raw).fields);
+    const record = asRecord(raw);
+    const rawFields = Array.isArray(raw)
+        ? raw
+        : raw && typeof raw === "object" && !Array.isArray(raw) && Array.isArray(record.fields)
+            ? record.fields
+            : undefined;
+    if (!rawFields) {
+        throw new Error("Unexpected Kibana fields response shape");
+    }
     return rawFields
         .map((field) => {
         const fieldRecord = asRecord(field);
         const name = fieldRecord.name;
         if (typeof name !== "string") {
-            return null;
+            throw new Error("Kibana fields response contained an entry without a field name");
         }
         const subType = asRecord(fieldRecord.subType);
         const nested = asRecord(subType.nested);
@@ -84,7 +153,6 @@ function normalizeKibanaFieldsResponse(raw) {
             subfields: [],
         };
     })
-        .filter((field) => field !== null)
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 function resolveSchemaIndexPatterns(source, schemaBackend) {
@@ -136,6 +204,11 @@ function inferPrimitiveFieldType(value, fieldName) {
         if (fieldName?.endsWith(".keyword")) {
             return "keyword";
         }
+        if (fieldName &&
+            /(^@timestamp$)|((^|[._-])(timestamp|time|date|created|ingested|updated)([._-]|$))/i.test(fieldName) &&
+            !Number.isNaN(Date.parse(value))) {
+            return "date";
+        }
         return "text";
     }
     return undefined;
@@ -254,18 +327,99 @@ function normalizeSearchSampleFields(raw) {
     }
     return [...fieldMap.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
+class RequestGate {
+    maxConcurrency;
+    maxQueueDepth;
+    active = 0;
+    waiters = [];
+    constructor(maxConcurrency, maxQueueDepth) {
+        this.maxConcurrency = maxConcurrency;
+        this.maxQueueDepth = maxQueueDepth;
+    }
+    acquire(signal) {
+        if (signal.aborted) {
+            return Promise.reject(signal.reason);
+        }
+        if (this.active >= this.maxConcurrency && this.waiters.length >= this.maxQueueDepth) {
+            return Promise.reject(new RequestQueueFullError(this.maxQueueDepth));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                signal,
+                resolve,
+                reject,
+                onAbort: () => {
+                    const index = this.waiters.indexOf(waiter);
+                    if (index >= 0) {
+                        this.waiters.splice(index, 1);
+                    }
+                    reject(signal.reason);
+                },
+            };
+            signal.addEventListener("abort", waiter.onAbort, { once: true });
+            this.waiters.push(waiter);
+            this.dispatch();
+        });
+    }
+    dispatch() {
+        while (this.active < this.maxConcurrency) {
+            const waiter = this.waiters.shift();
+            if (!waiter) {
+                return;
+            }
+            waiter.signal.removeEventListener("abort", waiter.onAbort);
+            if (waiter.signal.aborted) {
+                waiter.reject(waiter.signal.reason);
+                continue;
+            }
+            this.active += 1;
+            let released = false;
+            waiter.resolve(() => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                this.active -= 1;
+                this.dispatch();
+            });
+        }
+    }
+}
+class RequestQueueFullError extends Error {
+    maxQueueDepth;
+    constructor(maxQueueDepth) {
+        super(`Kibana request queue is full (${maxQueueDepth} waiting requests)`);
+        this.maxQueueDepth = maxQueueDepth;
+        this.name = "RequestQueueFullError";
+    }
+}
 export class KibanaClient {
     config;
-    constructor(config) {
+    requestGate;
+    queueTimeoutMs;
+    constructor(config, options = {}) {
         this.config = config;
+        this.requestGate = new RequestGate(options.maxConcurrency ?? 8, options.maxQueueDepth ?? 32);
+        this.queueTimeoutMs = Math.min(options.queueTimeoutMs ?? config.timeoutMs, config.timeoutMs);
     }
     async requestJson(url, options = {}) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        const timeoutController = new AbortController();
+        const timeout = setTimeout(() => timeoutController.abort(new DOMException(`Timed out after ${this.config.timeoutMs}ms`, "TimeoutError")), this.config.timeoutMs);
+        const signal = options.callerSignal
+            ? AbortSignal.any([timeoutController.signal, options.callerSignal])
+            : timeoutController.signal;
+        const queueController = new AbortController();
+        const queueTimeout = setTimeout(() => queueController.abort(new DOMException(`Queue wait timed out after ${this.queueTimeoutMs}ms`, "TimeoutError")), this.queueTimeoutMs);
+        const queueSignal = AbortSignal.any([signal, queueController.signal]);
+        let phase = "queue";
+        let release;
         try {
+            release = await this.requestGate.acquire(queueSignal);
+            clearTimeout(queueTimeout);
+            phase = "request";
             const response = await fetch(url, {
                 method: options.method ?? "GET",
-                signal: controller.signal,
+                signal,
                 headers: {
                     Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
                     "Content-Type": "application/json",
@@ -273,113 +427,134 @@ export class KibanaClient {
                 },
                 ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
             });
+            phase = "response";
             if (!response.ok) {
                 const errorBody = await response.text();
                 throw new KibanaHttpError(response.status, errorBody);
             }
-            return response.json();
+            return await response.json();
+        }
+        catch (error) {
+            const sourceLabel = options.sourceId ? ` for source '${options.sourceId}'` : "";
+            if (error instanceof KibanaRequestError) {
+                throw error;
+            }
+            if (options.callerSignal?.aborted) {
+                throw new KibanaRequestError("KIBANA_CANCELLED", phase, options.sourceId, this.config.timeoutMs, `[KIBANA_CANCELLED] Kibana request${sourceLabel} was cancelled during ${phase}`, error);
+            }
+            if (error instanceof RequestQueueFullError) {
+                throw new KibanaRequestError("KIBANA_OVERLOADED", "queue", options.sourceId, this.queueTimeoutMs, `[KIBANA_OVERLOADED] Kibana request queue${sourceLabel} is full (${error.maxQueueDepth} waiting requests)`, error);
+            }
+            if (queueController.signal.aborted) {
+                throw new KibanaRequestError("KIBANA_TIMEOUT", "queue", options.sourceId, this.queueTimeoutMs, `[KIBANA_TIMEOUT] Kibana request${sourceLabel} exceeded the ${this.queueTimeoutMs}ms queue-wait timeout`, error);
+            }
+            if (timeoutController.signal.aborted) {
+                throw new KibanaRequestError("KIBANA_TIMEOUT", phase, options.sourceId, this.config.timeoutMs, `[KIBANA_TIMEOUT] Kibana request${sourceLabel} timed out after ${this.config.timeoutMs}ms during ${phase}`, error);
+            }
+            if (error instanceof KibanaHttpError) {
+                const code = error.status === 401 || error.status === 403 ? "KIBANA_AUTHENTICATION" : "KIBANA_HTTP";
+                throw new KibanaRequestError(code, "response", options.sourceId, this.config.timeoutMs, `[${code}] Kibana request${sourceLabel} returned HTTP ${error.status}`, error, error.status);
+            }
+            const causeCode = getNetworkCauseCode(error);
+            const code = phase === "response" && !causeCode ? "KIBANA_RESPONSE" : classifyNetworkError(causeCode);
+            throw new KibanaRequestError(code, phase, options.sourceId, this.config.timeoutMs, `[${code}] Kibana request${sourceLabel} failed during ${phase}${causeCode ? ` (${causeCode})` : ""}`, error, undefined, causeCode);
         }
         finally {
+            release?.();
+            clearTimeout(queueTimeout);
             clearTimeout(timeout);
         }
     }
-    async execute(compiledQuery) {
+    async verifyConnection() {
+        const response = await this.requestJson(joinUrl(this.config.baseUrl, "/api/status"));
+        const overall = asRecord(asRecord(asRecord(response).status).overall);
+        const indicator = overall.level ?? overall.state;
+        if (typeof indicator !== "string" || !indicator.trim()) {
+            throw new Error("Kibana connection verification did not return a valid Kibana status response.");
+        }
+    }
+    async execute(compiledQuery, callerSignal) {
         const source = compiledQuery.source;
         const endpoint = joinUrl(this.config.baseUrl, source.backend.path);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-        try {
-            const body = source.backend.kind === "kibana_internal_search_es"
-                ? {
-                    params: {
-                        ...(source.backend.index ? { index: source.backend.index } : {}),
-                        body: compiledQuery.request.body,
-                    },
-                }
-                : compiledQuery.request.body;
-            const response = await fetch(endpoint, {
-                method: "POST",
-                signal: controller.signal,
-                headers: {
-                    Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
-                    "Content-Type": "application/json",
-                    ...(source.backend.kind === "kibana_internal_search_es"
-                        ? { "kbn-xsrf": "kibana-mcp-server" }
-                        : {}),
+        const body = source.backend.kind === "kibana_internal_search_es"
+            ? {
+                params: {
+                    ...(source.backend.index ? { index: source.backend.index } : {}),
+                    body: compiledQuery.request.body,
                 },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                throw new Error(`Kibana request failed for source '${source.id}' with status ${response.status}: ${errorBody}`);
             }
-            const responseJson = (await response.json());
+            : compiledQuery.request.body;
+        const responseJson = await this.requestJson(endpoint, {
+            method: "POST",
+            callerSignal,
+            sourceId: source.id,
+            headers: source.backend.kind === "kibana_internal_search_es"
+                ? { "kbn-xsrf": "kibana-mcp-server" }
+                : undefined,
+            body,
+        });
+        try {
             return {
                 source,
                 rawResponse: unwrapSearchResponse(responseJson),
             };
         }
-        finally {
-            clearTimeout(timeout);
+        catch (error) {
+            throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Kibana returned an unexpected search response for source '${source.id}'`, error);
         }
     }
-    async executeMany(sourceQueries) {
-        return Promise.all(sourceQueries.map((sourceQuery) => this.execute(sourceQuery)));
+    async executeMany(sourceQueries, callerSignal) {
+        const siblingController = new AbortController();
+        const signal = callerSignal
+            ? AbortSignal.any([callerSignal, siblingController.signal])
+            : siblingController.signal;
+        const executions = sourceQueries.map((sourceQuery) => this.execute(sourceQuery, signal));
+        try {
+            return await Promise.all(executions);
+        }
+        catch (error) {
+            siblingController.abort(error);
+            await Promise.allSettled(executions);
+            throw error;
+        }
     }
-    async describeFieldsViaSearchBackend(source) {
+    async describeFieldsViaSearchBackend(source, callerSignal) {
         const endpoint = joinUrl(this.config.baseUrl, source.backend.path);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-        try {
-            const body = source.backend.kind === "kibana_internal_search_es"
-                ? {
-                    params: {
-                        ...(source.backend.index ? { index: source.backend.index } : {}),
-                        body: {
-                            size: 20,
-                            sort: [{ [source.timeField]: { order: "desc" } }],
-                            fields: ["*"],
-                            _source: true,
-                            track_total_hits: false,
-                        },
+        const body = source.backend.kind === "kibana_internal_search_es"
+            ? {
+                params: {
+                    ...(source.backend.index ? { index: source.backend.index } : {}),
+                    body: {
+                        size: 20,
+                        fields: ["*"],
+                        _source: true,
+                        track_total_hits: false,
                     },
-                }
-                : {
-                    size: 20,
-                    sort: [{ [source.timeField]: { order: "desc" } }],
-                    fields: ["*"],
-                    _source: true,
-                    track_total_hits: false,
-                };
-            const response = await fetch(endpoint, {
-                method: "POST",
-                signal: controller.signal,
-                headers: {
-                    Authorization: `Basic ${encodeBasicAuth(this.config.username, this.config.password)}`,
-                    "Content-Type": "application/json",
-                    ...(source.backend.kind === "kibana_internal_search_es"
-                        ? { "kbn-xsrf": "kibana-mcp-server" }
-                        : {}),
                 },
-                body: JSON.stringify(body),
-            });
-            if (!response.ok) {
-                const errorBody = await response.text();
-                throw new Error(`Search transport fallback failed for source '${source.id}' with status ${response.status}: ${errorBody}`);
             }
-            const responseJson = (await response.json());
-            const rawResponse = unwrapSearchResponse(responseJson);
-            const fields = normalizeSearchSampleFields(rawResponse);
-            if (fields.length === 0) {
-                throw new Error(`Search transport fallback returned no fields for source '${source.id}'. Sample hits may be empty for the requested index pattern.`);
-            }
-            return fields;
-        }
-        finally {
-            clearTimeout(timeout);
+            : {
+                size: 20,
+                fields: ["*"],
+                _source: true,
+                track_total_hits: false,
+            };
+        const responseJson = await this.requestJson(endpoint, {
+            method: "POST",
+            callerSignal,
+            sourceId: source.id,
+            headers: source.backend.kind === "kibana_internal_search_es"
+                ? { "kbn-xsrf": "kibana-mcp-server" }
+                : undefined,
+            body,
+        });
+        const rawResponse = unwrapSearchResponse(responseJson);
+        const fields = normalizeSearchSampleFields(rawResponse);
+        if (fields.length === 0) {
+            throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Search transport fallback returned no fields for source '${source.id}'. Sample hits may be empty for the requested index pattern.`);
         }
+        return fields;
     }
-    async describeFields(source) {
+    async describeFields(source, callerSignal) {
         const schemaBackend = source.schema;
         if (!schemaBackend) {
             throw new Error(`Source '${source.id}' does not configure a schema backend. Add source.schema before using describe_fields or schema-dependent query features.`);
@@ -397,16 +572,21 @@ export class KibanaClient {
             try {
                 responseJson = await this.requestJson(url, {
                     method: "GET",
+                    callerSignal,
+                    sourceId: source.id,
                 });
             }
             catch (error) {
+                if (error instanceof KibanaRequestError) {
+                    throw error;
+                }
                 throw new Error(`Schema backend '${schemaBackend.kind}' request failed for source '${source.id}' at '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
             }
             try {
                 return normalizeFieldCapsResponse(responseJson);
             }
             catch (error) {
-                throw new Error(`Schema backend '${schemaBackend.kind}' returned an unexpected field capabilities payload for source '${source.id}': ${error instanceof Error ? error.message : String(error)}`);
+                throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Schema backend '${schemaBackend.kind}' returned an unexpected field capabilities payload for source '${source.id}': ${error instanceof Error ? error.message : String(error)}`, error);
             }
         }
         const attempts = [];
@@ -415,6 +595,8 @@ export class KibanaClient {
             try {
                 const responseJson = await this.requestJson(url, {
                     method: "GET",
+                    callerSignal,
+                    sourceId: source.id,
                     headers: {
                         "kbn-xsrf": "kibana-mcp-server",
                     },
@@ -423,18 +605,24 @@ export class KibanaClient {
                     return normalizeKibanaFieldsResponse(responseJson);
                 }
                 catch (error) {
-                    throw new Error(`Schema backend '${schemaBackend.kind}' returned an unexpected Kibana field payload for source '${source.id}' from '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
+                    throw new KibanaRequestError("KIBANA_RESPONSE", "response", source.id, this.config.timeoutMs, `[KIBANA_RESPONSE] Schema backend '${schemaBackend.kind}' returned an unexpected Kibana field payload for source '${source.id}' from '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`, error);
                 }
             }
             catch (error) {
-                if (error instanceof KibanaHttpError && error.status === 404) {
+                if (error instanceof KibanaRequestError && error.status === 404) {
                     attempts.push(`${schemaPath} -> 404`);
                     continue;
                 }
+                if (error instanceof KibanaRequestError) {
+                    throw error;
+                }
                 throw new Error(`Schema backend '${schemaBackend.kind}' request failed for source '${source.id}' at '${schemaPath}': ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        return this.describeFieldsViaSearchBackend(source).catch((fallbackError) => {
+        return this.describeFieldsViaSearchBackend(source, callerSignal).catch((fallbackError) => {
+            if (fallbackError instanceof KibanaRequestError) {
+                throw fallbackError;
+            }
             throw new Error(`Schema backend '${schemaBackend.kind}' returned 404 for source '${source.id}' on every known Kibana field-discovery path (${attempts.join(", ")}). Search transport fallback also failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
         });
     }

package/dist/src/profile_store.js

@@ -1,4 +1,5 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { z } from "zod";
 import { resolveProfilePaths } from "./profile_paths.js";
@@ -105,11 +106,28 @@ export class ProfileStore {
             defaultProfileId: profileId,
         });
     }
+    async replaceState(state) {
+        await this.save(savedProfileStoreStateSchema.parse(state));
+    }
     async save(state) {
         const mkdirImpl = this.io.mkdir ?? mkdir;
         const writeFileImpl = this.io.writeFile ?? writeFile;
         await mkdirImpl(dirname(this.paths.profilesPath), { recursive: true });
-        await writeFileImpl(this.paths.profilesPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+        if (this.io.writeFile) {
+            await writeFileImpl(this.paths.profilesPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+            return;
+        }
+        const temporaryPath = `${this.paths.profilesPath}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            await writeFileImpl(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, {
+                encoding: "utf8",
+                mode: 0o600,
+            });
+            await rename(temporaryPath, this.paths.profilesPath);
+        }
+        finally {
+            await rm(temporaryPath, { force: true }).catch(() => { });
+        }
     }
 }
 export function normalizeProfileId(name) {

package/dist/src/schema_catalog.js

@@ -54,19 +54,33 @@ function mergeFieldHints(source, fields) {
 export class SchemaCatalog {
     client;
     cache = new Map();
+    inFlight = new Map();
     constructor(client) {
         this.client = client;
     }
-    async getFields(source) {
+    async getFields(source, callerSignal) {
         const existing = this.cache.get(source.id);
         if (existing) {
             return existing;
         }
-        const pending = this.client
-            .describeFields(source)
-            .then((fields) => linkFieldRelationships(mergeFieldHints(source, fields)));
-        this.cache.set(source.id, pending);
-        return pending;
+        const pending = this.inFlight.get(source.id);
+        if (pending) {
+            return pending;
+        }
+        const discovery = this.client.describeFields(source, callerSignal).then((fields) => {
+            const resolved = linkFieldRelationships(mergeFieldHints(source, fields));
+            this.cache.set(source.id, resolved);
+            return resolved;
+        });
+        this.inFlight.set(source.id, discovery);
+        try {
+            return await discovery;
+        }
+        finally {
+            if (this.inFlight.get(source.id) === discovery) {
+                this.inFlight.delete(source.id);
+            }
+        }
     }
     filterFields(fields, query, limit = 100) {
         const normalizedQuery = query ? normalizeFieldName(query) : undefined;