pomitu 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 Flawid D'Souza
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+# Pomitu
+
+Pomitu is a simple process manager inspired by PM2
+
+## Installation
+
+To install Pomitu globally, run:
+
+```sh
+npm install -g pomitu
+```
+
+## Usage
+
+Pomitu provides several commands to manage your applications:
+
+### Start an application
+
+```sh
+pomitu start <config-file>
+```
+
+This command starts and daemonizes an app based on the configuration file provided.
+
+### Stop an application
+
+```sh
+pomitu stop <name>
+```
+
+This command stops a running app. Use `pomitu stop all` to stop all running apps.
+
+### List running applications
+
+```sh
+pomitu ls
+```
+
+This command lists all currently running applications managed by Pomitu.
+
+### Flush logs
+
+```sh
+pomitu flush [name]
+```
+
+This command flushes the logs for all apps or a specific app if a name is provided.
+
+## Configuration
+
+Pomitu uses a YAML configuration file to define the applications you want to manage. Here's an example structure:
+
+```yaml
+apps:
+  - name: "App 1"
+    cwd: "/path/to/app1"
+    run: "npm start"
+  - name: "App 2"
+    cwd: "/path/to/app2"
+    run: "node server.js"
+```
+
+## Development
+
+If you want to contribute to Pomitu or run it in development mode:
+
+1. Clone the repository
+2. Install dependencies:
+   ```sh
+   npm install
+   ```
+3. Run in development mode:
+   ```sh
+   npm run dev
+   ```
+
+### Linting
+
+To lint the code:
+```sh
+npm run lint
+```
+
+To lint and auto-fix:
+```sh
+npm run lint-fix
+```
+
+### Building
+
+To build the project:
+```sh
+npm run build
+```
+
+To build and run:
+```sh
+npm start
+```
+
+## License
+
+[ISC License](LICENSE)

package/dist/app.js

@@ -0,0 +1,23 @@
+#! /usr/bin/env node
+import { Command } from 'commander';
+import { start } from './commands/start.js';
+import { flush } from './commands/flush.js';
+import { stop } from './commands/stop.js';
+import { mkdirSync } from 'node:fs';
+import { ls } from './commands/ls.js';
+import { getPomituDirectory, getPomituLogsDirectory, getPomituPidsDirectory } from './helpers.js';
+function init() {
+    mkdirSync(getPomituDirectory(), { recursive: true });
+    mkdirSync(getPomituLogsDirectory(), { recursive: true });
+    mkdirSync(getPomituPidsDirectory(), { recursive: true });
+}
+init();
+const program = new Command();
+program
+    .name('pomitu')
+    .description('Pomitu is a process manager inspired by PM2')
+    .addCommand(start)
+    .addCommand(flush)
+    .addCommand(stop)
+    .addCommand(ls)
+    .parse();

package/dist/cli.js

@@ -0,0 +1,5 @@
+#!/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);

package/dist/commands/flush.js

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import { getPomituLogsDirectory } from '../helpers.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const pomituLogsDirectory = getPomituLogsDirectory();
+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));
+    }
+    const fullLogPaths = logs.map((log) => path.join(pomituLogsDirectory, log));
+    for (const logFilePath of fullLogPaths) {
+        console.log(`Flushing ${logFilePath}`);
+        fs.unlinkSync(logFilePath);
+    }
+    console.log('Logs flushed');
+});

package/dist/commands/ls.js

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import * as fs from 'node:fs';
+import { getPomituPidsDirectory, pidIsRunning } from '../helpers.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})`);
+        }
+        else {
+            console.warn(`- ${appName} (pid: ${pid}) is not running`);
+        }
+    }
+});

package/dist/commands/start.js

@@ -0,0 +1,56 @@
+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';
+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);
+        }
+        const run = parse(app.run);
+        if (!run.length) {
+            console.error(`Invalid run command for ${app.name}: ${app.run}`);
+            process.exit(1);
+        }
+        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());
+    }
+});

package/dist/commands/stop.js

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+import * as fs from 'node:fs';
+import { getPomituPidsDirectory, getFileNameFriendlyName, pidIsRunning, } from '../helpers.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);
+        }
+        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}`);
+        }
+    }
+    else {
+        console.warn(`${appName} with pid ${pid} is not running`);
+        fs.unlinkSync(pidFilePath);
+    }
+}

package/dist/helpers.js

@@ -0,0 +1,46 @@
+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');
+}
+export function getPomituLogsDirectory() {
+    return path.join(getPomituDirectory(), 'logs');
+}
+export function getPomituPidsDirectory() {
+    return path.join(getPomituDirectory(), 'pids');
+}
+export function getFileNameFriendlyName(name) {
+    return name.replaceAll(' ', '-').toLowerCase();
+}
+export function getProcessLogOutFilePath(name) {
+    return path.join(getPomituLogsDirectory(), `${name}-out.log`);
+}
+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 {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const configSchema = z.object({
+    apps: z.array(z.object({
+        name: z.string(),
+        cwd: z.string(),
+        run: z.string(),
+    })),
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "pomitu",
+    "version": "1.0.0",
+    "description": "Pomitu is a process manager inspired by PM2",
+    "type": "module",
+    "scripts": {
+        "dev": "tsx src/app.ts",
+        "build": "tsc",
+        "start": "node dist/app.js",
+        "lint": "eslint",
+        "lint-fix": "eslint --fix",
+        "prepublish": "npm run build"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.12.0",
+        "@stylistic/eslint-plugin-js": "^2.9.0",
+        "@types/node": "^22.7.4",
+        "@types/shell-quote": "^1.7.5",
+        "eslint": "^9.12.0",
+        "globals": "^15.10.0",
+        "tsx": "^4.19.1",
+        "typescript": "^4.4.3",
+        "typescript-eslint": "^8.8.0"
+    },
+    "main": "dist/app.js",
+    "bin": {
+        "pomitu": "./dist/app.js"
+    },
+    "author": "flawiddsouza",
+    "license": "ISC",
+    "dependencies": {
+        "commander": "^12.1.0",
+        "shell-quote": "^1.8.1",
+        "yaml": "^2.5.1",
+        "zod": "^3.23.8"
+    },
+    "files": [
+        "dist"
+    ]
+}