unitup 0.0.9 → 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,
@@ -16,7 +17,9 @@ import {
   findNodeExecutable,
   getServicesByGroup,
   inspectService,
-  getServiceFailures
+  getServiceFailures,
+  setServiceLimits,
+  executeJournalctlMaintenance
 } from './systemd.js';
 import { sanitizeServiceName, formatTable } from './utils.js';
 
@@ -32,6 +35,9 @@ export function parseArgs(argv) {
     flags: {
       name: '',
       group: '',
+      runtime: '',
+      runtimeArgs: [],
+      command: '',
       node: '',
       cwd: '',
       env: [],
@@ -46,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
     }
   };
 
@@ -60,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;
@@ -135,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;
@@ -153,11 +271,11 @@ 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 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
@@ -169,23 +287,23 @@ Usage:
   unitup list / unitup ls       List all services (--group <group>)
 
 Add Options:
-  --name <name>       Service name (default: script name)
-  --group <group>     Assign service to a group (default: default)
-  --node <path>       Custom Node.js executable path
-  --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 --group myproject --start
-  unitup list --group myproject
-  unitup start @myproject
-  unitup inspect api
-  unitup failures
-  unitup remove @myproject
+  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
 `);
 }
 
@@ -235,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 = {};
@@ -270,13 +402,19 @@ export async function runCli(argv = process.argv.slice(2)) {
           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}`);
@@ -288,6 +426,24 @@ 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 nameArg = positionals[0];
         if (!nameArg) {
@@ -345,8 +501,14 @@ export async function runCli(argv = process.argv.slice(2)) {
             console.log(`PID: ${status.pid}`);
             console.log(`Started: ${status.started}`);
             console.log(`Restarts: ${status.restarts}`);
-            console.log(`Script: ${status.script}`);
+            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;
@@ -367,7 +529,14 @@ export async function runCli(argv = process.argv.slice(2)) {
             follow: flags.follow,
             lines: flags.lines,
             cat: flags.cat,
-            output: flags.output
+            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);
@@ -376,6 +545,37 @@ export async function runCli(argv = process.argv.slice(2)) {
         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 nameArg = positionals[0];
         if (!nameArg) {
@@ -403,11 +603,10 @@ export async function runCli(argv = process.argv.slice(2)) {
 
         const table = formatTable(services, [
           { key: 'name', label: 'NAME' },
-          { key: 'group', label: 'GROUP' },
+          { key: 'runtime', label: 'RUNTIME' },
           { key: 'status', label: 'STATUS' },
           { key: 'pid', label: 'PID' },
-          { key: 'uptime', label: 'UPTIME' },
-          { key: 'restarts', label: 'RESTARTS' }
+          { key: 'command', label: 'COMMAND' }
         ]);
         console.log(table);
         break;
@@ -419,17 +618,19 @@ export async function runCli(argv = process.argv.slice(2)) {
           throw new Error('Service name is required.\nExample: unitup inspect api');
         }
         const info = await inspectService(nameArg);
-        console.log(`App: ${info.name}`);
+        console.log(`Name: ${info.name}`);
+        console.log(`Runtime: ${info.runtime}`);
         console.log(`Group: ${info.group}`);
-        console.log(`Status: ${info.status} (${info.activeState}/${info.subState})`);
-        console.log(`PID: ${info.pid}`);
-        console.log(`Restarts: ${info.restarts}`);
-        console.log(`Uptime: ${info.started}`);
-        console.log(`Script: ${info.script}`);
+        console.log(`Status: ${info.status}`);
+        console.log(`Command: ${info.command}`);
+        console.log(`Arguments: ${info.arguments}`);
         console.log(`Working directory: ${info.cwd}`);
-        console.log(`Node path: ${info.node}`);
-        console.log(`Unit file: ${info.unit}`);
-        console.log(`Unit path: ${info.unitPath}`);
+        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;
       }
 

package/src/doctor.js

@@ -9,6 +9,7 @@ import {
   checkNodeDiagnostics
 } from './systemd.js';
 import { getUserUnitDir } from './unit.js';
+import { findRuntimeExecutable } from './runtimes/common.js';
 
 /**
  * Runs system diagnostic checks and returns structured data.
@@ -24,14 +25,54 @@ export async function getDoctorInfo() {
   const lingering = await checkUserLinger();
   const nodeDiag = await checkNodeDiagnostics();
 
+  const nodePath = nodeDiag.execPath || (await findRuntimeExecutable(['node']));
+  const pythonPath = await findRuntimeExecutable(['python3', 'python']);
+  const rubyPath = await findRuntimeExecutable(['ruby']);
+  const phpPath = await findRuntimeExecutable(['php']);
+  const bunPath = await findRuntimeExecutable(['bun']);
+  const denoPath = await findRuntimeExecutable(['deno']);
+  const goPath = await findRuntimeExecutable(['go']);
+  const elixirPath = await findRuntimeExecutable(['elixir']);
+
+  const runtimes = {
+    'Node.js': nodePath,
+    'Python': pythonPath,
+    'Ruby': rubyPath,
+    'PHP': phpPath,
+    'Bun': bunPath,
+    'Deno': denoPath,
+    'Go': goPath,
+    'Elixir': elixirPath
+  };
+
+  let cgroupV2 = false;
+  let memoryController = false;
+  try {
+    if (fs.existsSync('/sys/fs/cgroup/cgroup.controllers')) {
+      cgroupV2 = true;
+      const controllers = fs.readFileSync('/sys/fs/cgroup/cgroup.controllers', 'utf8');
+      memoryController = controllers.includes('memory');
+    }
+  } catch {
+    // ignore
+  }
+
+  const memoryMaxSupported = linux && (cgroupV2 || userSystemd);
+  const memorySwapMaxSupported = linux && cgroupV2 && memoryController;
+
   return {
     linux,
     systemctl,
     systemdRunning: pid1,
     userSystemdAvailable: userSystemd,
+    cgroupV2,
+    memoryController,
+    memoryMaxSupported,
+    memorySwapMaxSupported,
     nodeDiag,
-    nodePath: nodeDiag.execPath || process.execPath,
+    nodePath: nodePath || process.execPath,
     nodeVersion: nodeDiag.version,
+    runtimes,
     unitDir: getUserUnitDir(),
     unitDirWritable,
     lingering,
@@ -71,24 +112,42 @@ export async function runDoctor() {
     console.log('! systemd user services unavailable');
   }
 
-  const n = info.nodeDiag;
-  if (n.found && n.executable) {
-    console.log(`✓ Node.js: ${n.execPath}`);
-    if (n.version) {
-      console.log(`✓ Node version: ${n.version}`);
-    }
-    if (n.inPath) {
-      console.log('✓ PATH includes node');
+  console.log('\nDetected runtimes:');
+  for (const [name, path] of Object.entries(info.runtimes)) {
+    if (path) {
+      console.log(`✓ ${name}: ${path}`);
     } else {
-      console.log('! node is not in standard PATH');
+      console.log(`- ${name}: not found`);
     }
+  }
+
+  console.log('\nMemory Controller Diagnostics:');
+  if (info.cgroupV2) {
+    console.log('✓ cgroup v2 detected');
   } else {
-    console.log(`✗ ${n.error || 'Node.js executable could not be resolved'}`);
-    if (n.solution) {
-      console.log(`\n${n.solution}\n`);
-    }
+    console.log('- cgroup v2 unavailable');
   }
 
+  if (info.memoryController) {
+    console.log('✓ Memory controller available');
+  } else {
+    console.log('- Memory controller unavailable');
+  }
+
+  if (info.memoryMaxSupported) {
+    console.log('✓ MemoryMax supported');
+  } else {
+    console.log('- MemoryMax unavailable');
+  }
+
+  if (info.memorySwapMaxSupported) {
+    console.log('✓ MemorySwapMax supported');
+  } else {
+    console.log('- MemorySwapMax unavailable');
+  }
+
+  console.log('');
+
   if (info.unitDirWritable) {
     console.log('✓ Unit directory writable');
   } else {

package/src/index.js

@@ -11,6 +11,8 @@ import {
   getServiceFailures,
   getServicesByGroup,
   runJournalctlLogs,
+  setServiceLimits,
+  executeJournalctlMaintenance,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
@@ -35,8 +37,11 @@ import {
   readAppMetadata,
   getAppMetadataPath,
   getAppsDir,
-  getUnitupDir
+  getUnitupDir,
+  validateMemorySize,
+  formatMemoryBytes
 } from './utils.js';
+import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
 
 export {
   // Main programmatic service management API
@@ -52,8 +57,18 @@ export {
   inspectService,
   getServiceFailures,
   getServicesByGroup,
+  setServiceLimits,
+  executeJournalctlMaintenance as executeJournalctlMaintenance,
   runJournalctlLogs as getServiceLogs,
 
+  // Memory & Validation helpers
+  validateMemorySize,
+  formatMemoryBytes,
+
+  // Runtime detection & resolution
+  detectRuntime,
+  resolveRuntimeConfig,
+
   // Metadata helpers
   readAppMetadata,
   getAppMetadataPath,

package/src/runtimes/bun.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createBunAdapter(opts = {}) {
+  const customPath = opts.command;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['bun']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Bun runtime could not be found.\n\nInstall Bun or specify its path:\n  unitup add server.ts --command /usr/bin/bun'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '-v');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'bun',
+    version
+  };
+}