@havesomecode/kibana-mcp-server 0.1.0

package/dist/src/cli.js

@@ -0,0 +1,160 @@
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { startMcpServer } from "./mcp_runtime.js";
+import { runSetupFlow } from "./setup_flow.js";
+function renderHelp() {
+    return [
+        "Kibana Log Investigation",
+        "",
+        "Usage:",
+        "  kibana-mcp-server [command]",
+        "",
+        "Commands:",
+        "  setup    Run guided machine setup",
+        "  serve    Start the stdio MCP server",
+        "  help     Show this help output",
+    ].join("\n");
+}
+export async function runCli(argv = process.argv.slice(2), io = {}, dependencies = {}) {
+    const stdout = io.stdout ?? ((text) => process.stdout.write(`${text}\n`));
+    const stderr = io.stderr ?? ((text) => process.stderr.write(`${text}\n`));
+    const stdin = io.stdin ?? process.stdin;
+    const stdoutStream = io.stdoutStream ?? process.stdout;
+    const [command, ...rest] = argv;
+    switch (command) {
+        case undefined:
+        case "setup": {
+            if (rest.length > 0) {
+                stderr(`Unknown arguments for setup: ${rest.join(" ")}`);
+                return 1;
+            }
+            const promptIo = await createPromptIo(stdout, {
+                stdin,
+                stdoutStream,
+                stdinIsTTY: io.stdinIsTTY,
+            });
+            try {
+                const result = await (dependencies.runSetupFlowFn ?? runSetupFlow)(promptIo);
+                stdout(`Saved ${result.profiles.length} environment${result.profiles.length === 1 ? "" : "s"}. Default environment: ${result.defaultProfileName}.`);
+                return 0;
+            }
+            finally {
+                await promptIo.close();
+            }
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            stdout(renderHelp());
+            return 0;
+        }
+        case "serve": {
+            if (rest.length > 0) {
+                stderr(`Unknown arguments for serve: ${rest.join(" ")}`);
+                return 1;
+            }
+            await (dependencies.startMcpServerFn ?? startMcpServer)();
+            return 0;
+        }
+        default: {
+            stderr(`Unknown command: ${command}`);
+            stderr(renderHelp());
+            return 1;
+        }
+    }
+}
+export async function createPromptIo(stdout, options = {}) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdoutStream = options.stdoutStream ?? process.stdout;
+    const stdinIsTTY = options.stdinIsTTY ?? Boolean(stdin.isTTY);
+    if (!stdinIsTTY) {
+        return createQueuedPromptIo(stdout, await readQueuedAnswers(stdin));
+    }
+    const maskingOutput = new MaskingWritable(stdoutStream);
+    const readline = createInterface({
+        input: stdin,
+        output: maskingOutput,
+    });
+    return {
+        info(message) {
+            stdout(message);
+        },
+        async prompt(message, options = {}) {
+            const suffix = options.defaultValue ? ` [${options.defaultValue}]` : "";
+            if (options.secret) {
+                maskingOutput.muted = false;
+                stdoutStream.write(`${message}: `);
+                maskingOutput.muted = true;
+                const answer = await readline.question("");
+                maskingOutput.muted = false;
+                stdoutStream.write("\n");
+                return answer || options.defaultValue || "";
+            }
+            const answer = await readline.question(`${message}${suffix}: `);
+            return answer || options.defaultValue || "";
+        },
+        async confirm(message, defaultValue = false) {
+            const answer = await readline.question(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"}: `);
+            const normalized = answer.trim().toLowerCase();
+            if (!normalized) {
+                return defaultValue;
+            }
+            return normalized === "y" || normalized === "yes";
+        },
+        async close() {
+            await readline.close();
+        },
+    };
+}
+function createQueuedPromptIo(stdout, answers) {
+    let answerIndex = 0;
+    function consumeAnswer(promptLabel) {
+        const answer = answers[answerIndex];
+        answerIndex += 1;
+        if (answer === undefined) {
+            throw new Error(`No stdin answer available for prompt '${promptLabel}'.`);
+        }
+        return answer;
+    }
+    return {
+        info(message) {
+            stdout(message);
+        },
+        async prompt(message, options = {}) {
+            const suffix = options.defaultValue ? ` [${options.defaultValue}]` : "";
+            stdout(`${message}${suffix}:`);
+            const answer = consumeAnswer(message);
+            return answer || options.defaultValue || "";
+        },
+        async confirm(message, defaultValue = false) {
+            stdout(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"}:`);
+            const normalized = consumeAnswer(message).trim().toLowerCase();
+            if (!normalized) {
+                return defaultValue;
+            }
+            return normalized === "y" || normalized === "yes";
+        },
+        async close() { },
+    };
+}
+async function readQueuedAnswers(stdin) {
+    let rawInput = "";
+    for await (const chunk of stdin) {
+        rawInput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    }
+    return rawInput.replaceAll("\r\n", "\n").split("\n");
+}
+class MaskingWritable extends Writable {
+    target;
+    muted = false;
+    constructor(target) {
+        super();
+        this.target = target;
+    }
+    _write(chunk, encoding, callback) {
+        if (!this.muted) {
+            this.target.write(chunk, encoding);
+        }
+        callback();
+    }
+}

package/dist/src/config.js

@@ -0,0 +1,204 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { ProfileStore } from "./profile_store.js";
+import { SecretStoreError, createSecretStore } from "./secret_store.js";
+export const DEFAULT_RUNTIME_SOURCE_CATALOG_PATH = "config/sources.runtime.json";
+export const DEFAULT_STATIC_SOURCE_CATALOG_PATH = "config/sources.json";
+export const PROFILE_NAME_ENV = "KIBANA_PROFILE";
+export class NoSavedProfileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NoSavedProfileError";
+    }
+}
+const bootstrapEnvSchema = z.object({
+    KIBANA_BASE_URL: z.url(),
+    KIBANA_USERNAME: z.string().min(1),
+    KIBANA_PASSWORD: z.string().min(1),
+    KIBANA_TIMEOUT_MS: z
+        .string()
+        .optional()
+        .transform((value) => {
+        if (!value) {
+            return undefined;
+        }
+        const numericValue = Number(value);
+        if (!Number.isFinite(numericValue) || numericValue <= 0) {
+            throw new Error("KIBANA_TIMEOUT_MS must be a positive number");
+        }
+        return numericValue;
+    }),
+    KIBANA_SOURCE_CATALOG_PATH: z.string().optional(),
+});
+const startupOverrideSchema = z.object({
+    KIBANA_BASE_URL: z.string().optional(),
+    KIBANA_USERNAME: z.string().optional(),
+    KIBANA_PASSWORD: z.string().optional(),
+    KIBANA_TIMEOUT_MS: z.string().optional(),
+    KIBANA_SOURCE_CATALOG_PATH: z.string().optional(),
+    [PROFILE_NAME_ENV]: z.string().optional(),
+});
+const fieldHintSchema = z.object({
+    name: z.string().min(1),
+    type: z.string().optional(),
+    description: z.string().optional(),
+    aliases: z.array(z.string().min(1)).default([]),
+});
+const sourceBackendSchema = z.object({
+    kind: z.enum(["elasticsearch_search", "kibana_internal_search_es"]),
+    path: z.string().min(1),
+    index: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
+});
+const sourceSchemaBackendSchema = z.object({
+    kind: z.enum([
+        "elasticsearch_field_caps",
+        "kibana_data_views_fields",
+        "kibana_index_patterns_fields",
+    ]),
+    path: z.string().min(1).optional(),
+    index: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
+});
+export const sourceDefinitionSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().optional(),
+    tags: z.array(z.string().min(1)).default([]),
+    timeField: z.string().min(1),
+    backend: sourceBackendSchema,
+    schema: sourceSchemaBackendSchema.optional(),
+    fieldHints: z.array(fieldHintSchema).default([]),
+    defaultTextFields: z.array(z.string().min(1)).default([]),
+    evidenceFields: z.array(z.string().min(1)).default([]),
+});
+export const sourceCatalogSchema = z.object({
+    sources: z.array(sourceDefinitionSchema).min(1),
+});
+export function resolveSourceCatalogPath(envInput = process.env) {
+    const explicitPath = envInput.KIBANA_SOURCE_CATALOG_PATH?.trim();
+    if (explicitPath) {
+        return explicitPath;
+    }
+    return DEFAULT_RUNTIME_SOURCE_CATALOG_PATH;
+}
+export function parseAppConfig(envInput, sourceCatalogInput) {
+    const env = bootstrapEnvSchema.parse(envInput);
+    const sourceCatalog = sourceCatalogSchema.parse(sourceCatalogInput);
+    return {
+        kibana: {
+            baseUrl: env.KIBANA_BASE_URL.replace(/\/+$/, ""),
+            username: env.KIBANA_USERNAME,
+            password: env.KIBANA_PASSWORD,
+            timeoutMs: env.KIBANA_TIMEOUT_MS ?? 10000,
+        },
+        sources: sourceCatalog.sources,
+    };
+}
+export async function loadConfigFromEnvironment(envInput = process.env, dependencies = {}) {
+    const overrides = startupOverrideSchema.parse(envInput);
+    const readFileImpl = dependencies.readFile ?? readFile;
+    if (hasPartialBootstrapConfig(overrides)) {
+        throw new Error("Incomplete Kibana bootstrap environment. Provide KIBANA_BASE_URL, KIBANA_USERNAME, and KIBANA_PASSWORD together.");
+    }
+    if (hasBootstrapConfig(overrides)) {
+        const preferredPath = resolveSourceCatalogPath(envInput);
+        const sourceCatalog = await loadSourceCatalog(preferredPath === DEFAULT_RUNTIME_SOURCE_CATALOG_PATH
+            ? [preferredPath, DEFAULT_STATIC_SOURCE_CATALOG_PATH]
+            : [preferredPath], readFileImpl);
+        const config = parseAppConfig(overrides, sourceCatalog);
+        return {
+            ...config,
+            sourceCatalogPath: preferredPath,
+            sourceCatalogOrigin: sourceCatalog.loadedFrom === DEFAULT_STATIC_SOURCE_CATALOG_PATH
+                ? "static_default"
+                : preferredPath === DEFAULT_RUNTIME_SOURCE_CATALOG_PATH
+                    ? "runtime_default"
+                    : "environment",
+        };
+    }
+    const profileStore = dependencies.profileStore ?? new ProfileStore();
+    const secretStore = dependencies.secretStore ?? createSecretStore();
+    const requestedProfileName = overrides[PROFILE_NAME_ENV]?.trim();
+    const profile = requestedProfileName
+        ? await profileStore.findProfile(requestedProfileName)
+        : await profileStore.getDefaultProfile();
+    if (!profile) {
+        if (!requestedProfileName) {
+            throw new NoSavedProfileError("No saved Kibana profile is available.");
+        }
+        throw new Error(requestedProfileName
+            ? `Saved Kibana profile '${requestedProfileName}' was not found.`
+            : "No saved Kibana profile is available.");
+    }
+    const savedSecret = await secretStore.load(profile.id).catch((error) => {
+        if (error instanceof SecretStoreError && error.code === "NOT_FOUND") {
+            throw new Error(`Saved Kibana credentials for profile '${profile.name}' are missing. Run setup again on this machine.`);
+        }
+        throw error;
+    });
+    const sourceCatalogPath = overrides.KIBANA_SOURCE_CATALOG_PATH?.trim() || profile.sourceCatalogPath;
+    const sourceCatalog = await loadSourceCatalog([sourceCatalogPath], readFileImpl);
+    return {
+        kibana: {
+            baseUrl: profile.baseUrl.replace(/\/+$/, ""),
+            username: savedSecret.username,
+            password: savedSecret.password,
+            timeoutMs: parseTimeoutOverride(overrides.KIBANA_TIMEOUT_MS) ?? profile.timeoutMs,
+        },
+        sources: sourceCatalogSchema.parse(sourceCatalog.value).sources,
+        profileName: profile.name,
+        sourceCatalogPath,
+        sourceCatalogOrigin: overrides.KIBANA_SOURCE_CATALOG_PATH?.trim() ? "environment" : "profile",
+    };
+}
+export async function persistSourceCatalog(sources, options = {}) {
+    const sourceCatalogPath = options.sourceCatalogPath ?? resolveSourceCatalogPath(options.envInput);
+    await mkdir(dirname(sourceCatalogPath), { recursive: true });
+    await writeFile(sourceCatalogPath, `${JSON.stringify({ sources }, null, 2)}\n`, "utf8");
+    return sourceCatalogPath;
+}
+function hasBootstrapConfig(envInput) {
+    return Boolean(envInput.KIBANA_BASE_URL?.trim() &&
+        envInput.KIBANA_USERNAME?.trim() &&
+        envInput.KIBANA_PASSWORD?.trim());
+}
+function hasPartialBootstrapConfig(envInput) {
+    const bootstrapValues = [
+        envInput.KIBANA_BASE_URL?.trim(),
+        envInput.KIBANA_USERNAME?.trim(),
+        envInput.KIBANA_PASSWORD?.trim(),
+    ].filter(Boolean);
+    return bootstrapValues.length > 0 && bootstrapValues.length < 3;
+}
+function parseTimeoutOverride(value) {
+    if (!value) {
+        return undefined;
+    }
+    const numericValue = Number(value);
+    if (!Number.isFinite(numericValue) || numericValue <= 0) {
+        throw new Error("KIBANA_TIMEOUT_MS must be a positive number");
+    }
+    return numericValue;
+}
+async function loadSourceCatalog(candidatePaths, readFileImpl) {
+    let sourceCatalogRaw;
+    let loadedFrom = candidatePaths[0];
+    let lastError;
+    for (const candidatePath of candidatePaths) {
+        try {
+            sourceCatalogRaw = await readFileImpl(candidatePath, "utf8");
+            loadedFrom = candidatePath;
+            break;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (!sourceCatalogRaw) {
+        throw lastError instanceof Error ? lastError : new Error("Source catalog could not be loaded");
+    }
+    return {
+        loadedFrom,
+        value: JSON.parse(sourceCatalogRaw),
+    };
+}

package/dist/src/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+runCli()
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});