unitup 0.0.8 → 0.0.10

package/src/cli.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs';
+import readline from 'node:readline';
 import { runDoctor } from './doctor.js';
 import {
   addService,
@@ -13,7 +14,12 @@ import {
   runJournalctlLogs,
   isLinux,
   isSystemctlAvailable,
-  findNodeExecutable
+  findNodeExecutable,
+  getServicesByGroup,
+  inspectService,
+  getServiceFailures,
+  setServiceLimits,
+  executeJournalctlMaintenance
 } from './systemd.js';
 import { sanitizeServiceName, formatTable } from './utils.js';
 
@@ -28,6 +34,10 @@ export function parseArgs(argv) {
     positionals: [],
     flags: {
       name: '',
+      group: '',
+      runtime: '',
+      runtimeArgs: [],
+      command: '',
       node: '',
       cwd: '',
       env: [],
@@ -42,7 +52,23 @@ export function parseArgs(argv) {
       output: '',
       lines: 100,
       help: false,
-      version: false
+      version: false,
+      memoryHigh: '',
+      memoryMax: '',
+      memorySwapMax: '',
+      resetMemory: false,
+      since: '',
+      until: '',
+      priority: '',
+      grep: '',
+      boot: false,
+      json: false,
+      diskUsage: false,
+      size: '',
+      time: '',
+      files: '',
+      yes: false,
+      dryRun: false
     }
   };
 
@@ -56,6 +82,24 @@ export function parseArgs(argv) {
     } else if (arg === '-v' || arg === '--version') {
       result.flags.version = true;
       i++;
+    } else if (arg === '--runtime') {
+      result.flags.runtime = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--runtime=')) {
+      result.flags.runtime = arg.slice(10);
+      i++;
+    } else if (arg === '--runtime-arg') {
+      if (argv[i + 1]) result.flags.runtimeArgs.push(argv[i + 1]);
+      i += 2;
+    } else if (arg.startsWith('--runtime-arg=')) {
+      result.flags.runtimeArgs.push(arg.slice(14));
+      i++;
+    } else if (arg === '--command') {
+      result.flags.command = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--command=')) {
+      result.flags.command = arg.slice(10);
+      i++;
     } else if (arg === '--node') {
       result.flags.node = argv[i + 1] || '';
       i += 2;
@@ -68,6 +112,12 @@ export function parseArgs(argv) {
     } else if (arg.startsWith('--name=')) {
       result.flags.name = arg.slice(7);
       i++;
+    } else if (arg === '--group') {
+      result.flags.group = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--group=')) {
+      result.flags.group = arg.slice(8);
+      i++;
     } else if (arg === '--cwd') {
       result.flags.cwd = argv[i + 1] || '';
       i += 2;
@@ -125,6 +175,84 @@ export function parseArgs(argv) {
     } else if (arg.startsWith('--output=')) {
       result.flags.output = arg.slice(9);
       i++;
+    } else if (arg === '--memory-high') {
+      result.flags.memoryHigh = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--memory-high=')) {
+      result.flags.memoryHigh = arg.slice(14);
+      i++;
+    } else if (arg === '--memory-max') {
+      result.flags.memoryMax = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--memory-max=')) {
+      result.flags.memoryMax = arg.slice(13);
+      i++;
+    } else if (arg === '--memory-swap-max') {
+      result.flags.memorySwapMax = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--memory-swap-max=')) {
+      result.flags.memorySwapMax = arg.slice(18);
+      i++;
+    } else if (arg === '--reset-memory') {
+      result.flags.resetMemory = true;
+      i++;
+    } else if (arg === '--since') {
+      result.flags.since = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--since=')) {
+      result.flags.since = arg.slice(8);
+      i++;
+    } else if (arg === '--until') {
+      result.flags.until = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--until=')) {
+      result.flags.until = arg.slice(8);
+      i++;
+    } else if (arg === '--priority') {
+      result.flags.priority = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--priority=')) {
+      result.flags.priority = arg.slice(11);
+      i++;
+    } else if (arg === '--grep') {
+      result.flags.grep = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--grep=')) {
+      result.flags.grep = arg.slice(7);
+      i++;
+    } else if (arg === '--boot' || arg === '-b') {
+      result.flags.boot = true;
+      i++;
+    } else if (arg === '--json') {
+      result.flags.json = true;
+      i++;
+    } else if (arg === '--disk-usage') {
+      result.flags.diskUsage = true;
+      i++;
+    } else if (arg === '--size') {
+      result.flags.size = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--size=')) {
+      result.flags.size = arg.slice(7);
+      i++;
+    } else if (arg === '--time') {
+      result.flags.time = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--time=')) {
+      result.flags.time = arg.slice(7);
+      i++;
+    } else if (arg === '--files') {
+      result.flags.files = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--files=')) {
+      result.flags.files = arg.slice(8);
+      i++;
+    } else if (arg === '--yes' || arg === '-y') {
+      result.flags.yes = true;
+      i++;
+    } else if (arg === '--dry-run') {
+      result.flags.dryRun = true;
+      i++;
     } else if (!arg.startsWith('-')) {
       if (!result.command) {
         result.command = arg;
@@ -143,36 +271,53 @@ export function parseArgs(argv) {
 
 export function printHelp() {
   console.log(`
-unitup - Minimal systemd user service wrapper for Node.js scripts
+unitup - Minimal systemd user service wrapper for any executable & runtime
 
 Usage:
-  unitup doctor                 Run system readiness check
-  unitup add <script> [options] Add script as systemd user service
-  unitup start <name>           Start a service (--enable to enable on boot)
-  unitup stop <name>            Stop a service
-  unitup restart <name>         Restart a service
-  unitup status <name>          Show status summary (--raw for full status)
-  unitup logs <name>            Show journalctl logs (--follow, --lines N)
-  unitup remove <name>          Stop, disable and delete a service
-  unitup list                   List all unitup user services
+  unitup doctor                 Run system readiness and runtime check
+  unitup add <script> [options] Add script or executable as systemd user service
+  unitup start <name|@group>    Start a service (--enable to enable on boot)
+  unitup stop <name|@group>     Stop a service
+  unitup restart <name|@group>  Restart a service
+  unitup status <name|@group>   Show status summary (--raw for full status)
+  unitup logs <name|@group>     Show journalctl logs (-f/--follow, -n/--lines N, -c/--cat)
+  unitup inspect <name>         View detailed app configuration and status
+  unitup failures               List all failed services with exit code & restarts
+  unitup remove <name|@group>   Stop, disable and delete a service
+  unitup list / unitup ls       List all services (--group <group>)
 
 Add Options:
-  --name <name>       Service name (default: script name)
-  --cwd <path>        Working directory
-  --restart <policy>  Restart policy (on-failure, always, etc. Default: on-failure)
-  --env KEY=value     Environment variable (can be specified multiple times)
-  --env-file <file>   Path to environment file
-  --arg <value>       Script argument (can be specified multiple times)
-  --start             Enable and start service immediately after creation
+  --name <name>          Service name (default: script/executable name)
+  --runtime <name>       Runtime (node, python, ruby, php, bun, deno, shell, go, elixir, native)
+  --runtime-arg <val>    Runtime argument (can be specified multiple times)
+  --command <path>       Custom executable command path (bypasses auto-detection)
+  --arg <value>          Argument to pass to command (can be specified multiple times)
+  --group <group>        Assign service to a group (default: default)
+  --cwd <path>           Working directory
+  --restart <policy>     Restart policy (on-failure, always, etc. Default: on-failure)
+  --env KEY=value        Environment variable (can be specified multiple times)
+  --env-file <file>      Path to environment file
+  --start                Enable and start service immediately after creation
 
 Examples:
-  unitup add server.js --name api --env NODE_ENV=production --start
-  unitup status api
-  unitup logs api --follow
-  unitup remove api
+  unitup add server.js --runtime node
+  unitup add worker.py --runtime python
+  unitup add ./server --runtime native
+  unitup add --name worker --command /usr/bin/python3 --arg worker.py --arg --port --arg 3000
 `);
 }
 
+async function resolveTargetNames(target) {
+  if (target && target.startsWith('@')) {
+    const list = await getServicesByGroup(target);
+    if (list.length === 0) {
+      throw new Error(`No services found in group "${target}".`);
+    }
+    return list;
+  }
+  return [target];
+}
+
 /**
  * Main CLI runner entrypoint.
  *
@@ -208,25 +353,39 @@ export async function runCli(argv = process.argv.slice(2)) {
 
       case 'add': {
         const scriptArg = positionals[0];
-        if (!scriptArg) {
-          throw new Error('Script file path is required.\nExample: unitup add app.js');
-        }
-
-        const resolvedNode = await findNodeExecutable(flags.node);
-        if (!resolvedNode) {
-          throw new Error('Node.js is required but not found.\nRun: unitup doctor');
-        }
+        let name = flags.name;
+        let absScriptPath = scriptArg ? path.resolve(process.cwd(), scriptArg) : undefined;
 
-        const absScriptPath = path.resolve(process.cwd(), scriptArg);
-        if (!fs.existsSync(absScriptPath)) {
-          throw new Error(`Script file does not exist: ${absScriptPath}`);
+        if (flags.node) {
+          const resolvedNode = await findNodeExecutable(flags.node);
+          if (!resolvedNode) {
+            throw new Error('Node.js is required but not found.\nRun: unitup doctor');
+          }
         }
 
-        let name = flags.name;
-        if (!name) {
-          const baseName = path.basename(scriptArg);
-          const ext = path.extname(baseName);
-          name = ext ? baseName.slice(0, -ext.length) : baseName;
+        if (flags.command) {
+          if (!name) {
+            if (scriptArg) {
+              const baseName = path.basename(scriptArg);
+              const ext = path.extname(baseName);
+              name = ext ? baseName.slice(0, -ext.length) : baseName;
+            } else {
+              const baseCmd = path.basename(flags.command);
+              name = baseCmd;
+            }
+          }
+        } else {
+          if (!scriptArg) {
+            throw new Error('Script file path or --command is required.\nExample: unitup add app.py --runtime python');
+          }
+          if (!fs.existsSync(absScriptPath)) {
+            throw new Error(`Script file does not exist: ${absScriptPath}`);
+          }
+          if (!name) {
+            const baseName = path.basename(scriptArg);
+            const ext = path.extname(baseName);
+            name = ext ? baseName.slice(0, -ext.length) : baseName;
+          }
         }
 
         const envObj = {};
@@ -241,14 +400,21 @@ export async function runCli(argv = process.argv.slice(2)) {
 
         const res = await addService({
           name,
+          group: flags.group || 'default',
           script: absScriptPath,
-          nodePath: resolvedNode,
-          cwd: flags.cwd ? path.resolve(process.cwd(), flags.cwd) : path.dirname(absScriptPath),
+          command: flags.command,
+          runtime: flags.runtime,
+          runtimeArgs: flags.runtimeArgs,
+          nodePath: flags.node,
+          cwd: flags.cwd ? path.resolve(process.cwd(), flags.cwd) : (absScriptPath ? path.dirname(absScriptPath) : process.cwd()),
           env: envObj,
           envFile: flags.envFile ? path.resolve(process.cwd(), flags.envFile) : undefined,
           restart: flags.restart,
           args: flags.args,
-          start: flags.start
+          start: flags.start,
+          memoryHigh: flags.memoryHigh,
+          memoryMax: flags.memoryMax,
+          memorySwapMax: flags.memorySwapMax
         });
 
         console.log(`✓ Service "${res.name}" created at ${res.unitPath}`);
@@ -260,91 +426,228 @@ export async function runCli(argv = process.argv.slice(2)) {
         break;
       }
 
+      case 'limits': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup limits api --memory-high 400M --memory-max 512M');
+        }
+        const info = await setServiceLimits(nameArg, {
+          memoryHigh: flags.memoryHigh,
+          memoryMax: flags.memoryMax,
+          memorySwapMax: flags.memorySwapMax,
+          resetMemory: flags.resetMemory
+        });
+        console.log(`✓ Service "${info.name}" limits updated.`);
+        console.log(`Memory High: ${info.memoryHigh}`);
+        console.log(`Memory Max: ${info.memoryMax}`);
+        console.log(`Swap Max: ${info.memorySwapMax}`);
+        break;
+      }
+
       case 'start': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup start api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup start api or unitup start @myproject');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await startService(name, flags.enable);
+          console.log(`✓ Service "${sanitizeServiceName(name)}" ${flags.enable ? 'enabled & ' : ''}started.`);
         }
-        await startService(name, flags.enable);
-        console.log(`✓ Service "${sanitizeServiceName(name)}" ${flags.enable ? 'enabled & ' : ''}started.`);
         break;
       }
 
       case 'stop': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup stop api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup stop api or unitup stop @myproject');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await stopService(name);
+          console.log(`✓ Service "${sanitizeServiceName(name)}" stopped.`);
         }
-        await stopService(name);
-        console.log(`✓ Service "${sanitizeServiceName(name)}" stopped.`);
         break;
       }
 
       case 'restart': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup restart api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup restart api or unitup restart @myproject');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await restartService(name);
+          console.log(`✓ Service "${sanitizeServiceName(name)}" restarted.`);
         }
-        await restartService(name);
-        console.log(`✓ Service "${sanitizeServiceName(name)}" restarted.`);
         break;
       }
 
       case 'status': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup status api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup status api or unitup status @myproject');
         }
 
-        if (flags.raw) {
-          const raw = await getServiceStatusRaw(name);
-          console.log(raw);
-        } else {
-          const status = await getServiceStatus(name);
-          console.log(`${status.name}\n`);
-          console.log(`Status: ${status.status}`);
-          console.log(`PID: ${status.pid}`);
-          console.log(`Started: ${status.started}`);
-          console.log(`Restarts: ${status.restarts}`);
-          console.log(`Script: ${status.script}`);
-          console.log(`Working directory: ${status.cwd}`);
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          if (flags.raw) {
+            const raw = await getServiceStatusRaw(name);
+            console.log(raw);
+          } else {
+            const status = await getServiceStatus(name);
+            console.log(`${status.name}\n`);
+            console.log(`Status: ${status.status}`);
+            console.log(`PID: ${status.pid}`);
+            console.log(`Started: ${status.started}`);
+            console.log(`Restarts: ${status.restarts}`);
+            console.log(`Command: ${status.command}`);
+            console.log(`Arguments: ${status.arguments}`);
+            console.log(`Working directory: ${status.cwd}`);
+            console.log(`Memory: ${status.memory}`);
+            console.log(`Memory Peak: ${status.memoryPeak}`);
+            console.log(`Memory High: ${status.memoryHigh}`);
+            console.log(`Memory Max: ${status.memoryMax}`);
+            console.log(`Swap Max: ${status.memorySwapMax}`);
+          }
         }
         break;
       }
 
       case 'logs': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup logs api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup logs api or unitup logs @myproject');
         }
-        const output = await runJournalctlLogs(name, {
-          follow: flags.follow,
-          lines: flags.lines,
-          cat: flags.cat,
-          output: flags.output
-        });
-        if (typeof output === 'string') {
-          console.log(output);
+
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          if (targetNames.length > 1) {
+            console.log(`=== Logs for ${name} ===`);
+          }
+          const output = await runJournalctlLogs(name, {
+            follow: flags.follow,
+            lines: flags.lines,
+            cat: flags.cat,
+            output: flags.output,
+            since: flags.since,
+            until: flags.until,
+            priority: flags.priority,
+            grep: flags.grep,
+            boot: flags.boot,
+            json: flags.json,
+            diskUsage: flags.diskUsage
+          });
+          if (typeof output === 'string') {
+            console.log(output);
+          }
         }
         break;
       }
 
+      case 'journal': {
+        const action = positionals[0];
+        if (!action) {
+          throw new Error('Journal action is required (disk-usage, rotate, vacuum).\nExample: unitup journal vacuum --size 500M');
+        }
+
+        if (action === 'vacuum' && !flags.yes && !flags.dryRun) {
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          const answer = await new Promise((resolve) => {
+            rl.question('This operation affects archived journal logs system-wide,\nnot only services managed by unitup.\n\nContinue? [y/N] ', (ans) => {
+              rl.close();
+              resolve(ans.trim());
+            });
+          });
+          if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+            console.log('Aborted.');
+            break;
+          }
+        }
+
+        const result = await executeJournalctlMaintenance(action, {
+          size: flags.size,
+          time: flags.time,
+          files: flags.files,
+          yes: flags.yes,
+          dryRun: flags.dryRun
+        });
+        console.log(result);
+        break;
+      }
+
       case 'remove': {
-        const name = positionals[0];
-        if (!name) {
-          throw new Error('Service name is required.\nExample: unitup remove api');
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup remove api or unitup remove @myproject');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await removeService(name);
+          console.log(`✓ Service "${sanitizeServiceName(name)}" removed.`);
         }
-        await removeService(name);
-        console.log(`✓ Service "${sanitizeServiceName(name)}" removed.`);
         break;
       }
 
+      case 'ls':
       case 'list': {
-        const services = await listServices();
+        const services = await listServices({ group: flags.group });
+        if (services.length === 0) {
+          if (flags.group) {
+            console.log(`No services found in group "${flags.group}".`);
+          } else {
+            console.log('No unitup user services found.');
+          }
+          break;
+        }
+
         const table = formatTable(services, [
           { key: 'name', label: 'NAME' },
+          { key: 'runtime', label: 'RUNTIME' },
+          { key: 'status', label: 'STATUS' },
+          { key: 'pid', label: 'PID' },
+          { key: 'command', label: 'COMMAND' }
+        ]);
+        console.log(table);
+        break;
+      }
+
+      case 'inspect': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup inspect api');
+        }
+        const info = await inspectService(nameArg);
+        console.log(`Name: ${info.name}`);
+        console.log(`Runtime: ${info.runtime}`);
+        console.log(`Group: ${info.group}`);
+        console.log(`Status: ${info.status}`);
+        console.log(`Command: ${info.command}`);
+        console.log(`Arguments: ${info.arguments}`);
+        console.log(`Working directory: ${info.cwd}`);
+        console.log(`Unit: ${info.unit}`);
+        console.log(`Memory: ${info.memory}`);
+        console.log(`Memory Peak: ${info.memoryPeak}`);
+        console.log(`Memory High: ${info.memoryHigh}`);
+        console.log(`Memory Max: ${info.memoryMax}`);
+        console.log(`Swap Max: ${info.memorySwapMax}`);
+        break;
+      }
+
+      case 'failures': {
+        const failures = await getServiceFailures();
+        if (failures.length === 0) {
+          console.log('✓ No failed services.');
+          break;
+        }
+
+        const table = formatTable(failures, [
+          { key: 'name', label: 'NAME' },
+          { key: 'group', label: 'GROUP' },
           { key: 'status', label: 'STATUS' },
-          { key: 'enabled', label: 'ENABLED' }
+          { key: 'exitCode', label: 'EXIT_CODE' },
+          { key: 'restarts', label: 'RESTARTS' },
+          { key: 'uptime', label: 'UPTIME' }
         ]);
         console.log(table);
         break;