pomitu 1.4.0 → 1.6.0

package/README.md

@@ -98,7 +98,7 @@ If you want to contribute to Pomitu or run it in development mode:
 Dev installation test:
 
 ```sh
-npm run build && npm pack && npm install -g pomitu-1.4.0.tgz && rm pomitu-1.4.0.tgz
+npm run build && npm pack && npm install -g pomitu-1.6.0.tgz && rm pomitu-1.6.0.tgz
 ```
 
 ### Linting

package/dist/commands/start.js

@@ -47,6 +47,9 @@ export const start = new Command('start')
                 });
             }
         }
+        if (runInteractive && anyTuiActive) {
+            console.log('A TUI session is already running in another terminal — not opening a new one');
+        }
         if (runInteractive && !anyTuiActive) {
             render(React.createElement(ProcessTUI, {
                 configPath: name,

package/dist/components/PersistentSelectInput.js

@@ -0,0 +1,225 @@
+/**
+ * Drop-in replacement for ink-select-input's SelectInput that preserves scroll
+ * position when items change, instead of resetting to the top.
+ */
+import { isDeepStrictEqual } from 'node:util';
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { Box, useInput, useStdin } from 'ink';
+import { Indicator, Item as ItemComponent } from 'ink-select-input';
+function rotateArray(arr, k) {
+    if (arr.length === 0)
+        return arr;
+    const n = arr.length;
+    const steps = ((k % n) + n) % n;
+    if (steps === 0)
+        return [...arr];
+    return [...arr.slice(-steps), ...arr.slice(0, -steps)];
+}
+export function PersistentSelectInput({ items = [], isFocused = true, initialIndex = 0, indicatorComponent: IndicatorComp = Indicator, itemComponent: ItemComp = ItemComponent, limit: customLimit, onSelect, onHighlight, headingPredicate, }) {
+    const hasLimit = typeof customLimit === 'number' && items.length > customLimit;
+    const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
+    const lastIndex = limit - 1;
+    const [rotateIndex, setRotateIndex] = useState(initialIndex > lastIndex ? lastIndex - initialIndex : 0);
+    const [selectedIndex, setSelectedIndex] = useState(initialIndex ? (initialIndex > lastIndex ? lastIndex : initialIndex) : 0);
+    const previousItems = useRef(items);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { internal_eventEmitter } = useStdin();
+    useEffect(() => {
+        if (!isFocused || items.length === 0)
+            return;
+        const handleHomeEnd = (data) => {
+            const str = data.toString();
+            const isHome = str === '\x1b[H' || str === '\x1bOH' || str === '\x1b[1~' || str === '\x1b[7~';
+            const isEnd = str === '\x1b[F' || str === '\x1bOF' || str === '\x1b[4~' || str === '\x1b[8~';
+            if (isHome) {
+                setSelectedIndex(0);
+                setRotateIndex(0);
+                if (typeof onHighlight === 'function' && items[0])
+                    onHighlight(items[0]);
+            }
+            if (isEnd) {
+                if (hasLimit) {
+                    const newRotateIndex = -(items.length - limit);
+                    setRotateIndex(newRotateIndex);
+                    setSelectedIndex(limit - 1);
+                    const sliced = rotateArray(items, newRotateIndex).slice(0, limit);
+                    if (typeof onHighlight === 'function' && sliced[limit - 1])
+                        onHighlight(sliced[limit - 1]);
+                }
+                else {
+                    const lastIdx = items.length - 1;
+                    setSelectedIndex(lastIdx);
+                    if (typeof onHighlight === 'function' && items[lastIdx])
+                        onHighlight(items[lastIdx]);
+                }
+            }
+        };
+        internal_eventEmitter?.on('input', handleHomeEnd);
+        return () => {
+            internal_eventEmitter?.removeListener('input', handleHomeEnd);
+        };
+    }, [isFocused, items, hasLimit, limit, onHighlight, internal_eventEmitter]);
+    useEffect(() => {
+        if (!isDeepStrictEqual(previousItems.current.map(item => item.value), items.map(item => item.value))) {
+            const newHasLimit = typeof customLimit === 'number' && items.length > customLimit;
+            if (newHasLimit) {
+                // Clamp scroll and cursor to new valid bounds
+                const maxScroll = items.length - customLimit;
+                setRotateIndex(prev => Math.max(-maxScroll, Math.min(0, prev)));
+                setSelectedIndex(prev => Math.min(prev, customLimit - 1));
+            }
+            else {
+                // No scrolling needed anymore
+                setRotateIndex(0);
+                setSelectedIndex(prev => Math.min(prev, Math.max(0, items.length - 1)));
+            }
+        }
+        previousItems.current = items;
+    }, [items, customLimit]);
+    useInput(useCallback((input, key) => {
+        if (input === 'k' || key.upArrow) {
+            const atVisualTop = selectedIndex === 0;
+            if (hasLimit) {
+                if (atVisualTop) {
+                    if (rotateIndex < 0) {
+                        // Scroll window up
+                        const nextRotateIndex = rotateIndex + 1;
+                        setRotateIndex(nextRotateIndex);
+                        const sliced = rotateArray(items, nextRotateIndex).slice(0, limit);
+                        if (typeof onHighlight === 'function' && sliced[0])
+                            onHighlight(sliced[0]);
+                    }
+                    // else: already at absolute top, do nothing
+                }
+                else {
+                    const nextSelectedIndex = selectedIndex - 1;
+                    setSelectedIndex(nextSelectedIndex);
+                    const sliced = rotateArray(items, rotateIndex).slice(0, limit);
+                    if (typeof onHighlight === 'function' && sliced[nextSelectedIndex])
+                        onHighlight(sliced[nextSelectedIndex]);
+                }
+            }
+            else {
+                // No limit: wrap around
+                const nextSelectedIndex = atVisualTop ? items.length - 1 : selectedIndex - 1;
+                setSelectedIndex(nextSelectedIndex);
+                if (typeof onHighlight === 'function' && items[nextSelectedIndex])
+                    onHighlight(items[nextSelectedIndex]);
+            }
+        }
+        if (input === 'j' || key.downArrow) {
+            const atVisualBottom = selectedIndex === (hasLimit ? limit : items.length) - 1;
+            if (hasLimit) {
+                const atAbsBottom = rotateIndex <= -(items.length - limit);
+                if (atVisualBottom) {
+                    if (!atAbsBottom) {
+                        // Scroll window down
+                        const nextRotateIndex = rotateIndex - 1;
+                        setRotateIndex(nextRotateIndex);
+                        const sliced = rotateArray(items, nextRotateIndex).slice(0, limit);
+                        if (typeof onHighlight === 'function' && sliced[limit - 1])
+                            onHighlight(sliced[limit - 1]);
+                    }
+                    // else: already at absolute bottom, do nothing
+                }
+                else {
+                    const nextSelectedIndex = selectedIndex + 1;
+                    setSelectedIndex(nextSelectedIndex);
+                    const sliced = rotateArray(items, rotateIndex).slice(0, limit);
+                    if (typeof onHighlight === 'function' && sliced[nextSelectedIndex])
+                        onHighlight(sliced[nextSelectedIndex]);
+                }
+            }
+            else {
+                // No limit: wrap around
+                const nextSelectedIndex = atVisualBottom ? 0 : selectedIndex + 1;
+                setSelectedIndex(nextSelectedIndex);
+                if (typeof onHighlight === 'function' && items[nextSelectedIndex])
+                    onHighlight(items[nextSelectedIndex]);
+            }
+        }
+        if (key.pageUp || key.pageDown) {
+            const absIndex = hasLimit ? -rotateIndex + selectedIndex : selectedIndex;
+            let targetAbs = -1;
+            if (headingPredicate) {
+                if (key.pageUp) {
+                    for (let i = absIndex - 1; i >= 0; i--) {
+                        if (items[i] && headingPredicate(items[i])) {
+                            targetAbs = i;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    for (let i = absIndex + 1; i < items.length; i++) {
+                        if (items[i] && headingPredicate(items[i])) {
+                            targetAbs = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                targetAbs = key.pageUp
+                    ? Math.max(absIndex - limit, 0)
+                    : Math.min(absIndex + limit, items.length - 1);
+            }
+            if (targetAbs < 0)
+                return;
+            if (hasLimit) {
+                const windowStart = -rotateIndex;
+                let newWindowStart;
+                if (targetAbs < windowStart) {
+                    newWindowStart = targetAbs;
+                }
+                else if (targetAbs >= windowStart + limit) {
+                    newWindowStart = Math.min(targetAbs, items.length - limit);
+                }
+                else {
+                    newWindowStart = windowStart;
+                }
+                const newRotateIndex = -newWindowStart;
+                const newSelectedIndex = targetAbs - newWindowStart;
+                setRotateIndex(newRotateIndex);
+                setSelectedIndex(newSelectedIndex);
+                const sliced = rotateArray(items, newRotateIndex).slice(0, limit);
+                if (typeof onHighlight === 'function' && sliced[newSelectedIndex])
+                    onHighlight(sliced[newSelectedIndex]);
+            }
+            else {
+                setSelectedIndex(targetAbs);
+                if (typeof onHighlight === 'function' && items[targetAbs])
+                    onHighlight(items[targetAbs]);
+            }
+        }
+        if (/^[1-9]$/.test(input)) {
+            const targetIndex = Number.parseInt(input, 10) - 1;
+            const visibleItems = hasLimit
+                ? rotateArray(items, rotateIndex).slice(0, limit)
+                : items;
+            if (targetIndex >= 0 && targetIndex < visibleItems.length) {
+                const selectedItem = visibleItems[targetIndex];
+                if (selectedItem) {
+                    onSelect?.(selectedItem);
+                }
+            }
+        }
+        if (key.return) {
+            const slicedItems = hasLimit
+                ? rotateArray(items, rotateIndex).slice(0, limit)
+                : items;
+            if (typeof onSelect === 'function') {
+                onSelect(slicedItems[selectedIndex]);
+            }
+        }
+    }, [hasLimit, limit, rotateIndex, selectedIndex, items, onSelect, onHighlight, headingPredicate]), { isActive: isFocused });
+    const slicedItems = hasLimit
+        ? rotateArray(items, rotateIndex).slice(0, limit)
+        : items;
+    return (React.createElement(Box, { flexDirection: "column" }, slicedItems.map((item, index) => {
+        const isSelected = index === selectedIndex;
+        return (React.createElement(Box, { key: item.key ?? String(item.value) },
+            React.createElement(IndicatorComp, { isSelected: isSelected }),
+            React.createElement(ItemComp, { isSelected: isSelected, label: item.label })));
+    })));
+}

package/dist/components/ProcessTUI.js

@@ -2,8 +2,8 @@ import React, { useState, useEffect, useMemo, useCallback, useRef } from 'react'
 import readline from 'node:readline';
 import { existsSync } from 'node:fs';
 import open from 'open';
-import { Box, Text, useApp, useStdin } from 'ink';
-import SelectInput from 'ink-select-input';
+import { Box, Text, useApp, useStdin, useInput } from 'ink';
+import { PersistentSelectInput } from './PersistentSelectInput.js';
 import { ProcessManager, ConfigManager } from '../services/index.js';
 import { getFileNameFriendlyName, getProcessLogOutFilePath, getProcessLogErrorFilePath, getPomituSignalsDirectory } from '../helpers.js';
 import chokidar from 'chokidar';
@@ -18,8 +18,15 @@ export function ProcessTUI({ configPath, clearLogs }) {
     const [messageColor, setMessageColor] = useState('green');
     const [isProcessing, setIsProcessing] = useState(false);
     const [isReloading, setIsReloading] = useState(false);
-    const [searchMode, setSearchMode] = useState(false);
+    const [searchActive, setSearchActive] = useState(false);
     const [searchQuery, setSearchQuery] = useState('');
+    // ESC via Ink's own pipeline — no readline disambiguation delay
+    useInput(useCallback((_input, key) => {
+        if (key.escape) {
+            setSearchActive(false);
+            setSearchQuery('');
+        }
+    }, []), { isActive: searchActive });
     const previousRawModeRef = useRef(false);
     const rawModeCapturedRef = useRef(false);
     const appsRef = useRef([]);
@@ -148,6 +155,13 @@ export function ProcessTUI({ configPath, clearLogs }) {
         appsRef.current = apps;
         apps.forEach(app => writeTuiPresence(app.name));
     }, [apps]);
+    // Heartbeat: refresh TUI presence file mtimes so isTuiActive can detect stale files
+    useEffect(() => {
+        const interval = setInterval(() => {
+            appsRef.current.forEach(app => writeTuiPresence(app.name));
+        }, 10000);
+        return () => clearInterval(interval);
+    }, []);
     // Set up chokidar watcher for IPC signals (mounted once; uses refs for latest state)
     useEffect(() => {
         const signalsDir = getPomituSignalsDirectory();
@@ -186,44 +200,39 @@ export function ProcessTUI({ configPath, clearLogs }) {
             setRawMode(true);
         }
         const handleKeypress = (str, key) => {
-            // Handle search mode
-            if (searchMode) {
-                if (key?.name === 'escape') {
-                    setSearchMode(false);
-                    setSearchQuery('');
-                    return;
-                }
+            if (key?.ctrl && key.name === 'c') {
+                cleanExit();
+                return;
+            }
+            if (searchActive) {
                 if (key?.name === 'backspace') {
                     setSearchQuery(prev => prev.slice(0, -1));
                     return;
                 }
-                if (key?.name === 'return') {
-                    setSearchMode(false);
-                    return;
-                }
-                if (str && str.length === 1 && !key?.ctrl && !key?.meta) {
+                if (key?.name !== 'return' && str && str.length === 1 && !key?.ctrl && !key?.meta) {
                     setSearchQuery(prev => prev + str);
-                    return;
                 }
+                // ESC is handled by useInput (Ink pipeline); arrow keys, Enter, and other
+                // navigation are handled by PersistentSelectInput via Ink's input pipeline
                 return;
             }
-            // Normal mode
             if (str === 'q') {
                 cleanExit();
             }
             if (str === 'r') {
                 reloadConfig();
             }
-            if (str === '/') {
-                setSearchMode(true);
-                setSearchQuery('');
+            if (str === 'e') {
+                open(configPath).catch(error => {
+                    setMessage(`Failed to open config: ${error instanceof Error ? error.message : String(error)}`);
+                    setMessageColor('red');
+                    setTimeout(() => setMessage(''), 3000);
+                });
             }
-            if (key?.name === 'escape' && searchQuery) {
+            if (str === '/') {
+                setSearchActive(true);
                 setSearchQuery('');
             }
-            if (key?.ctrl && key.name === 'c') {
-                cleanExit();
-            }
         };
         // Use prependListener to capture keys before other handlers
         stdin.prependListener('keypress', handleKeypress);
@@ -233,7 +242,7 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 setRawMode(previousRawModeRef.current);
             }
         };
-    }, [stdin, setRawMode, cleanExit, reloadConfig, searchMode, searchQuery]);
+    }, [stdin, setRawMode, cleanExit, reloadConfig, searchActive]);
     // Handle Ctrl+C signal directly - use prependListener to be first
     useEffect(() => {
         const handleSigInt = () => {
@@ -305,6 +314,20 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 setIsProcessing(false);
                 return;
             }
+            else if (action === 'opencwd') {
+                try {
+                    await open(app.cwd);
+                    setMessage('Opening working directory...');
+                    setMessageColor('green');
+                }
+                catch (error) {
+                    setMessage(`Failed to open directory: ${error instanceof Error ? error.message : String(error)}`);
+                    setMessageColor('red');
+                }
+                setTimeout(() => setMessage(''), 3000);
+                setIsProcessing(false);
+                return;
+            }
             setProcesses(computeStatuses());
         }
         catch (error) {
@@ -318,9 +341,9 @@ export function ProcessTUI({ configPath, clearLogs }) {
         // Clear message after 3 seconds
         setTimeout(() => setMessage(''), 3000);
     }, [apps, clearLogs, computeStatuses, processManager, isProcessing, isReloading]);
-    const getMenuItems = useCallback(() => {
+    const buildMenuItems = useCallback((statuses) => {
         const items = [];
-        processes.forEach(proc => {
+        statuses.forEach(proc => {
             const statusLabel = proc.isRunning
                 ? `🟢 Running (PID: ${proc.pid})`
                 : '🔴 Stopped';
@@ -342,9 +365,13 @@ export function ProcessTUI({ configPath, clearLogs }) {
                     value: `viewout:${proc.name}`
                 });
                 items.push({
-                    label: '  └─ View Error Log',
+                    label: '  ├─ View Error Log',
                     value: `viewerr:${proc.name}`
                 });
+                items.push({
+                    label: '  └─ Open Working Directory',
+                    value: `opencwd:${proc.name}`
+                });
             }
             else {
                 items.push({
@@ -356,21 +383,25 @@ export function ProcessTUI({ configPath, clearLogs }) {
                     value: `viewout:${proc.name}`
                 });
                 items.push({
-                    label: '  └─ View Error Log',
+                    label: '  ├─ View Error Log',
                     value: `viewerr:${proc.name}`
                 });
+                items.push({
+                    label: '  └─ Open Working Directory',
+                    value: `opencwd:${proc.name}`
+                });
             }
         });
         return items;
-    }, [processes]);
+    }, []);
+    const allItems = useMemo(() => buildMenuItems(processes), [buildMenuItems, processes]);
     const items = useMemo(() => {
-        const allItems = getMenuItems();
         if (!searchQuery)
             return allItems;
         const query = searchQuery.toLowerCase();
         return allItems.filter(item => item.label.toLowerCase().includes(query) ||
             item.value.toLowerCase().includes(query));
-    }, [getMenuItems, searchQuery]);
+    }, [allItems, searchQuery]);
     const handleMenuSelect = useCallback((item) => {
         if (item.value === 'separator' || item.value.startsWith('info:')) {
             // Informational rows are read-only
@@ -392,23 +423,25 @@ export function ProcessTUI({ configPath, clearLogs }) {
             React.createElement(Text, { bold: true, color: "cyan" }, "Pomitu Process Manager - Interactive Mode")),
         processes.length > 0 ? (React.createElement(React.Fragment, null,
             React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { dimColor: true }, "Use arrow keys to navigate, Enter to select, '/' to search, 'r' to reload, 'q' or Ctrl+C to quit")),
-            searchMode && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Use arrow keys to navigate, Enter to select, '/' to search, 'r' to reload, 'e' to edit config, 'q' or Ctrl+C to quit")),
+            searchActive && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { color: "yellow" },
                     "Search: ",
                     searchQuery),
-                React.createElement(Text, { dimColor: true }, " (ESC to cancel, Enter to apply)"))),
-            searchQuery && !searchMode && (React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: "green" },
-                    "Filtering: ",
-                    searchQuery),
-                React.createElement(Text, { dimColor: true }, " (/ to edit, ESC to clear)"))),
-            items.length > 15 && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, " (ESC to clear)"))),
+            searchActive && searchQuery && items.length < allItems.length && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Showing ",
+                    items.length,
+                    " of ",
+                    allItems.length,
+                    " items"))),
+            !searchActive && items.length > 15 && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { dimColor: true },
                     "Showing 15 of ",
                     items.length,
                     " items - scroll with \u2191\u2193 arrows"))),
-            React.createElement(SelectInput, { items: items, onSelect: handleMenuSelect, isFocused: !isProcessing && !isReloading && !searchMode, limit: 15 }))) : (React.createElement(Text, null, "Loading processes...")),
+            React.createElement(PersistentSelectInput, { items: items, onSelect: handleMenuSelect, isFocused: !isProcessing && !isReloading, limit: 15, headingPredicate: item => item.value.startsWith('info:') }))) : (React.createElement(Text, null, "Loading processes...")),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { color: notificationColor ?? 'gray' }, notificationText ?? ' '))));
 }

package/dist/services/IpcSignal.js

@@ -13,14 +13,19 @@ export function clearTuiPresence(appName) {
         fs.unlinkSync(tuiPidPath);
     }
 }
+const TUI_HEARTBEAT_MAX_AGE_MS = 30000;
 export function isTuiActive(appName) {
     const tuiPidPath = getTuiPidPath(getFileNameFriendlyName(appName));
     if (!fs.existsSync(tuiPidPath)) {
         return false;
     }
     try {
-        const pid = parseInt(fs.readFileSync(tuiPidPath, 'utf-8'));
-        return !isNaN(pid) && pidIsRunning(pid);
+        const stat = fs.statSync(tuiPidPath);
+        if (Date.now() - stat.mtimeMs > TUI_HEARTBEAT_MAX_AGE_MS) {
+            fs.unlinkSync(tuiPidPath);
+            return false;
+        }
+        return true;
     }
     catch {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pomitu",
-    "version": "1.4.0",
+    "version": "1.6.0",
     "description": "Pomitu is a process manager inspired by PM2",
     "type": "module",
     "scripts": {