@havesomecode/kibana-mcp-server 1.2.1 → 1.3.1

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

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runCli } from "./run_cli.js";
+process.exitCode = await runCli(process.argv);

package/dist/src/bin/run_cli.js

@@ -0,0 +1,49 @@
+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, 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(argv);
+    }
+    catch (error) {
+        if (error instanceof CommanderError)
+            return error.exitCode;
+        io.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    return exitCode;
+}

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;
+}

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.1",
+  "version": "1.3.1",
   "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;
-});