pomitu 1.0.0 → 1.1.1

package/README.md

@@ -22,6 +22,25 @@ pomitu start <config-file>
 
 This command starts and daemonizes an app based on the configuration file provided.
 
+#### Interactive Mode (TUI)
+
+```sh
+pomitu start <config-file> --no-daemon
+```
+
+Run in interactive mode with a Terminal User Interface (TUI) that allows you to:
+- View the status of all processes in real-time
+- Start, stop, and restart individual apps
+- Navigate with arrow keys
+- Press `q` to quit
+
+The interactive mode is perfect for development when you want to manage multiple processes and see their status at a glance.
+
+#### Options
+
+- `--no-daemon` - Run in interactive TUI mode instead of daemonizing
+- `--clear-logs` - Clear log files before starting the app
+
 ### Stop an application
 
 ```sh
@@ -30,6 +49,8 @@ pomitu stop <name>
 
 This command stops a running app. Use `pomitu stop all` to stop all running apps.
 
+**Note:** In interactive TUI mode (`--no-daemon`), you can stop apps directly from the interface instead of using this command.
+
 ### List running applications
 
 ```sh
@@ -74,6 +95,12 @@ If you want to contribute to Pomitu or run it in development mode:
    npm run dev
    ```
 
+Dev installation test:
+
+```sh
+npm run build && npm pack && npm install -g pomitu-1.1.1.tgz && rm pomitu-1.1.1.tgz
+```
+
 ### Linting
 
 To lint the code:

package/dist/commands/flush.js

@@ -1,20 +1,22 @@
 import { Command } from 'commander';
-import { getPomituLogsDirectory } from '../helpers.js';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-const pomituLogsDirectory = getPomituLogsDirectory();
+import { LogManager } from '../services/index.js';
 export const flush = new Command('flush')
     .description('flush logs')
     .argument('[name]', 'name of the app whose logs you want to flush')
     .action((name) => {
-    let logs = fs.readdirSync(pomituLogsDirectory);
-    if (name) {
-        logs = logs.filter((log) => log.startsWith(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');
+        }
     }
-    const fullLogPaths = logs.map((log) => path.join(pomituLogsDirectory, log));
-    for (const logFilePath of fullLogPaths) {
-        console.log(`Flushing ${logFilePath}`);
-        fs.unlinkSync(logFilePath);
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log('Logs flushed');
 });

package/dist/commands/ls.js

@@ -1,25 +1,28 @@
 import { Command } from 'commander';
-import * as fs from 'node:fs';
-import { getPomituPidsDirectory, pidIsRunning } from '../helpers.js';
+import { ProcessManager } from '../services/index.js';
 export const ls = new Command('ls')
     .description('list all running apps')
     .action(() => {
-    const pidsDirectory = getPomituPidsDirectory();
-    const pidFiles = fs.readdirSync(pidsDirectory);
-    if (pidFiles.length === 0) {
-        console.log('No running processes found');
-        return;
-    }
-    console.log('Running processes:');
-    for (const pidFile of pidFiles) {
-        const pidFilePath = `${pidsDirectory}/${pidFile}`;
-        const pid = parseInt(fs.readFileSync(pidFilePath, 'utf-8'));
-        const appName = pidFile.replace('.pid', '');
-        if (pidIsRunning(pid)) {
-            console.log(`- ${appName} (pid: ${pid})`);
+    try {
+        const processManager = new ProcessManager();
+        const processes = processManager.listRunningProcesses();
+        if (processes.length === 0) {
+            console.log('No running processes found');
+            return;
         }
-        else {
-            console.warn(`- ${appName} (pid: ${pid}) is not running`);
+        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`);
+            }
         }
     }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
 });

package/dist/commands/restart.js

@@ -0,0 +1,65 @@
+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 (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.`);
+            }
+        }
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});

package/dist/commands/start.js

@@ -1,56 +1,36 @@
 import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import { parse } from 'shell-quote';
-import { readConfig, getProcessLogOutFilePath, getProcessLogErrorFilePath, getProcessPidFilePath, pidIsRunning, getFileNameFriendlyName, } from '../helpers.js';
-import * as fs from 'node:fs';
+import { ProcessManager, ConfigManager } from '../services/index.js';
+import React from 'react';
+import { render } from 'ink';
+import { ProcessTUI } from '../components/ProcessTUI.js';
 export const start = new Command('start')
     .description('start and daemonize an app')
     .argument('<name>', '[name|namespace|file|ecosystem|id...]')
-    .action((name) => {
-    const config = readConfig(name);
-    for (const app of config.apps) {
-        console.log(`Starting: ${app.name} (${app.cwd})`);
-        if (!fs.existsSync(app.cwd)) {
-            console.error(`Directory ${app.cwd} does not exist`);
-            process.exit(1);
+    .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) {
+            processManager.startApp(app, {
+                daemon: options.daemon,
+                clearLogs: options.clearLogs
+            });
         }
-        const run = parse(app.run);
-        if (!run.length) {
-            console.error(`Invalid run command for ${app.name}: ${app.run}`);
-            process.exit(1);
+        if (runInteractive) {
+            render(React.createElement(ProcessTUI, {
+                configPath: name,
+                clearLogs: options.clearLogs
+            }));
         }
-        const fileNameFriendAppName = getFileNameFriendlyName(app.name);
-        const existingPidFilePath = getProcessPidFilePath(fileNameFriendAppName);
-        if (fs.existsSync(existingPidFilePath)) {
-            const existingPid = parseInt(fs.readFileSync(existingPidFilePath, 'utf-8'));
-            if (pidIsRunning(existingPid)) {
-                console.warn(`Process ${app.name} is already running with pid ${existingPid}`);
-                console.log(`Stopping ${app.name} at pid ${existingPid}`);
-                try {
-                    process.kill(existingPid);
-                }
-                catch (e) {
-                    const error = e;
-                    console.error(`Error stopping ${app.name}: ${error.message}`);
-                }
-            }
-            fs.unlinkSync(existingPidFilePath);
-        }
-        const stdout = fs.openSync(getProcessLogOutFilePath(fileNameFriendAppName), 'a');
-        const stderr = fs.openSync(getProcessLogErrorFilePath(fileNameFriendAppName), 'a');
-        const startedProcess = spawn(run[0], run.slice(1), {
-            cwd: app.cwd,
-            stdio: ['ignore', stdout, stderr],
-            detached: true,
-        });
-        startedProcess.on('error', (error) => {
-            console.error(`Error starting ${app.name}: ${error.message}`);
-            process.exit(1);
-        });
-        startedProcess.on('spawn', () => {
-            console.log(`Started: ${app.name} with pid ${startedProcess.pid}`);
-        });
-        startedProcess.unref();
-        fs.writeFileSync(getProcessPidFilePath(fileNameFriendAppName), startedProcess.pid.toString());
+    }
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
 });

package/dist/commands/stop.js

@@ -1,49 +1,30 @@
 import { Command } from 'commander';
-import * as fs from 'node:fs';
-import { getPomituPidsDirectory, getFileNameFriendlyName, pidIsRunning, } from '../helpers.js';
+import { ProcessManager } from '../services/index.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((name) => {
-    const pidsDirectory = getPomituPidsDirectory();
-    const pidFiles = fs.readdirSync(pidsDirectory);
-    if (name === 'all') {
-        if (pidFiles.length === 0) {
-            console.warn('No running processes found');
-            return;
-        }
-        for (const pidFile of pidFiles) {
-            stopProcess(pidFile, name);
-        }
-    }
-    else {
-        const fileNameFriendlyName = getFileNameFriendlyName(name);
-        const pidFile = `${fileNameFriendlyName}.pid`;
-        if (pidFiles.includes(pidFile)) {
-            stopProcess(pidFile, name);
+    .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)`);
+            }
         }
         else {
-            console.warn(`No running process found for ${name}`);
-        }
-    }
-});
-function stopProcess(pidFile, appName) {
-    const pidFilePath = `${getPomituPidsDirectory()}/${pidFile}`;
-    const pid = parseInt(fs.readFileSync(pidFilePath, 'utf-8'));
-    if (pidIsRunning(pid)) {
-        console.log(`Stopping ${appName} with pid ${pid}`);
-        try {
-            process.kill(pid);
-            fs.unlinkSync(pidFilePath);
-            console.log(`${appName} with pid ${pid} stopped`);
-        }
-        catch (e) {
-            const error = e;
-            console.error(`Error stopping ${appName} with pid ${pid}: ${error.message}`);
+            const success = await processManager.stopApp(name);
+            if (!success) {
+                console.warn(`No running process found for ${name}`);
+            }
         }
     }
-    else {
-        console.warn(`${appName} with pid ${pid} is not running`);
-        fs.unlinkSync(pidFilePath);
+    catch (error) {
+        const err = error;
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-}
+});

package/dist/components/ProcessTUI.js

@@ -0,0 +1,212 @@
+import React, { useState, useEffect, useMemo, useCallback, useRef } from 'react';
+import readline from 'node:readline';
+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';
+export function ProcessTUI({ configPath, clearLogs }) {
+    const { exit } = useApp();
+    const { stdin, setRawMode } = useStdin();
+    const [processes, setProcesses] = useState([]);
+    const [apps, setApps] = useState([]);
+    const [message, setMessage] = useState('');
+    const [messageColor, setMessageColor] = useState('green');
+    const [isProcessing, setIsProcessing] = useState(false);
+    const previousRawModeRef = useRef(false);
+    const rawModeCapturedRef = useRef(false);
+    // Create managers only once
+    const processManager = useMemo(() => new ProcessManager(), []);
+    const configManager = useMemo(() => new ConfigManager(), []);
+    const cleanExit = useCallback(() => {
+        if (setRawMode) {
+            setRawMode(previousRawModeRef.current);
+        }
+        exit();
+        process.exit(0);
+    }, [exit, setRawMode]);
+    const computeStatuses = useCallback(() => {
+        if (apps.length === 0) {
+            return [];
+        }
+        const runningProcesses = processManager.listRunningProcesses();
+        return apps.map(app => {
+            const fileNameFriendlyName = getFileNameFriendlyName(app.name);
+            const running = runningProcesses.find(p => p.name === fileNameFriendlyName);
+            return {
+                name: app.name,
+                pid: running?.pid ?? null,
+                isRunning: running?.isRunning ?? false
+            };
+        });
+    }, [apps, processManager]);
+    // Load config on mount
+    useEffect(() => {
+        try {
+            const config = configManager.readConfig(configPath);
+            configManager.validateConfig(config);
+            setApps(config.apps);
+        }
+        catch (error) {
+            const err = error;
+            setMessage(`Error loading config: ${err.message}`);
+            setMessageColor('red');
+        }
+    }, [configPath, configManager]);
+    // Update process status
+    useEffect(() => {
+        setProcesses(computeStatuses());
+    }, [computeStatuses]);
+    // Handle keyboard input - use keypress events to intercept BEFORE SelectInput
+    useEffect(() => {
+        if (!stdin)
+            return;
+        // Enable keypress events and raw mode for immediate key detection
+        readline.emitKeypressEvents(stdin);
+        const stream = stdin;
+        if (!rawModeCapturedRef.current) {
+            const previousRawMode = typeof stream.isRaw === 'boolean' ? stream.isRaw : false;
+            previousRawModeRef.current = previousRawMode;
+            rawModeCapturedRef.current = true;
+        }
+        if (setRawMode) {
+            setRawMode(true);
+        }
+        const handleKeypress = (str, key) => {
+            if (str === 'q') {
+                cleanExit();
+            }
+            if (key?.ctrl && key.name === 'c') {
+                cleanExit();
+            }
+        };
+        // Use prependListener to capture keys before other handlers
+        stdin.prependListener('keypress', handleKeypress);
+        return () => {
+            stdin.removeListener('keypress', handleKeypress);
+            if (setRawMode) {
+                setRawMode(previousRawModeRef.current);
+            }
+        };
+    }, [stdin, setRawMode, cleanExit]);
+    // Handle Ctrl+C signal directly - use prependListener to be first
+    useEffect(() => {
+        const handleSigInt = () => {
+            cleanExit();
+        };
+        // Use prependListener to ensure we handle SIGINT before Ink does
+        process.prependListener('SIGINT', handleSigInt);
+        return () => {
+            process.removeListener('SIGINT', handleSigInt);
+        };
+    }, [cleanExit]);
+    const handleSelect = useCallback(async (item) => {
+        if (isProcessing)
+            return; // Prevent multiple simultaneous operations
+        const [action, appName] = item.value.split(':');
+        const app = apps.find(a => a.name === appName);
+        if (!app) {
+            setMessage(`App ${appName} not found`);
+            setMessageColor('red');
+            return;
+        }
+        setIsProcessing(true);
+        try {
+            if (action === 'start') {
+                await processManager.startApp(app, {
+                    daemon: false,
+                    clearLogs: clearLogs ?? false
+                });
+                setMessage(`Started ${appName}`);
+                setMessageColor('green');
+            }
+            else if (action === 'stop') {
+                const success = await processManager.stopApp(appName, { quiet: true });
+                if (success) {
+                    setMessage(`Stopped ${appName}`);
+                    setMessageColor('green');
+                }
+                else {
+                    setMessage(`Failed to stop ${appName}`);
+                    setMessageColor('red');
+                }
+            }
+            else if (action === 'restart') {
+                const success = await processManager.stopApp(appName, { quiet: true });
+                if (success) {
+                    // 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');
+                }
+            }
+            setProcesses(computeStatuses());
+        }
+        catch (error) {
+            const err = error;
+            setMessage(`Error: ${err.message}`);
+            setMessageColor('red');
+        }
+        finally {
+            setIsProcessing(false);
+        }
+        // Clear message after 3 seconds
+        setTimeout(() => setMessage(''), 3000);
+    }, [apps, clearLogs, computeStatuses, processManager, isProcessing]);
+    const getMenuItems = useCallback(() => {
+        const items = [];
+        processes.forEach(proc => {
+            const statusLabel = proc.isRunning
+                ? `🟢 Running (PID: ${proc.pid})`
+                : '🔴 Stopped';
+            items.push({
+                label: `${proc.name.padEnd(40)} ${statusLabel}`,
+                value: `info:${proc.name}`
+            });
+            if (proc.isRunning) {
+                items.push({
+                    label: `  ├─ Stop ${proc.name}`,
+                    value: `stop:${proc.name}`
+                });
+                items.push({
+                    label: `  └─ Restart ${proc.name}`,
+                    value: `restart:${proc.name}`
+                });
+            }
+            else {
+                items.push({
+                    label: `  └─ Start ${proc.name}`,
+                    value: `start:${proc.name}`
+                });
+            }
+        });
+        return items;
+    }, [processes]);
+    const items = useMemo(() => getMenuItems(), [getMenuItems]);
+    const handleMenuSelect = useCallback((item) => {
+        if (item.value === 'separator' || item.value.startsWith('info:')) {
+            // Informational rows are read-only
+        }
+        else {
+            handleSelect(item);
+        }
+    }, [handleSelect]);
+    const notificationText = isProcessing ? 'Processing...' : message;
+    const notificationColor = isProcessing ? '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")),
+        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, 'q' or Ctrl+C to quit")),
+            React.createElement(SelectInput, { items: items, onSelect: handleMenuSelect, isFocused: !isProcessing }))) : (React.createElement(Text, null, "Loading processes...")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: notificationColor ?? 'gray' }, notificationText ?? ' '))));
+}

package/dist/helpers.js

@@ -1,17 +1,5 @@
-import * as fs from 'node:fs';
-import * as YAML from 'yaml';
-import { configSchema } from './schema.js';
 import { homedir } from 'node:os';
 import * as path from 'node:path';
-export function readConfig(configFilePath) {
-    const configParsed = YAML.parse(fs.readFileSync(configFilePath, 'utf8'));
-    const { success, data: config } = configSchema.safeParse(configParsed);
-    if (!success) {
-        console.error('Invalid config file');
-        process.exit(1);
-    }
-    return config;
-}
 export function getPomituDirectory() {
     const homeDirectory = homedir();
     return path.join(homeDirectory, '.pomitu');
@@ -31,9 +19,6 @@ export function getProcessLogOutFilePath(name) {
 export function getProcessLogErrorFilePath(name) {
     return path.join(getPomituLogsDirectory(), `${name}-error.log`);
 }
-export function getProcessPidFilePath(name) {
-    return path.join(getPomituPidsDirectory(), `${name}.pid`);
-}
 // From: https://stackoverflow.com/a/21296291/4932305
 export function pidIsRunning(pid) {
     try {

package/dist/services/ConfigManager.js

@@ -0,0 +1,50 @@
+import * as fs from 'node:fs';
+import * as YAML from 'yaml';
+import { configSchema } from '../schema.js';
+export class ConfigManager {
+    readConfig(configFilePath) {
+        if (!fs.existsSync(configFilePath)) {
+            throw new Error(`Config file not found: ${configFilePath}`);
+        }
+        try {
+            const configContent = fs.readFileSync(configFilePath, 'utf8');
+            const configParsed = YAML.parse(configContent);
+            const { success, data: config, error } = configSchema.safeParse(configParsed);
+            if (!success) {
+                throw new Error(`Invalid config file: ${error.message}`);
+            }
+            return config;
+        }
+        catch (error) {
+            const err = error;
+            throw new Error(`Error reading config file: ${err.message}`);
+        }
+    }
+    validateAppConfig(app) {
+        if (!app.name?.trim()) {
+            throw new Error('App name is required');
+        }
+        if (!app.cwd?.trim()) {
+            throw new Error(`App '${app.name}' must have a valid working directory`);
+        }
+        if (!app.run?.trim()) {
+            throw new Error(`App '${app.name}' must have a valid run command`);
+        }
+    }
+    validateConfig(config) {
+        if (!config.apps || !Array.isArray(config.apps)) {
+            throw new Error('Config must contain an apps array');
+        }
+        if (config.apps.length === 0) {
+            throw new Error('Config must contain at least one app');
+        }
+        const appNames = new Set();
+        for (const app of config.apps) {
+            this.validateAppConfig(app);
+            if (appNames.has(app.name)) {
+                throw new Error(`Duplicate app name found: ${app.name}`);
+            }
+            appNames.add(app.name);
+        }
+    }
+}

package/dist/services/LogManager.js

@@ -0,0 +1,50 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getPomituLogsDirectory, getProcessLogOutFilePath, getProcessLogErrorFilePath, getFileNameFriendlyName } from '../helpers.js';
+export class LogManager {
+    logsDirectory;
+    constructor() {
+        this.logsDirectory = getPomituLogsDirectory();
+    }
+    clearAppLogs(appName) {
+        const stdoutPath = getProcessLogOutFilePath(appName);
+        const stderrPath = getProcessLogErrorFilePath(appName);
+        if (fs.existsSync(stdoutPath)) {
+            fs.unlinkSync(stdoutPath);
+        }
+        if (fs.existsSync(stderrPath)) {
+            fs.unlinkSync(stderrPath);
+        }
+    }
+    flushLogs(appName) {
+        if (!fs.existsSync(this.logsDirectory)) {
+            return [];
+        }
+        let logs = fs.readdirSync(this.logsDirectory);
+        if (appName) {
+            const fileNameFriendlyName = getFileNameFriendlyName(appName);
+            logs = logs.filter((log) => log.startsWith(fileNameFriendlyName));
+        }
+        const fullLogPaths = logs.map((log) => path.join(this.logsDirectory, log));
+        const flushedFiles = [];
+        for (const logFilePath of fullLogPaths) {
+            if (fs.existsSync(logFilePath)) {
+                console.log(`Flushing ${logFilePath}`);
+                fs.unlinkSync(logFilePath);
+                flushedFiles.push(logFilePath);
+            }
+        }
+        return flushedFiles;
+    }
+    getLogFiles(appName) {
+        if (!fs.existsSync(this.logsDirectory)) {
+            return [];
+        }
+        let logs = fs.readdirSync(this.logsDirectory);
+        if (appName) {
+            const fileNameFriendlyName = getFileNameFriendlyName(appName);
+            logs = logs.filter((log) => log.startsWith(fileNameFriendlyName));
+        }
+        return logs.map((log) => path.join(this.logsDirectory, log));
+    }
+}

package/dist/services/PidManager.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import { getPomituPidsDirectory } from '../helpers.js';
+import * as path from 'node:path';
+export class PidManager {
+    pidsDirectory;
+    constructor() {
+        this.pidsDirectory = getPomituPidsDirectory();
+    }
+    savePid(appName, pid) {
+        const pidFilePath = this.getPidFilePath(appName);
+        fs.writeFileSync(pidFilePath, pid.toString());
+    }
+    getPid(appName) {
+        const pidFilePath = this.getPidFilePath(appName);
+        if (!fs.existsSync(pidFilePath)) {
+            return null;
+        }
+        try {
+            const pidContent = fs.readFileSync(pidFilePath, 'utf-8');
+            return parseInt(pidContent);
+        }
+        catch {
+            return null;
+        }
+    }
+    removePid(appName) {
+        const pidFilePath = this.getPidFilePath(appName);
+        if (fs.existsSync(pidFilePath)) {
+            fs.unlinkSync(pidFilePath);
+        }
+    }
+    getAllPidFiles() {
+        if (!fs.existsSync(this.pidsDirectory)) {
+            return [];
+        }
+        return fs.readdirSync(this.pidsDirectory).filter(file => file.endsWith('.pid'));
+    }
+    getPidFilePath(appName) {
+        return path.join(this.pidsDirectory, `${appName}.pid`);
+    }
+}

package/dist/services/ProcessManager.js

@@ -0,0 +1,132 @@
+import { spawn } from 'node:child_process';
+import { parse } from 'shell-quote';
+import * as fs from 'node:fs';
+import { getProcessLogOutFilePath, getProcessLogErrorFilePath, pidIsRunning, getFileNameFriendlyName, } from '../helpers.js';
+import { PidManager } from './PidManager.js';
+import { LogManager } from './LogManager.js';
+export class ProcessManager {
+    pidManager = new PidManager();
+    logManager = new LogManager();
+    async startApp(app, options = {}) {
+        const isDaemon = options.daemon ?? true;
+        if (isDaemon) {
+            console.log(`Starting: ${app.name} (${app.cwd})`);
+        }
+        if (!fs.existsSync(app.cwd)) {
+            throw new Error(`Directory ${app.cwd} does not exist`);
+        }
+        const run = parse(app.run);
+        if (!run.length) {
+            throw new Error(`Invalid run command for ${app.name}: ${app.run}`);
+        }
+        const fileNameFriendAppName = getFileNameFriendlyName(app.name);
+        // Check if process is already running and stop it
+        await this.stopIfRunning(app.name);
+        // Clear logs if requested
+        if (options.clearLogs) {
+            this.logManager.clearAppLogs(fileNameFriendAppName);
+        }
+        // Start the process
+        const process = await this.spawnProcess(app, run, options.daemon ?? true);
+        // Save PID
+        this.pidManager.savePid(fileNameFriendAppName, process.pid);
+        if (isDaemon) {
+            console.log(`Started: ${app.name} with pid ${process.pid}`);
+        }
+    }
+    async stopApp(name, options = {}) {
+        const quiet = options.quiet ?? false;
+        const fileNameFriendlyName = getFileNameFriendlyName(name);
+        const pid = this.pidManager.getPid(fileNameFriendlyName);
+        if (!pid) {
+            return false;
+        }
+        if (!pidIsRunning(pid)) {
+            console.warn(`${name} with pid ${pid} is not running`);
+            this.pidManager.removePid(fileNameFriendlyName);
+            return false;
+        }
+        if (!quiet) {
+            console.log(`Stopping ${name} with pid ${pid}`);
+        }
+        try {
+            process.kill(pid);
+            this.pidManager.removePid(fileNameFriendlyName);
+            if (!quiet) {
+                console.log(`${name} with pid ${pid} stopped`);
+            }
+            return true;
+        }
+        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 = [];
+        for (const pidFile of pidFiles) {
+            const appName = pidFile.replace('.pid', '');
+            const pid = this.pidManager.getPid(appName);
+            if (pid) {
+                processes.push({
+                    name: appName,
+                    pid,
+                    isRunning: pidIsRunning(pid)
+                });
+            }
+        }
+        return processes;
+    }
+    async stopIfRunning(appName) {
+        const fileNameFriendAppName = getFileNameFriendlyName(appName);
+        const existingPid = this.pidManager.getPid(fileNameFriendAppName);
+        if (existingPid && pidIsRunning(existingPid)) {
+            console.warn(`Process ${appName} is already running with pid ${existingPid}`);
+            console.log(`Stopping ${appName} at pid ${existingPid}`);
+            try {
+                process.kill(existingPid);
+            }
+            catch (error) {
+                const err = error;
+                console.error(`Error stopping ${appName}: ${err.message}`);
+            }
+        }
+        this.pidManager.removePid(fileNameFriendAppName);
+    }
+    async spawnProcess(app, command, daemon) {
+        const fileNameFriendAppName = getFileNameFriendlyName(app.name);
+        const stdoutPath = getProcessLogOutFilePath(fileNameFriendAppName);
+        const stderrPath = getProcessLogErrorFilePath(fileNameFriendAppName);
+        const stdout = fs.openSync(stdoutPath, 'a');
+        const stderr = fs.openSync(stderrPath, 'a');
+        return new Promise((resolve, reject) => {
+            const startedProcess = spawn(command[0], command.slice(1), {
+                cwd: app.cwd,
+                stdio: ['ignore', stdout, stderr],
+                detached: daemon,
+            });
+            startedProcess.on('error', (error) => {
+                reject(new Error(`Error starting ${app.name}: ${error.message}`));
+            });
+            startedProcess.on('spawn', () => {
+                if (daemon) {
+                    startedProcess.unref();
+                }
+                resolve(startedProcess);
+            });
+        });
+    }
+}

package/dist/services/index.js

@@ -0,0 +1,4 @@
+export { ProcessManager } from './ProcessManager.js';
+export { PidManager } from './PidManager.js';
+export { LogManager } from './LogManager.js';
+export { ConfigManager } from './ConfigManager.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pomitu",
-    "version": "1.0.0",
+    "version": "1.1.1",
     "description": "Pomitu is a process manager inspired by PM2",
     "type": "module",
     "scripts": {
@@ -15,6 +15,7 @@
         "@eslint/js": "^9.12.0",
         "@stylistic/eslint-plugin-js": "^2.9.0",
         "@types/node": "^22.7.4",
+        "@types/react": "^19.2.2",
         "@types/shell-quote": "^1.7.5",
         "eslint": "^9.12.0",
         "globals": "^15.10.0",
@@ -24,12 +25,15 @@
     },
     "main": "dist/app.js",
     "bin": {
-        "pomitu": "./dist/app.js"
+        "pomitu": "dist/app.js"
     },
     "author": "flawiddsouza",
     "license": "ISC",
     "dependencies": {
         "commander": "^12.1.0",
+        "ink": "^6.4.0",
+        "ink-select-input": "^6.2.0",
+        "react": "^19.2.0",
         "shell-quote": "^1.8.1",
         "yaml": "^2.5.1",
         "zod": "^3.23.8"

package/dist/cli.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const app_js_1 = require("./app.js");
-app_js_1.program.parse(process.argv);