terminal-pilot 0.0.1 → 0.0.3

package/README.md

@@ -1,38 +1,23 @@
-# @poe-code/terminal-pilot
+# terminal-pilot
 
-`terminal-pilot` is a Playwright-like SDK and MCP server for automating interactive CLI apps through a real pseudoterminal (PTY).
+`terminal-pilot` is a Playwright-like SDK for automating interactive CLI apps through a real pseudoterminal (PTY).
 
 Use it when plain stdio is not enough: menus, prompts, arrow-key navigation, confirmations, and terminal redraws such as `poe-code configure`.
 
 For design rationale and scope, see `docs/plans/terminal-pilot.md`.
 
+For the MCP server, see [terminal-pilot-mcp](../terminal-pilot-mcp).
+
 ## What it includes
 
 - **SDK:** `TerminalPilot` → `TerminalSession` → `TerminalScreen`
-- **MCP server:** 10 tools for AI-driven CLI automation
 - **Real PTY execution:** works with interactive CLIs that expect a terminal
 - **Headless by default:** optional `observe: true` mirrors PTY output for debugging
 
 ## Entry points
 
 ```ts
-import { TerminalPilot } from "@poe-code/terminal-pilot";
-```
-
-```ts
-import { createTerminalPilotMcpServer, main } from "@poe-code/terminal-pilot/mcp";
-```
-
-CLI bin:
-
-```sh
-terminal-pilot-mcp
-```
-
-Development entry point in this repo:
-
-```sh
-npx tsx packages/terminal-pilot/src/mcp-server.ts
+import { TerminalPilot } from "terminal-pilot";
 ```
 
 ## SDK API
@@ -42,7 +27,7 @@ npx tsx packages/terminal-pilot/src/mcp-server.ts
 Creates and tracks active terminal sessions.
 
 ```ts
-import { TerminalPilot } from "@poe-code/terminal-pilot";
+import { TerminalPilot } from "terminal-pilot";
 
 const pilot = await TerminalPilot.launch();
 
@@ -188,125 +173,11 @@ class TerminalScreen {
 }
 ```
 
-## MCP server
-
-The MCP server holds one in-memory `TerminalPilot` instance and exposes terminal automation over stdio.
-
-### Run it
-
-Development:
-
-```sh
-npx tsx packages/terminal-pilot/src/mcp-server.ts
-```
-
-Built / installed package:
-
-```sh
-terminal-pilot-mcp
-```
-
-Programmatic:
-
-```ts
-import { main } from "@poe-code/terminal-pilot/mcp";
-
-await main();
-```
-
-### Connect to an MCP client
-
-Install the package globally from a local build:
-
-```sh
-cd packages/terminal-pilot
-npm pack --pack-destination /tmp && npm install -g /tmp/poe-code-terminal-pilot-*.tgz && rm /tmp/poe-code-terminal-pilot-*.tgz
-```
-
-This makes the `terminal-pilot-mcp` bin available globally.
-
-**Claude Code** (`~/.claude.json` or project `.mcp.json`):
-
-```json
-{
-  "mcpServers": {
-    "terminal-pilot": {
-      "command": "terminal-pilot-mcp"
-    }
-  }
-}
-```
-
-**Claude Desktop** (`claude_desktop_config.json`):
-
-```json
-{
-  "mcpServers": {
-    "terminal-pilot": {
-      "command": "terminal-pilot-mcp"
-    }
-  }
-}
-```
-
-**Cursor** (`.cursor/mcp.json`):
-
-```json
-{
-  "mcpServers": {
-    "terminal-pilot": {
-      "command": "terminal-pilot-mcp"
-    }
-  }
-}
-```
-
-### Tools
-
-`void` means the tool returns no payload.
-
-| Tool | Input | Output |
-| --- | --- | --- |
-| `terminal_create_session` | `{ command: string, args?: string[], cwd?: string, cols?: number, rows?: number, observe?: boolean }` | `{ sessionId: string, pid: number }` |
-| `terminal_type` | `{ sessionId: string, text: string }` | `void` |
-| `terminal_press_key` | `{ sessionId: string, key: TerminalKey }` | `void` |
-| `terminal_send_signal` | `{ sessionId: string, signal: string }` | `void` |
-| `terminal_wait_for` | `{ sessionId: string, pattern: string, timeout?: number }` | `{ matched: true, output: string }` |
-| `terminal_read_screen` | `{ sessionId: string }` | `{ lines: string[], cursor: { row: number, col: number }, size: { rows: number, cols: number } }` |
-| `terminal_read_history` | `{ sessionId: string, last?: number }` | `{ lines: string[] }` |
-| `terminal_resize` | `{ sessionId: string, cols: number, rows: number }` | `void` |
-| `terminal_close_session` | `{ sessionId: string }` | `{ exitCode: number }` |
-| `terminal_list_sessions` | `{}` | `{ sessions: Array<{ id: string, command: string, pid: number }> }` |
-
-Practical notes:
-
-- `terminal_wait_for.pattern` is compiled as a JavaScript `RegExp` on the server.
-- `terminal_type` maps to `session.fill(...)` for bulk text entry.
-- `terminal_read_screen` returns the **current visible screen**, not scrollback.
-- `terminal_read_history` returns ANSI-stripped output since session start.
-- `terminal_list_sessions` returns **active** sessions only.
-- `observe: true` mirrors PTY output to `stderr`, which is useful when debugging MCP-driven runs.
-
-Minimal MCP flow:
-
-```json
-{"tool":"terminal_create_session","arguments":{"command":"poe-code","args":["configure"]}}
-{"tool":"terminal_wait_for","arguments":{"sessionId":"<id>","pattern":"Pick an agent to configure:"}}
-{"tool":"terminal_press_key","arguments":{"sessionId":"<id>","key":"Enter"}}
-{"tool":"terminal_read_screen","arguments":{"sessionId":"<id>"}}
-{"tool":"terminal_close_session","arguments":{"sessionId":"<id>"}}
-```
-
 ## Environment variables
 
 There are **no terminal-pilot-specific environment variables**.
 
-Runtime environment is controlled per session:
-
-- SDK: `newSession({ env })`
-- MCP server: spawned commands inherit the MCP server process environment unless you override it in your command wrapper
-
-There are also **no package-level config files or config options** beyond the per-session options above.
+Runtime environment is controlled per session via `newSession({ env })`. There are no package-level config files or config options beyond the per-session options.
 
 ## Testing
 
@@ -340,7 +211,7 @@ Example fixture-based test:
 
 ```ts
 import path from "node:path";
-import { TerminalPilot } from "@poe-code/terminal-pilot";
+import { TerminalPilot } from "terminal-pilot";
 
 const pilot = await TerminalPilot.launch();
 const tsxPath = path.join(process.cwd(), "node_modules", ".bin", "tsx");
@@ -371,7 +242,7 @@ Use a temporary home directory so you do not touch your real config while testin
 import { mkdtempSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { TerminalPilot } from "@poe-code/terminal-pilot";
+import { TerminalPilot } from "terminal-pilot";
 
 const tmpHome = mkdtempSync(path.join(os.tmpdir(), "poe-configure-test-"));
 const pilot = await TerminalPilot.launch();

package/dist/keys.js

@@ -14,18 +14,24 @@ const NAMED_KEY_SEQUENCES = {
     PageDown: "\x1b[6~",
     Space: " "
 };
+const NAMED_KEY_LOWER = new Map(Object.entries(NAMED_KEY_SEQUENCES).map(([k, v]) => [k.toLowerCase(), v]));
+const VALID_KEYS_HINT = `Valid keys: ${Object.keys(NAMED_KEY_SEQUENCES).join(", ")}, Control+<letter>, Alt+<key>`;
+function unknownKeyError(key) {
+    return new Error(`Unknown terminal key: ${key}. ${VALID_KEYS_HINT}`);
+}
 export function keyToSequence(key) {
-    const namedSequence = NAMED_KEY_SEQUENCES[key];
+    const lowerKey = key.toLowerCase();
+    const namedSequence = NAMED_KEY_LOWER.get(lowerKey);
     if (namedSequence !== undefined) {
         return namedSequence;
     }
-    if (key.startsWith("Control+")) {
-        return controlKeyToSequence(key);
+    if (lowerKey.startsWith("control+")) {
+        return controlKeyToSequence(key.slice("control+".length));
     }
-    if (key.startsWith("Alt+")) {
-        const nestedKey = key.slice("Alt+".length);
+    if (lowerKey.startsWith("alt+")) {
+        const nestedKey = key.slice("alt+".length);
         if (nestedKey.length === 0) {
-            throw new Error(`Unknown terminal key: ${key}`);
+            throw unknownKeyError(key);
         }
         if (nestedKey.length === 1) {
             return "\x1b" + nestedKey;
@@ -34,20 +40,19 @@ export function keyToSequence(key) {
             return "\x1b" + keyToSequence(nestedKey);
         }
         catch {
-            throw new Error(`Unknown terminal key: ${key}`);
+            throw unknownKeyError(key);
         }
     }
-    throw new Error(`Unknown terminal key: ${key}`);
+    throw unknownKeyError(key);
 }
-function controlKeyToSequence(key) {
-    const controlKey = key.slice("Control+".length);
+function controlKeyToSequence(controlKey) {
     if (controlKey.length !== 1) {
-        throw new Error(`Unknown terminal key: ${key}`);
+        throw unknownKeyError(`Control+${controlKey}`);
     }
     const uppercaseLetter = controlKey.toUpperCase();
     const charCode = uppercaseLetter.charCodeAt(0);
     if (charCode < 65 || charCode > 90) {
-        throw new Error(`Unknown terminal key: ${key}`);
+        throw unknownKeyError(`Control+${controlKey}`);
     }
     return String.fromCharCode(charCode - 64);
 }

package/dist/terminal-session.js

@@ -66,7 +66,7 @@ export class TerminalSession {
         }
     }
     async fill(text) {
-        await this.send(text);
+        await this.send(text.replace(/\r?\n/g, "\r"));
     }
     async press(key) {
         await this.send(keyToSequence(key));
@@ -140,7 +140,9 @@ export class TerminalSession {
     async resize(cols, rows) {
         this.currentCols = cols;
         this.currentRows = rows;
-        this.pty.resize(cols, rows);
+        if (this.exitCode === null) {
+            this.pty.resize(cols, rows);
+        }
         this.terminal.resize(cols, rows);
     }
     async close() {
@@ -149,11 +151,12 @@ export class TerminalSession {
         }
         if (!this.closeRequested) {
             this.closeRequested = true;
+            const gracefulExitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
+            if (gracefulExitCode !== null) {
+                return gracefulExitCode;
+            }
             if (this.signalRequested) {
-                const exitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
-                if (exitCode !== null) {
-                    return exitCode;
-                }
+                return this.exitPromise;
             }
             if (this.exitCode === null) {
                 this.pty.kill("SIGTERM");
@@ -252,13 +255,19 @@ function signalToExitCode(signal) {
     return 128 + signalNumber;
 }
 function matchPattern(buffer, pattern) {
-    if (typeof pattern === "string") {
-        return buffer.includes(pattern) ? pattern : null;
+    const clean = normalizeHistoryBuffer(stripAnsi(buffer));
+    for (const line of clean.split("\n")) {
+        if (typeof pattern === "string") {
+            if (line.includes(pattern))
+                return line;
+        }
+        else {
+            const flags = removeCharacter(pattern.flags, "g");
+            if (new RegExp(pattern.source, flags).test(line))
+                return line;
+        }
     }
-    const flags = removeCharacter(pattern.flags, "g");
-    const localPattern = new RegExp(pattern.source, flags);
-    const match = localPattern.exec(buffer);
-    return match?.[0] ?? null;
+    return null;
 }
 function removeCharacter(input, charToRemove) {
     let output = "";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "terminal-pilot",
-  "version": "0.0.1",
-  "description": "Headless terminal session manager with MCP server support",
+  "version": "0.0.3",
+  "description": "Playwright-like SDK for automating interactive CLI apps through a real PTY",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,19 +9,12 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
-    },
-    "./mcp": {
-      "types": "./dist/mcp-server.d.ts",
-      "import": "./dist/mcp-server.js"
     }
   },
-  "bin": {
-    "terminal-pilot-mcp": "dist/mcp-server.js"
-  },
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "tsc",
-    "install-local-package": "TMPD=$(mktemp -d) && cd ../tiny-stdio-mcp-server && npm pack --pack-destination $TMPD && cd ../terminal-pilot && npm pack --pack-destination $TMPD && npm install -g $TMPD/poe-code-terminal-pilot-*.tgz $TMPD/tiny-stdio-mcp-server-*.tgz && rm -rf $TMPD"
+    "install-local-package": "TMPD=$(mktemp -d) && npm pack --pack-destination $TMPD && npm install -g $TMPD/terminal-pilot-*.tgz && rm -rf $TMPD"
   },
   "files": [
     "dist"
@@ -37,14 +30,12 @@
   "license": "MIT",
   "keywords": [
     "terminal",
-    "mcp",
     "pty",
     "headless"
   ],
   "dependencies": {
     "headless-terminal": "^0.4.0",
-    "node-pty": "^1.1.0",
-    "tiny-stdio-mcp-server": "^0.1.0"
+    "node-pty": "^1.1.0"
   },
   "devDependencies": {}
 }

package/dist/mcp-server.d.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { type Server } from "tiny-stdio-mcp-server";
-import { TerminalPilot } from "./terminal-pilot.js";
-type RuntimeProcess = Pick<typeof process, "on" | "off">;
-export declare function createTerminalPilotMcpServer(agent: TerminalPilot): Server;
-export declare function main({ launchAgent, createMcpServer, runtimeProcess }?: {
-    launchAgent?: typeof TerminalPilot.launch;
-    createMcpServer?: (agent: TerminalPilot) => Server;
-    runtimeProcess?: RuntimeProcess;
-}): Promise<void>;
-export {};

package/dist/mcp-server.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-import packageJson from "../package.json" with { type: "json" };
-import { createServer } from "tiny-stdio-mcp-server";
-import { terminalPilotMcpTools } from "./mcp-tools.js";
-import { TerminalPilot } from "./terminal-pilot.js";
-export function createTerminalPilotMcpServer(agent) {
-    const server = createServer({
-        name: "terminal-pilot",
-        version: packageJson.version
-    });
-    for (const tool of terminalPilotMcpTools(agent)) {
-        server.tool(tool.name, tool.description, tool.inputSchema, tool.handler);
-    }
-    return server;
-}
-export async function main({ launchAgent = TerminalPilot.launch, createMcpServer = createTerminalPilotMcpServer, runtimeProcess = process } = {}) {
-    const agent = await launchAgent();
-    let closed = false;
-    const closeAgent = async () => {
-        if (closed) {
-            return;
-        }
-        closed = true;
-        await agent.close();
-    };
-    const handleExit = () => {
-        void closeAgent();
-    };
-    runtimeProcess.on("exit", handleExit);
-    try {
-        await createMcpServer(agent).listen();
-    }
-    finally {
-        runtimeProcess.off("exit", handleExit);
-        await closeAgent();
-    }
-}
-if (import.meta.url === `file://${process.argv[1]}`) {
-    void main();
-}

package/dist/mcp-tools.d.ts

@@ -1,46 +0,0 @@
-import { type ToolDefinition } from "tiny-stdio-mcp-server";
-import type { TerminalKey } from "./keys.js";
-import type { TerminalPilot } from "./terminal-pilot.js";
-export type TerminalPilotMcpTool<T = Record<string, unknown>> = ToolDefinition<T>;
-export declare function terminalCreateSessionTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    command: string;
-    args?: string[];
-    cwd?: string;
-    cols?: number;
-    rows?: number;
-    observe?: boolean;
-}>;
-export declare function terminalTypeTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    text: string;
-}>;
-export declare function terminalPressKeyTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    key: TerminalKey;
-}>;
-export declare function terminalSendSignalTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    signal: string;
-}>;
-export declare function terminalWaitForTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    pattern: string;
-    timeout?: number;
-}>;
-export declare function terminalReadScreenTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-}>;
-export declare function terminalReadHistoryTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    last?: number;
-}>;
-export declare function terminalResizeTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-    cols: number;
-    rows: number;
-}>;
-export declare function terminalCloseSessionTool(agent: TerminalPilot): TerminalPilotMcpTool<{
-    sessionId: string;
-}>;
-export declare function terminalPilotMcpTools(agent: TerminalPilot): Array<TerminalPilotMcpTool<any>>;
-export declare function terminalListSessionsTool(agent: TerminalPilot): TerminalPilotMcpTool<Record<string, never>>;

package/dist/mcp-tools.js

@@ -1,169 +0,0 @@
-import { defineSchema } from "tiny-stdio-mcp-server";
-export function terminalCreateSessionTool(agent) {
-    return {
-        name: "terminal_create_session",
-        description: "Spawn an interactive CLI in a PTY",
-        inputSchema: defineSchema({
-            command: { type: "string", description: "Command to execute" },
-            args: { type: "array", description: "Command arguments", optional: true },
-            cwd: { type: "string", description: "Working directory", optional: true },
-            cols: { type: "number", description: "Terminal width in columns", optional: true },
-            rows: { type: "number", description: "Terminal height in rows", optional: true },
-            observe: { type: "boolean", description: "Mirror PTY output to stderr", optional: true }
-        }),
-        async handler(input) {
-            const session = await agent.newSession(input);
-            return { sessionId: session.id, pid: session.pid };
-        }
-    };
-}
-export function terminalTypeTool(agent) {
-    return {
-        name: "terminal_type",
-        description: "Write text to an active terminal session",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            text: { type: "string", description: "Text to write to the session" }
-        }),
-        async handler(input) {
-            await agent.getSession(input.sessionId).fill(input.text);
-            return undefined;
-        }
-    };
-}
-export function terminalPressKeyTool(agent) {
-    return {
-        name: "terminal_press_key",
-        description: "Send a named key press to an active terminal session",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            key: { type: "string", description: "Named key to press" }
-        }),
-        async handler(input) {
-            await agent.getSession(input.sessionId).press(input.key);
-            return undefined;
-        }
-    };
-}
-export function terminalSendSignalTool(agent) {
-    return {
-        name: "terminal_send_signal",
-        description: "Send a process signal to an active terminal session",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            signal: { type: "string", description: "Signal to send to the session process" }
-        }),
-        async handler(input) {
-            await agent.getSession(input.sessionId).signal(input.signal);
-            return undefined;
-        }
-    };
-}
-export function terminalWaitForTool(agent) {
-    return {
-        name: "terminal_wait_for",
-        description: "Wait for terminal output to match a pattern",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            pattern: { type: "string", description: "Regular expression pattern to wait for" },
-            timeout: { type: "number", description: "Maximum wait time in milliseconds", optional: true }
-        }),
-        async handler(input) {
-            const session = agent.getSession(input.sessionId);
-            const pattern = new RegExp(input.pattern);
-            const output = input.timeout === undefined
-                ? await session.waitFor(pattern)
-                : await session.waitFor(pattern, { timeout: input.timeout });
-            return { matched: true, output };
-        }
-    };
-}
-export function terminalReadScreenTool(agent) {
-    return {
-        name: "terminal_read_screen",
-        description: "Read the current visible terminal screen",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" }
-        }),
-        async handler(input) {
-            const screen = await agent.getSession(input.sessionId).screen();
-            return {
-                lines: [...screen.lines],
-                cursor: { ...screen.cursor },
-                size: { ...screen.size }
-            };
-        }
-    };
-}
-export function terminalReadHistoryTool(agent) {
-    return {
-        name: "terminal_read_history",
-        description: "Read terminal output history",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            last: { type: "number", description: "Return only the last N lines", optional: true }
-        }),
-        async handler(input) {
-            const lines = await agent.getSession(input.sessionId).history({ last: input.last });
-            return { lines };
-        }
-    };
-}
-export function terminalResizeTool(agent) {
-    return {
-        name: "terminal_resize",
-        description: "Resize an active terminal session",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" },
-            cols: { type: "number", description: "Terminal width in columns" },
-            rows: { type: "number", description: "Terminal height in rows" }
-        }),
-        async handler(input) {
-            await agent.getSession(input.sessionId).resize(input.cols, input.rows);
-            return undefined;
-        }
-    };
-}
-export function terminalCloseSessionTool(agent) {
-    return {
-        name: "terminal_close_session",
-        description: "Close an active terminal session",
-        inputSchema: defineSchema({
-            sessionId: { type: "string", description: "Terminal session id" }
-        }),
-        async handler(input) {
-            const exitCode = await agent.getSession(input.sessionId).close();
-            return { exitCode };
-        }
-    };
-}
-export function terminalPilotMcpTools(agent) {
-    return [
-        terminalCreateSessionTool(agent),
-        terminalTypeTool(agent),
-        terminalPressKeyTool(agent),
-        terminalSendSignalTool(agent),
-        terminalWaitForTool(agent),
-        terminalReadScreenTool(agent),
-        terminalReadHistoryTool(agent),
-        terminalResizeTool(agent),
-        terminalCloseSessionTool(agent),
-        terminalListSessionsTool(agent)
-    ];
-}
-export function terminalListSessionsTool(agent) {
-    return {
-        name: "terminal_list_sessions",
-        description: "List active terminal sessions",
-        inputSchema: defineSchema({}),
-        async handler() {
-            return {
-                sessions: agent.sessions().map((session) => ({
-                    id: session.id,
-                    command: session.command,
-                    pid: session.pid
-                }))
-            };
-        }
-    };
-}

package/dist/testing/menu-cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env tsx
-export {};

package/dist/testing/menu-cli.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env tsx
-import readline from "node:readline";
-const options = ["Option 1", "Option 2", "Option 3"];
-const { stdin, stdout } = process;
-let selectedIndex = 0;
-let renderedLineCount = 0;
-let hasExited = false;
-readline.emitKeypressEvents(stdin);
-if (stdin.isTTY) {
-    stdin.setRawMode(true);
-}
-stdin.resume();
-render();
-stdin.on("keypress", (_, key) => {
-    if (key.ctrl && key.name === "c") {
-        exitWithCode(130);
-        return;
-    }
-    if (key.name === "up") {
-        selectedIndex = (selectedIndex + options.length - 1) % options.length;
-        render();
-        return;
-    }
-    if (key.name === "down") {
-        selectedIndex = (selectedIndex + 1) % options.length;
-        render();
-        return;
-    }
-    if (key.name === "return" || key.name === "enter") {
-        cleanup();
-        stdout.write(`You selected: ${options[selectedIndex]}\n`);
-        process.exit(0);
-    }
-});
-process.on("SIGINT", () => {
-    exitWithCode(130);
-});
-function cleanup() {
-    if (stdin.isTTY) {
-        stdin.setRawMode(false);
-    }
-    stdin.pause();
-}
-function render() {
-    if (renderedLineCount > 0) {
-        readline.moveCursor(stdout, 0, -renderedLineCount);
-        readline.clearScreenDown(stdout);
-    }
-    const lines = [
-        "Select an option:",
-        ...options.map((option, index) => `${index === selectedIndex ? ">" : " "} ${option}`)
-    ];
-    stdout.write(`${lines.join("\n")}\n`);
-    renderedLineCount = lines.length;
-}
-function exitWithCode(code) {
-    if (hasExited) {
-        return;
-    }
-    hasExited = true;
-    cleanup();
-    process.exit(code);
-}

package/dist/testing/test-cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env tsx
-export {};

package/dist/testing/test-cli.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env tsx
-import readline from "node:readline";
-const terminal = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-});
-let hasGreeted = false;
-process.stdout.write("What is your name? ");
-terminal.on("line", (name) => {
-    if (hasGreeted) {
-        return;
-    }
-    hasGreeted = true;
-    console.log(`Hello, ${name}!`);
-    terminal.close();
-});
-terminal.on("close", () => {
-    if (!hasGreeted) {
-        console.log(`Hello, ${terminal.line}!`);
-    }
-    process.exit(0);
-});