@positronic/cli 0.0.50 → 0.0.52

package/dist/src/components/top-navigator.js

@@ -0,0 +1,259 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import React, { useState, useEffect, useRef } from 'react';
+import { Text, Box, useStdout, useInput, useApp } from 'ink';
+import { EventSource } from 'eventsource';
+import { getApiBaseUrl, isApiLocalDevMode } from '../commands/helpers.js';
+import { useApiDelete } from '../hooks/useApi.js';
+import { ErrorComponent } from './error.js';
+import { BrainTopTable } from './brain-top-table.js';
+import { Watch } from './watch.js';
+export var TopNavigator = function(param) {
+    var brainFilter = param.brainFilter;
+    var write = useStdout().write;
+    var exit = useApp().exit;
+    // Navigation state
+    var _useState = _sliced_to_array(useState('list'), 2), mode = _useState[0], setMode = _useState[1];
+    var _useState1 = _sliced_to_array(useState(0), 2), selectedIndex = _useState1[0], setSelectedIndex = _useState1[1];
+    var _useState2 = _sliced_to_array(useState(null), 2), selectedRunId = _useState2[0], setSelectedRunId = _useState2[1];
+    // Data state
+    var _useState3 = _sliced_to_array(useState([]), 2), runningBrains = _useState3[0], setRunningBrains = _useState3[1];
+    var _useState4 = _sliced_to_array(useState(null), 2), error = _useState4[0], setError = _useState4[1];
+    var _useState5 = _sliced_to_array(useState(false), 2), isConnected = _useState5[0], setIsConnected = _useState5[1];
+    var _useState6 = _sliced_to_array(useState(0), 2), setTick = _useState6[1];
+    // Kill state (for list mode)
+    var _useState7 = _sliced_to_array(useState(false), 2), confirmingKill = _useState7[0], setConfirmingKill = _useState7[1];
+    var _useState8 = _sliced_to_array(useState(false), 2), isKilling = _useState8[0], setIsKilling = _useState8[1];
+    var _useState9 = _sliced_to_array(useState(null), 2), killMessage = _useState9[0], setKillMessage = _useState9[1];
+    var _useApiDelete = useApiDelete('brain'), killBrain = _useApiDelete.execute, killError = _useApiDelete.error;
+    var eventSourceRef = useRef(null);
+    var hasReceivedDataRef = useRef(false);
+    // Filter brains client-side
+    var filteredBrains = brainFilter ? runningBrains.filter(function(b) {
+        return b.brainTitle.toLowerCase().includes(brainFilter.toLowerCase());
+    }) : runningBrains;
+    // Enter alternate screen buffer on mount, exit on unmount
+    // Skip in test environment to avoid interfering with test output capture
+    useEffect(function() {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        // Enter alternate screen buffer and clear
+        write('\x1B[?1049h\x1B[2J\x1B[H');
+        return function() {
+            // Exit alternate screen buffer
+            write('\x1B[?1049l');
+        };
+    }, [
+        write
+    ]);
+    // Update tick every second to refresh duration display (in list mode)
+    useEffect(function() {
+        if (mode !== 'list') return;
+        var interval = setInterval(function() {
+            setTick(function(t) {
+                return t + 1;
+            });
+        }, 1000);
+        return function() {
+            return clearInterval(interval);
+        };
+    }, [
+        mode
+    ]);
+    // Connect to EventSource for live updates (only in list mode)
+    useEffect(function() {
+        if (mode !== 'list') {
+            // Close existing connection when leaving list mode
+            if (eventSourceRef.current) {
+                eventSourceRef.current.close();
+                eventSourceRef.current = null;
+            }
+            return;
+        }
+        var baseUrl = getApiBaseUrl();
+        var url = "".concat(baseUrl, "/brains/watch");
+        var es = new EventSource(url);
+        eventSourceRef.current = es;
+        setIsConnected(false);
+        setError(null);
+        hasReceivedDataRef.current = false;
+        es.onopen = function() {
+            setIsConnected(true);
+            setError(null);
+        };
+        es.onmessage = function(event) {
+            try {
+                var data = JSON.parse(event.data);
+                setRunningBrains(data.runningBrains || []);
+                hasReceivedDataRef.current = true;
+            } catch (e) {
+                setError(new Error("Error parsing event data: ".concat(e.message)));
+            }
+        };
+        es.onerror = function() {
+            // Only show error if we haven't received any data yet
+            if (!hasReceivedDataRef.current) {
+                var errorMessage = isApiLocalDevMode() ? 'Error connecting to the local development server. Is it running? Start it with "positronic server" or "px s".' : 'Connection failed. Please check your network connection and verify the project URL is correct.';
+                setError(new Error(errorMessage));
+                setIsConnected(false);
+            }
+            es.close();
+        };
+        return function() {
+            es.close();
+        };
+    }, [
+        mode
+    ]);
+    // Keyboard handling
+    useInput(function(input, key) {
+        if (mode === 'list') {
+            // Handle kill confirmation
+            if (confirmingKill) {
+                if (input === 'y') {
+                    var brain = filteredBrains[selectedIndex];
+                    if (brain) {
+                        setConfirmingKill(false);
+                        setIsKilling(true);
+                        killBrain("/brains/runs/".concat(brain.brainRunId)).then(function() {
+                            setKillMessage("Killed: ".concat(brain.brainTitle));
+                            setTimeout(function() {
+                                return setKillMessage(null);
+                            }, 2000);
+                        }).finally(function() {
+                            setIsKilling(false);
+                        });
+                    }
+                } else if (input === 'n' || key.escape) {
+                    setConfirmingKill(false);
+                }
+                return;
+            }
+            // List mode navigation (arrows and vim j/k)
+            if ((key.upArrow || input === 'k') && filteredBrains.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev - 1 + filteredBrains.length) % filteredBrains.length;
+                });
+            } else if ((key.downArrow || input === 'j') && filteredBrains.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev + 1) % filteredBrains.length;
+                });
+            } else if (key.return && filteredBrains.length > 0) {
+                // Drill into watch view
+                var brain1 = filteredBrains[selectedIndex];
+                if (brain1) {
+                    setSelectedRunId(brain1.brainRunId);
+                    setMode('detail');
+                }
+            } else if (input === 'x' && filteredBrains.length > 0 && !isKilling) {
+                setConfirmingKill(true);
+            } else if (input === 'q' || key.escape) {
+                exit();
+            }
+        } else if (mode === 'detail') {
+            // Detail mode navigation - b or escape goes back to list
+            if (input === 'b' || key.escape) {
+                setSelectedRunId(null);
+                setMode('list');
+            }
+        }
+    });
+    // Adjust selectedIndex if brains list shrinks
+    useEffect(function() {
+        if (filteredBrains.length > 0 && selectedIndex >= filteredBrains.length) {
+            setSelectedIndex(filteredBrains.length - 1);
+        }
+    }, [
+        filteredBrains.length,
+        selectedIndex
+    ]);
+    // Error state
+    if (error) {
+        return /*#__PURE__*/ React.createElement(ErrorComponent, {
+            error: {
+                title: 'Connection Error',
+                message: error.message,
+                details: error.stack
+            }
+        });
+    }
+    // Detail mode - show Watch component
+    if (mode === 'detail' && selectedRunId) {
+        return /*#__PURE__*/ React.createElement(Watch, {
+            runId: selectedRunId,
+            manageScreenBuffer: false,
+            footer: "b back • x kill"
+        });
+    }
+    // List mode - show connecting state
+    if (!isConnected) {
+        return /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, null, "Connecting to watch service..."));
+    }
+    // Build footer based on state
+    var listFooter = 'j/k or ↑/↓ select • Enter watch • x kill • esc quit';
+    if (confirmingKill) {
+        var brain = filteredBrains[selectedIndex];
+        listFooter = 'Kill "'.concat(brain === null || brain === void 0 ? void 0 : brain.brainTitle, '"? (y/n)');
+    }
+    // List mode - show table
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ React.createElement(BrainTopTable, {
+        runningBrains: runningBrains,
+        selectedIndex: selectedIndex,
+        interactive: true,
+        brainFilter: brainFilter,
+        footer: listFooter
+    }), isKilling && /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
+        color: "yellow"
+    }, "Killing brain...")), killMessage && /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
+        color: "green"
+    }, killMessage)), killError && /*#__PURE__*/ React.createElement(ErrorComponent, {
+        error: killError
+    }));
+};