pomitu 1.3.0 → 1.4.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.3.0.tgz && rm pomitu-1.3.0.tgz
+npm run build && npm pack && npm install -g pomitu-1.4.0.tgz && rm pomitu-1.4.0.tgz
 ```
 
 ### Linting

package/dist/app.js

@@ -3,13 +3,15 @@ import { Command } from 'commander';
 import { start } from './commands/start.js';
 import { flush } from './commands/flush.js';
 import { stop } from './commands/stop.js';
+import { restart } from './commands/restart.js';
 import { mkdirSync } from 'node:fs';
 import { ls } from './commands/ls.js';
-import { getPomituDirectory, getPomituLogsDirectory, getPomituPidsDirectory } from './helpers.js';
+import { getPomituDirectory, getPomituLogsDirectory, getPomituPidsDirectory, getPomituSignalsDirectory } from './helpers.js';
 function init() {
     mkdirSync(getPomituDirectory(), { recursive: true });
     mkdirSync(getPomituLogsDirectory(), { recursive: true });
     mkdirSync(getPomituPidsDirectory(), { recursive: true });
+    mkdirSync(getPomituSignalsDirectory(), { recursive: true });
 }
 init();
 const program = new Command();
@@ -19,5 +21,6 @@ program
     .addCommand(start)
     .addCommand(flush)
     .addCommand(stop)
+    .addCommand(restart)
     .addCommand(ls)
     .parse();

package/dist/commands/flush.js

@@ -4,17 +4,19 @@ export const flush = new Command('flush')
     .description('flush logs')
     .argument('[name]', 'name of the app whose logs you want to flush')
     .action((name) => {
-        try {
-            const logManager = new LogManager();
-            const flushedFiles = logManager.flushLogs(name);
-            if (flushedFiles.length === 0) {
-                console.log('No log files found to flush');
-            } else {
-                console.log('Logs flushed');
-            }
-        } catch (error) {
-            const err = error;
-            console.error(`Error: ${err.message}`);
-            process.exit(1);
+    try {
+        const logManager = new LogManager();
+        const flushedFiles = logManager.flushLogs(name);
+        if (flushedFiles.length === 0) {
+            console.log('No log files found to flush');
         }
-    });
+        else {
+            console.log('Logs flushed');
+        }
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/ls.js

@@ -3,24 +3,26 @@ import { ProcessManager } from '../services/index.js';
 export const ls = new Command('ls')
     .description('list all running apps')
     .action(() => {
-        try {
-            const processManager = new ProcessManager();
-            const processes = processManager.listRunningProcesses();
-            if (processes.length === 0) {
-                console.log('No running processes found');
-                return;
+    try {
+        const processManager = new ProcessManager();
+        const processes = processManager.listRunningProcesses();
+        if (processes.length === 0) {
+            console.log('No running processes found');
+            return;
+        }
+        console.log('Running processes:');
+        for (const process of processes) {
+            if (process.isRunning) {
+                console.log(`- ${process.name} (pid: ${process.pid})`);
             }
-            console.log('Running processes:');
-            for (const process of processes) {
-                if (process.isRunning) {
-                    console.log(`- ${process.name} (pid: ${process.pid})`);
-                } else {
-                    console.warn(`- ${process.name} (pid: ${process.pid}) is not running`);
-                }
+            else {
+                console.warn(`- ${process.name} (pid: ${process.pid}) is not running`);
             }
-        } catch (error) {
-            const err = error;
-            console.error(`Error: ${err.message}`);
-            process.exit(1);
         }
-    });
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/restart.js

@@ -1,62 +1,33 @@
-import { Command } from 'commander';
-import { ProcessManager, ConfigManager } from '../services/index.js';
-export const restart = new Command('restart')
-    .description('restart a running app or all apps')
-    .argument('<name>', 'name of the app to restart, "all" to restart all apps, or path to config file')
-    .option('--no-daemon', 'do not daemonize the app')
-    .option('--clear-logs', 'clear log files before restarting the app')
-    .action(async (name, options) => {
-        try {
-            const processManager = new ProcessManager();
-            const configManager = new ConfigManager();
-            if (name === 'all') {
-            // Get all running processes
-                const runningProcesses = processManager.listRunningProcesses();
-                if (runningProcesses.length === 0) {
-                    console.warn('No running processes found');
-                    return;
-                }
-                // Stop all processes
-                const stoppedCount = await processManager.stopAllApps();
-                console.log(`Stopped ${stoppedCount} process(es)`);
-                // We need the config to restart, but we don't have it for individual apps
-                console.warn('Note: Cannot restart apps without config file. Use "pomitu start <config-file>" to start them again.');
-            } else {
-            // Check if it's a config file path
-                let isConfigFile = false;
-                try {
-                    const config = configManager.readConfig(name);
-                    if (config && config.apps) {
-                        isConfigFile = true;
-                        // Restart all apps from the config
-                        for (const app of config.apps) {
-                            const success = await processManager.stopApp(app.name);
-                            if (success) {
-                                console.log(`Stopped ${app.name}`);
-                            }
-                            // Start the app again
-                            await processManager.startApp(app, {
-                                daemon: options.daemon,
-                                clearLogs: options.clearLogs
-                            });
-                        }
-                    }
-                } catch {
-                // Not a config file, treat as app name
-                }
-                if (!isConfigFile) {
-                // Treat as app name - stop it
-                    const success = await processManager.stopApp(name);
-                    if (!success) {
-                        console.warn(`No running process found for ${name}`);
-                        return;
-                    }
-                    console.warn(`Stopped ${name}. To restart, you need to use "pomitu start <config-file>" as app config is not stored.`);
-                }
-            }
-        } catch (error) {
-            const err = error;
-            console.error(`Error: ${err.message}`);
-            process.exit(1);
-        }
-    });
+import { Command } from 'commander';
+import { PidManager } from '../services/PidManager.js';
+import { isTuiActive, writeSignal, waitForPidState } from '../services/IpcSignal.js';
+import { getFileNameFriendlyName } from '../helpers.js';
+export const restart = new Command('restart')
+    .description('restart a running app (works whether managed by TUI or daemon)')
+    .argument('<name>', 'name of the app to restart')
+    .action(async (name) => {
+    try {
+        if (isTuiActive(name)) {
+            writeSignal(name, 'restart');
+            await waitForPidState(name, 'absent', 3000);
+            const confirmed = await waitForPidState(name, 'present', 3000);
+            if (confirmed) {
+                const pidManager = new PidManager();
+                const pid = pidManager.getPid(getFileNameFriendlyName(name));
+                console.log(`Restarted ${name} (PID: ${pid})`);
+            }
+            else {
+                console.warn(`Restart signal sent but could not confirm ${name} restarted within timeout`);
+            }
+        }
+        else {
+            console.error(`No active TUI session found for ${name}. For daemon-mode processes, use: pomitu stop ${name} && pomitu start <config>`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/start.js

@@ -1,5 +1,8 @@
 import { Command } from 'commander';
 import { ProcessManager, ConfigManager } from '../services/index.js';
+import { isTuiActive, writeSignal, waitForPidState } from '../services/IpcSignal.js';
+import { PidManager } from '../services/PidManager.js';
+import { getFileNameFriendlyName, pidIsRunning } from '../helpers.js';
 import React from 'react';
 import { render } from 'ink';
 import { ProcessTUI } from '../components/ProcessTUI.js';
@@ -9,27 +12,51 @@ export const start = new Command('start')
     .option('--no-daemon', 'do not daemonize the app and show interactive TUI')
     .option('--clear-logs', 'clear log files before starting the app')
     .action(async (name, options) => {
-        try {
-            const configManager = new ConfigManager();
-            const processManager = new ProcessManager();
-            const config = configManager.readConfig(name);
-            configManager.validateConfig(config);
-            const runInteractive = options.daemon === false;
-            for (const app of config.apps) {
+    try {
+        const configManager = new ConfigManager();
+        const processManager = new ProcessManager();
+        const config = configManager.readConfig(name);
+        configManager.validateConfig(config);
+        const runInteractive = options.daemon === false;
+        let anyTuiActive = false;
+        const pidManager = new PidManager();
+        for (const app of config.apps) {
+            if (isTuiActive(app.name)) {
+                anyTuiActive = true;
+                const existingPid = pidManager.getPid(getFileNameFriendlyName(app.name));
+                const wasRunning = existingPid !== null && pidIsRunning(existingPid);
+                writeSignal(app.name, 'start');
+                if (!runInteractive) {
+                    if (wasRunning) {
+                        await waitForPidState(app.name, 'absent', 3000);
+                    }
+                    const confirmed = await waitForPidState(app.name, 'present', 3000);
+                    if (confirmed) {
+                        const pid = pidManager.getPid(getFileNameFriendlyName(app.name));
+                        console.log(`Started ${app.name} with pid ${pid}`);
+                    }
+                    else {
+                        console.warn(`Start signal sent but could not confirm ${app.name} started within timeout`);
+                    }
+                }
+            }
+            else {
                 processManager.startApp(app, {
                     daemon: options.daemon,
                     clearLogs: options.clearLogs
                 });
             }
-            if (runInteractive) {
-                render(React.createElement(ProcessTUI, {
-                    configPath: name,
-                    clearLogs: options.clearLogs
-                }));
-            }
-        } catch (error) {
-            const err = error;
-            console.error(`Error: ${err.message}`);
-            process.exit(1);
         }
-    });
+        if (runInteractive && !anyTuiActive) {
+            render(React.createElement(ProcessTUI, {
+                configPath: name,
+                clearLogs: options.clearLogs
+            }));
+        }
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/stop.js

@@ -1,27 +1,57 @@
 import { Command } from 'commander';
 import { ProcessManager } from '../services/index.js';
+import { isTuiActive, writeSignal, waitForPidState } from '../services/IpcSignal.js';
 export const stop = new Command('stop')
     .description('stop a running app or all apps')
     .argument('<name>', 'name of the app to stop or "all" to stop all apps')
     .action(async (name) => {
-        try {
-            const processManager = new ProcessManager();
-            if (name === 'all') {
-                const stoppedCount = await processManager.stopAllApps();
-                if (stoppedCount === 0) {
-                    console.warn('No running processes found');
-                } else {
-                    console.log(`Stopped ${stoppedCount} process(es)`);
+    try {
+        const processManager = new ProcessManager();
+        if (name === 'all') {
+            const runningProcesses = processManager.listRunningProcesses();
+            let stoppedCount = 0;
+            for (const proc of runningProcesses) {
+                if (isTuiActive(proc.name)) {
+                    writeSignal(proc.name, 'stop');
+                    const confirmed = await waitForPidState(proc.name, 'absent');
+                    if (confirmed)
+                        stoppedCount++;
                 }
-            } else {
+                else {
+                    const success = await processManager.stopApp(proc.name);
+                    if (success)
+                        stoppedCount++;
+                }
+            }
+            if (stoppedCount === 0) {
+                console.warn('No running processes found');
+            }
+            else {
+                console.log(`Stopped ${stoppedCount} process(es)`);
+            }
+        }
+        else {
+            if (isTuiActive(name)) {
+                writeSignal(name, 'stop');
+                const confirmed = await waitForPidState(name, 'absent');
+                if (confirmed) {
+                    console.log(`Stopped ${name}`);
+                }
+                else {
+                    console.warn(`Stop signal sent but could not confirm ${name} stopped within timeout`);
+                }
+            }
+            else {
                 const success = await processManager.stopApp(name);
                 if (!success) {
                     console.warn(`No running process found for ${name}`);
                 }
             }
-        } catch (error) {
-            const err = error;
-            console.error(`Error: ${err.message}`);
-            process.exit(1);
         }
-    });
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/components/ProcessTUI.js

@@ -5,7 +5,10 @@ import open from 'open';
 import { Box, Text, useApp, useStdin } from 'ink';
 import SelectInput from 'ink-select-input';
 import { ProcessManager, ConfigManager } from '../services/index.js';
-import { getFileNameFriendlyName, getProcessLogOutFilePath, getProcessLogErrorFilePath } from '../helpers.js';
+import { getFileNameFriendlyName, getProcessLogOutFilePath, getProcessLogErrorFilePath, getPomituSignalsDirectory } from '../helpers.js';
+import chokidar from 'chokidar';
+import * as path from 'node:path';
+import { writeTuiPresence, clearTuiPresence, readAndClearSignal } from '../services/IpcSignal.js';
 export function ProcessTUI({ configPath, clearLogs }) {
     const { exit } = useApp();
     const { stdin, setRawMode } = useStdin();
@@ -19,6 +22,8 @@ export function ProcessTUI({ configPath, clearLogs }) {
     const [searchQuery, setSearchQuery] = useState('');
     const previousRawModeRef = useRef(false);
     const rawModeCapturedRef = useRef(false);
+    const appsRef = useRef([]);
+    const ipcHandlerRef = useRef(null);
     // Create managers only once
     const processManager = useMemo(() => new ProcessManager(), []);
     const configManager = useMemo(() => new ConfigManager(), []);
@@ -34,13 +39,15 @@ export function ProcessTUI({ configPath, clearLogs }) {
             await open(filePath);
             setMessage('Opening log file...');
             setMessageColor('green');
-        } catch (error) {
+        }
+        catch (error) {
             setMessage(`Failed to open log: ${error instanceof Error ? error.message : String(error)}`);
             setMessageColor('red');
         }
         setTimeout(() => setMessage(''), 3000);
     }, []);
     const cleanExit = useCallback(() => {
+        appsRef.current.forEach(app => clearTuiPresence(app.name));
         if (setRawMode) {
             setRawMode(previousRawModeRef.current);
         }
@@ -88,7 +95,8 @@ export function ProcessTUI({ configPath, clearLogs }) {
                             if (success) {
                                 stoppedApps.push(proc.name);
                             }
-                        } catch (error) {
+                        }
+                        catch (error) {
                             // Continue even if stop fails
                             console.error(`Failed to stop ${proc.name}:`, error);
                         }
@@ -98,17 +106,21 @@ export function ProcessTUI({ configPath, clearLogs }) {
             setApps(config.apps);
             if (stoppedApps.length > 0) {
                 setMessage(`Configuration reloaded. Stopped ${stoppedApps.length} running app(s): ${stoppedApps.join(', ')}`);
-            } else if (removedApps.length > 0) {
+            }
+            else if (removedApps.length > 0) {
                 setMessage(`Configuration reloaded. ${removedApps.length} app(s) removed (none were running)`);
-            } else {
+            }
+            else {
                 setMessage('Configuration reloaded successfully');
             }
             setMessageColor('green');
-        } catch (error) {
+        }
+        catch (error) {
             const err = error;
             setMessage(`Error reloading config: ${err.message}`);
             setMessageColor('red');
-        } finally {
+        }
+        finally {
             setIsReloading(false);
             // Clear message after 3 seconds
             setTimeout(() => setMessage(''), 3000);
@@ -120,7 +132,8 @@ export function ProcessTUI({ configPath, clearLogs }) {
             const config = configManager.readConfig(configPath);
             configManager.validateConfig(config);
             setApps(config.apps);
-        } catch (error) {
+        }
+        catch (error) {
             const err = error;
             setMessage(`Error loading config: ${err.message}`);
             setMessageColor('red');
@@ -130,6 +143,33 @@ export function ProcessTUI({ configPath, clearLogs }) {
     useEffect(() => {
         setProcesses(computeStatuses());
     }, [computeStatuses]);
+    // Sync appsRef and write TUI presence files whenever apps change
+    useEffect(() => {
+        appsRef.current = apps;
+        apps.forEach(app => writeTuiPresence(app.name));
+    }, [apps]);
+    // Set up chokidar watcher for IPC signals (mounted once; uses refs for latest state)
+    useEffect(() => {
+        const signalsDir = getPomituSignalsDirectory();
+        const watcher = chokidar.watch(signalsDir, { ignoreInitial: true });
+        const handleSignalFile = (filePath) => {
+            const fileBaseName = path.basename(filePath, '.json');
+            const matchedApp = appsRef.current.find(a => getFileNameFriendlyName(a.name) === fileBaseName);
+            if (!matchedApp)
+                return;
+            const action = readAndClearSignal(matchedApp.name);
+            if (!action)
+                return;
+            if (ipcHandlerRef.current) {
+                ipcHandlerRef.current(matchedApp.name, action);
+            }
+        };
+        watcher.on('add', handleSignalFile);
+        watcher.on('change', handleSignalFile);
+        return () => {
+            watcher.close();
+        };
+    }, []);
     // Handle keyboard input - use keypress events to intercept BEFORE SelectInput
     useEffect(() => {
         if (!stdin)
@@ -208,7 +248,9 @@ export function ProcessTUI({ configPath, clearLogs }) {
     const handleSelect = useCallback(async (item) => {
         if (isProcessing || isReloading)
             return; // Prevent multiple simultaneous operations
-        const [action, appName] = item.value.split(':');
+        const colonIndex = item.value.indexOf(':');
+        const action = item.value.slice(0, colonIndex);
+        const appName = item.value.slice(colonIndex + 1);
         const app = apps.find(a => a.name === appName);
         if (!app) {
             setMessage(`App ${appName} not found`);
@@ -224,37 +266,39 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 });
                 setMessage(`Started ${appName}`);
                 setMessageColor('green');
-            } else if (action === 'stop') {
+            }
+            else if (action === 'stop') {
                 const success = await processManager.stopApp(appName, { quiet: true });
                 if (success) {
                     setMessage(`Stopped ${appName}`);
                     setMessageColor('green');
-                } else {
+                }
+                else {
                     setMessage(`Failed to stop ${appName}`);
                     setMessageColor('red');
                 }
-            } else if (action === 'restart') {
-                const success = await processManager.stopApp(appName, { quiet: true });
-                if (success) {
+            }
+            else if (action === 'restart') {
+                const wasRunning = await processManager.stopApp(appName, { quiet: true });
+                if (wasRunning) {
                     // Wait a bit before restarting
                     await new Promise(resolve => setTimeout(resolve, 500));
-                    await processManager.startApp(app, {
-                        daemon: false,
-                        clearLogs: clearLogs ?? false
-                    });
-                    setMessage(`Restarted ${appName}`);
-                    setMessageColor('green');
-                } else {
-                    setMessage(`Failed to stop ${appName} for restart`);
-                    setMessageColor('red');
                 }
-            } else if (action === 'viewout') {
+                await processManager.startApp(app, {
+                    daemon: false,
+                    clearLogs: clearLogs ?? false
+                });
+                setMessage(`Restarted ${appName}`);
+                setMessageColor('green');
+            }
+            else if (action === 'viewout') {
                 const fileNameFriendly = getFileNameFriendlyName(appName);
                 const logPath = getProcessLogOutFilePath(fileNameFriendly);
                 openFileInNativeApp(logPath);
                 setIsProcessing(false);
                 return;
-            } else if (action === 'viewerr') {
+            }
+            else if (action === 'viewerr') {
                 const fileNameFriendly = getFileNameFriendlyName(appName);
                 const logPath = getProcessLogErrorFilePath(fileNameFriendly);
                 openFileInNativeApp(logPath);
@@ -262,11 +306,13 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 return;
             }
             setProcesses(computeStatuses());
-        } catch (error) {
+        }
+        catch (error) {
             const err = error;
             setMessage(`Error: ${err.message}`);
             setMessageColor('red');
-        } finally {
+        }
+        finally {
             setIsProcessing(false);
         }
         // Clear message after 3 seconds
@@ -299,7 +345,8 @@ export function ProcessTUI({ configPath, clearLogs }) {
                     label: '  └─ View Error Log',
                     value: `viewerr:${proc.name}`
                 });
-            } else {
+            }
+            else {
                 items.push({
                     label: `  ├─ Start ${proc.name}`,
                     value: `start:${proc.name}`
@@ -327,34 +374,41 @@ export function ProcessTUI({ configPath, clearLogs }) {
     const handleMenuSelect = useCallback((item) => {
         if (item.value === 'separator' || item.value.startsWith('info:')) {
             // Informational rows are read-only
-        } else {
+        }
+        else {
             handleSelect(item);
         }
     }, [handleSelect]);
+    // Keep IPC signal handler up to date with current handleSelect
+    useEffect(() => {
+        ipcHandlerRef.current = (appName, action) => {
+            handleSelect({ label: '', value: `${action}:${appName}` });
+        };
+    }, [handleSelect]);
     const notificationText = isProcessing ? 'Processing...' : (isReloading ? 'Reloading...' : message);
     const notificationColor = (isProcessing || isReloading) ? 'yellow' : message ? messageColor : undefined;
-    return (React.createElement(Box, { flexDirection: 'column' },
-        React.createElement(Box, { borderStyle: 'round', borderColor: 'cyan', padding: 1, marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: 'cyan' }, 'Pomitu Process Manager - Interactive Mode')),
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { borderStyle: "round", borderColor: "cyan", padding: 1, marginBottom: 1 },
+            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')),
+                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, { color: 'yellow' },
-                    'Search: ',
+                React.createElement(Text, { color: "yellow" },
+                    "Search: ",
                     searchQuery),
-                React.createElement(Text, { dimColor: true }, ' (ESC to cancel, Enter to apply)'))),
+                React.createElement(Text, { dimColor: true }, " (ESC to cancel, Enter to apply)"))),
             searchQuery && !searchMode && (React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: 'green' },
-                    'Filtering: ',
+                React.createElement(Text, { color: "green" },
+                    "Filtering: ",
                     searchQuery),
-                React.createElement(Text, { dimColor: true }, ' (/ to edit, ESC to clear)'))),
+                React.createElement(Text, { dimColor: true }, " (/ to edit, ESC to clear)"))),
             items.length > 15 && (React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { dimColor: true },
-                    'Showing 15 of ',
+                    "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...')),
+                    " 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(Box, { marginTop: 1 },
             React.createElement(Text, { color: notificationColor ?? 'gray' }, notificationText ?? ' '))));
 }

package/dist/helpers.js

@@ -13,6 +13,15 @@ export function getPomituPidsDirectory() {
 export function getFileNameFriendlyName(name) {
     return name.replaceAll(' ', '-').toLowerCase();
 }
+export function getPomituSignalsDirectory() {
+    return path.join(getPomituDirectory(), 'signals');
+}
+export function getProcessSignalPath(name) {
+    return path.join(getPomituSignalsDirectory(), `${name}.json`);
+}
+export function getTuiPidPath(name) {
+    return path.join(getPomituPidsDirectory(), `${name}-tui.pid`);
+}
 export function getProcessLogOutFilePath(name) {
     return path.join(getPomituLogsDirectory(), `${name}-out.log`);
 }
@@ -24,7 +33,8 @@ export function pidIsRunning(pid) {
     try {
         process.kill(pid, 0);
         return true;
-    } catch {
+    }
+    catch {
         return false;
     }
 }

package/dist/services/ConfigManager.js

@@ -14,7 +14,8 @@ export class ConfigManager {
                 throw new Error(`Invalid config file: ${error.message}`);
             }
             return config;
-        } catch (error) {
+        }
+        catch (error) {
             const err = error;
             throw new Error(`Error reading config file: ${err.message}`);
         }

package/dist/services/IpcSignal.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import { getProcessSignalPath, getTuiPidPath, getFileNameFriendlyName, pidIsRunning } from '../helpers.js';
+import { PidManager } from './PidManager.js';
+const SIGNAL_MAX_AGE_MS = 5000;
+const WAIT_POLL_INTERVAL_MS = 100;
+export function writeTuiPresence(appName) {
+    const tuiPidPath = getTuiPidPath(getFileNameFriendlyName(appName));
+    fs.writeFileSync(tuiPidPath, process.pid.toString());
+}
+export function clearTuiPresence(appName) {
+    const tuiPidPath = getTuiPidPath(getFileNameFriendlyName(appName));
+    if (fs.existsSync(tuiPidPath)) {
+        fs.unlinkSync(tuiPidPath);
+    }
+}
+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);
+    }
+    catch {
+        return false;
+    }
+}
+export function writeSignal(appName, action) {
+    const signalPath = getProcessSignalPath(getFileNameFriendlyName(appName));
+    const payload = { action, timestamp: Date.now() };
+    fs.writeFileSync(signalPath, JSON.stringify(payload));
+}
+export function readAndClearSignal(appName) {
+    const signalPath = getProcessSignalPath(getFileNameFriendlyName(appName));
+    if (!fs.existsSync(signalPath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(signalPath, 'utf-8');
+        fs.unlinkSync(signalPath);
+        const payload = JSON.parse(raw);
+        if (Date.now() - payload.timestamp > SIGNAL_MAX_AGE_MS) {
+            return null;
+        }
+        return payload.action;
+    }
+    catch {
+        return null;
+    }
+}
+export async function waitForPidState(appName, state, timeoutMs = 3000) {
+    const pidManager = new PidManager();
+    const fileNameFriendlyName = getFileNameFriendlyName(appName);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const pid = pidManager.getPid(fileNameFriendlyName);
+        const isRunning = pid !== null && pidIsRunning(pid);
+        if (state === 'present' && isRunning)
+            return true;
+        if (state === 'absent' && !isRunning)
+            return true;
+        await new Promise(resolve => setTimeout(resolve, WAIT_POLL_INTERVAL_MS));
+    }
+    return false;
+}

package/dist/services/PidManager.js

@@ -18,7 +18,8 @@ export class PidManager {
         try {
             const pidContent = fs.readFileSync(pidFilePath, 'utf-8');
             return parseInt(pidContent);
-        } catch {
+        }
+        catch {
             return null;
         }
     }
@@ -32,7 +33,7 @@ export class PidManager {
         if (!fs.existsSync(this.pidsDirectory)) {
             return [];
         }
-        return fs.readdirSync(this.pidsDirectory).filter(file => file.endsWith('.pid'));
+        return fs.readdirSync(this.pidsDirectory).filter(file => file.endsWith('.pid') && !file.endsWith('-tui.pid'));
     }
     getPidFilePath(appName) {
         return path.join(this.pidsDirectory, `${appName}.pid`);

package/dist/services/ProcessManager.js

@@ -56,23 +56,13 @@ export class ProcessManager {
                 console.log(`${name} with pid ${pid} stopped`);
             }
             return true;
-        } catch (error) {
+        }
+        catch (error) {
             const err = error;
             console.error(`Error stopping ${name} with pid ${pid}: ${err.message}`);
             return false;
         }
     }
-    async stopAllApps(options = {}) {
-        const runningProcesses = this.listRunningProcesses();
-        let stoppedCount = 0;
-        for (const processInfo of runningProcesses) {
-            const success = await this.stopApp(processInfo.name, options);
-            if (success) {
-                stoppedCount++;
-            }
-        }
-        return stoppedCount;
-    }
     listRunningProcesses() {
         const pidFiles = this.pidManager.getAllPidFiles();
         const processes = [];
@@ -97,7 +87,8 @@ export class ProcessManager {
             console.log(`Stopping ${appName} at pid ${existingPid}`);
             try {
                 process.kill(existingPid);
-            } catch (error) {
+            }
+            catch (error) {
                 const err = error;
                 console.error(`Error stopping ${appName}: ${err.message}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pomitu",
-    "version": "1.3.0",
+    "version": "1.4.0",
     "description": "Pomitu is a process manager inspired by PM2",
     "type": "module",
     "scripts": {
@@ -31,6 +31,7 @@
     "author": "flawiddsouza",
     "license": "ISC",
     "dependencies": {
+        "chokidar": "^5.0.0",
         "commander": "^12.1.0",
         "ink": "^6.4.0",
         "ink-select-input": "^6.2.0",