testeranto 0.200.1 → 0.203.0

package/dist/module/src/components/pure/ModalContent.js

@@ -1,79 +0,0 @@
-import React from "react";
-import { Modal } from "react-bootstrap";
-import { ThemeCard } from "./ThemeCard";
-import "../../App.scss";
-export const ModalContent = ({ theme, handleThemeChange, }) => (React.createElement(React.Fragment, null,
-    React.createElement(Modal.Header, { closeButton: true, className: "border-0" },
-        React.createElement(Modal.Title, { className: "d-flex align-items-center" },
-            React.createElement("i", { className: "bi bi-palette-fill me-2" }),
-            React.createElement("span", null, "Settings"))),
-    React.createElement("div", { className: "alert alert-warning mx-3 mt-2 mb-0" },
-        React.createElement("i", { className: "bi bi-exclamation-triangle-fill me-2" }),
-        React.createElement("strong", null, "Warning:"),
-        " Themes are an experimental feature. Only \"Business casual\" is fully supported at this time."),
-    React.createElement(Modal.Body, { className: "p-0" },
-        React.createElement("div", { className: "p-3" },
-            React.createElement("div", { className: "row g-3" },
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "system", title: "9 to 5", description: "Follows your OS theme", style: {
-                        background: "linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%)",
-                        borderColor: "#adb5bd",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "light", title: "Business casual", description: "Clean & professional", style: {
-                        background: "linear-gradient(135deg, #ffffff 0%, #f1f3f5 100%)",
-                        borderColor: "#ced4da",
-                        color: "#212529",
-                        borderWidth: "2px",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "dark", title: "Business formal", description: "Premium & focused", style: {
-                        background: "linear-gradient(135deg, #1a1a2e 0%, #16213e 100%)",
-                        borderColor: "#4ecdc4",
-                        color: "#f8f9fa",
-                        borderWidth: "2px",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "light-vibrant", title: "Office Party", description: "Colorful & fun", style: {
-                        background: "linear-gradient(135deg, #ff2d75 0%, #00e5ff 100%)",
-                        borderColor: "#ffeb3b",
-                        color: "#fff",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "dark-vibrant", title: "After Party", description: "Neon nightlife", style: {
-                        background: "linear-gradient(135deg, #16213e 0%, #e94560 100%)",
-                        borderColor: "#00e5ff",
-                        color: "#fff",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "sepia", title: "WFH", description: "Vintage warmth", style: {
-                        background: "linear-gradient(135deg, #f4ecd8 0%, #d0b88f 100%)",
-                        borderColor: "#8b6b4a",
-                        color: "#3a3226",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "light-grayscale", title: "Serious Business", description: "Simple & distraction-free", style: {
-                        background: "linear-gradient(135deg, #f5f5f5 0%, #e0e0e0 100%)",
-                        borderColor: "#666",
-                        color: "#333",
-                        borderWidth: "2px",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "dark-grayscale", title: "Very Serious business", description: "Maximum readability", style: {
-                        background: "linear-gradient(135deg, #111 0%, #333 100%)",
-                        borderColor: "#ff6b6b",
-                        color: "#e0e0e0",
-                        borderWidth: "2px",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "daily", title: "Dreaming of PTO", description: "Sunrise, sunset", style: {
-                        background: "linear-gradient(135deg, #6eafff 0%, #f9fbf0 100%)",
-                        borderColor: "#f7d62e",
-                        color: "#00192d",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "protanopia", title: "Protanopia", description: "Red-blind mode", style: {
-                        background: "linear-gradient(135deg, #f8f9fa 0%, #e0e8ff 100%)",
-                        borderColor: "#3366cc",
-                        color: "#333",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "deuteranopia", title: "Deuteranopia", description: "Green-blind mode", style: {
-                        background: "linear-gradient(135deg, #f8f9fa 0%, #ffe0e0 100%)",
-                        borderColor: "#cc6633",
-                        color: "#333",
-                    } }),
-                React.createElement(ThemeCard, { theme: theme, handleThemeChange: handleThemeChange, value: "tritanopia", title: "Tritanopia", description: "Blue-blind mode", style: {
-                        background: "linear-gradient(135deg, #f8f9fa 0%, #e0ffe0 100%)",
-                        borderColor: "#00aa66",
-                        color: "#333",
-                    } }))))));

package/dist/module/src/components/pure/ModalContent.test/implementation.js

@@ -1,32 +0,0 @@
-import { assert } from "chai";
-export const implementation = {
-    suites: {
-        Default: "Modal Content Tests",
-    },
-    givens: {
-        Default: () => ({
-            theme: "light",
-            handleThemeChange: () => { },
-        }),
-    },
-    whens: {},
-    thens: {
-        hasModalHeader: () => (state) => {
-            var _a;
-            const header = (_a = state.htmlElement) === null || _a === void 0 ? void 0 : _a.querySelector('.modal-header');
-            assert.exists(header, 'Should have Modal.Header');
-            return state;
-        },
-        hasThemeCards: () => (state) => {
-            var _a;
-            const themeCards = (_a = state.htmlElement) === null || _a === void 0 ? void 0 : _a.querySelectorAll('.theme-card');
-            assert.isAtLeast(themeCards === null || themeCards === void 0 ? void 0 : themeCards.length, 1, 'Should render ThemeCard components');
-            return state;
-        },
-        takeScreenshot: (name) => async (state, pm) => {
-            // For web tests, we can use the PM's screenshot capability
-            // The actual implementation will be handled by the test runner
-            return state;
-        },
-    },
-};

package/dist/module/src/components/pure/ModalContent.test/index.js

@@ -1,53 +0,0 @@
-import Testeranto from "testeranto-react/src/react-dom/component/web";
-import { implementation } from "./implementation";
-import { specification } from "./specification";
-import { ModalContent } from "../ModalContent";
-import React from "react";
-import ReactDOM from "react-dom/client";
-const testAdapter = {
-    beforeAll: async (input, testResource, pm) => {
-        // The subject is the component itself, which we'll use to create instances
-        return ModalContent;
-    },
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        // Create a container and mount the component
-        const container = document.createElement('div');
-        document.body.appendChild(container);
-        const props = initializer();
-        const root = ReactDOM.createRoot(container);
-        const reactElement = React.createElement(subject, props);
-        root.render(reactElement);
-        // Wait for the component to render
-        await new Promise(resolve => setTimeout(resolve, 0));
-        return {
-            htmlElement: container,
-            reactElement: reactElement,
-            domRoot: root
-        };
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        return whenCB(store, pm);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        return thenCB(store, pm);
-    },
-    afterEach: async (store, key, pm) => {
-        // Cleanup
-        if (store.domRoot) {
-            store.domRoot.unmount();
-        }
-        if (store.htmlElement && store.htmlElement.parentNode) {
-            store.htmlElement.parentNode.removeChild(store.htmlElement);
-        }
-        return store;
-    },
-    afterAll: async (store, pm) => {
-        // No-op for now
-    },
-    assertThis: (assertion) => {
-        // The assertions are handled in the then implementations
-        // This can be a no-op or can wrap the assertion if needed
-        return assertion;
-    }
-};
-export default Testeranto(ModalContent, specification, implementation, testAdapter);

package/dist/module/src/components/pure/ModalContent.test/specification.js

@@ -1,15 +0,0 @@
-export const specification = (Suite, Given, When, Then) => {
-    return [
-        Suite.Default("ModalContent Component Tests", {
-            basicRender: Given.Default([
-                "ModalContent should render",
-                "It should contain a Modal.Header",
-                "It should render the ThemeCard components",
-            ], [], [
-                Then.hasModalHeader(undefined),
-                Then.hasThemeCards(undefined),
-                Then.takeScreenshot("modal-content.png"),
-            ]),
-        }),
-    ];
-};

package/dist/module/src/components/pure/ModalContent.test/types.js

@@ -1,3 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export {};

package/dist/module/src/components/pure/NavBar.js

@@ -1,37 +0,0 @@
-import React from 'react';
-import { Navbar, Container, Nav, Badge } from 'react-bootstrap';
-import { Link, useLocation } from 'react-router-dom';
-export const NavBar = ({ title, backLink, navItems = [], rightContent, }) => {
-    const location = useLocation();
-    return (React.createElement(Navbar, { bg: "light", expand: "lg", className: "mb-2", sticky: "top", expanded: false },
-        React.createElement(Container, { fluid: true },
-            backLink && (React.createElement(Nav.Link, { as: Link, to: backLink, className: "me-2 fs-3 text-primary", style: {
-                    padding: '0.25rem 0.75rem',
-                    border: '2px solid var(--bs-primary)',
-                    borderRadius: '50%',
-                    display: 'inline-flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '2.5rem',
-                    height: '2.5rem'
-                }, title: "Go up one level" }, "\u2191")),
-            React.createElement(Navbar.Brand, { className: backLink ? 'ms-2' : '' }, title),
-            React.createElement(Navbar.Toggle, { "aria-controls": "basic-navbar-nav", style: { display: 'none' } }),
-            React.createElement(Navbar.Collapse, { id: "basic-navbar-nav" },
-                navItems.length > 0 && (React.createElement(Nav, { className: "me-auto" }, navItems.map((item, i) => {
-                    const className = [
-                        item.className,
-                        item.active ? 'text-primary fw-bold border-bottom border-2 border-primary' : '',
-                        typeof item.label === 'string' && item.label.includes('❌') ? 'text-danger fw-bold' : '',
-                        typeof item.label === 'string' && item.label.includes('✅') ? 'text-success fw-bold' : '',
-                        !item.active && typeof item.label !== 'string' ? 'text-secondary' : ''
-                    ].filter(Boolean).join(' ');
-                    return (React.createElement(Nav.Link, { key: i, as: item.to ? Link : 'div', to: item.to, active: item.active, className: className, title: typeof item.label === 'string' ? item.label : undefined },
-                        item.icon && React.createElement("span", { className: "me-2" }, item.icon),
-                        item.label,
-                        item.badge && (React.createElement(Badge, { bg: item.badge.variant, className: "ms-2" }, item.badge.text))));
-                }))),
-                rightContent && (React.createElement(Nav, null, React.Children.map(rightContent, (child) => {
-                    return child;
-                })))))));
-};

package/dist/module/src/components/pure/ProcessManager.js

@@ -1,75 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Modal, Button, ListGroup, Badge } from 'react-bootstrap';
-export const ProcessManager = ({ show, onHide, ws }) => {
-    const [processes, setProcesses] = useState([]);
-    useEffect(() => {
-        if (show && ws) {
-            // Request current processes when modal is shown
-            ws.send(JSON.stringify({ type: 'getRunningProcesses' }));
-        }
-    }, [show, ws]);
-    useEffect(() => {
-        if (!ws)
-            return;
-        const handleMessage = (event) => {
-            try {
-                const data = JSON.parse(event.data);
-                if (data.type === 'runningProcesses') {
-                    setProcesses(data.processes.map((p) => (Object.assign(Object.assign({}, p), { status: 'running' }))));
-                }
-                else if (data.type === 'processStarted') {
-                    setProcesses(prev => [...prev, Object.assign(Object.assign({}, data), { status: 'running' })]);
-                }
-                else if (data.type === 'processExited') {
-                    setProcesses(prev => prev.map(p => p.processId === data.processId
-                        ? Object.assign(Object.assign({}, p), { status: 'exited', exitCode: data.exitCode }) : p));
-                }
-                else if (data.type === 'processError') {
-                    setProcesses(prev => prev.map(p => p.processId === data.processId
-                        ? Object.assign(Object.assign({}, p), { status: 'error', error: data.error }) : p));
-                }
-            }
-            catch (error) {
-                console.error('Error parsing process message:', error);
-            }
-        };
-        ws.addEventListener('message', handleMessage);
-        return () => ws.removeEventListener('message', handleMessage);
-    }, [ws]);
-    const getStatusBadge = (process) => {
-        switch (process.status) {
-            case 'running':
-                return React.createElement(Badge, { bg: "success" }, "Running");
-            case 'exited':
-                return React.createElement(Badge, { bg: "secondary" },
-                    "Exited (",
-                    process.exitCode,
-                    ")");
-            case 'error':
-                return React.createElement(Badge, { bg: "danger" }, "Error");
-            default:
-                return React.createElement(Badge, { bg: "warning" }, "Unknown");
-        }
-    };
-    return (React.createElement(Modal, { show: show, onHide: onHide, size: "lg" },
-        React.createElement(Modal.Header, { closeButton: true },
-            React.createElement(Modal.Title, null, "Running Aider Processes")),
-        React.createElement(Modal.Body, null,
-            React.createElement(ListGroup, null,
-                processes.map(process => (React.createElement(ListGroup.Item, { key: process.processId, className: "d-flex justify-content-between align-items-start" },
-                    React.createElement("div", { className: "ms-2 me-auto" },
-                        React.createElement("div", { className: "fw-bold" }, process.command),
-                        React.createElement("small", { className: "text-muted" },
-                            "PID: ",
-                            process.pid || 'N/A',
-                            " | Started: ",
-                            new Date(process.timestamp).toLocaleString()),
-                        process.error && (React.createElement("div", { className: "text-danger mt-1" },
-                            React.createElement("small", null,
-                                "Error: ",
-                                process.error)))),
-                    getStatusBadge(process)))),
-                processes.length === 0 && (React.createElement(ListGroup.Item, null, "No active processes")))),
-        React.createElement(Modal.Footer, null,
-            React.createElement(Button, { variant: "secondary", onClick: onHide }, "Close"))));
-};

package/dist/module/src/components/pure/ProcessManagerView.js

@@ -1,200 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import React, { useState, useEffect, useRef } from "react";
-import { Container, Row, Col, Badge, Button } from "react-bootstrap";
-import { useNavigate } from "react-router-dom";
-export const ProcessManagerView = ({ processes, onRefresh, onBack, loading, onKillProcess, }) => {
-    const navigate = useNavigate();
-    const [selectedProcess, setSelectedProcess] = useState(null);
-    const [ws, setWs] = useState(null);
-    const [processLogs, setProcessLogs] = useState([]);
-    const [autoScroll, setAutoScroll] = useState(true);
-    const logsContainerRef = useRef(null);
-    const [isNavbarCollapsed, setIsNavbarCollapsed] = useState(false);
-    // Set up WebSocket connection
-    useEffect(() => {
-        const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-        const wsUrl = `${wsProtocol}//${window.location.host}`;
-        const websocket = new WebSocket(wsUrl);
-        setWs(websocket);
-        websocket.onmessage = (event) => {
-            try {
-                const data = JSON.parse(event.data);
-                // Handle process data response
-                if (data.type === "processData" &&
-                    selectedProcess &&
-                    data.processId === selectedProcess.processId) {
-                    setSelectedProcess((prev) => prev
-                        ? Object.assign(Object.assign({}, prev), { logs: data.logs || [] }) : null);
-                    setProcessLogs(data.logs || []);
-                }
-                // Handle new log messages
-                else if ((data.type === "processStdout" || data.type === "processStderr") &&
-                    selectedProcess &&
-                    data.processId === selectedProcess.processId) {
-                    setProcessLogs((prev) => [...prev, data.data]);
-                }
-            }
-            catch (error) {
-                console.error("Error parsing WebSocket message:", error);
-            }
-        };
-        return () => {
-            websocket.close();
-        };
-    }, [selectedProcess]);
-    // Request process data when selected
-    useEffect(() => {
-        if (selectedProcess && ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({
-                type: "getProcess",
-                processId: selectedProcess.processId,
-            }));
-        }
-    }, [selectedProcess, ws]);
-    // Auto-scroll to bottom when new logs arrive and autoScroll is enabled
-    useEffect(() => {
-        if (autoScroll && logsContainerRef.current) {
-            logsContainerRef.current.scrollTop =
-                logsContainerRef.current.scrollHeight;
-        }
-    }, [processLogs, autoScroll]);
-    // Handle scroll events to determine if we should auto-scroll
-    const handleLogsScroll = () => {
-        if (logsContainerRef.current) {
-            const { scrollTop, scrollHeight, clientHeight } = logsContainerRef.current;
-            const isAtBottom = scrollHeight - scrollTop <= clientHeight + 10; // 10px threshold
-            setAutoScroll(isAtBottom);
-        }
-    };
-    const getStatusBadge = (process) => {
-        switch (process.status) {
-            case "running":
-                return React.createElement(Badge, { bg: "success" }, "Running");
-            case "exited":
-                return React.createElement(Badge, { bg: "secondary" },
-                    "Exited (",
-                    process.exitCode,
-                    ")");
-            case "error":
-                return React.createElement(Badge, { bg: "danger" }, "Error");
-            default:
-                return React.createElement(Badge, { bg: "warning" }, "Unknown");
-        }
-    };
-    const handleSelectProcess = (process) => {
-        setSelectedProcess(process);
-        setProcessLogs(process.logs || []);
-    };
-    const handleInput = (data) => {
-        if (ws &&
-            ws.readyState === WebSocket.OPEN &&
-            (selectedProcess === null || selectedProcess === void 0 ? void 0 : selectedProcess.status) === "running") {
-            ws.send(JSON.stringify({
-                type: "stdin",
-                processId: selectedProcess.processId,
-                data: data,
-            }));
-        }
-    };
-    return (React.createElement(Container, { fluid: true, className: "px-0 h-100" },
-        React.createElement(Row, { className: "g-0", style: { height: "calc(100vh - 56px)" } },
-            React.createElement(Col, { sm: 3, className: "border-end", style: {
-                    height: "100%",
-                    overflow: "auto",
-                    backgroundColor: "#f8f9fa",
-                } },
-                React.createElement("div", { className: "p-1" },
-                    processes.map((process) => (React.createElement("div", { key: process.processId, className: `p-2 mb-1 rounded ${(selectedProcess === null || selectedProcess === void 0 ? void 0 : selectedProcess.processId) === process.processId
-                            ? "bg-primary text-white"
-                            : "bg-white border"}`, style: { cursor: "pointer" }, onClick: () => handleSelectProcess(process), title: process.command },
-                        React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
-                            React.createElement("div", { className: "flex-grow-1", style: { minWidth: 0 } },
-                                React.createElement("div", { className: "fw-bold text-truncate small" }, process.command.split(" ")[0]),
-                                React.createElement("div", { className: `text-truncate ${(selectedProcess === null || selectedProcess === void 0 ? void 0 : selectedProcess.processId) === process.processId
-                                        ? "text-white-50"
-                                        : "text-muted"}`, style: { fontSize: "0.7rem" } },
-                                    "PID: ",
-                                    process.pid || "N/A",
-                                    " |",
-                                    " ",
-                                    new Date(process.timestamp).toLocaleTimeString())),
-                            React.createElement("div", { className: "ms-2" }, getStatusBadge(process))),
-                        process.error && (React.createElement("div", { className: `mt-1 ${(selectedProcess === null || selectedProcess === void 0 ? void 0 : selectedProcess.processId) === process.processId
-                                ? "text-warning"
-                                : "text-danger"}`, style: { fontSize: "0.7rem" } },
-                            React.createElement("div", { className: "text-truncate" },
-                                "Error: ",
-                                process.error)))))),
-                    processes.length === 0 && !loading && (React.createElement("div", { className: "p-2 text-center text-muted small" }, "No active processes")),
-                    loading && processes.length === 0 && (React.createElement("div", { className: "p-2 text-center small" },
-                        React.createElement("div", { className: "spinner-border spinner-border-sm", role: "status" },
-                            React.createElement("span", { className: "visually-hidden" }, "Loading...")))))),
-            React.createElement(Col, { sm: 5, className: "border-end p-3", style: { height: "100%", overflow: "auto" } }, selectedProcess ? (React.createElement("div", null,
-                React.createElement("div", { className: "mb-3" },
-                    React.createElement("strong", null, "Command:"),
-                    React.createElement("code", { className: "bg-light p-2 rounded d-block mt-1", style: { fontSize: "0.8rem" } }, selectedProcess.command)),
-                React.createElement("div", { className: "mb-2" },
-                    React.createElement("strong", null, "Status:"),
-                    React.createElement("div", { className: "mt-1" }, getStatusBadge(selectedProcess))),
-                React.createElement("div", { className: "mb-2" },
-                    React.createElement("strong", null, "PID:"),
-                    React.createElement("div", { className: "text-muted" }, selectedProcess.pid || "N/A")),
-                React.createElement("div", { className: "mb-2" },
-                    React.createElement("strong", null, "Started:"),
-                    React.createElement("div", { className: "text-muted" }, new Date(selectedProcess.timestamp).toLocaleString())),
-                selectedProcess.exitCode !== undefined && (React.createElement("div", { className: "mb-2" },
-                    React.createElement("strong", null, "Exit Code:"),
-                    React.createElement("div", { className: "text-muted" }, selectedProcess.exitCode))),
-                selectedProcess.error && (React.createElement("div", { className: "mt-3" },
-                    React.createElement("strong", { className: "text-danger" }, "Error:"),
-                    React.createElement("div", { className: "text-danger small mt-1" }, selectedProcess.error))))) : (React.createElement("div", { className: "text-center text-muted mt-5" },
-                React.createElement("i", null, "Select a process to view details")))),
-            React.createElement(Col, { sm: 4, className: "p-0", style: { height: "100%", overflow: "hidden" } }, selectedProcess ? (React.createElement("div", { className: "d-flex flex-column h-100" },
-                React.createElement("div", { ref: logsContainerRef, className: "bg-dark text-light flex-grow-1", style: {
-                        overflowY: "auto",
-                        fontFamily: 'Monaco, Menlo, "Ubuntu Mono", monospace',
-                        fontSize: "14px",
-                        lineHeight: "1.4",
-                        // padding: '1rem'
-                    }, onScroll: handleLogsScroll },
-                    processLogs.length > 0 ? (React.createElement("pre", { className: "mb-0", style: {
-                            whiteSpace: "pre-wrap",
-                            wordBreak: "break-word",
-                            backgroundColor: "transparent",
-                            border: "none",
-                            color: "inherit",
-                        } }, processLogs.join(""))) : (React.createElement("div", { className: "text-muted text-center py-4" },
-                        React.createElement("i", null, "No output yet"))),
-                    !autoScroll && (React.createElement("div", { className: "position-sticky bottom-0 d-flex justify-content-center mb-2" },
-                        React.createElement(Button, { variant: "primary", size: "sm", onClick: () => {
-                                setAutoScroll(true);
-                                if (logsContainerRef.current) {
-                                    logsContainerRef.current.scrollTop =
-                                        logsContainerRef.current.scrollHeight;
-                                }
-                            } }, "Scroll to Bottom")))),
-                selectedProcess.status === "running" && (React.createElement("div", { className: "border-top bg-white p-3", style: { flexShrink: 0 } },
-                    onKillProcess && (React.createElement("div", { className: "mb-3" },
-                        React.createElement(Button, { variant: "danger", size: "sm", onClick: () => onKillProcess(selectedProcess.processId), className: "w-100" }, "\u23F9\uFE0F Stop Process"))),
-                    React.createElement("div", { className: "input-group" },
-                        React.createElement("input", { type: "text", className: "form-control", placeholder: "Type input and press Enter...", onKeyPress: (e) => {
-                                if (e.key === "Enter") {
-                                    const target = e.target;
-                                    const inputValue = target.value;
-                                    if (inputValue.trim()) {
-                                        handleInput(inputValue + "\n");
-                                        target.value = "";
-                                    }
-                                }
-                            }, autoFocus: true }),
-                        React.createElement("button", { className: "btn btn-primary", type: "button", onClick: () => {
-                                const input = document.querySelector("input");
-                                const inputValue = input.value;
-                                if (inputValue.trim()) {
-                                    handleInput(inputValue + "\n");
-                                    input.value = "";
-                                }
-                            } }, "Send")),
-                    React.createElement("small", { className: "text-muted" }, "\uD83D\uDCA1 Press Enter to send input to the process"))))) : (React.createElement("div", { className: "p-3 text-center text-muted mt-5" },
-                React.createElement("i", null, "Live logs will appear here when a process is selected")))))));
-};