@havesomecode/kibana-mcp-server 1.4.0 → 2.0.0

package/README.md

@@ -24,7 +24,13 @@ The server never writes to Elasticsearch or Kibana, and never guesses an index.
 
 ## Quick start
 
-Pre-provision the connection values in the environment, then bootstrap:
+Bootstrap the connection; missing values are prompted for:
+
+```bash
+npx -y @havesomecode/kibana-mcp-server bootstrap --client codex
+```
+
+For prompt-free automation, provision the connection values in the environment:
 
 ```bash
 export KIBANA_BASE_URL='https://kibana.example.com'
@@ -32,10 +38,15 @@ export KIBANA_USERNAME='elastic'
 export KIBANA_PASSWORD='use-a-secret-provider'
 
 npx -y @havesomecode/kibana-mcp-server bootstrap --client codex
+unset KIBANA_BASE_URL KIBANA_USERNAME KIBANA_PASSWORD
 ```
 
 Bootstrap verifies only the Kibana connection, creates an empty managed catalog, stores the credentials securely and registers the server. It does not list, scan, infer, or configure indexes: the agent asks which exact index or pattern to use, then calls `configure_index`.
 
+Clear the connection variables from the MCP server environment after bootstrap so startup uses the saved profile. Direct environment connections take precedence over profiles and require an explicit catalog path or store.
+
+The server requires a connection at startup. Use bootstrap, a configuration file, or connection environment variables with an explicit `KIBANA_SOURCE_CATALOG_PATH`. It does not accept credentials through MCP tools or search the checkout for a catalog. `bootstrap` always saves only the connection. Bare `setup` guides hand-authored catalog import; `setup` with connection options uses the same bootstrap flow.
+
 Never pass passwords as command-line arguments. Use `KIBANA_PASSWORD`, `--password-env NAME`, or `--password-stdin`.
 
 Install the agent skill that teaches the investigation workflow:
@@ -50,6 +61,8 @@ npx skills add Havesomecode/kibana-mcp-server \
 
 `INSTALL.md` is the deterministic install and handoff guide for agents.
 
+For a version-matched handoff, resolve the selected branch, tag, or package metadata to the full commit SHA. That SHA is the **resolved installation commit** used in `https://raw.githubusercontent.com/Havesomecode/kibana-mcp-server/<resolved-commit>/README.md`. Read `INSTALL.md` and the skills from the same commit. Do not infer a Git tag from an npm version; use the exact package's `gitHead`. A maintained checkout can verify the handoff with `node scripts/readme-handoff.mjs <resolved-installation-ref>`.
+
 ## Run it as a shared service
 
 By default the server speaks stdio and serves one configuration. Over HTTP, one process serves every caller of your gateway, each with their own source catalog:
@@ -75,11 +88,16 @@ kibana-mcp-server serve --http --config ./kibana.mcp.config.ts
 
 Catalogs can live in files, Redis, PostgreSQL, MongoDB, SQLite, or a store you write. The HTTP transport trusts the profile header as sent: only a gateway that has authenticated the caller should reach it.
 
+## Repository Codex plugin
+
+`npm run build` creates a self-contained runtime in `plugins/kibana-log-investigation/dist/`. The repo-local Codex plugin launches that installed bundle through `mcp-launcher.mjs`, without depending on the original checkout or its `node_modules`. Use `npm run verify:entrypoint` for the isolated copied-plugin handshake, and inspect Codex's MCP startup status plus sanitized stderr before restarting a discussion.
+
 ## Documentation
 
 | Topic | Link |
 | --- | --- |
 | Getting started | https://havesomecode.github.io/kibana-mcp-server/guide/getting-started |
+| Agent plugins and skills | https://havesomecode.github.io/kibana-mcp-server/ai/agent-plugins |
 | Investigating with an agent | https://havesomecode.github.io/kibana-mcp-server/guide/investigating |
 | HTTP transport and security model | https://havesomecode.github.io/kibana-mcp-server/deployment/http |
 | Catalog stores | https://havesomecode.github.io/kibana-mcp-server/deployment/catalog-stores |

package/dist/src/bin/run_cli.js

@@ -1,6 +1,7 @@
 import { Command, CommanderError } from "commander";
+import registerBootstrapCommand from "../commands/bootstrap.js";
 import registerServeCommand from "../commands/serve.js";
-import registerSetupCommands from "../commands/setup.js";
+import registerSetupCommand from "../commands/setup.js";
 import { startMcpServer } from "../transports/stdio.js";
 import { createCliIo } from "../utils/cli_io.js";
 import { createCliUi } from "../utils/cli_ui.js";
@@ -8,7 +9,6 @@ export async function runCli(argv, overrides = {}, dependencies = {}) {
     const io = createCliIo(overrides);
     let exitCode = 0;
     const context = {
-        argv,
         io,
         ui: createCliUi(io),
         dependencies,
@@ -34,7 +34,8 @@ export async function runCli(argv, overrides = {}, dependencies = {}) {
             exitCode = 1;
         }
     });
-    registerSetupCommands(program, context);
+    registerSetupCommand(program, context);
+    registerBootstrapCommand(program, context);
     registerServeCommand(program, context);
     try {
         await program.parseAsync(argv);

package/dist/src/commands/bootstrap.d.ts

@@ -0,0 +1,18 @@
+import { type Command } from "commander";
+import type { CliCommandContext } from "./context.js";
+export interface BootstrapOptions {
+    profile?: string;
+    url?: string;
+    username?: string;
+    passwordStdin?: boolean;
+    passwordEnv?: string;
+    timeout?: number;
+    client?: "codex" | "none";
+    package?: string;
+    mcpName?: string;
+    replace?: boolean;
+    default: boolean;
+}
+export default function registerBootstrap(program: Command, context: CliCommandContext): void;
+export declare function addBootstrapOptions(command: Command): Command;
+export declare function runBootstrapCommand(options: BootstrapOptions, context: CliCommandContext): Promise<void>;

package/dist/src/commands/bootstrap.js

@@ -0,0 +1,98 @@
+import { InvalidArgumentError, Option } from "commander";
+import { runBootstrap } from "../setup/bootstrap.js";
+import { createPromptIo } from "../utils/cli_prompts.js";
+export default function registerBootstrap(program, context) {
+    addBootstrapOptions(program
+        .command("bootstrap")
+        .description("Verify and save only the Kibana connection")
+        .addHelpText("after", "\nBootstrap does not inspect or configure indexes. Missing connection values are prompted for.\n\nConnection options use KIBANA_BASE_URL, KIBANA_USERNAME, and KIBANA_PASSWORD as fallbacks. Passwords are accepted only through --password-stdin, --password-env <NAME>, KIBANA_PASSWORD, or a secret prompt. Profile defaults to KIBANA_PROFILE, then default.")).action((options) => runBootstrapCommand(options, context));
+}
+export function addBootstrapOptions(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");
+}
+export async function runBootstrapCommand(options, context) {
+    const { env, stdin } = context.io;
+    let promptIo;
+    try {
+        let baseUrl = options.url?.trim() || env.KIBANA_BASE_URL?.trim();
+        let username = options.username?.trim() || env.KIBANA_USERNAME?.trim();
+        let password = options.passwordStdin
+            ? (await readAllInput(stdin)).replace(/\r?\n$/, "")
+            : options.passwordEnv !== undefined
+                ? env[options.passwordEnv]
+                : env.KIBANA_PASSWORD;
+        const promptForPassword = !password && !options.passwordStdin && options.passwordEnv === undefined;
+        if (!baseUrl || !username || promptForPassword) {
+            promptIo = await createPromptIo(context.io);
+        }
+        baseUrl ||= (await promptIo?.prompt("Kibana base URL"))?.trim();
+        if (!baseUrl) {
+            throw new Error("Kibana base URL is required via --url, KIBANA_BASE_URL, or the associated prompt.");
+        }
+        username ||= (await promptIo?.prompt("Kibana username"))?.trim();
+        if (!username) {
+            throw new Error("Kibana username is required via --username, KIBANA_USERNAME, or the associated prompt.");
+        }
+        if (promptForPassword) {
+            password = (await promptIo?.prompt("Kibana password", { secret: true }))?.trim();
+        }
+        if (!password) {
+            throw new Error("Kibana password is required via an option, KIBANA_PASSWORD, or the associated prompt.");
+        }
+        const result = await (context.dependencies.runBootstrapFn ?? runBootstrap)({
+            profileName: options.profile?.trim() || env.KIBANA_PROFILE?.trim() || "default",
+            baseUrl,
+            username,
+            password,
+            client: options.client ?? "codex",
+            packageSpecifier: options.package,
+            mcpName: options.mcpName,
+            makeDefault: options.default,
+            replaceExisting: options.replace ?? false,
+            timeoutMs: options.timeout,
+        });
+        context.ui.success(renderBootstrapResult(result));
+    }
+    catch (error) {
+        context.ui.error(error instanceof Error ? error.message : String(error));
+        context.setExitCode(1);
+    }
+    finally {
+        await promptIo?.close();
+    }
+}
+function parseTimeout(value) {
+    const timeout = Number(value);
+    if (!Number.isInteger(timeout) || timeout <= 0 || timeout > 120000) {
+        throw new InvalidArgumentError("--timeout must be a positive integer no greater than 120000 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;
+}

package/dist/src/commands/context.d.ts

@@ -5,7 +5,6 @@ import type { startMcpServer } from "../transports/stdio.js";
 import type { CliIo } from "../utils/cli_io.js";
 import type { CliUi } from "../utils/cli_ui.js";
 export interface CliCommandContext {
-    argv: string[];
     io: CliIo;
     ui: CliUi;
     dependencies: {

package/dist/src/commands/setup.d.ts

@@ -1,3 +1,3 @@
-import { type Command } from "commander";
+import type { Command } from "commander";
 import type { CliCommandContext } from "./context.js";
 export default function registerSetup(program: Command, context: CliCommandContext): void;

package/dist/src/commands/setup.js

@@ -1,17 +1,14 @@
-import { InvalidArgumentError, Option } from "commander";
-import { runBootstrap as runBootstrapFlow } from "../setup/bootstrap.js";
 import { runSetupFlow } from "../setup/setup_flow.js";
 import { PromptCancelledError, createPromptIo } from "../utils/cli_prompts.js";
+import { addBootstrapOptions, runBootstrapCommand } from "./bootstrap.js";
 export default function registerSetup(program, context) {
-    const setupCommand = addOptions(program
+    addBootstrapOptions(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);
+        .description("Run guided setup, or connection-only bootstrap with options")
+        .addHelpText("after", "\nWithout connection options, setup is guided even when connection environment values exist. With any connection option, setup uses bootstrap: it does not inspect or configure indexes and prompts only for missing connection values.")).action(async (options, command) => {
+        if (command.options.some((option) => command.getOptionValueSource(option.attributeName()) === "cli")) {
+            return runBootstrapCommand(options, context);
+        }
         const promptIo = await createPromptIo(context.io);
         try {
             const result = await (context.dependencies.runSetupFlowFn ?? runSetupFlow)(promptIo);
@@ -28,105 +25,3 @@ export default function registerSetup(program, context) {
         }
     });
 }
-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;
-}

package/dist/src/config/environment.d.ts

@@ -3,13 +3,8 @@ import { z } from "zod";
 import { type SecretStore } from "../profiles/secret_store.js";
 import { ProfileStore } from "../profiles/store.js";
 import type { AppConfig, ResolvedAppConfig } from "../types.js";
-export declare const DEFAULT_RUNTIME_SOURCE_CATALOG_PATH = "config/sources.runtime.json";
-export declare const DEFAULT_STATIC_SOURCE_CATALOG_PATH = "config/sources.json";
 export declare const PROFILE_NAME_ENV = "KIBANA_PROFILE";
 export declare const PROFILE_PLACEHOLDER = "{profile}";
-export declare class NoSavedProfileError extends Error {
-    constructor(message: string);
-}
 export declare const sourceDefinitionSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -81,7 +76,6 @@ export declare const sourceCatalogSchema: z.ZodObject<{
         evidenceFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare function resolveSourceCatalogPath(envInput?: NodeJS.ProcessEnv): string;
 export declare function parseAppConfig(envInput: unknown, sourceCatalogInput: unknown): AppConfig;
 export declare function loadConfigFromEnvironment(envInput?: NodeJS.ProcessEnv, dependencies?: {
     profileStore?: Pick<ProfileStore, "findProfile" | "getDefaultProfile">;
@@ -93,8 +87,3 @@ export declare function loadConfigFromEnvironment(envInput?: NodeJS.ProcessEnv,
  * Reads the connection supplied through the bootstrap environment variables, if any.
  */
 export declare function readBootstrapConnection(envInput?: NodeJS.ProcessEnv): AppConfig["kibana"] | undefined;
-export declare function persistSourceCatalog(sources: AppConfig["sources"], options?: {
-    envInput?: NodeJS.ProcessEnv;
-    sourceCatalogPath?: string;
-    catalog?: unknown;
-}): Promise<string>;

package/dist/src/config/environment.js

@@ -3,17 +3,8 @@ import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { SecretStoreError, createSecretStore } from "../profiles/secret_store.js";
 import { ProfileStore } from "../profiles/store.js";
-import { writeTextAtomically } from "../utils/fs.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 const PROFILE_PLACEHOLDER = "{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),
@@ -112,13 +103,6 @@ function buildKibanaConfig(env) {
         timeoutMs: env.KIBANA_TIMEOUT_MS ?? 10000,
     };
 }
-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);
@@ -132,19 +116,14 @@ export async function loadConfigFromEnvironment(envInput = process.env, dependen
     const readFileImpl = dependencies.readFile ?? readFile;
     const kibana = readBootstrapConnection(envInput);
     if (kibana) {
-        const preferredPath = resolveSourceCatalogPath(envInput);
-        const sourceCatalog = await loadSourceCatalog(preferredPath === DEFAULT_RUNTIME_SOURCE_CATALOG_PATH
-            ? [preferredPath, DEFAULT_STATIC_SOURCE_CATALOG_PATH]
-            : [preferredPath], readFileImpl);
+        const sourceCatalogPath = overrides.KIBANA_SOURCE_CATALOG_PATH?.trim();
+        if (!sourceCatalogPath) {
+            throw new Error("KIBANA_SOURCE_CATALOG_PATH is required for an environment connection.");
+        }
         return {
             kibana,
-            sources: sourceCatalogSchema.parse(sourceCatalog.value).sources,
-            sourceCatalogPath: preferredPath,
-            sourceCatalogOrigin: sourceCatalog.loadedFrom === DEFAULT_STATIC_SOURCE_CATALOG_PATH
-                ? "static_default"
-                : preferredPath === DEFAULT_RUNTIME_SOURCE_CATALOG_PATH
-                    ? "runtime_default"
-                    : "environment",
+            sources: await loadSourceCatalog(sourceCatalogPath, readFileImpl),
+            sourceCatalogPath,
         };
     }
     const profileStore = dependencies.profileStore ?? new ProfileStore();
@@ -156,12 +135,9 @@ export async function loadConfigFromEnvironment(envInput = process.env, dependen
         })
         : 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.");
+            : "No saved Kibana connection is available. Run connection bootstrap first.");
     }
     const savedSecret = await secretStore.load(profile.id).catch((error) => {
         if (error instanceof SecretStoreError && error.code === "NOT_FOUND") {
@@ -170,7 +146,6 @@ export async function loadConfigFromEnvironment(envInput = process.env, dependen
         throw error;
     });
     const sourceCatalogPath = overrides.KIBANA_SOURCE_CATALOG_PATH?.trim() || profile.sourceCatalogPath;
-    const sourceCatalog = await loadSourceCatalog([sourceCatalogPath], readFileImpl);
     return {
         kibana: {
             baseUrl: profile.baseUrl.replace(/\/+$/, ""),
@@ -178,10 +153,9 @@ export async function loadConfigFromEnvironment(envInput = process.env, dependen
             password: savedSecret.password,
             timeoutMs: parseTimeoutOverride(overrides.KIBANA_TIMEOUT_MS) ?? profile.timeoutMs,
         },
-        sources: sourceCatalogSchema.parse(sourceCatalog.value).sources,
+        sources: await loadSourceCatalog(sourceCatalogPath, readFileImpl),
         profileName: profile.name,
         sourceCatalogPath,
-        sourceCatalogOrigin: overrides.KIBANA_SOURCE_CATALOG_PATH?.trim() ? "environment" : "profile",
     };
 }
 /**
@@ -196,11 +170,6 @@ export function readBootstrapConnection(envInput = process.env) {
         ? buildKibanaConfig(bootstrapEnvSchema.parse(overrides))
         : undefined;
 }
-export async function persistSourceCatalog(sources, options = {}) {
-    const sourceCatalogPath = options.sourceCatalogPath ?? resolveSourceCatalogPath(options.envInput);
-    await writeTextAtomically(sourceCatalogPath, `${JSON.stringify(options.catalog ?? { sources }, null, 2)}\n`);
-    return sourceCatalogPath;
-}
 function hasBootstrapConfig(envInput) {
     return Boolean(envInput.KIBANA_BASE_URL?.trim() &&
         envInput.KIBANA_USERNAME?.trim() &&
@@ -224,25 +193,6 @@ function parseTimeoutOverride(value) {
     }
     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),
-    };
+async function loadSourceCatalog(path, readFileImpl) {
+    return sourceCatalogSchema.parse(JSON.parse(await readFileImpl(path, "utf8"))).sources;
 }

package/dist/src/config/startup.js

@@ -1,7 +1,7 @@
 import { bindCatalogStore } from "../stores/catalog_store.js";
 import { createFileCatalogStore } from "../stores/file.js";
 import { CONFIG_FILE_ENV, applyConfigFile, loadConfigFile, } from "./config_file.js";
-import { NoSavedProfileError, PROFILE_NAME_ENV, PROFILE_PLACEHOLDER, loadConfigFromEnvironment, readBootstrapConnection, } from "./environment.js";
+import { PROFILE_NAME_ENV, PROFILE_PLACEHOLDER, loadConfigFromEnvironment, readBootstrapConnection, } from "./environment.js";
 /** Profile served over stdio when per-profile catalogs are configured and none is named. */
 export const DEFAULT_PROFILE_NAME = "default";
 /**
@@ -71,16 +71,8 @@ async function resolveConfiguration(envInput, dependencies, customStore) {
     }
     // Named saved profiles carry their own catalog: the global catalog override is not applied.
     const loadProfileConfig = (profileName) => loadConfigFromEnvironment({ KIBANA_TIMEOUT_MS: envInput.KIBANA_TIMEOUT_MS, [PROFILE_NAME_ENV]: profileName }, { ...dependencies, exactProfileName: true });
-    try {
-        return {
-            defaultConfig: await loadConfigFromEnvironment(envInput, dependencies),
-            loadProfileConfig,
-        };
-    }
-    catch (error) {
-        if (error instanceof NoSavedProfileError) {
-            return {};
-        }
-        throw error;
-    }
+    return {
+        defaultConfig: await loadConfigFromEnvironment(envInput, dependencies),
+        loadProfileConfig,
+    };
 }

package/dist/src/mcp_entry.js

@@ -1,6 +1,3 @@
 #!/usr/bin/env node
 import { startMcpServer } from "./transports/stdio.js";
-startMcpServer().catch((error) => {
-    console.error(error);
-    process.exitCode = 1;
-});
+await startMcpServer();

package/dist/src/profiles/runtime.d.ts

@@ -26,14 +26,10 @@ export declare class ProfileRuntimeRegistry {
     private readonly inFlight;
     private readonly clients;
     private readonly refreshes;
-    private defaultRuntime?;
+    private readonly defaultRuntime?;
     constructor(options?: ProfileRuntimeRegistryOptions);
     get hasDefault(): boolean;
     get supportsNamedProfiles(): boolean;
-    /** False only for a server started without any configuration, waiting for the legacy 'configure' tool. */
-    get isConfigured(): boolean;
-    getDefault(): ProfileRuntime | undefined;
-    setDefault(config: ResolvedAppConfig): ProfileRuntime;
     resolve(profileName?: string): Promise<ProfileRuntime>;
     private refresh;
     replaceSources(runtime: ProfileRuntime, sources: SourceDefinition[], catalogContent?: string | undefined): void;

package/dist/src/profiles/runtime.js

@@ -15,6 +15,9 @@ export class ProfileRuntimeRegistry {
     refreshes = new WeakMap();
     defaultRuntime;
     constructor(options = {}) {
+        if (!options.defaultConfig && !options.loadProfileConfig) {
+            throw new Error("No saved Kibana connection is available. Run connection bootstrap first.");
+        }
         this.kibanaClientFactory =
             options.kibanaClientFactory ?? ((config) => new KibanaClient(config));
         this.loadProfileConfig = options.loadProfileConfig;
@@ -29,25 +32,12 @@ export class ProfileRuntimeRegistry {
     get supportsNamedProfiles() {
         return this.loadProfileConfig !== undefined;
     }
-    /** False only for a server started without any configuration, waiting for the legacy 'configure' tool. */
-    get isConfigured() {
-        return this.hasDefault || this.supportsNamedProfiles;
-    }
-    getDefault() {
-        return this.defaultRuntime;
-    }
-    setDefault(config) {
-        this.defaultRuntime = this.createRuntime(config);
-        return this.defaultRuntime;
-    }
     async resolve(profileName) {
         if (profileName === undefined) {
             if (this.defaultRuntime) {
                 return this.refresh(this.defaultRuntime);
             }
-            throw new Error(this.loadProfileConfig
-                ? "No profile was supplied for this call and no default profile is configured."
-                : "Server is not configured. Call the 'configure' tool first.");
+            throw new Error("No profile was supplied for this call and no default profile is configured.");
         }
         // Names are compared exactly: two identities differing only by case are two profiles, each
         // with its own catalog.

package/dist/src/server.d.ts

@@ -1,7 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import { type KibanaClient } from "./kibana/client.js";
 import { ProfileRuntimeRegistry } from "./profiles/runtime.js";
-import { executeConfigure } from "./tools/configure.js";
 import { executeConfigureIndex } from "./tools/configure_index.js";
 import { executeDescribeFields } from "./tools/describe_fields.js";
 import { executeDiscover } from "./tools/discover.js";
@@ -12,7 +11,6 @@ import type { ResolvedAppConfig } from "./types.js";
 export interface Application {
     server: McpServer;
     handlers: {
-        configure: (input: unknown) => Promise<Awaited<ReturnType<typeof executeConfigure>>["result"]>;
         configure_index: (input: unknown, callerSignal?: AbortSignal) => Promise<Awaited<ReturnType<typeof executeConfigureIndex>>["result"]>;
         describe_fields: (input: unknown, callerSignal?: AbortSignal) => Promise<Awaited<ReturnType<typeof executeDescribeFields>>>;
         discover: (input: unknown) => Promise<ReturnType<typeof executeDiscover>>;