@kirrosh/apitool 0.4.3

package/src/mcp/tools/query-db.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getDb } from "../../db/schema.ts";
+import { listCollections, listRuns, getRunById, getResultsByRunId } from "../../db/queries.ts";
+
+export function registerQueryDbTool(server: McpServer, dbPath?: string) {
+  server.registerTool("query_db", {
+    description:
+      "Query the apitool database. Actions: list_collections (all APIs with run stats), " +
+      "list_runs (recent test runs), get_run_results (full detail for a run), " +
+      "diagnose_failure (only failed/errored steps for a run).",
+    inputSchema: {
+      action: z.enum(["list_collections", "list_runs", "get_run_results", "diagnose_failure"])
+        .describe("Query action to perform"),
+      runId: z.optional(z.number().int())
+        .describe("Run ID (required for get_run_results and diagnose_failure)"),
+      limit: z.optional(z.number().int().min(1).max(100))
+        .describe("Max number of runs to return (default: 20, only for list_runs)"),
+    },
+  }, async ({ action, runId, limit }) => {
+    try {
+      getDb(dbPath);
+
+      switch (action) {
+        case "list_collections": {
+          const collections = listCollections();
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(collections, null, 2) }],
+          };
+        }
+
+        case "list_runs": {
+          const runs = listRuns(limit ?? 20);
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(runs, null, 2) }],
+          };
+        }
+
+        case "get_run_results": {
+          if (runId == null) {
+            return {
+              content: [{ type: "text" as const, text: JSON.stringify({ error: "runId is required for get_run_results" }, null, 2) }],
+              isError: true,
+            };
+          }
+          const run = getRunById(runId);
+          if (!run) {
+            return {
+              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
+              isError: true,
+            };
+          }
+          const results = getResultsByRunId(runId);
+          const detail = {
+            run: {
+              id: run.id,
+              started_at: run.started_at,
+              finished_at: run.finished_at,
+              total: run.total,
+              passed: run.passed,
+              failed: run.failed,
+              skipped: run.skipped,
+              trigger: run.trigger,
+              environment: run.environment,
+              duration_ms: run.duration_ms,
+            },
+            results: results.map(r => ({
+              suite_name: r.suite_name,
+              test_name: r.test_name,
+              status: r.status,
+              duration_ms: r.duration_ms,
+              request_method: r.request_method,
+              request_url: r.request_url,
+              response_status: r.response_status,
+              error_message: r.error_message,
+              assertions: r.assertions,
+            })),
+          };
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(detail, null, 2) }],
+          };
+        }
+
+        case "diagnose_failure": {
+          if (runId == null) {
+            return {
+              content: [{ type: "text" as const, text: JSON.stringify({ error: "runId is required for diagnose_failure" }, null, 2) }],
+              isError: true,
+            };
+          }
+          const diagRun = getRunById(runId);
+          if (!diagRun) {
+            return {
+              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
+              isError: true,
+            };
+          }
+          const allResults = getResultsByRunId(runId);
+          const failures = allResults
+            .filter(r => r.status === "fail" || r.status === "error")
+            .map(r => ({
+              suite_name: r.suite_name,
+              test_name: r.test_name,
+              status: r.status,
+              error_message: r.error_message,
+              request_method: r.request_method,
+              request_url: r.request_url,
+              response_status: r.response_status,
+              response_headers: r.response_headers
+                ? JSON.parse(r.response_headers)
+                : undefined,
+              assertions: r.assertions,
+              duration_ms: r.duration_ms,
+            }));
+          const result = {
+            run: {
+              id: diagRun.id,
+              started_at: diagRun.started_at,
+              environment: diagRun.environment,
+              duration_ms: diagRun.duration_ms,
+            },
+            summary: {
+              total: diagRun.total,
+              passed: diagRun.passed,
+              failed: diagRun.failed,
+            },
+            failures,
+          };
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+          };
+        }
+      }
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
+        isError: true,
+      };
+    }
+  });
+}

package/src/mcp/tools/run-tests.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { executeRun } from "../../core/runner/execute-run.ts";
+
+export function registerRunTestsTool(server: McpServer, dbPath?: string) {
+  server.registerTool("run_tests", {
+    description: "Execute API tests from a YAML file or directory and return results summary with failures. " +
+      "Use after saving test suites with save_test_suite. Check query_db(action: 'diagnose_failure') for detailed failure analysis.",
+    inputSchema: {
+      testPath: z.string().describe("Path to test YAML file or directory"),
+      envName: z.optional(z.string()).describe("Environment name (loads .env.<name>.yaml)"),
+      safe: z.optional(z.boolean()).describe("Run only GET tests (read-only, safe mode)"),
+      tag: z.optional(z.array(z.string())).describe("Filter suites by tag (OR logic)"),
+    },
+  }, async ({ testPath, envName, safe, tag }) => {
+    const { runId, results } = await executeRun({
+      testPath,
+      envName,
+      trigger: "mcp",
+      dbPath,
+      safe,
+      tag,
+    });
+
+    const total = results.reduce((s, r) => s + r.total, 0);
+    const passed = results.reduce((s, r) => s + r.passed, 0);
+    const failed = results.reduce((s, r) => s + r.failed, 0);
+    const skipped = results.reduce((s, r) => s + r.skipped, 0);
+
+    const failedSteps = results.flatMap(r =>
+      r.steps.filter(s => s.status === "fail" || s.status === "error").map(s => ({
+        suite: r.suite_name,
+        test: s.name,
+        status: s.status,
+        error: s.error,
+        assertions: s.assertions.filter(a => !a.passed).map(a => ({
+          field: a.field,
+          expected: a.expected,
+          actual: a.actual,
+        })),
+      }))
+    );
+
+    const hints: string[] = [];
+    if (failedSteps.length > 0) {
+      hints.push("Use query_db(action: 'diagnose_failure', runId: " + runId + ") for detailed failure analysis");
+    }
+    hints.push("Ask the user if they want to set up CI/CD to run these tests automatically on push. If yes, use ci_init to generate a workflow and help them push to GitHub/GitLab.");
+
+    const summary = {
+      runId,
+      total,
+      passed,
+      failed,
+      skipped,
+      suites: results.length,
+      status: failed === 0 ? "all_passed" : "has_failures",
+      ...(failedSteps.length > 0 ? { failures: failedSteps } : {}),
+      hints,
+    };
+
+    return {
+      content: [{ type: "text" as const, text: JSON.stringify(summary, null, 2) }],
+    };
+  });
+}

package/src/mcp/tools/save-test-suite.ts

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { validateSuite } from "../../core/parser/schema.ts";
+import { join, dirname } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import YAML from "yaml";
+
+export function registerSaveTestSuiteTool(server: McpServer, dbPath?: string) {
+  server.registerTool("save_test_suite", {
+    description: "Save a YAML test suite file with validation. Parses and validates the YAML content " +
+      "before writing. Returns structured errors if validation fails so you can fix and retry. " +
+      "Use after generating test content with generate_tests_guide.",
+    inputSchema: {
+      filePath: z.string().describe("Path for saving the YAML test file (e.g. apis/petstore/tests/pets-crud.yaml)"),
+      content: z.string().describe("YAML content of the test suite"),
+      overwrite: z.optional(z.boolean()).describe("Overwrite existing file (default: false)"),
+    },
+  }, async ({ filePath, content, overwrite }) => {
+    try {
+      // Parse YAML
+      let parsed: unknown;
+      try {
+        parsed = YAML.parse(content);
+      } catch (err) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({
+            saved: false,
+            error: `YAML parse error: ${(err as Error).message}`,
+            hint: "Check YAML syntax — indentation, colons, and quoting",
+          }, null, 2) }],
+          isError: true,
+        };
+      }
+
+      // Validate against test suite schema
+      try {
+        validateSuite(parsed);
+      } catch (err) {
+        const message = (err as Error).message;
+        // Extract Zod error details
+        let hint = "Check the test suite structure matches the expected format";
+        if (message.includes("status")) {
+          hint = "Status codes must be numbers, not strings (e.g. status: 200, not status: \"200\")";
+        } else if (message.includes("exists")) {
+          hint = "exists must be boolean true/false, not string \"true\"/\"false\"";
+        } else if (message.includes("tests")) {
+          hint = "Suite must have a 'tests' array with at least one test step";
+        }
+
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({
+            saved: false,
+            error: `Validation: ${message}`,
+            hint,
+          }, null, 2) }],
+          isError: true,
+        };
+      }
+
+      // Detect hardcoded credentials — long opaque strings in auth headers
+      const credentialPattern = /Authorization\s*:\s*["']?(Basic|Bearer)\s+([A-Za-z0-9+/=_\-]{20,})["']?/g;
+      const credMatches = [...content.matchAll(credentialPattern)];
+      const suspiciousCredentials = credMatches.filter(m => {
+        const value = m[2]!;
+        // Allow {{variable}} references — flag only literal tokens
+        return !value.startsWith("{{") && !value.endsWith("}}");
+      });
+      if (suspiciousCredentials.length > 0) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({
+            saved: false,
+            error: "Hardcoded credentials detected in Authorization header(s)",
+            hint: "Never put literal API keys or tokens in YAML files. Store them in the environment instead: use manage_environment(action: \"set\", name: \"default\", collectionName: \"...\", variables: {\"api_key\": \"...\"}) and reference as {{api_key}} in headers.",
+            detected: suspiciousCredentials.map(m => `${m[1]} <redacted>`),
+          }, null, 2) }],
+          isError: true,
+        };
+      }
+
+      // Resolve path
+      const resolvedPath = filePath.startsWith("/") || /^[a-zA-Z]:/.test(filePath)
+        ? filePath
+        : join(process.cwd(), filePath);
+
+      // Check existing file
+      if (!overwrite && existsSync(resolvedPath)) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({
+            saved: false,
+            error: `File already exists: ${resolvedPath}`,
+            hint: "Use overwrite: true to replace the existing file",
+          }, null, 2) }],
+          isError: true,
+        };
+      }
+
+      // Create directories
+      const dir = dirname(resolvedPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      // Write original YAML content (preserve formatting/comments)
+      await Bun.write(resolvedPath, content);
+
+      // Extract summary info
+      const suite = parsed as Record<string, unknown>;
+      const tests = (suite.tests as unknown[]) ?? [];
+
+      const result: Record<string, unknown> = {
+        saved: true,
+        filePath: resolvedPath,
+        suite: {
+          name: suite.name,
+          tests: tests.length,
+          base_url: suite.base_url ?? null,
+        },
+      };
+
+      // CI hint
+      result.hint = "After tests are ready, ask the user if they want to set up CI/CD with ci_init to run tests automatically on push.";
+
+      // Attempt to compute coverage hint
+      try {
+        const testDir = dirname(resolvedPath);
+        const { findCollectionByTestPath } = await import("../../db/queries.ts");
+        const { getDb } = await import("../../db/schema.ts");
+        getDb(dbPath);
+        const collection = findCollectionByTestPath(testDir);
+        if (collection?.openapi_spec) {
+          const { readOpenApiSpec, extractEndpoints } = await import("../../core/generator/openapi-reader.ts");
+          const { scanCoveredEndpoints, filterUncoveredEndpoints } = await import("../../core/generator/coverage-scanner.ts");
+
+          const doc = await readOpenApiSpec(collection.openapi_spec);
+          const allEndpoints = extractEndpoints(doc);
+          const covered = await scanCoveredEndpoints(testDir);
+          const uncovered = filterUncoveredEndpoints(allEndpoints, covered);
+
+          const total = allEndpoints.length;
+          const coveredCount = total - uncovered.length;
+          const percentage = total > 0 ? Math.round((coveredCount / total) * 100) : 0;
+
+          const coverage: Record<string, unknown> = { percentage, covered: coveredCount, total, uncoveredCount: uncovered.length };
+          if (percentage < 80 && uncovered.length > 0) {
+            coverage.suggestion = `Use generate_missing_tests to cover ${uncovered.length} remaining endpoint${uncovered.length > 1 ? "s" : ""}`;
+          }
+          result.coverage = coverage;
+        }
+      } catch { /* silently skip coverage if unavailable */ }
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({
+          saved: false,
+          error: (err as Error).message,
+        }, null, 2) }],
+        isError: true,
+      };
+    }
+  });
+}

package/src/mcp/tools/send-request.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { executeRequest } from "../../core/runner/http-client.ts";
+import { loadEnvironment, substituteString, substituteDeep } from "../../core/parser/variables.ts";
+
+export function registerSendRequestTool(server: McpServer) {
+  server.registerTool("send_request", {
+    description: "Send an ad-hoc HTTP request. Supports variable interpolation from environments (e.g. {{base_url}}).",
+    inputSchema: {
+      method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).describe("HTTP method"),
+      url: z.string().describe("Request URL (supports {{variable}} interpolation)"),
+      headers: z.optional(z.string()).describe("Request headers as JSON string (e.g. '{\"Content-Type\": \"application/json\"}')"),
+      body: z.optional(z.string()).describe("Request body (JSON string)"),
+      timeout: z.optional(z.number().int().positive()).describe("Request timeout in ms"),
+      envName: z.optional(z.string()).describe("Environment name for variable interpolation"),
+    },
+  }, async ({ method, url, headers, body, timeout, envName }) => {
+    try {
+      const vars = await loadEnvironment(envName);
+
+      const resolvedUrl = substituteString(url, vars) as string;
+      const parsedHeaders = headers ? JSON.parse(headers) as Record<string, string> : {};
+      const resolvedHeaders = Object.keys(parsedHeaders).length > 0 ? substituteDeep(parsedHeaders, vars) : {};
+      const resolvedBody = body ? substituteString(body, vars) as string : undefined;
+
+      const response = await executeRequest(
+        {
+          method,
+          url: resolvedUrl,
+          headers: resolvedHeaders,
+          body: resolvedBody,
+        },
+        timeout ? { timeout } : undefined,
+      );
+
+      const result = {
+        status: response.status,
+        headers: response.headers,
+        body: response.body_parsed ?? response.body,
+        duration_ms: response.duration_ms,
+      };
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
+        isError: true,
+      };
+    }
+  });
+}

package/src/mcp/tools/setup-api.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { setupApi } from "../../core/setup-api.ts";
+
+export function registerSetupApiTool(server: McpServer, dbPath?: string) {
+  server.registerTool("setup_api", {
+    description: "Register a new API for testing. Creates directory structure, reads OpenAPI spec, " +
+      "sets up environment variables, and creates a collection in the database. " +
+      "Use this before generating tests for a new API.",
+    inputSchema: {
+      name: z.string().describe("API name (e.g. 'petstore')"),
+      specPath: z.optional(z.string()).describe("Path or URL to OpenAPI spec"),
+      dir: z.optional(z.string()).describe("Base directory (default: ./apis/<name>/)"),
+      envVars: z.optional(z.string()).describe("Environment variables as JSON string (e.g. '{\"base_url\": \"...\", \"token\": \"...\"}')"),
+      force: z.optional(z.boolean()).describe("If true, delete existing API with same name and recreate from scratch"),
+    },
+  }, async ({ name, specPath, dir, envVars, force }) => {
+    try {
+      let parsedEnvVars: Record<string, string> | undefined;
+      if (envVars) {
+        try {
+          parsedEnvVars = JSON.parse(envVars);
+        } catch {
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify({ error: "envVars must be a valid JSON string" }, null, 2) }],
+            isError: true,
+          };
+        }
+      }
+      const result = await setupApi({
+        name,
+        spec: specPath,
+        dir,
+        envVars: parsedEnvVars,
+        dbPath,
+        force,
+      });
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
+        isError: true,
+      };
+    }
+  });
+}

package/src/mcp/tools/validate-tests.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { parse } from "../../core/parser/yaml-parser.ts";
+
+export function registerValidateTestsTool(server: McpServer) {
+  server.registerTool("validate_tests", {
+    description: "Validate YAML test files without running them. Returns parsed suite info or validation errors.",
+    inputSchema: {
+      testPath: z.string().describe("Path to test YAML file or directory"),
+    },
+  }, async ({ testPath }) => {
+    try {
+      const suites = await parse(testPath);
+      const totalSteps = suites.reduce((sum, s) => sum + s.tests.length, 0);
+
+      const result = {
+        valid: true,
+        suites: suites.length,
+        tests: totalSteps,
+        details: suites.map(s => ({
+          name: s.name,
+          tests: s.tests.length,
+          tags: s.tags,
+          description: s.description,
+          source: (s as any)._source,
+        })),
+      };
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify({
+          valid: false,
+          error: (err as Error).message,
+        }, null, 2) }],
+        isError: true,
+      };
+    }
+  });
+}

package/src/tui/chat-ui.ts

@@ -0,0 +1,150 @@
+import { createInterface } from "readline";
+import { runAgentTurn } from "../core/agent/agent-loop.ts";
+import { trimContext } from "../core/agent/context-manager.ts";
+import type { AgentConfig, ToolEvent } from "../core/agent/types.ts";
+import type { ModelMessage } from "ai";
+
+// ── ANSI helpers ──
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const MAGENTA = "\x1b[35m";
+
+// Mouse reporting escape sequences
+const DISABLE_MOUSE = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l";
+// Regex to strip mouse escape sequences from input
+// Covers SGR extended, X10, urxvt mouse protocols
+const MOUSE_SEQ_RE = /\x1b\[\<[\d;]*[mM]|\x1b\[M[\s\S]{3}|\x1b\[\d+;\d+;\d+M/g;
+
+function printToolEvent(event: ToolEvent) {
+  const args = Object.entries(event.args)
+    .filter(([, v]) => v !== undefined)
+    .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+    .slice(0, 3)
+    .join(", ");
+
+  const result = event.result as Record<string, unknown> | null;
+  let summary = "done";
+  if (result) {
+    if ("error" in result) summary = `error: ${result.error}`;
+    else if ("status" in result) summary = String(result.status);
+    else if ("valid" in result) summary = result.valid ? "valid" : "invalid";
+    else if ("runId" in result) summary = `run #${result.runId}`;
+  }
+
+  process.stdout.write(`  ${MAGENTA}↳ ${event.toolName}${RESET}${DIM}(${args})${RESET} → ${summary}\n`);
+}
+
+export async function startChatUI(config: AgentConfig): Promise<void> {
+  const { provider } = config.provider;
+  const model = config.provider.model;
+  const safeLabel = config.safeMode ? ` ${YELLOW}[SAFE]${RESET}` : "";
+
+  // Disable mouse reporting that may be left over from other TUI apps
+  process.stdout.write(DISABLE_MOUSE);
+
+  console.log(`\n${BOLD}${CYAN}apitool chat${RESET} — ${provider}/${model}${safeLabel}`);
+  console.log(`${DIM}Commands: /clear, /tokens, /quit  |  Ctrl+C to exit${RESET}\n`);
+
+  const messages: ModelMessage[] = [];
+  let totalIn = 0;
+  let totalOut = 0;
+  let busy = false;
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${BOLD}${CYAN}> ${RESET}`,
+    terminal: true,
+  });
+
+  rl.prompt();
+
+  rl.on("line", async (raw: string) => {
+    // Strip mouse escape sequences that leak into input
+    const text = raw.replace(MOUSE_SEQ_RE, "").trim();
+
+    if (!text || busy) {
+      if (!busy) rl.prompt();
+      return;
+    }
+
+    if (text === "/quit" || text === "/exit") {
+      rl.close();
+      return;
+    }
+
+    if (text === "/clear") {
+      messages.length = 0;
+      totalIn = 0;
+      totalOut = 0;
+      console.log(`${DIM}Conversation cleared.${RESET}\n`);
+      rl.prompt();
+      return;
+    }
+
+    if (text === "/tokens") {
+      console.log(`${DIM}Tokens: ${totalIn} in / ${totalOut} out${RESET}\n`);
+      rl.prompt();
+      return;
+    }
+
+    busy = true;
+    messages.push({ role: "user", content: text });
+
+    // Trim context if conversation is long
+    const trimmed = trimContext(
+      messages.map((m) => ({
+        role: m.role as "user" | "assistant",
+        content: typeof m.content === "string" ? m.content : "",
+      })),
+    );
+
+    process.stdout.write(`\n${DIM}thinking...${RESET}`);
+
+    try {
+      const result = await runAgentTurn(
+        trimmed.map((m) => ({ role: m.role, content: m.content })),
+        config,
+        (event) => {
+          process.stdout.write(`\r\x1b[K`);
+          printToolEvent(event);
+          process.stdout.write(`${DIM}thinking...${RESET}`);
+        },
+      );
+
+      process.stdout.write(`\r\x1b[K`);
+
+      const responseText = result.text || "(no response)";
+      console.log(`\n${GREEN}${BOLD}AI${RESET} ${responseText}\n`);
+
+      totalIn += result.inputTokens;
+      totalOut += result.outputTokens;
+      messages.push({ role: "assistant", content: responseText });
+    } catch (err) {
+      process.stdout.write(`\r\x1b[K`);
+      console.log(`\n${YELLOW}Error: ${(err as Error).message}${RESET}\n`);
+    }
+
+    busy = false;
+    rl.prompt();
+  });
+
+  rl.on("close", () => {
+    // Disable mouse reporting on exit too
+    process.stdout.write(DISABLE_MOUSE);
+    console.log(`\n${DIM}Bye! (${totalIn} in / ${totalOut} out tokens)${RESET}`);
+    process.exit(0);
+  });
+
+  // Also disable mouse on SIGINT
+  process.on("SIGINT", () => {
+    process.stdout.write(DISABLE_MOUSE);
+    rl.close();
+  });
+
+  await new Promise<void>(() => {});
+}