@rawwee/interactive-mcp 1.0.0

package/dist/commands/intensive-chat/index.js

@@ -0,0 +1,289 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import os from 'os';
+import crypto from 'crypto';
+import logger from '../../utils/logger.js';
+import { spawnDetachedTerminal } from '../../utils/spawn-detached-terminal.js';
+import { SEARCH_ROOT_ENV_KEY } from '../../utils/search-root.js';
+import { USER_INPUT_TIMEOUT_SECONDS, USER_INPUT_TIMEOUT_SENTINEL, } from '../../constants.js';
+// Get the directory name of the current module
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Global object to keep track of active intensive chat sessions
+const activeSessions = {};
+// Start heartbeat monitoring for sessions
+startSessionMonitoring();
+/**
+ * Generate a unique temporary directory path for a session
+ * @returns Path to a temporary directory
+ */
+async function createSessionDir() {
+    const tempDir = os.tmpdir();
+    const sessionId = crypto.randomBytes(8).toString('hex');
+    const sessionDir = path.join(tempDir, `intensive-chat-${sessionId}`);
+    // Create the session directory
+    await fs.mkdir(sessionDir, { recursive: true });
+    return sessionDir;
+}
+/**
+ * Start an intensive chat session
+ * @param title Title for the chat session
+ * @param baseDirectory Default base directory for autocomplete/search
+ * @param timeoutSeconds Optional timeout for each question in seconds
+ * @returns Session ID for the created session
+ */
+export async function startIntensiveChatSession(title, baseDirectory, timeoutSeconds) {
+    // Create a session directory
+    const sessionDir = await createSessionDir();
+    // Generate a unique session ID
+    const sessionId = path.basename(sessionDir).replace('intensive-chat-', '');
+    // Path to the UI script - Updated to use the compiled 'ui.js' filename
+    const uiScriptPath = path.join(__dirname, 'ui.js');
+    // Create options payload for the UI
+    const options = {
+        sessionId,
+        title,
+        outputDir: sessionDir,
+        timeoutSeconds,
+        searchRoot: baseDirectory,
+    };
+    logger.info({
+        sessionId,
+        title,
+        timeoutSeconds: timeoutSeconds ?? USER_INPUT_TIMEOUT_SECONDS,
+    }, 'Starting intensive chat session with timeout configuration.');
+    // Encode options as base64 payload
+    const payload = Buffer.from(JSON.stringify(options)).toString('base64');
+    const encodedSearchRoot = Buffer.from(baseDirectory, 'utf8').toString('base64');
+    const childProcess = spawnDetachedTerminal({
+        scriptPath: uiScriptPath,
+        args: [payload, encodedSearchRoot],
+        macLauncherPath: path.join(sessionDir, `interactive-mcp-intchat-${sessionId}.command`),
+        macFallbackLogMessage: 'Fallback open -a Terminal failed (intensive chat)',
+        env: {
+            [SEARCH_ROOT_ENV_KEY]: baseDirectory,
+        },
+    });
+    // Unref the process so it can run independently
+    childProcess.unref();
+    // Store session info
+    activeSessions[sessionId] = {
+        id: sessionId,
+        process: childProcess, // Use the conditionally spawned process
+        outputDir: sessionDir,
+        lastHeartbeatTime: Date.now(),
+        isActive: true,
+        title,
+        timeoutSeconds,
+        baseDirectory,
+    };
+    // Wait a bit to ensure the UI has started
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return sessionId;
+}
+/**
+ * Ask a new question in an existing intensive chat session
+ * @param sessionId ID of the session to ask in
+ * @param question The question text to ask
+ * @param baseDirectory Base directory override for this question
+ * @param predefinedOptions Optional predefined options for the question
+ * @returns The user's response or null if session is not active
+ */
+export async function askQuestionInSession(sessionId, question, baseDirectory, predefinedOptions) {
+    const session = activeSessions[sessionId];
+    if (!session || !session.isActive) {
+        return null; // Session doesn't exist or is not active
+    }
+    const effectiveSearchRoot = baseDirectory || session.baseDirectory;
+    // Generate a unique ID for this question-answer pair
+    const questionId = crypto.randomUUID();
+    // Create the input data object
+    const inputData = {
+        id: questionId,
+        text: question,
+        searchRoot: effectiveSearchRoot,
+    };
+    if (predefinedOptions && predefinedOptions.length > 0) {
+        inputData.options = predefinedOptions;
+    }
+    // Write the combined input data to a session-specific JSON file
+    const inputFilePath = path.join(session.outputDir, `${sessionId}.json`);
+    await fs.writeFile(inputFilePath, JSON.stringify(inputData), 'utf8');
+    // Wait for the response file corresponding to the generated ID
+    const responseFilePath = path.join(session.outputDir, `response-${questionId}.txt`);
+    // Wait for response with timeout
+    const effectiveTimeoutSeconds = session.timeoutSeconds ?? USER_INPUT_TIMEOUT_SECONDS;
+    const maxWaitTime = effectiveTimeoutSeconds * 1000;
+    const pollInterval = 100; // 100ms polling interval
+    const startTime = Date.now();
+    logger.info({ sessionId, questionId, timeoutSeconds: effectiveTimeoutSeconds }, 'Waiting for intensive chat response using effective timeout.');
+    while (Date.now() - startTime < maxWaitTime) {
+        try {
+            // Check if the response file exists
+            await fs.access(responseFilePath);
+            // Read the response
+            const response = await fs.readFile(responseFilePath, 'utf8');
+            // Clean up the response file
+            await fs.unlink(responseFilePath).catch(() => { });
+            return response;
+        }
+        catch {
+            // Response file doesn't exist yet, check session status
+            if (!(await isSessionActive(sessionId))) {
+                return null; // Session has ended
+            }
+            // Wait before polling again
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+    }
+    // Timeout reached
+    logger.info({ sessionId, questionId, timeoutSeconds: effectiveTimeoutSeconds }, 'Intensive chat question timed out.');
+    return USER_INPUT_TIMEOUT_SENTINEL;
+}
+/**
+ * Stop an active intensive chat session
+ * @param sessionId ID of the session to stop
+ * @returns True if session was stopped, false otherwise
+ */
+export async function stopIntensiveChatSession(sessionId) {
+    const session = activeSessions[sessionId];
+    if (!session || !session.isActive) {
+        return false; // Session doesn't exist or is already inactive
+    }
+    // Write close signal file
+    const closeFilePath = path.join(session.outputDir, 'close-session.txt');
+    await fs.writeFile(closeFilePath, '', 'utf8');
+    // Give the process some time to exit gracefully
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    try {
+        // Force kill the process if it's still running
+        if (!session.process.killed) {
+            // Kill process group on Unix-like systems, standard kill on Windows
+            try {
+                if (os.platform() !== 'win32') {
+                    process.kill(-session.process.pid, 'SIGTERM');
+                }
+                else {
+                    process.kill(session.process.pid, 'SIGTERM');
+                }
+            }
+            catch {
+                // console.error("Error killing process:", killError);
+                // Fallback or ignore if process already exited or group kill failed
+            }
+        }
+    }
+    catch {
+        // Process might have already exited
+    }
+    // Mark session as inactive
+    session.isActive = false;
+    // Clean up session directory after a delay
+    setTimeout(() => {
+        // Use void to mark intentionally unhandled promise
+        void (async () => {
+            try {
+                await fs.rm(session.outputDir, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+            // Remove from active sessions
+            delete activeSessions[sessionId];
+        })();
+    }, 2000);
+    return true;
+}
+/**
+ * Check if a session is still active
+ * @param sessionId ID of the session to check
+ * @returns True if session is active, false otherwise
+ */
+export async function isSessionActive(sessionId) {
+    const session = activeSessions[sessionId];
+    if (!session) {
+        return false; // Session doesn't exist
+    }
+    if (!session.isActive) {
+        return false; // Session was manually marked as inactive
+    }
+    try {
+        // Check the heartbeat file
+        const heartbeatPath = path.join(session.outputDir, 'heartbeat.txt');
+        const stats = await fs.stat(heartbeatPath);
+        // Check if heartbeat was updated recently (within last 2 seconds)
+        const heartbeatAge = Date.now() - stats.mtime.getTime();
+        if (heartbeatAge > 2000) {
+            // Heartbeat is too old, session is likely dead
+            session.isActive = false;
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        // If error is ENOENT (file not found), assume session is still starting
+        // Check if err is an object and has a code property before accessing it
+        if (err &&
+            typeof err === 'object' &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            // Optional: Could add a check here to see if the session is very new
+            // e.g., if (Date.now() - session.startTime < 2000) return true;
+            // For now, let's assume ENOENT means it's possibly still starting.
+            return true;
+        }
+        // Handle cases where err is not an object with a code property or other errors
+        logger.error({ sessionId, error: err instanceof Error ? err.message : String(err) }, `Error checking heartbeat for session ${sessionId}`);
+        session.isActive = false;
+        return false;
+    }
+}
+/**
+ * Start background monitoring of all active sessions
+ */
+function startSessionMonitoring() {
+    // Remove async from setInterval callback
+    setInterval(() => {
+        // Use void to mark intentionally unhandled promise
+        void (async () => {
+            for (const sessionId of Object.keys(activeSessions)) {
+                const isActive = await isSessionActive(sessionId);
+                if (!isActive && activeSessions[sessionId]) {
+                    // Clean up inactive session
+                    try {
+                        // Kill process if it's somehow still running
+                        if (!activeSessions[sessionId].process.killed) {
+                            try {
+                                if (os.platform() !== 'win32') {
+                                    process.kill(-activeSessions[sessionId].process.pid, 'SIGTERM');
+                                }
+                                else {
+                                    process.kill(activeSessions[sessionId].process.pid, 'SIGTERM');
+                                }
+                            }
+                            catch {
+                                // console.error("Error killing process:", killError);
+                                // Ignore errors during cleanup
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore errors during cleanup
+                    }
+                    // Clean up session directory
+                    try {
+                        await fs.rm(activeSessions[sessionId].outputDir, {
+                            recursive: true,
+                            force: true,
+                        });
+                    }
+                    catch {
+                        // Ignore errors during cleanup
+                    }
+                    // Remove from active sessions
+                    delete activeSessions[sessionId];
+                }
+            }
+        })();
+    }, 5000); // Check every 5 seconds
+}

package/dist/commands/intensive-chat/ui.js

@@ -0,0 +1,301 @@
+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 crypto from 'crypto';
+import { InteractiveInput } from '../../components/InteractiveInput.js';
+import { MarkdownText } from '../../components/MarkdownText.js';
+import { PromptStatus } from '../../components/PromptStatus.js';
+import { USER_INPUT_TIMEOUT_SECONDS, USER_INPUT_TIMEOUT_SENTINEL, } from '../../constants.js';
+import logger from '../../utils/logger.js';
+import { resolveSearchRoot } from '../../utils/search-root.js';
+const { createCliRenderer } = OpenTuiCore;
+const { createRoot } = OpenTuiReact;
+const { useTerminalDimensions } = OpenTuiReact;
+const decodeSearchRootArg = (encodedSearchRoot) => {
+    if (!encodedSearchRoot) {
+        return undefined;
+    }
+    try {
+        return Buffer.from(encodedSearchRoot, 'base64').toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+};
+const parseArgs = () => {
+    const args = process.argv.slice(2);
+    const searchRootFromArg = decodeSearchRootArg(args[1]);
+    const defaults = {
+        sessionId: crypto.randomUUID(),
+        title: 'Interactive Chat Session',
+        outputDir: undefined,
+        searchRoot: searchRootFromArg,
+        timeoutSeconds: USER_INPUT_TIMEOUT_SECONDS,
+    };
+    if (args[0]) {
+        try {
+            const decoded = Buffer.from(args[0], 'base64').toString('utf8');
+            const parsed = JSON.parse(decoded);
+            return {
+                ...defaults,
+                ...parsed,
+                searchRoot: parsed.searchRoot ?? searchRootFromArg,
+            };
+        }
+        catch (e) {
+            logger.error({ error: e }, 'Invalid input options payload, using defaults.');
+        }
+    }
+    return defaults;
+};
+const options = parseArgs();
+const writeResponseToFile = async (questionId, response) => {
+    if (!options.outputDir)
+        return;
+    const responseFilePath = path.join(options.outputDir, `response-${questionId}.txt`);
+    await fs.writeFile(responseFilePath, response, 'utf8');
+    await new Promise((resolve) => setTimeout(resolve, 500));
+};
+const updateHeartbeat = async () => {
+    if (!options.outputDir)
+        return;
+    const heartbeatPath = path.join(options.outputDir, 'heartbeat.txt');
+    try {
+        const dir = path.dirname(heartbeatPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(heartbeatPath, Date.now().toString(), 'utf8');
+    }
+    catch (writeError) {
+        logger.error({ heartbeatPath, error: writeError }, `Failed to write heartbeat file ${heartbeatPath}`);
+    }
+};
+const handleExit = () => {
+    if (options.outputDir) {
+        fs.writeFile(path.join(options.outputDir, 'session-closed.txt'), '', 'utf8')
+            .then(() => process.exit(0))
+            .catch((error) => {
+            logger.error({ error }, 'Failed to write exit file');
+            process.exit(1);
+        });
+    }
+    else {
+        process.exit(0);
+    }
+};
+process.on('SIGINT', handleExit);
+process.on('SIGTERM', handleExit);
+process.on('beforeExit', handleExit);
+const App = ({ sessionId, title, outputDir, searchRoot, timeoutSeconds, onCloseSession, }) => {
+    const [chatHistory, setChatHistory] = useState([]);
+    const [currentQuestionId, setCurrentQuestionId] = useState(null);
+    const [currentPredefinedOptions, setCurrentPredefinedOptions] = useState(undefined);
+    const [sessionSearchRoot, setSessionSearchRoot] = useState(undefined);
+    const [currentSearchRoot, setCurrentSearchRoot] = useState(undefined);
+    const [timeLeft, setTimeLeft] = useState(null);
+    const [followInput, setFollowInput] = useState(false);
+    const timerRef = useRef(null);
+    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 });
+    }, []);
+    useEffect(() => {
+        console.clear();
+    }, []);
+    useEffect(() => {
+        let mounted = true;
+        void resolveSearchRoot(searchRoot, { argvEntry: process.argv[1] }).then((resolvedSearchRoot) => {
+            if (!mounted) {
+                return;
+            }
+            setSessionSearchRoot(resolvedSearchRoot);
+            setCurrentSearchRoot((prev) => prev ?? resolvedSearchRoot);
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [searchRoot]);
+    useEffect(() => {
+        if (!currentQuestionId) {
+            return;
+        }
+        setFollowInput(false);
+        scrollRef.current?.scrollTo?.({ x: 0, y: 0 });
+    }, [currentQuestionId]);
+    useEffect(() => {
+        scrollRef.current?.scrollTo?.({
+            x: 0,
+            y: followInput ? Number.MAX_SAFE_INTEGER : 0,
+        });
+    }, [followInput, height, width]);
+    useEffect(() => {
+        const questionPoller = setInterval(async () => {
+            if (!outputDir)
+                return;
+            try {
+                await updateHeartbeat();
+                const inputFilePath = path.join(outputDir, `${sessionId}.json`);
+                try {
+                    const inputExists = await fs.stat(inputFilePath);
+                    if (inputExists) {
+                        const inputFileContent = await fs.readFile(inputFilePath, 'utf8');
+                        let questionId = null;
+                        let questionText = null;
+                        let incomingOptions;
+                        let incomingSearchRoot;
+                        try {
+                            const inputData = JSON.parse(inputFileContent);
+                            if (typeof inputData === 'object' &&
+                                inputData !== null &&
+                                typeof inputData.id === 'string' &&
+                                typeof inputData.text === 'string' &&
+                                (inputData.options === undefined ||
+                                    Array.isArray(inputData.options)) &&
+                                (inputData.searchRoot === undefined ||
+                                    typeof inputData.searchRoot === 'string')) {
+                                questionId = inputData.id;
+                                questionText = inputData.text;
+                                incomingOptions = Array.isArray(inputData.options)
+                                    ? inputData.options.map(String)
+                                    : undefined;
+                                incomingSearchRoot = inputData.searchRoot;
+                            }
+                            else {
+                                logger.error(`Invalid format in ${sessionId}.json. Expected JSON with id (string), text (string), and optional options (array), and optional searchRoot (string).`);
+                            }
+                        }
+                        catch (parseError) {
+                            logger.error({ file: `${sessionId}.json`, error: parseError }, `Error parsing ${sessionId}.json as JSON`);
+                        }
+                        if (questionId && questionText) {
+                            await addNewQuestion(questionId, questionText, incomingOptions, incomingSearchRoot);
+                            await fs.unlink(inputFilePath);
+                        }
+                        else {
+                            logger.error(`Deleting invalid input file: ${inputFilePath}`);
+                            await fs.unlink(inputFilePath);
+                        }
+                    }
+                }
+                catch (e) {
+                    if (typeof e === 'object' &&
+                        e !== null &&
+                        'code' in e &&
+                        e.code !== 'ENOENT') {
+                        logger.error({ inputFilePath, error: e }, `Error checking/reading input file ${inputFilePath}`);
+                    }
+                }
+                const closeFilePath = path.join(outputDir, 'close-session.txt');
+                try {
+                    await fs.stat(closeFilePath);
+                    onCloseSession();
+                }
+                catch {
+                    // No close request.
+                }
+            }
+            catch (error) {
+                logger.error({ error }, 'Error in poll cycle');
+            }
+        }, 100);
+        return () => clearInterval(questionPoller);
+    }, [onCloseSession, outputDir, sessionId]);
+    useEffect(() => {
+        if (timeLeft === null || !currentQuestionId) {
+            if (timerRef.current) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+            return;
+        }
+        if (timeLeft <= 0) {
+            if (timerRef.current) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+            void handleSubmit(currentQuestionId, USER_INPUT_TIMEOUT_SENTINEL);
+            return;
+        }
+        if (!timerRef.current) {
+            timerRef.current = setInterval(() => {
+                setTimeLeft((prev) => (prev !== null ? prev - 1 : null));
+            }, 1000);
+        }
+        return () => {
+            if (timerRef.current) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+        };
+    }, [timeLeft, currentQuestionId]);
+    const addNewQuestion = async (questionId, questionText, incomingOptions, incomingSearchRoot) => {
+        console.clear();
+        if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+        setChatHistory((prev) => [
+            ...prev,
+            {
+                text: questionText,
+                isQuestion: true,
+            },
+        ]);
+        setCurrentQuestionId(questionId);
+        setCurrentPredefinedOptions(incomingOptions);
+        const resolvedSearchRoot = await resolveSearchRoot(incomingSearchRoot ?? sessionSearchRoot ?? searchRoot, { argvEntry: process.argv[1] });
+        setCurrentSearchRoot(resolvedSearchRoot);
+        setTimeLeft(timeoutSeconds);
+    };
+    const handleSubmit = async (questionId, value) => {
+        if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+        setTimeLeft(null);
+        setChatHistory((prev) => prev.map((msg) => {
+            if (msg.isQuestion &&
+                !msg.answer &&
+                msg ===
+                    prev
+                        .slice()
+                        .reverse()
+                        .find((m) => m.isQuestion && !m.answer)) {
+                return { ...msg, answer: value };
+            }
+            return msg;
+        }));
+        setCurrentQuestionId(null);
+        setCurrentPredefinedOptions(undefined);
+        setCurrentSearchRoot(sessionSearchRoot);
+        if (outputDir) {
+            await writeResponseToFile(questionId, value);
+        }
+    };
+    const percentage = timeLeft !== null && timeoutSeconds > 0
+        ? (timeLeft / timeoutSeconds) * 100
+        : 0;
+    return (_jsxs("box", { flexDirection: "column", width: "100%", height: "100%", backgroundColor: "black", paddingLeft: isNarrow ? 0 : 1, paddingRight: isNarrow ? 0 : 1, children: [_jsxs("box", { marginBottom: 1, flexDirection: "column", width: "100%", paddingLeft: 1, paddingRight: 1, gap: 0, children: [_jsx("text", { fg: "magenta", children: _jsx("strong", { children: title }) }), _jsxs("text", { fg: "gray", wrapMode: "word", children: ["Session ", sessionId] }), !isNarrow && _jsx("text", { fg: "gray", children: "Waiting for prompts\u2026" })] }), _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, children: [_jsx("box", { flexDirection: "column", width: "100%", gap: 2, children: chatHistory.map((msg, i) => (_jsxs("box", { flexDirection: "column", width: "100%", paddingLeft: 1, paddingRight: 1, gap: 1, children: [msg.isQuestion ? (_jsxs("box", { flexDirection: "column", width: "100%", gap: 0, children: [_jsx("text", { fg: "cyan", children: _jsx("strong", { children: "QUESTION" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.text, showCodeCopyControls: true }) })] })) : null, msg.answer ? (_jsxs("box", { flexDirection: "column", width: "100%", marginTop: 0, children: [_jsx("text", { fg: "green", children: _jsx("strong", { children: "ANSWER" }) }), _jsx("box", { paddingLeft: isNarrow ? 1 : 2, children: _jsx(MarkdownText, { content: msg.answer, showCodeCopyControls: true }) })] })) : null] }, `msg-${i}`))) }), currentQuestionId && (_jsxs("box", { flexDirection: "column", marginTop: 1, paddingLeft: 1, paddingRight: 1, gap: 1, children: [_jsx(InteractiveInput, { question: chatHistory
+                                        .slice()
+                                        .reverse()
+                                        .find((m) => m.isQuestion && !m.answer)
+                                        ?.text || '', questionId: currentQuestionId, predefinedOptions: currentPredefinedOptions, searchRoot: currentSearchRoot, onSubmit: handleSubmit, onInputActivity: keepInputVisible }), timeLeft !== null && (_jsx("box", { marginTop: 0, children: _jsx(PromptStatus, { value: percentage, timeLeftSeconds: timeLeft, critical: timeLeft <= 10 }) }))] }))] }) })] }));
+};
+async function startUi() {
+    const renderer = await createCliRenderer({
+        exitOnCtrlC: false,
+    });
+    const root = createRoot(renderer);
+    root.render(_jsx(App, { ...options, onCloseSession: handleExit }));
+}
+void startUi().catch((error) => {
+    logger.error({ error }, 'Failed to start intensive chat UI');
+    process.exit(1);
+});