@rawwee/interactive-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 josippapez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# @rawwee/interactive-mcp
+
+[![npm version](https://img.shields.io/npm/v/%40rawwee%2Finteractive-mcp)](https://www.npmjs.com/package/@rawwee/interactive-mcp) [![npm downloads](https://img.shields.io/npm/dm/%40rawwee%2Finteractive-mcp)](https://www.npmjs.com/package/@rawwee/interactive-mcp) [![GitHub license](https://img.shields.io/github/license/josippapez/interactive-mcp-server)](https://github.com/josippapez/interactive-mcp-server/blob/main/LICENSE) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier) [![Platforms](https://img.shields.io/badge/Platform-Windows%20%7C%20macOS%20%7C%20Linux-blue)](https://github.com/josippapez/interactive-mcp-server) [![GitHub last commit](https://img.shields.io/github/last-commit/josippapez/interactive-mcp-server)](https://github.com/josippapez/interactive-mcp-server/commits/main)
+
+![Screenshot 2025-05-13 213745](https://github.com/user-attachments/assets/40208534-5910-4eb2-bfbc-58f7d93aec95)
+
+A MCP Server implemented in Node.js/TypeScript, facilitating interactive communication between LLMs and users. **Note:** This server is designed to run locally alongside the MCP client (e.g., Claude Desktop, VS Code), as it needs direct access to the user's operating system to display notifications and command-line prompts.
+
+_(Note: This project is in its early stages.)_
+
+## Tools
+
+This server exposes the following tools via the Model Context Protocol (MCP):
+
+- `request_user_input`: Asks the user a question and returns their answer. Can display predefined options.
+- `message_complete_notification`: Sends a simple OS notification.
+- `start_intensive_chat`: Initiates a persistent command-line chat session.
+- `ask_intensive_chat`: Asks a question within an active intensive chat session.
+- `stop_intensive_chat`: Closes an active intensive chat session.
+
+## Usage Scenarios
+
+This server is ideal for scenarios where an LLM needs to interact directly with the user on their local machine, such as:
+
+- Interactive setup or configuration processes.
+- Gathering feedback during code generation or modification.
+- Clarifying instructions or confirming actions in pair programming.
+- Any workflow requiring user input or confirmation during LLM operation.
+
+## Client Configuration
+
+This section explains how to configure MCP clients to use the `@rawwee/interactive-mcp` server package.
+
+By default, user prompts will time out after 30 seconds. You can customize server options like timeout or disabled tools by adding command-line flags directly to the `args` array when configuring your client.
+
+Please make sure you have the `npx` command available.
+
+### Usage with Claude Desktop / Cursor
+
+Add the following minimal configuration to your `claude_desktop_config.json` (Claude Desktop) or `mcp.json` (Cursor):
+
+```json
+{
+  "mcpServers": {
+    "interactive": {
+      "command": "npx",
+      "args": ["-y", "@rawwee/interactive-mcp"]
+    }
+  }
+}
+```
+
+**With specific version**
+
+```json
+{
+  "mcpServers": {
+    "interactive": {
+      "command": "npx",
+      "args": ["-y", "@rawwee/interactive-mcp@1.9.0"]
+    }
+  }
+}
+```
+
+**Example with Custom Timeout (30s):**
+
+```json
+{
+  "mcpServers": {
+    "interactive": {
+      "command": "npx",
+      "args": ["-y", "@rawwee/interactive-mcp", "-t", "30"]
+    }
+  }
+}
+```
+
+### Usage with VS Code
+
+Add the following minimal configuration to your User Settings (JSON) file or `.vscode/mcp.json`:
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "interactive-mcp": {
+        "command": "npx",
+        "args": ["-y", "@rawwee/interactive-mcp"]
+      }
+    }
+  }
+}
+```
+
+#### macOS Recommendations
+
+For a smoother experience on macOS using the default `Terminal.app`, consider this profile setting:
+
+- **(Shell Tab):** Under **"When the shell exits"** (**Terminal > Settings > Profiles > _[Your Profile]_ > Shell**), select **"Close if the shell exited cleanly"** or **"Close the window"**. This helps manage windows when the MCP server starts and stops.
+
+## Development Setup
+
+This section is primarily for developers looking to modify or contribute to the server. If you just want to _use_ the server with an MCP client, see the "Client Configuration" section above.
+
+### Prerequisites
+
+- **Bun:** Required for runtime execution and dependency management.
+- **Node.js:** Required for TypeScript tooling and Node APIs used by the server.
+
+### Installation (Developers)
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/josippapez/interactive-mcp-server
+   cd interactive-mcp-server
+   ```
+
+2. Install dependencies:
+
+   ```bash
+   bun install
+   ```
+
+### Running the Application (Developers)
+
+```bash
+bun run start
+```
+
+### Terminal UI backend status
+
+`interactive-mcp` now uses OpenTUI (`@opentui/core`, `@opentui/react`) for terminal UI rendering.
+
+OpenTUI is the terminal UI renderer backend.
+
+#### Command-Line Options
+
+The `interactive-mcp` server accepts the following command-line options. These should typically be configured in your MCP client's JSON settings by adding them directly to the `args` array (see "Client Configuration" examples).
+
+| Option            | Alias | Description                                                                                                                                                                                           |
+| ----------------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--timeout`       | `-t`  | Sets the default timeout (in seconds) for user input prompts. Defaults to 30 seconds.                                                                                                                 |
+| `--disable-tools` | `-d`  | Disables specific tools or groups (comma-separated list). Prevents the server from advertising or registering them. Options: `request_user_input`, `message_complete_notification`, `intensive_chat`. |
+
+**Example:** Setting multiple options in the client config `args` array:
+
+```jsonc
+// Example combining options in client config's "args":
+"args": [
+  "-y", "@rawwee/interactive-mcp",
+  "-t", "30", // Set timeout to 30 seconds
+  "--disable-tools", "message_complete_notification,intensive_chat" // Disable notifications and intensive chat
+]
+```
+
+## Development Commands
+
+- **Build:** `bun run build`
+- **Lint:** `bun run lint`
+- **Format:** `bun run format`
+
+## Release & Publishing Workflow
+
+Package releases are handled by **GitHub Actions** in `.github/workflows/publish.yml` (manual `workflow_dispatch`).
+
+- Choose `release_type` when running the workflow:
+  - `stable` → releases from `main`
+  - `rc` → releases from `next`
+- The workflow uses:
+  - **Node.js 24** (`actions/setup-node`)
+  - **Bun** (`oven-sh/setup-bun`)
+- For semantic-release + trusted publishing, keep `actions/setup-node` without `registry-url` to avoid npm auth conflicts (`EINVALIDNPMTOKEN`).
+- Release pipeline commands:
+  - `bun install --frozen-lockfile`
+  - `bun run build`
+  - `bunx semantic-release`
+- npm publishing uses **trusted publishing (OIDC)** via GitHub Actions (`id-token: write`), not a long-lived npm token.
+
+## Guiding Principles for Interaction
+
+When interacting with this MCP server (e.g., as an LLM client), please adhere to the following principles to ensure clarity and reduce unexpected changes:
+
+- **Prioritize Interaction:** Utilize the provided MCP tools (`request_user_input`, `start_intensive_chat`, etc.) frequently to engage with the user.
+- **Seek Clarification:** If requirements, instructions, or context are unclear, **always** ask clarifying questions before proceeding. Do not make assumptions.
+- **Confirm Actions:** Before performing significant actions (like modifying files, running complex commands, or making architectural decisions), confirm the plan with the user.
+- **Provide Options:** Whenever possible, present the user with predefined options through the MCP tools to facilitate quick decisions.
+
+You can provide these instructions to an LLM client like this:
+
+```markdown
+# Interaction
+
+- Please use the interactive MCP tools
+- Please provide options to interactive MCP if possible
+
+# Reduce Unexpected Changes
+
+- Do not make assumption.
+- Ask more questions before executing, until you think the requirement is clear enough.
+```
+
+## Contributing
+
+Contributions are welcome! Please follow standard development practices. (Further details can be added later).
+
+## License
+
+MIT (See `LICENSE` file for details - if applicable, or specify license directly).

package/dist/commands/input/index.js

@@ -0,0 +1,216 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fsPromises from 'fs/promises';
+import { watch } from 'fs';
+import os from 'os';
+import crypto from 'crypto';
+// Updated import to use @ alias
+import { USER_INPUT_TIMEOUT_SECONDS, USER_INPUT_TIMEOUT_SENTINEL, } from '../../constants.js';
+import logger from '../../utils/logger.js';
+import { spawnDetachedTerminal } from '../../utils/spawn-detached-terminal.js';
+import { SEARCH_ROOT_ENV_KEY } from '../../utils/search-root.js';
+// Get the directory name of the current module
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Define cleanupResources outside the promise to be accessible in the final catch
+async function cleanupResources(heartbeatPath, responsePath, optionsPath) {
+    await Promise.allSettled([
+        fsPromises.unlink(responsePath).catch(() => { }),
+        fsPromises.unlink(heartbeatPath).catch(() => { }),
+        fsPromises.unlink(optionsPath).catch(() => { }), // Cleanup options file
+        // Potentially add cleanup for other session-related files if needed
+    ]);
+}
+/**
+ * Display a command window with a prompt and return user input
+ * @param projectName Name of the project requesting input (used for title)
+ * @param promptMessage Message to display to the user
+ * @param timeoutSeconds Timeout in seconds
+ * @param showCountdown Whether to show a countdown timer
+ * @param baseDirectory Base directory for autocomplete/search root
+ * @param predefinedOptions Optional list of predefined options for quick selection
+ * @returns User input, timeout sentinel, or empty string if process exits unexpectedly
+ */
+export async function getCmdWindowInput(projectName, promptMessage, timeoutSeconds = USER_INPUT_TIMEOUT_SECONDS, // Use constant as default
+showCountdown = true, baseDirectory, predefinedOptions) {
+    // Create a temporary file for the detached process to write to
+    const sessionId = crypto.randomBytes(8).toString('hex');
+    const tempDir = os.tmpdir();
+    const tempFilePath = path.join(tempDir, `cmd-ui-response-${sessionId}.txt`);
+    const heartbeatFilePath = path.join(tempDir, `cmd-ui-heartbeat-${sessionId}.txt`);
+    const optionsFilePath = path.join(tempDir, `cmd-ui-options-${sessionId}.json`); // New options file path
+    return new Promise((resolve) => {
+        // Wrap the async setup logic in an IIFE
+        void (async () => {
+            // Path to the UI script (will be in the same directory after compilation)
+            const uiScriptPath = path.join(__dirname, 'ui.js');
+            // Gather options
+            const options = {
+                projectName,
+                prompt: promptMessage,
+                timeout: timeoutSeconds,
+                showCountdown,
+                searchRoot: baseDirectory,
+                sessionId,
+                outputFile: tempFilePath,
+                heartbeatFile: heartbeatFilePath, // Pass heartbeat file path too
+                predefinedOptions,
+            };
+            let ui;
+            // Moved setup into try block
+            try {
+                logger.info({
+                    sessionId,
+                    timeoutSeconds,
+                    showCountdown,
+                    hasPredefinedOptions: Array.isArray(predefinedOptions) && predefinedOptions.length > 0,
+                }, 'Starting command input UI with timeout configuration.');
+                // Write options to the file before spawning
+                await fsPromises.writeFile(optionsFilePath, JSON.stringify(options), 'utf8');
+                // Platform-specific detached terminal spawning
+                const encodedSearchRoot = Buffer.from(baseDirectory, 'utf8').toString('base64');
+                ui = spawnDetachedTerminal({
+                    scriptPath: uiScriptPath,
+                    args: [sessionId, tempDir, encodedSearchRoot],
+                    darwinArgs: [sessionId, tempDir, encodedSearchRoot],
+                    macLauncherPath: path.join(tempDir, `interactive-mcp-launch-${sessionId}.command`),
+                    macFallbackLogMessage: 'Fallback open -a Terminal failed',
+                    env: {
+                        [SEARCH_ROOT_ENV_KEY]: baseDirectory,
+                    },
+                });
+                let watcher = null;
+                let timeoutHandle = null;
+                let heartbeatInterval = null;
+                let heartbeatFileSeen = false; // Track if we've ever seen the heartbeat file
+                const startTime = Date.now(); // Record start time for initial grace period
+                const startupGraceMs = timeoutSeconds * 1000 + 5000;
+                // Define cleanupAndResolve inside the promise scope
+                const cleanupAndResolve = async (response) => {
+                    if (heartbeatInterval) {
+                        clearInterval(heartbeatInterval);
+                        heartbeatInterval = null;
+                    }
+                    if (watcher) {
+                        watcher.close();
+                        watcher = null;
+                    }
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                        timeoutHandle = null;
+                    }
+                    // Pass optionsFilePath to cleanupResources
+                    await cleanupResources(heartbeatFilePath, tempFilePath, optionsFilePath);
+                    resolve(response);
+                };
+                // Listen for process exit events - moved definition before IIFE start
+                const handleExit = (code) => {
+                    // If the process exited with a non-zero code and watcher/timeout still exist
+                    if (code !== 0 && (watcher || timeoutHandle)) {
+                        void cleanupAndResolve('');
+                    }
+                };
+                const handleError = () => {
+                    if (watcher || timeoutHandle) {
+                        // Only cleanup if not already cleaned up
+                        void cleanupAndResolve('');
+                    }
+                };
+                ui.on('exit', handleExit);
+                ui.on('error', handleError);
+                // Unref the child process so the parent can exit independently
+                ui.unref();
+                // Create an empty temp file before watching for user response
+                await fsPromises.writeFile(tempFilePath, '', 'utf8'); // Use renamed import
+                // Wait briefly for the heartbeat file to potentially be created
+                await new Promise((res) => setTimeout(res, 500));
+                // Watch for content being written to the temp file
+                watcher = watch(tempFilePath, (eventType) => {
+                    // Removed async
+                    if (eventType === 'change') {
+                        // Read the response and cleanup
+                        // Use an async IIFE inside the non-async callback
+                        void (async () => {
+                            try {
+                                const data = await fsPromises.readFile(tempFilePath, 'utf8'); // Use renamed import
+                                if (data) {
+                                    const response = data.trim();
+                                    if (response === USER_INPUT_TIMEOUT_SENTINEL) {
+                                        logger.info({ sessionId, timeoutSeconds }, 'Input UI reported timeout sentinel.');
+                                    }
+                                    void cleanupAndResolve(response); // Mark promise as intentionally ignored
+                                }
+                            }
+                            catch (readError) {
+                                logger.error({ err: readError }, 'Error reading response file');
+                                void cleanupAndResolve('');
+                            }
+                        })();
+                    }
+                });
+                // Start heartbeat check interval
+                heartbeatInterval = setInterval(() => {
+                    // Removed async
+                    // Use an async IIFE inside the non-async callback
+                    void (async () => {
+                        try {
+                            const stats = await fsPromises.stat(heartbeatFilePath); // Use renamed import
+                            const now = Date.now();
+                            // If file hasn't been modified in the last 3 seconds, assume dead
+                            if (now - stats.mtime.getTime() > 3000) {
+                                logger.info(`Heartbeat file ${heartbeatFilePath} hasn't been updated recently. Process likely exited.`);
+                                void cleanupAndResolve(''); // Mark promise as intentionally ignored
+                            }
+                            else {
+                                heartbeatFileSeen = true; // Mark that we've seen the file
+                            }
+                        }
+                        catch (err) {
+                            // Type err as unknown
+                            // Check if err is an error object with a code property
+                            if (err && typeof err === 'object' && 'code' in err) {
+                                const error = err; // Type assertion
+                                if (error.code === 'ENOENT') {
+                                    // File not found
+                                    if (heartbeatFileSeen) {
+                                        // File existed before but is now gone, assume dead
+                                        logger.info(`Heartbeat file ${heartbeatFilePath} not found after being seen. Process likely exited.`);
+                                        void cleanupAndResolve(''); // Mark promise as intentionally ignored
+                                    }
+                                    else if (Date.now() - startTime > startupGraceMs) {
+                                        // File never appeared before configured timeout budget passed, assume dead
+                                        logger.info(`Heartbeat file ${heartbeatFilePath} never appeared within ${Math.floor(startupGraceMs / 1000)}s. Process likely failed to start or was blocked by permissions.`);
+                                        void cleanupAndResolve(USER_INPUT_TIMEOUT_SENTINEL);
+                                    }
+                                    // Otherwise, file just hasn't appeared yet, wait longer
+                                }
+                                else {
+                                    // Removed check for !== 'ENOENT' as it's implied
+                                    // Log other errors and resolve
+                                    logger.error({ error }, 'Heartbeat check error');
+                                    void cleanupAndResolve('');
+                                }
+                            }
+                            else {
+                                // Handle cases where err is not an object with a code property
+                                logger.error({ error: err }, 'Unexpected heartbeat check error');
+                                void cleanupAndResolve(''); // Mark promise as intentionally ignored
+                            }
+                        }
+                    })();
+                }, 1500); // Check every 1.5 seconds
+                // Timeout to stop watching if no response within limit
+                timeoutHandle = setTimeout(() => {
+                    logger.info(`Input timeout reached after ${timeoutSeconds} seconds.`); // Added logger info
+                    void cleanupAndResolve(USER_INPUT_TIMEOUT_SENTINEL); // Mark promise as intentionally ignored
+                }, timeoutSeconds * 1000 + 5000); // Add a bit more buffer
+            }
+            catch (setupError) {
+                logger.error({ error: setupError }, 'Error during cmd-input setup');
+                // Ensure cleanup happens even if setup fails
+                // Pass optionsFilePath to cleanupResources
+                await cleanupResources(heartbeatFilePath, tempFilePath, optionsFilePath);
+                resolve(''); // Resolve with empty string after attempting cleanup
+            }
+        })(); // Execute the IIFE
+    });
+}

package/dist/commands/input/ui.js

@@ -0,0 +1,231 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import * as OpenTuiCore from '@opentui/core';
+import * as OpenTuiReact from '@opentui/react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import logger from '../../utils/logger.js';
+import { InteractiveInput } from '../../components/InteractiveInput.js';
+import { PromptStatus } from '../../components/PromptStatus.js';
+import { USER_INPUT_TIMEOUT_SENTINEL } from '../../constants.js';
+import { resolveSearchRoot } from '../../utils/search-root.js';
+const { createCliRenderer } = OpenTuiCore;
+const { createRoot } = OpenTuiReact;
+const { useTerminalDimensions } = OpenTuiReact;
+const defaultOptions = {
+    prompt: 'Enter your response:',
+    timeout: 30,
+    showCountdown: false,
+    projectName: undefined,
+    searchRoot: undefined,
+    predefinedOptions: undefined,
+};
+const decodeSearchRootArg = (encodedSearchRoot) => {
+    if (!encodedSearchRoot) {
+        return undefined;
+    }
+    try {
+        return Buffer.from(encodedSearchRoot, 'base64').toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+};
+const readOptionsFromFile = async () => {
+    const args = process.argv.slice(2);
+    const sessionId = args[0];
+    const searchRootFromArg = decodeSearchRootArg(args[2]);
+    if (!sessionId) {
+        logger.error('No sessionId provided. Exiting.');
+        throw new Error('No sessionId provided');
+    }
+    let tempDir = args[1];
+    if (!tempDir) {
+        tempDir = os.tmpdir();
+    }
+    const optionsFilePath = path.join(tempDir, `cmd-ui-options-${sessionId}.json`);
+    try {
+        const optionsData = await fs.readFile(optionsFilePath, 'utf8');
+        const parsedOptions = JSON.parse(optionsData);
+        if (!parsedOptions.sessionId ||
+            !parsedOptions.outputFile ||
+            !parsedOptions.heartbeatFile) {
+            throw new Error('Required options missing in options file.');
+        }
+        return {
+            ...defaultOptions,
+            ...parsedOptions,
+            searchRoot: parsedOptions.searchRoot ?? searchRootFromArg,
+            sessionId: parsedOptions.sessionId,
+            outputFile: parsedOptions.outputFile,
+            heartbeatFile: parsedOptions.heartbeatFile,
+        };
+    }
+    catch (error) {
+        logger.error({
+            optionsFilePath,
+            error: error instanceof Error ? error.message : String(error),
+        }, `Failed to read or parse options file ${optionsFilePath}`);
+        throw error;
+    }
+};
+const writeResponseToFile = async (outputFile, response) => {
+    if (!outputFile)
+        return;
+    await fs.writeFile(outputFile, response, 'utf8');
+};
+let options = null;
+let exitHandlerAttached = false;
+async function initialize() {
+    try {
+        options = await readOptionsFromFile();
+        options.searchRoot = await resolveSearchRoot(options.searchRoot, {
+            argvEntry: process.argv[1],
+        });
+        if (!exitHandlerAttached) {
+            const handleExit = () => {
+                if (options && options.outputFile) {
+                    writeResponseToFile(options.outputFile, '')
+                        .catch((error) => {
+                        logger.error({ error }, 'Failed to write exit file');
+                    })
+                        .finally(() => process.exit(0));
+                }
+                else {
+                    process.exit(0);
+                }
+            };
+            process.on('SIGINT', handleExit);
+            process.on('SIGTERM', handleExit);
+            process.on('beforeExit', handleExit);
+            exitHandlerAttached = true;
+        }
+    }
+    catch (error) {
+        logger.error({ error }, 'Initialization failed');
+        process.exit(1);
+    }
+}
+const App = ({ options: appOptions, onExit }) => {
+    const { projectName, prompt, timeout, showCountdown, outputFile, heartbeatFile, predefinedOptions, searchRoot, } = appOptions;
+    const [timeLeft, setTimeLeft] = useState(timeout);
+    const [followInput, setFollowInput] = useState(false);
+    const hasCompletedRef = useRef(false);
+    const scrollRef = useRef(null);
+    const { width, height } = useTerminalDimensions();
+    const isNarrow = width < 90;
+    const keepInputVisible = useCallback(() => {
+        setFollowInput(true);
+        scrollRef.current?.scrollTo?.({ x: 0, y: Number.MAX_SAFE_INTEGER });
+    }, []);
+    const finishPrompt = useCallback((response) => {
+        if (hasCompletedRef.current) {
+            return;
+        }
+        hasCompletedRef.current = true;
+        writeResponseToFile(outputFile, response)
+            .catch((err) => {
+            logger.error('Failed to write response file:', err);
+        })
+            .finally(() => {
+            onExit();
+        });
+    }, [onExit, outputFile]);
+    useEffect(() => {
+        console.clear();
+    }, []);
+    useEffect(() => {
+        setFollowInput(false);
+        scrollRef.current?.scrollTo?.({ x: 0, y: 0 });
+    }, [prompt]);
+    useEffect(() => {
+        scrollRef.current?.scrollTo?.({
+            x: 0,
+            y: followInput ? Number.MAX_SAFE_INTEGER : 0,
+        });
+    }, [followInput, height, width]);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setTimeLeft((prev) => {
+                if (prev <= 1) {
+                    clearInterval(timer);
+                    finishPrompt(USER_INPUT_TIMEOUT_SENTINEL);
+                    return 0;
+                }
+                return prev - 1;
+            });
+        }, 1000);
+        return () => {
+            clearInterval(timer);
+        };
+    }, [finishPrompt]);
+    useEffect(() => {
+        if (!heartbeatFile) {
+            return;
+        }
+        const heartbeatInterval = setInterval(() => {
+            void (async () => {
+                try {
+                    const now = new Date();
+                    await fs.utimes(heartbeatFile, now, now);
+                }
+                catch (err) {
+                    if (err &&
+                        typeof err === 'object' &&
+                        'code' in err &&
+                        err.code === 'ENOENT') {
+                        try {
+                            await fs.writeFile(heartbeatFile, '', 'utf8');
+                        }
+                        catch {
+                            // Ignore heartbeat create failures (permissions/path issues).
+                        }
+                    }
+                }
+            })();
+        }, 1000);
+        return () => {
+            clearInterval(heartbeatInterval);
+        };
+    }, [heartbeatFile]);
+    const handleSubmit = (value) => {
+        logger.debug(`User submitted: ${value}`);
+        finishPrompt(value);
+    };
+    const handleInputSubmit = (_questionId, value) => {
+        handleSubmit(value);
+    };
+    const progressValue = timeout > 0 ? (timeLeft / timeout) * 100 : 0;
+    return (_jsxs("box", { flexDirection: "column", width: "100%", height: "100%", backgroundColor: "black", paddingLeft: isNarrow ? 0 : 1, paddingRight: isNarrow ? 0 : 1, children: [_jsx("scrollbox", { ref: scrollRef, flexGrow: 1, width: "100%", scrollY: true, stickyScroll: followInput, stickyStart: followInput ? 'bottom' : undefined, viewportCulling: false, scrollbarOptions: {
+                    showArrows: false,
+                }, children: _jsxs("box", { flexDirection: "column", width: "100%", paddingBottom: 1, gap: 2, children: [_jsx("box", { width: "100%", paddingLeft: 1, paddingRight: 1, children: _jsxs("box", { flexDirection: "column", width: "100%", gap: 0, children: [projectName && (_jsx("text", { fg: "magenta", children: _jsx("strong", { children: projectName }) })), _jsx("text", { fg: "gray", wrapMode: "word", children: isNarrow
+                                            ? 'Keyboard-first prompt mode'
+                                            : 'Keyboard-first prompt mode • Tab / Shift+Tab switches mode' })] }) }), _jsx("box", { width: "100%", paddingLeft: 1, paddingRight: 1, gap: 1, children: _jsx(InteractiveInput, { question: prompt, questionId: prompt, predefinedOptions: predefinedOptions, searchRoot: searchRoot, onSubmit: handleInputSubmit, onInputActivity: keepInputVisible }) })] }) }), showCountdown && (_jsx("box", { marginTop: 0, paddingLeft: 1, paddingRight: 1, children: _jsx(PromptStatus, { value: progressValue, timeLeftSeconds: timeLeft, critical: timeLeft <= 10 }) }))] }));
+};
+async function startUi() {
+    await initialize();
+    if (!options) {
+        logger.error('Options could not be initialized. Cannot render App.');
+        process.exit(1);
+        return;
+    }
+    const renderer = await createCliRenderer({
+        exitOnCtrlC: false,
+    });
+    const root = createRoot(renderer);
+    let closed = false;
+    const closeApp = () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        renderer.destroy();
+        process.exit(0);
+    };
+    root.render(_jsx(App, { options: options, onExit: closeApp }));
+}
+void startUi().catch((error) => {
+    logger.error({ error }, 'Failed to start input UI');
+    process.exit(1);
+});