@havesomecode/kibana-mcp-server 1.2.0 → 1.3.0

package/README.md

@@ -104,7 +104,7 @@ npm run build
 5. Open the plugin directory in Codex and install `Kibana Log Investigation` from the repo marketplace.
    - if the current model cannot complete that install itself, do the Codex UI click manually and let the agent continue with configuration afterward
 6. Restart Codex if the new MCP server does not appear immediately.
-7. Run `node dist/src/index.js bootstrap --client none` to verify the connection and save an empty profile. The repo plugin already supplies the client registration.
+7. Run `node dist/src/bin/kibana-mcp-server.js bootstrap --client none` to verify the connection and save an empty profile. The repo plugin already supplies the client registration.
 8. In a fresh thread, call `discover`, ask the user for the exact index or pattern, then call `configure_index` only after they answer.
 
 Repo-scoped plugin files:
@@ -134,7 +134,7 @@ The preferred path is deterministic connection-only bootstrap:
 
 Guided setup remains available for hand-authored source catalogs:
 
-- `npm run setup` or `node dist/src/index.js setup`
+- `npm run setup` or `node dist/src/bin/kibana-mcp-server.js setup`
 - saves non-secret profile metadata in the user’s machine-level app config directory
 - saves credentials in the platform credential store
   - macOS Keychain
@@ -177,6 +177,10 @@ Environment variables:
 - `KIBANA_TIMEOUT_MS` optional, default `10000`
 - `KIBANA_SOURCE_CATALOG_PATH` optional, default `config/sources.runtime.json`
 
+`KIBANA_TIMEOUT_MS` bounds each Kibana HTTP request end to end: it includes waiting for a request slot, connecting, and reading the response body. The server allows at most eight concurrent Kibana requests and 32 queued requests per configured client; excess work fails immediately with `KIBANA_OVERLOADED`. Cancelled MCP tool calls abort their queued or in-flight backend work.
+
+Backend failures use stable diagnostic codes such as `KIBANA_TIMEOUT`, `KIBANA_CANCELLED`, `KIBANA_OVERLOADED`, `KIBANA_AUTHENTICATION`, `KIBANA_DNS`, `KIBANA_TLS`, `KIBANA_CONNECTION`, and `KIBANA_RESPONSE`. Failed backend tool results also expose the diagnostic fields in `_meta.kibana_request_error`.
+
 `KIBANA_BASE_URL` is the Kibana base prefix that the server joins with each configured backend or schema path.
 
 Use:

package/dist/src/bin/kibana-mcp-server.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { Command, CommanderError } from "commander";
+import registerServeCommand from "../commands/serve.js";
+import registerSetupCommands from "../commands/setup.js";
+import { startMcpServer } from "../mcp_runtime.js";
+import { createCliIo } from "../utils/cli_io.js";
+import { createCliUi } from "../utils/cli_ui.js";
+export async function runCli(argv = process.argv.slice(2), overrides = {}, dependencies = {}) {
+    const io = createCliIo(overrides);
+    let exitCode = 0;
+    const context = {
+        argv,
+        io,
+        ui: createCliUi(io),
+        dependencies,
+        setExitCode: (code) => {
+            exitCode = code;
+        },
+    };
+    const program = new Command()
+        .name("kibana-mcp-server")
+        .description("Kibana Log Investigation")
+        .showHelpAfterError()
+        .exitOverride()
+        .configureOutput({
+        writeOut: (message) => io.stdout(message.trimEnd()),
+        writeErr: (message) => io.stderr(message.trimEnd()),
+    })
+        .action(async () => {
+        try {
+            await (dependencies.startMcpServerFn ?? startMcpServer)(io.env);
+        }
+        catch (error) {
+            context.ui.error(error instanceof Error ? error.message : String(error));
+            exitCode = 1;
+        }
+    });
+    registerSetupCommands(program, context);
+    registerServeCommand(program, context);
+    try {
+        await program.parseAsync(["node", "kibana-mcp-server", ...argv], { from: "node" });
+    }
+    catch (error) {
+        if (error instanceof CommanderError)
+            return error.exitCode;
+        io.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    return exitCode;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    process.exitCode = await runCli();
+}

package/dist/src/commands/context.js

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

package/dist/src/commands/serve.js

@@ -0,0 +1,19 @@
+import { PROFILE_NAME_ENV } from "../config.js";
+import { startMcpServer } from "../mcp_runtime.js";
+export default (program, context) => {
+    program
+        .command("serve")
+        .description("Start the stdio MCP server")
+        .option("--profile <name>", "Saved profile name")
+        .action(async (options) => {
+        try {
+            await (context.dependencies.startMcpServerFn ?? startMcpServer)(options.profile
+                ? { ...context.io.env, [PROFILE_NAME_ENV]: options.profile }
+                : context.io.env);
+        }
+        catch (error) {
+            context.ui.error(error instanceof Error ? error.message : String(error));
+            context.setExitCode(1);
+        }
+    });
+};

package/dist/src/commands/setup.js

@@ -0,0 +1,132 @@
+import { InvalidArgumentError, Option } from "commander";
+import { runBootstrap as runBootstrapFlow } from "../bootstrap.js";
+import { runSetupFlow } from "../setup_flow.js";
+import { PromptCancelledError, createPromptIo } from "../utils/cli_prompts.js";
+export default function registerSetup(program, context) {
+    const setupCommand = addOptions(program
+        .command("setup")
+        .alias("bootstrap")
+        .description("Run guided machine setup and connection bootstrap")
+        .addHelpText("after", "\nBootstrap is an alias for setup. Without options, setup is guided; with options, it verifies and saves only the Kibana connection and does not inspect or configure indexes.\n\nConnection 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."));
+    setupCommand.action(async () => {
+        const options = readOptions(context.argv);
+        if (context.argv.some((argument) => argument.startsWith("-")))
+            return runBootstrap(options, context);
+        const promptIo = await createPromptIo(context.io);
+        try {
+            const result = await (context.dependencies.runSetupFlowFn ?? runSetupFlow)(promptIo);
+            context.ui.success(`Saved ${result.profiles.length} environment${result.profiles.length === 1 ? "" : "s"}. Default environment: ${result.defaultProfileName}.`);
+        }
+        catch (error) {
+            if (error instanceof PromptCancelledError)
+                context.setExitCode(130);
+            else
+                throw error;
+        }
+        finally {
+            await promptIo.close();
+        }
+    });
+}
+function readOptions(argv) {
+    const value = (flag) => {
+        const index = argv.indexOf(flag);
+        return index === -1 ? undefined : argv[index + 1];
+    };
+    return {
+        profile: value("--profile"),
+        url: value("--url"),
+        username: value("--username"),
+        passwordStdin: argv.includes("--password-stdin"),
+        passwordEnv: value("--password-env"),
+        timeout: value("--timeout") === undefined ? undefined : Number(value("--timeout")),
+        client: value("--client"),
+        package: value("--package"),
+        mcpName: value("--mcp-name"),
+        replace: argv.includes("--replace"),
+        default: !argv.includes("--no-default"),
+    };
+}
+function addOptions(command) {
+    return command
+        .option("--profile <name>", "Saved profile name")
+        .option("--url <url>", "Kibana base URL")
+        .option("--username <name>", "Kibana basic-auth username")
+        .addOption(new Option("--password-stdin", "Read the password from stdin").conflicts("passwordEnv"))
+        .option("--password-env <name>", "Read the password from an environment variable")
+        .addOption(new Option("--timeout <milliseconds>", "Kibana request timeout").argParser(parseTimeout))
+        .addOption(new Option("--client <codex|none>", "Client registration mode").choices(["codex", "none"]))
+        .option("--package <specifier>", "Package specifier for client registration")
+        .option("--mcp-name <name>", "MCP registration name")
+        .option("--replace", "Replace an existing catalog")
+        .option("--no-default", "Do not make this profile the default");
+}
+async function runBootstrap(options, context) {
+    const needsPrompt = !options.url ||
+        !options.username ||
+        (!options.passwordStdin && options.passwordEnv === undefined);
+    const promptIo = needsPrompt ? await createPromptIo(context.io) : undefined;
+    try {
+        const result = await (context.dependencies.runBootstrapFn ?? runBootstrapFlow)(await resolveBootstrapOptions(options, context, promptIo));
+        context.ui.success(renderBootstrapResult(result));
+    }
+    catch (error) {
+        context.ui.error(error instanceof Error ? error.message : String(error));
+        context.setExitCode(1);
+    }
+    finally {
+        await promptIo?.close();
+    }
+}
+async function resolveBootstrapOptions(values, context, prompter) {
+    const { env, stdin } = context.io;
+    const baseUrl = values.url?.trim() || (await prompter?.prompt("Kibana base URL"))?.trim();
+    if (!baseUrl)
+        throw new Error("Kibana base URL is required via --url or the associated prompt.");
+    const username = values.username?.trim() || (await prompter?.prompt("Kibana username"))?.trim();
+    if (!username)
+        throw new Error("Kibana username is required via --username or the associated prompt.");
+    const password = values.passwordStdin
+        ? (await readAllInput(stdin)).replace(/\r?\n$/, "")
+        : values.passwordEnv
+            ? env[values.passwordEnv]
+            : (await prompter?.prompt("Kibana password", { secret: true }))?.trim();
+    if (!password)
+        throw new Error("Kibana password is required via an option or the associated prompt.");
+    return {
+        profileName: values.profile?.trim() || env.KIBANA_PROFILE?.trim() || "default",
+        baseUrl,
+        username,
+        password,
+        client: values.client ?? "codex",
+        packageSpecifier: values.package,
+        mcpName: values.mcpName,
+        makeDefault: values.default,
+        replaceExisting: values.replace ?? false,
+        timeoutMs: values.timeout,
+    };
+}
+function parseTimeout(value) {
+    const timeout = Number(value);
+    if (!Number.isFinite(timeout)) {
+        throw new InvalidArgumentError("--timeout must be a number of milliseconds.");
+    }
+    return timeout;
+}
+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 raw = "";
+    for await (const chunk of stdin)
+        raw += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    return raw;
+}