@spssrl/sps-ps-agent 1.0.0

package/bin/sps-ps-agent.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+const config = require('../src/config');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const command = process.argv[2];
+
+switch (command) {
+    case 'init':
+        handleInit();
+        break;
+    case 'start':
+        handleStart();
+        break;
+    case 'stop':
+        handleStop();
+        break;
+    case 'status':
+        handleStatus();
+        break;
+    case 'token':
+        handleToken();
+        break;
+    default:
+        showHelp();
+}
+
+function handleInit() {
+    const force = process.argv.includes('--force');
+    const result = config.init({ force });
+
+    if (result.created) {
+        console.log('\n  SPS-PS Agent initialized!');
+        console.log(`  Config: ${config.CONFIG_FILE}`);
+        console.log(`  Port: ${result.config.port}`);
+        console.log(`  Token: ${result.config.token}`);
+        console.log(`  Server: ${result.config.serverName}`);
+        console.log('\n  Copy the token above into your CRM server configuration.');
+        console.log('  Start the agent with: sps-ps-agent start\n');
+    } else {
+        console.log('\n  Config already exists. Use --force to overwrite.');
+        console.log(`  Config: ${config.CONFIG_FILE}`);
+        console.log(`  Token: ${result.config.token}\n`);
+    }
+}
+
+function handleStart() {
+    const cfg = config.load();
+    if (!cfg) {
+        console.error('No configuration found. Run: sps-ps-agent init');
+        process.exit(1);
+    }
+
+    const existingPid = config.readPid();
+    if (existingPid && config.isRunning(existingPid)) {
+        console.log(`Agent already running (PID: ${existingPid})`);
+        process.exit(0);
+    }
+
+    if (process.argv.includes('--daemon') || process.argv.includes('-d')) {
+        // Daemonize
+        const serverPath = path.join(__dirname, '..', 'src', 'server.js');
+        const child = spawn(process.execPath, [serverPath], {
+            detached: true,
+            stdio: 'ignore',
+            env: { ...process.env }
+        });
+        child.unref();
+        config.savePid(child.pid);
+        console.log(`\n  SPS-PS Agent started in background (PID: ${child.pid})`);
+        console.log(`  Port: ${cfg.port}`);
+        console.log(`  Stop with: sps-ps-agent stop\n`);
+    } else {
+        // Foreground
+        require('../src/server').start();
+    }
+}
+
+function handleStop() {
+    const pid = config.readPid();
+    if (!pid) {
+        console.log('Agent is not running (no PID file).');
+        return;
+    }
+
+    if (!config.isRunning(pid)) {
+        console.log(`Agent is not running (stale PID: ${pid}). Cleaning up.`);
+        config.removePid();
+        return;
+    }
+
+    try {
+        process.kill(pid, 'SIGTERM');
+        console.log(`Agent stopped (PID: ${pid}).`);
+        config.removePid();
+    } catch (err) {
+        console.error(`Failed to stop agent: ${err.message}`);
+    }
+}
+
+function handleStatus() {
+    const cfg = config.load();
+    if (!cfg) {
+        console.log('\n  Not initialized. Run: sps-ps-agent init\n');
+        return;
+    }
+
+    const pid = config.readPid();
+    const running = pid && config.isRunning(pid);
+
+    console.log('\n  SPS-PS Agent Status');
+    console.log(`  Server: ${cfg.serverName}`);
+    console.log(`  Port: ${cfg.port}`);
+    console.log(`  Status: ${running ? `Running (PID: ${pid})` : 'Stopped'}`);
+    console.log(`  Config: ${config.CONFIG_FILE}\n`);
+}
+
+function handleToken() {
+    const cfg = config.load();
+    if (!cfg) {
+        console.log('Not initialized. Run: sps-ps-agent init');
+        return;
+    }
+    console.log(cfg.token);
+}
+
+function showHelp() {
+    const version = require('../package.json').version;
+    console.log(`
+  SPS-PS Agent v${version}
+
+  Usage: sps-ps-agent <command>
+
+  Commands:
+    init          Initialize configuration (generates token)
+    start         Start the agent (add -d for daemon mode)
+    stop          Stop the agent
+    status        Show agent status
+    token         Display the authentication token
+
+  Options:
+    init --force  Overwrite existing configuration
+    start -d      Run as background daemon
+`);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@spssrl/sps-ps-agent",
+  "version": "1.0.0",
+  "description": "SPS Process Services - Lightweight PM2 monitoring agent",
+  "main": "src/server.js",
+  "bin": {
+    "sps-ps-agent": "./bin/sps-ps-agent.js"
+  },
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "node src/server.js"
+  },
+  "keywords": ["pm2", "process", "monitoring", "agent", "sps"],
+  "author": "SPS Srl",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "pm2": "^5.4.0",
+    "systeminformation": "^5.23.0",
+    "uuid": "^10.0.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { v4: uuidv4 } = require('uuid');
+
+const CONFIG_DIR = path.join(os.homedir(), '.sps-ps-agent');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const PID_FILE = path.join(CONFIG_DIR, 'agent.pid');
+
+const DEFAULT_CONFIG = {
+    port: 9876,
+    token: null,
+    serverName: os.hostname(),
+    bindAddress: '0.0.0.0',
+    corsOrigins: ['*']
+};
+
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+
+function load() {
+    ensureConfigDir();
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw);
+}
+
+function save(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+function init(options = {}) {
+    const existing = load();
+    if (existing && !options.force) {
+        return { created: false, config: existing };
+    }
+    const config = {
+        ...DEFAULT_CONFIG,
+        token: uuidv4(),
+        ...options
+    };
+    save(config);
+    return { created: true, config };
+}
+
+function savePid(pid) {
+    ensureConfigDir();
+    fs.writeFileSync(PID_FILE, String(pid), 'utf-8');
+}
+
+function readPid() {
+    if (!fs.existsSync(PID_FILE)) return null;
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+}
+
+function removePid() {
+    if (fs.existsSync(PID_FILE)) {
+        fs.unlinkSync(PID_FILE);
+    }
+}
+
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+module.exports = {
+    CONFIG_DIR,
+    CONFIG_FILE,
+    PID_FILE,
+    load,
+    save,
+    init,
+    savePid,
+    readPid,
+    removePid,
+    isRunning
+};

package/src/middleware/auth.js

@@ -0,0 +1,19 @@
+const config = require('../config');
+
+function authMiddleware(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({ error: 'Missing or invalid authorization header' });
+    }
+
+    const token = authHeader.slice(7);
+    const cfg = config.load();
+
+    if (!cfg || token !== cfg.token) {
+        return res.status(403).json({ error: 'Invalid token' });
+    }
+
+    next();
+}
+
+module.exports = authMiddleware;

package/src/routes/logs.js

@@ -0,0 +1,44 @@
+const { Router } = require('express');
+const fs = require('fs');
+const pm2Service = require('../services/pm2');
+
+const router = Router();
+
+// GET /api/processes/:name/logs?lines=100&type=out|err|all
+router.get('/:name/logs', async (req, res) => {
+    const lines = Math.min(parseInt(req.query.lines) || 100, 5000);
+    const type = req.query.type || 'all'; // out, err, all
+
+    try {
+        const desc = await pm2Service.withConnection(() => pm2Service.describe(req.params.name));
+        const env = desc.pm2_env || {};
+        const outPath = env.pm_out_log_path;
+        const errPath = env.pm_err_log_path;
+
+        const result = {};
+
+        if ((type === 'out' || type === 'all') && outPath) {
+            result.out = tailFile(outPath, lines);
+        }
+        if ((type === 'err' || type === 'all') && errPath) {
+            result.err = tailFile(errPath, lines);
+        }
+
+        res.json({ success: true, process: req.params.name, logs: result });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+function tailFile(filePath, numLines) {
+    try {
+        if (!fs.existsSync(filePath)) return '';
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const allLines = content.split('\n');
+        return allLines.slice(-numLines).join('\n');
+    } catch {
+        return '';
+    }
+}
+
+module.exports = router;

package/src/routes/processes.js

@@ -0,0 +1,56 @@
+const { Router } = require('express');
+const pm2Service = require('../services/pm2');
+
+const router = Router();
+
+// GET /api/processes - List all PM2 processes
+router.get('/', async (req, res) => {
+    try {
+        const processes = await pm2Service.withConnection(() => pm2Service.list());
+        res.json({ success: true, data: processes });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// POST /api/processes/:name/restart
+router.post('/:name/restart', async (req, res) => {
+    try {
+        const result = await pm2Service.withConnection(() => pm2Service.restart(req.params.name));
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// POST /api/processes/:name/stop
+router.post('/:name/stop', async (req, res) => {
+    try {
+        const result = await pm2Service.withConnection(() => pm2Service.stop(req.params.name));
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// POST /api/processes/:name/start
+router.post('/:name/start', async (req, res) => {
+    try {
+        const result = await pm2Service.withConnection(() => pm2Service.start(req.params.name));
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// DELETE /api/processes/:name
+router.delete('/:name', async (req, res) => {
+    try {
+        const result = await pm2Service.withConnection(() => pm2Service.deleteProcess(req.params.name));
+        res.json(result);
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+module.exports = router;

package/src/routes/system.js

@@ -0,0 +1,66 @@
+const { Router } = require('express');
+const si = require('systeminformation');
+const os = require('os');
+
+const router = Router();
+
+// GET /api/status - Quick health check
+router.get('/status', async (req, res) => {
+    res.json({
+        success: true,
+        agent: 'sps-ps-agent',
+        version: require('../../package.json').version,
+        hostname: os.hostname(),
+        platform: os.platform(),
+        uptime: os.uptime(),
+        timestamp: new Date().toISOString()
+    });
+});
+
+// GET /api/system - Detailed system info
+router.get('/system', async (req, res) => {
+    try {
+        const [cpu, mem, disk, osInfo, time] = await Promise.all([
+            si.currentLoad(),
+            si.mem(),
+            si.fsSize(),
+            si.osInfo(),
+            si.time()
+        ]);
+
+        res.json({
+            success: true,
+            data: {
+                hostname: os.hostname(),
+                platform: osInfo.platform,
+                distro: osInfo.distro,
+                release: osInfo.release,
+                arch: osInfo.arch,
+                uptime: os.uptime(),
+                cpu: {
+                    load: Math.round(cpu.currentLoad * 100) / 100,
+                    cores: os.cpus().length
+                },
+                memory: {
+                    total: mem.total,
+                    used: mem.used,
+                    free: mem.free,
+                    usage_percent: Math.round((mem.used / mem.total) * 10000) / 100
+                },
+                disk: disk.map(d => ({
+                    fs: d.fs,
+                    size: d.size,
+                    used: d.used,
+                    available: d.available,
+                    usage_percent: d.use,
+                    mount: d.mount
+                })),
+                timestamp: new Date().toISOString()
+            }
+        });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+
+module.exports = router;

package/src/server.js

@@ -0,0 +1,69 @@
+const express = require('express');
+const cors = require('cors');
+const config = require('./config');
+const authMiddleware = require('./middleware/auth');
+const processRoutes = require('./routes/processes');
+const logRoutes = require('./routes/logs');
+const systemRoutes = require('./routes/system');
+
+function createServer() {
+    const cfg = config.load();
+    if (!cfg) {
+        console.error('No configuration found. Run: sps-ps-agent init');
+        process.exit(1);
+    }
+
+    const app = express();
+
+    app.use(cors({ origin: cfg.corsOrigins || '*' }));
+    app.use(express.json());
+
+    // Public health endpoint (no auth)
+    app.get('/api/ping', (req, res) => {
+        res.json({ pong: true, timestamp: new Date().toISOString() });
+    });
+
+    // All other routes require auth
+    app.use('/api', authMiddleware);
+
+    // Routes
+    app.use('/api', systemRoutes);
+    app.use('/api/processes', processRoutes);
+    app.use('/api/processes', logRoutes);
+
+    return { app, cfg };
+}
+
+function start() {
+    const { app, cfg } = createServer();
+    const port = cfg.port || 9876;
+    const bind = cfg.bindAddress || '0.0.0.0';
+
+    const server = app.listen(port, bind, () => {
+        console.log(`\n  SPS-PS Agent v${require('../package.json').version}`);
+        console.log(`  Server: ${cfg.serverName}`);
+        console.log(`  Listening: http://${bind}:${port}`);
+        console.log(`  Token: ${cfg.token.substring(0, 8)}...`);
+        console.log('');
+
+        config.savePid(process.pid);
+    });
+
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        config.removePid();
+        server.close(() => process.exit(0));
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    return server;
+}
+
+module.exports = { createServer, start };
+
+// Direct execution
+if (require.main === module) {
+    start();
+}

package/src/services/pm2.js

@@ -0,0 +1,114 @@
+const pm2 = require('pm2');
+
+function connect() {
+    return new Promise((resolve, reject) => {
+        pm2.connect((err) => {
+            if (err) reject(err);
+            else resolve();
+        });
+    });
+}
+
+function disconnect() {
+    pm2.disconnect();
+}
+
+function list() {
+    return new Promise((resolve, reject) => {
+        pm2.list((err, list) => {
+            if (err) reject(err);
+            else resolve(list.map(formatProcess));
+        });
+    });
+}
+
+function describe(nameOrId) {
+    return new Promise((resolve, reject) => {
+        pm2.describe(nameOrId, (err, desc) => {
+            if (err) reject(err);
+            else if (!desc || desc.length === 0) reject(new Error(`Process "${nameOrId}" not found`));
+            else resolve(desc[0]);
+        });
+    });
+}
+
+function restart(nameOrId) {
+    return new Promise((resolve, reject) => {
+        pm2.restart(nameOrId, (err) => {
+            if (err) reject(err);
+            else resolve({ success: true, action: 'restart', process: nameOrId });
+        });
+    });
+}
+
+function stop(nameOrId) {
+    return new Promise((resolve, reject) => {
+        pm2.stop(nameOrId, (err) => {
+            if (err) reject(err);
+            else resolve({ success: true, action: 'stop', process: nameOrId });
+        });
+    });
+}
+
+function start(nameOrId) {
+    return new Promise((resolve, reject) => {
+        pm2.restart(nameOrId, (err) => {
+            if (err) reject(err);
+            else resolve({ success: true, action: 'start', process: nameOrId });
+        });
+    });
+}
+
+function deleteProcess(nameOrId) {
+    return new Promise((resolve, reject) => {
+        pm2.delete(nameOrId, (err) => {
+            if (err) reject(err);
+            else resolve({ success: true, action: 'delete', process: nameOrId });
+        });
+    });
+}
+
+function formatProcess(proc) {
+    const env = proc.pm2_env || {};
+    const monit = proc.monit || {};
+    const startedAt = env.pm_uptime || null;
+    const uptime = startedAt ? Date.now() - startedAt : 0;
+
+    return {
+        pm_id: env.pm_id ?? proc.pm_id,
+        name: env.name || proc.name,
+        status: env.status || 'unknown',
+        cpu: monit.cpu || 0,
+        memory: monit.memory || 0,
+        uptime,
+        restarts: env.restart_time || 0,
+        pid: proc.pid || 0,
+        exec_mode: env.exec_mode || 'fork',
+        node_version: env.node_version || process.version,
+        script: env.pm_exec_path || '',
+        cwd: env.pm_cwd || '',
+        created_at: startedAt ? new Date(startedAt).toISOString() : null,
+        log_path: env.pm_out_log_path || null,
+        error_log_path: env.pm_err_log_path || null
+    };
+}
+
+async function withConnection(fn) {
+    await connect();
+    try {
+        return await fn();
+    } finally {
+        disconnect();
+    }
+}
+
+module.exports = {
+    withConnection,
+    list,
+    describe,
+    restart,
+    stop,
+    start,
+    deleteProcess,
+    formatProcess
+};

package/templates/sps-ps-agent.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=SPS Process Services Agent
+After=network.target
+
+[Service]
+Type=simple
+User=root
+ExecStart=/usr/bin/env node /usr/lib/node_modules/sps-ps-agent/src/server.js
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target