@havesomecode/kibana-mcp-server 1.2.0 → 1.3.0

package/dist/src/tools/configure_index.js

@@ -43,7 +43,7 @@ export async function executeConfigureIndex(inputValue, options) {
             JSON.stringify(existingSource.backend.index) !== JSON.stringify(proposedSource.backend.index)) {
             throw new Error(`Source id '${proposedSource.id}' already refers to a different index. Re-run with replace=true only after the user explicitly approves replacement.`);
         }
-        const discoveredFields = await options.kibanaClient.describeFields(proposedSource);
+        const discoveredFields = await options.kibanaClient.describeFields(proposedSource, options.callerSignal);
         if (discoveredFields.length === 0) {
             throw new Error(`Explicit index pattern '${input.index}' resolved to no fields. Check the index and Kibana permissions.`);
         }
@@ -65,7 +65,7 @@ export async function executeConfigureIndex(inputValue, options) {
             resolvedNestedFilters: [],
             resolvedSortBy: verifiedSource.timeField,
             advisories: [],
-        });
+        }, options.callerSignal);
         const sources = existingSource
             ? existingCatalog.sources.map((source) => source.id === verifiedSource.id ? verifiedSource : source)
             : [...existingCatalog.sources, verifiedSource];

package/dist/src/tools/describe_fields.js

@@ -21,9 +21,9 @@ export const describeFieldsOutputSchema = z.object({
         preferred_exact_field: z.string().optional(),
     })),
 });
-export async function executeDescribeFields(input, sourceCatalog, schemaCatalog) {
+export async function executeDescribeFields(input, sourceCatalog, schemaCatalog, callerSignal) {
     const [source] = sourceCatalog.getRequiredSources([input.source_id]);
-    const fields = await schemaCatalog.getFields(source);
+    const fields = await schemaCatalog.getFields(source, callerSignal);
     const filteredFields = schemaCatalog.filterFields(fields, input.query, input.limit);
     return {
         source_id: source.id,

package/dist/src/tools/filter.js

@@ -111,6 +111,7 @@ export async function executeFilter(input, sourceCatalog, kibanaClient, options)
         resolveFieldAliases: false,
         resolvePreferredExactFields: true,
         schemaCatalog: options?.schemaCatalog,
+        callerSignal: options?.callerSignal,
     });
 }
 export function formatFilterResult(result) {

package/dist/src/tools/query.js

@@ -234,9 +234,12 @@ export async function executeQuery(input, sourceCatalog, kibanaClient, options)
     if (schemaCatalog && needsSchemaResolution) {
         for (const source of sources) {
             try {
-                sourceSchemas.set(source.id, await schemaCatalog.getFields(source));
+                sourceSchemas.set(source.id, await schemaCatalog.getFields(source, options?.callerSignal));
             }
             catch (error) {
+                if (options?.callerSignal?.aborted) {
+                    throw error;
+                }
                 sourceSchemaErrors.set(source.id, error instanceof Error ? error.message : String(error));
             }
         }
@@ -246,7 +249,7 @@ export async function executeQuery(input, sourceCatalog, kibanaClient, options)
         ...(sourceSchemas.size > 0 ? { sourceSchemas } : {}),
         ...(sourceSchemaErrors.size > 0 ? { sourceSchemaErrors } : {}),
     });
-    const executions = await kibanaClient.executeMany(plan.sourceQueries);
+    const executions = await kibanaClient.executeMany(plan.sourceQueries, options?.callerSignal);
     return queryOutputSchema.parse(normalizeQueryResponse(plan, executions));
 }
 export function formatQueryResult(result) {

package/dist/src/utils/cli_io.js

@@ -0,0 +1,11 @@
+export function createCliIo(overrides = {}) {
+    return {
+        stdout: overrides.stdout ?? ((text) => process.stdout.write(`${text}\n`)),
+        stderr: overrides.stderr ?? ((text) => process.stderr.write(`${text}\n`)),
+        stdin: overrides.stdin ?? process.stdin,
+        stdoutStream: overrides.stdoutStream ?? process.stdout,
+        stdinIsTTY: overrides.stdinIsTTY,
+        env: overrides.env ?? process.env,
+        isStdoutOverridden: overrides.stdout !== undefined,
+    };
+}

package/dist/src/utils/cli_prompts.js

@@ -0,0 +1,67 @@
+import { cancel, confirm, isCancel, log, password, text } from "@clack/prompts";
+export class PromptCancelledError extends Error {
+    constructor() {
+        super("Setup cancelled.");
+    }
+}
+export async function createPromptIo(io) {
+    const stdinIsTTY = io.stdinIsTTY ?? Boolean(io.stdin.isTTY);
+    if (!stdinIsTTY)
+        return createQueuedPromptIo(io.stdout, await readQueuedAnswers(io.stdin));
+    return {
+        info: (message) => log.info(message, { output: io.stdoutStream }),
+        async prompt(message, options = {}) {
+            return unwrap(await (options.secret ? password : text)({
+                message,
+                defaultValue: options.defaultValue,
+                input: io.stdin,
+                output: io.stdoutStream,
+            }), io.stdoutStream);
+        },
+        async confirm(message, defaultValue = false) {
+            return unwrap(await confirm({
+                message,
+                initialValue: defaultValue,
+                input: io.stdin,
+                output: io.stdoutStream,
+            }), io.stdoutStream);
+        },
+        async close() { },
+    };
+}
+function unwrap(answer, output) {
+    if (isCancel(answer)) {
+        cancel("Setup cancelled.", { output });
+        throw new PromptCancelledError();
+    }
+    return answer;
+}
+function createQueuedPromptIo(stdout, answers) {
+    let index = 0;
+    const consume = (label) => {
+        const answer = answers[index++];
+        if (answer === undefined)
+            throw new Error(`No stdin answer available for prompt '${label}'.`);
+        return answer;
+    };
+    return {
+        info: stdout,
+        async prompt(message, options = {}) {
+            const suffix = options.defaultValue ? ` [${options.defaultValue}]` : "";
+            stdout(`${message}${suffix}:`);
+            return consume(message) || options.defaultValue || "";
+        },
+        async confirm(message, defaultValue = false) {
+            stdout(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"}:`);
+            const answer = consume(message).trim().toLowerCase();
+            return answer ? answer === "y" || answer === "yes" : defaultValue;
+        },
+        async close() { },
+    };
+}
+async function readQueuedAnswers(stdin) {
+    let raw = "";
+    for await (const chunk of stdin)
+        raw += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    return raw.replaceAll("\r\n", "\n").split("\n");
+}

package/dist/src/utils/cli_ui.js

@@ -0,0 +1,19 @@
+import { log } from "@clack/prompts";
+export function createCliUi(io) {
+    return {
+        success(message) {
+            if (io.isStdoutOverridden) {
+                io.stdout(message);
+                return;
+            }
+            log.success(message, { output: io.stdoutStream });
+        },
+        error(message) {
+            if (io.isStdoutOverridden) {
+                io.stderr(message);
+                return;
+            }
+            log.error(message, { output: io.stdoutStream });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@havesomecode/kibana-mcp-server",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "MIT",
   "description": "Read-only MCP server for Kibana-backed log investigation and schema-aware querying",
   "homepage": "https://havesomecode.github.io/kibana-mcp-server/",
@@ -11,7 +11,7 @@
   "type": "module",
   "main": "dist/src/mcp_entry.js",
   "bin": {
-    "kibana-mcp-server": "dist/src/index.js"
+    "kibana-mcp-server": "dist/src/bin/kibana-mcp-server.js"
   },
   "publishConfig": {
     "access": "public",
@@ -40,7 +40,7 @@
     "dev": "tsx src/mcp_entry.ts",
     "release": "semantic-release",
     "release:dry-run": "semantic-release --dry-run",
-    "setup": "node dist/src/index.js setup",
+    "setup": "node dist/src/bin/kibana-mcp-server.js setup",
     "start": "node dist/src/mcp_entry.js",
     "test": "vitest run",
     "verify:release-contract": "node scripts/verify-release-contract.mjs",
@@ -50,7 +50,9 @@
   },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
+    "@clack/prompts": "^1.8.0",
     "@modelcontextprotocol/server": "2.0.0",
+    "commander": "^14.0.3",
     "zod": "^4.0.0"
   },
   "devDependencies": {
@@ -60,7 +62,7 @@
     "@types/node": "^25.5.2",
     "semantic-release": "^25.0.1",
     "tsx": "^4.0.0",
-    "typescript": "^5.7.0",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.3"
   }
 }

package/dist/src/cli.js

@@ -1,323 +0,0 @@
-import { createInterface } from "node:readline/promises";
-import { Writable } from "node:stream";
-import { parseArgs } from "node:util";
-import { runBootstrap } from "./bootstrap.js";
-import { PROFILE_NAME_ENV } from "./config.js";
-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",
-        "  bootstrap  Verify, save, and register a profile without prompts",
-        "  serve      Start the stdio MCP server",
-        "  help       Show this help output",
-    ].join("\n");
-}
-function renderBootstrapHelp() {
-    return [
-        "Usage:",
-        "  kibana-mcp-server bootstrap [options]",
-        "  kibana-mcp-server setup [options]  # compatible non-interactive alias",
-        "",
-        "Bootstrap verifies and saves only the Kibana connection; it does not inspect or configure indexes.",
-        "After installation, ask the agent to configure a specific index or index pattern.",
-        "",
-        "Connection options use KIBANA_BASE_URL, KIBANA_USERNAME, and KIBANA_PASSWORD as fallbacks.",
-        "Passwords are accepted only through --password-stdin, --password-env <NAME>, or KIBANA_PASSWORD.",
-        "",
-        "Options:",
-        "  --profile <name>        Saved profile name (default: KIBANA_PROFILE or default)",
-        "  --url <url>             Kibana base URL",
-        "  --username <name>       Kibana basic-auth username",
-        "  --password-stdin        Read the password from stdin",
-        "  --password-env <name>   Read the password from a named environment variable",
-        "  --client <codex|none>   Register Codex or skip client registration (default: codex)",
-        "  --package <specifier>   Exact package specifier used by the Codex registration",
-        "  --mcp-name <name>       Base name for the transport-hashed Codex registration",
-        "  --replace               Explicitly replace an existing catalog with an empty managed catalog",
-        "  --no-default            Do not make this profile the default",
-    ].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 env = io.env ?? process.env;
-    const [command, ...rest] = argv;
-    switch (command) {
-        case undefined: {
-            try {
-                await (dependencies.startMcpServerFn ?? startMcpServer)(env);
-                return 0;
-            }
-            catch (error) {
-                stderr(error instanceof Error ? error.message : String(error));
-                return 1;
-            }
-        }
-        case "setup": {
-            if (rest.length > 0) {
-                if (rest.includes("--help") || rest.includes("-h")) {
-                    stdout(renderBootstrapHelp());
-                    return 0;
-                }
-                try {
-                    const options = await parseBootstrapOptions(rest, stdin, env);
-                    const result = await (dependencies.runBootstrapFn ?? runBootstrap)(options);
-                    stdout(renderBootstrapResult(result));
-                    return 0;
-                }
-                catch (error) {
-                    stderr(error instanceof Error ? error.message : String(error));
-                    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 "bootstrap": {
-            if (rest.includes("--help") || rest.includes("-h")) {
-                stdout(renderBootstrapHelp());
-                return 0;
-            }
-            try {
-                const options = await parseBootstrapOptions(rest, stdin, env);
-                const result = await (dependencies.runBootstrapFn ?? runBootstrap)(options);
-                stdout(renderBootstrapResult(result));
-                return 0;
-            }
-            catch (error) {
-                stderr(error instanceof Error ? error.message : String(error));
-                return 1;
-            }
-        }
-        case "serve": {
-            try {
-                const { values } = parseArgs({
-                    args: rest,
-                    allowPositionals: false,
-                    strict: true,
-                    options: {
-                        profile: { type: "string" },
-                    },
-                });
-                const serveEnv = values.profile ? { ...env, [PROFILE_NAME_ENV]: values.profile } : env;
-                await (dependencies.startMcpServerFn ?? startMcpServer)(serveEnv);
-            }
-            catch (error) {
-                stderr(error instanceof Error ? error.message : String(error));
-                return 1;
-            }
-            return 0;
-        }
-        default: {
-            stderr(`Unknown command: ${command}`);
-            stderr(renderHelp());
-            return 1;
-        }
-    }
-}
-async function parseBootstrapOptions(args, stdin, env) {
-    const { values } = parseArgs({
-        args,
-        allowPositionals: false,
-        strict: true,
-        options: {
-            profile: { type: "string" },
-            url: { type: "string" },
-            username: { type: "string" },
-            "password-stdin": { type: "boolean" },
-            "password-env": { type: "string" },
-            timeout: { type: "string" },
-            client: { type: "string" },
-            package: { type: "string" },
-            "mcp-name": { type: "string" },
-            replace: { type: "boolean" },
-            "no-default": { type: "boolean" },
-        },
-    });
-    const baseUrl = values.url?.trim() || env.KIBANA_BASE_URL?.trim();
-    if (!baseUrl) {
-        throw new Error("Kibana base URL is required via --url or KIBANA_BASE_URL.");
-    }
-    const username = values.username?.trim() || env.KIBANA_USERNAME?.trim();
-    if (!username) {
-        throw new Error("Kibana username is required via --username or KIBANA_USERNAME.");
-    }
-    if (values["password-stdin"] && values["password-env"]) {
-        throw new Error("Use only one of --password-stdin or --password-env.");
-    }
-    let password;
-    if (values["password-stdin"]) {
-        password = (await readAllInput(stdin)).replace(/\r?\n$/, "");
-    }
-    else if (values["password-env"]) {
-        password = env[values["password-env"]];
-        if (password === undefined) {
-            throw new Error(`Password environment variable '${values["password-env"]}' is not set.`);
-        }
-    }
-    else {
-        password = env.KIBANA_PASSWORD;
-    }
-    if (!password) {
-        throw new Error("Kibana password is required via --password-stdin, --password-env, or KIBANA_PASSWORD.");
-    }
-    const client = values.client ?? "codex";
-    if (client !== "codex" && client !== "none") {
-        throw new Error("--client must be either 'codex' or 'none'.");
-    }
-    const timeoutMs = values.timeout === undefined ? undefined : Number(values.timeout);
-    if (timeoutMs !== undefined && !Number.isFinite(timeoutMs)) {
-        throw new Error("--timeout must be a number of milliseconds.");
-    }
-    return {
-        profileName: values.profile?.trim() || env[PROFILE_NAME_ENV]?.trim() || "default",
-        baseUrl,
-        username,
-        password,
-        client,
-        packageSpecifier: values.package,
-        mcpName: values["mcp-name"],
-        makeDefault: !values["no-default"],
-        replaceExisting: values.replace ?? false,
-        timeoutMs,
-    };
-}
-function renderBootstrapResult(result) {
-    return [
-        `Bootstrap verified for profile '${result.profileName}'.`,
-        result.sourceCount === 0
-            ? "Source catalog is empty. No Kibana indexes were inspected or configured. Ask the user which index or index pattern to configure before querying logs."
-            : `Preserved ${result.sourceCount} explicitly configured source${result.sourceCount === 1 ? "" : "s"}; bootstrap did not inspect them.`,
-        result.registered
-            ? `Codex MCP registration is installed and verified for profile '${result.profileName}'.`
-            : "Client registration was skipped by request.",
-    ].join("\n");
-}
-async function readAllInput(stdin) {
-    let rawInput = "";
-    for await (const chunk of stdin) {
-        rawInput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    }
-    return rawInput;
-}
-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/index.js

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