pomitu 1.2.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.2.0.tgz && rm pomitu-1.2.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/restart.js

@@ -1,60 +1,28 @@
 import { Command } from 'commander';
-import { ProcessManager, ConfigManager } from '../services/index.js';
+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 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) => {
+    .description('restart a running app (works whether managed by TUI or daemon)')
+    .argument('<name>', 'name of the app to restart')
+    .action(async (name) => {
     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;
+        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`);
             }
-            // 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 (error) {
-                // 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.`);
-            }
+            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) {

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';
@@ -15,13 +18,36 @@ export const start = new Command('start')
         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) {
-            processManager.startApp(app, {
-                daemon: options.daemon,
-                clearLogs: options.clearLogs
-            });
+            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) {
+        if (runInteractive && !anyTuiActive) {
             render(React.createElement(ProcessTUI, {
                 configPath: name,
                 clearLogs: options.clearLogs

package/dist/commands/stop.js

@@ -1,5 +1,6 @@
 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')
@@ -7,7 +8,21 @@ export const stop = new Command('stop')
     try {
         const processManager = new ProcessManager();
         if (name === 'all') {
-            const stoppedCount = await processManager.stopAllApps();
+            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 {
+                    const success = await processManager.stopApp(proc.name);
+                    if (success)
+                        stoppedCount++;
+                }
+            }
             if (stoppedCount === 0) {
                 console.warn('No running processes found');
             }
@@ -16,9 +31,21 @@ export const stop = new Command('stop')
             }
         }
         else {
-            const success = await processManager.stopApp(name);
-            if (!success) {
-                console.warn(`No running process found for ${name}`);
+            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}`);
+                }
             }
         }
     }

package/dist/components/ProcessTUI.js

@@ -1,9 +1,14 @@
 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 { ProcessManager, ConfigManager } from '../services/index.js';
-import { getFileNameFriendlyName } 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();
@@ -13,12 +18,36 @@ 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 [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(), []);
+    // Function to open file in native app
+    const openFileInNativeApp = useCallback(async (filePath) => {
+        if (!existsSync(filePath)) {
+            setMessage(`Log file not found: ${filePath}`);
+            setMessageColor('red');
+            setTimeout(() => setMessage(''), 3000);
+            return;
+        }
+        try {
+            await open(filePath);
+            setMessage('Opening log file...');
+            setMessageColor('green');
+        }
+        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);
         }
@@ -114,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)
@@ -130,12 +186,41 @@ 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?.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) {
+                    setSearchQuery(prev => prev + str);
+                    return;
+                }
+                return;
+            }
+            // Normal mode
             if (str === 'q') {
                 cleanExit();
             }
             if (str === 'r') {
                 reloadConfig();
             }
+            if (str === '/') {
+                setSearchMode(true);
+                setSearchQuery('');
+            }
+            if (key?.name === 'escape' && searchQuery) {
+                setSearchQuery('');
+            }
             if (key?.ctrl && key.name === 'c') {
                 cleanExit();
             }
@@ -148,7 +233,7 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 setRawMode(previousRawModeRef.current);
             }
         };
-    }, [stdin, setRawMode, cleanExit, reloadConfig]);
+    }, [stdin, setRawMode, cleanExit, reloadConfig, searchMode, searchQuery]);
     // Handle Ctrl+C signal directly - use prependListener to be first
     useEffect(() => {
         const handleSigInt = () => {
@@ -163,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`);
@@ -192,21 +279,31 @@ export function ProcessTUI({ configPath, clearLogs }) {
                 }
             }
             else if (action === 'restart') {
-                const success = await processManager.stopApp(appName, { quiet: true });
-                if (success) {
+                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');
                 }
+                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') {
+                const fileNameFriendly = getFileNameFriendlyName(appName);
+                const logPath = getProcessLogErrorFilePath(fileNameFriendly);
+                openFileInNativeApp(logPath);
+                setIsProcessing(false);
+                return;
             }
             setProcesses(computeStatuses());
         }
@@ -237,20 +334,43 @@ export function ProcessTUI({ configPath, clearLogs }) {
                     value: `stop:${proc.name}`
                 });
                 items.push({
-                    label: `  └─ Restart ${proc.name}`,
+                    label: `  ├─ Restart ${proc.name}`,
                     value: `restart:${proc.name}`
                 });
+                items.push({
+                    label: '  ├─ View Output Log',
+                    value: `viewout:${proc.name}`
+                });
+                items.push({
+                    label: '  └─ View Error Log',
+                    value: `viewerr:${proc.name}`
+                });
             }
             else {
                 items.push({
-                    label: `  └─ Start ${proc.name}`,
+                    label: `  ├─ Start ${proc.name}`,
                     value: `start:${proc.name}`
                 });
+                items.push({
+                    label: '  ├─ View Output Log',
+                    value: `viewout:${proc.name}`
+                });
+                items.push({
+                    label: '  └─ View Error Log',
+                    value: `viewerr:${proc.name}`
+                });
             }
         });
         return items;
     }, [processes]);
-    const items = useMemo(() => getMenuItems(), [getMenuItems]);
+    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]);
     const handleMenuSelect = useCallback((item) => {
         if (item.value === 'separator' || item.value.startsWith('info:')) {
             // Informational rows are read-only
@@ -259,6 +379,12 @@ export function ProcessTUI({ configPath, clearLogs }) {
             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" },
@@ -266,8 +392,23 @@ 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, 'r' to reload config, 'q' or Ctrl+C to quit")),
-            React.createElement(SelectInput, { items: items, onSelect: handleMenuSelect, isFocused: !isProcessing && !isReloading }))) : (React.createElement(Text, null, "Loading processes...")),
+                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: ",
+                    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 },
+                    "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(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`);
 }

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

@@ -33,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

@@ -63,17 +63,6 @@ export class ProcessManager {
             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 = [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pomitu",
-    "version": "1.2.0",
+    "version": "1.4.0",
     "description": "Pomitu is a process manager inspired by PM2",
     "type": "module",
     "scripts": {
@@ -31,9 +31,11 @@
     "author": "flawiddsouza",
     "license": "ISC",
     "dependencies": {
+        "chokidar": "^5.0.0",
         "commander": "^12.1.0",
         "ink": "^6.4.0",
         "ink-select-input": "^6.2.0",
+        "open": "^11.0.0",
         "react": "^19.2.0",
         "shell-quote": "^1.8.1",
         "yaml": "^2.5.1",