unitup 0.0.8 → 0.0.10

package/src/runtimes/php.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createPhpAdapter(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(['php']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'PHP runtime could not be found.\n\nInstall PHP or specify its path:\n  unitup add index.php --command /usr/bin/php'
+    );
+  }
+
+  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: 'php',
+    version
+  };
+}

package/src/runtimes/python.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createPythonAdapter(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(['python3', 'python']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Python runtime could not be found.\n\nInstall Python or specify its path:\n  unitup add worker.py --command /usr/bin/python3'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '--version');
+  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: 'python',
+    version
+  };
+}

package/src/runtimes/ruby.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createRubyAdapter(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(['ruby']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Ruby runtime could not be found.\n\nInstall Ruby or specify its path:\n  unitup add app.rb --command /usr/bin/ruby'
+    );
+  }
+
+  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: 'ruby',
+    version
+  };
+}

package/src/runtimes/shell.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createShellAdapter(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(['bash', 'sh']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Shell runtime could not be found.\n\nInstall bash/sh or specify its path:\n  unitup add script.sh --command /bin/bash'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '--version');
+  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: 'shell',
+    version
+  };
+}

package/src/systemd.js

@@ -5,7 +5,8 @@ import path from 'node:path';
 import {
   sanitizeServiceName,
   getUnitFilename,
-  formatRelativeTime
+  formatRelativeTime,
+  readAppMetadata
 } from './utils.js';
 import {
   getUserUnitDir,
@@ -263,6 +264,8 @@ export async function checkUserLinger() {
 // Systemd Operations
 // ---------------------------------------------------------------------------
 
+import { resolveRuntimeConfig } from './runtimes/index.js';
+
 export async function daemonReload() {
   const res = await runCommand('systemctl', ['--user', 'daemon-reload']);
   if (res.code !== 0) {
@@ -277,7 +280,16 @@ export async function resetFailed() {
 
 export async function addService(opts) {
   const safeName = sanitizeServiceName(opts.name);
-  const { path: unitPath } = writeUnitFile({ ...opts, name: safeName });
+  const runtimeConfig = await resolveRuntimeConfig({ ...opts, name: safeName });
+
+  const { path: unitPath } = writeUnitFile({
+    ...opts,
+    name: safeName,
+    runtime: runtimeConfig.runtime,
+    command: runtimeConfig.command,
+    args: runtimeConfig.args,
+    cwd: opts.cwd
+  });
 
   await daemonReload();
 
@@ -289,6 +301,17 @@ export async function addService(opts) {
 }
 
 export async function startService(name, enable = false) {
+  if (name && typeof name === 'string' && name.startsWith('@')) {
+    const list = await getServicesByGroup(name);
+    if (list.length === 0) {
+      throw new Error(`No services found in group "${name}".`);
+    }
+    for (const s of list) {
+      await startService(s, enable);
+    }
+    return true;
+  }
+
   const safeName = sanitizeServiceName(name);
   if (!unitFileExists(safeName)) {
     throw new Error(`Service "${safeName}" does not exist.\nCreate it with: unitup add <script> --name ${safeName}`);
@@ -306,6 +329,17 @@ export async function startService(name, enable = false) {
 }
 
 export async function stopService(name) {
+  if (name && typeof name === 'string' && name.startsWith('@')) {
+    const list = await getServicesByGroup(name);
+    if (list.length === 0) {
+      throw new Error(`No services found in group "${name}".`);
+    }
+    for (const s of list) {
+      await stopService(s);
+    }
+    return true;
+  }
+
   const safeName = sanitizeServiceName(name);
   if (!unitFileExists(safeName)) {
     throw new Error(`Service "${safeName}" does not exist.`);
@@ -319,6 +353,17 @@ export async function stopService(name) {
 }
 
 export async function restartService(name) {
+  if (name && typeof name === 'string' && name.startsWith('@')) {
+    const list = await getServicesByGroup(name);
+    if (list.length === 0) {
+      throw new Error(`No services found in group "${name}".`);
+    }
+    for (const s of list) {
+      await restartService(s);
+    }
+    return true;
+  }
+
   const safeName = sanitizeServiceName(name);
   if (!unitFileExists(safeName)) {
     throw new Error(`Service "${safeName}" does not exist.`);
@@ -332,6 +377,17 @@ export async function restartService(name) {
 }
 
 export async function removeService(name) {
+  if (name && typeof name === 'string' && name.startsWith('@')) {
+    const list = await getServicesByGroup(name);
+    if (list.length === 0) {
+      throw new Error(`No services found in group "${name}".`);
+    }
+    for (const s of list) {
+      await removeService(s);
+    }
+    return true;
+  }
+
   const safeName = sanitizeServiceName(name);
   if (!unitFileExists(safeName)) {
     throw new Error(`Service "${safeName}" does not exist.`);
@@ -386,11 +442,12 @@ export async function getServiceStatus(name) {
   // Read unit file content for script and working dir
   let script = 'unknown';
   let cwd = 'unknown';
+  let parsed = {};
 
   const unitPath = getUnitPath(safeName);
   try {
     const content = fs.readFileSync(unitPath, 'utf8');
-    const parsed = parseUnitContent(content);
+    parsed = parseUnitContent(content);
     if (parsed.script) script = parsed.script;
     if (parsed.cwd) cwd = parsed.cwd;
   } catch {
@@ -420,6 +477,17 @@ export async function getServiceStatus(name) {
     ? formatRelativeTime(startedRaw)
     : 'never';
 
+  const meta = readAppMetadata(safeName);
+  const command = meta?.command || parsed.command || meta?.node || process.execPath;
+  const argsList = meta?.args || (parsed.script ? [parsed.script] : []);
+
+  const { formatMemoryBytes } = await import('./utils.js');
+  const memoryCurrent = formatMemoryBytes(show.MemoryCurrent);
+  const memoryPeak = formatMemoryBytes(show.MemoryPeak);
+  const memoryHigh = formatMemoryBytes(show.MemoryHigh || meta?.resources?.memoryHigh || parsed.memoryHigh);
+  const memoryMax = formatMemoryBytes(show.MemoryMax || meta?.resources?.memoryMax || parsed.memoryMax);
+  const memorySwapMax = formatMemoryBytes(show.MemorySwapMax || meta?.resources?.memorySwapMax || parsed.memorySwapMax);
+
   return {
     name: safeName,
     unitFile: getUnitFilename(safeName),
@@ -430,16 +498,66 @@ export async function getServiceStatus(name) {
     restarts,
     started,
     startedRaw,
+    command,
+    arguments: argsList.join(' '),
+    args: argsList,
     script,
-    cwd
+    cwd,
+    memory: memoryCurrent,
+    memoryPeak,
+    memoryHigh,
+    memoryMax,
+    memorySwapMax
   };
 }
 
-export async function listServices() {
+export async function getServicesByGroup(groupName) {
+  const cleanGroup = groupName.startsWith('@') ? groupName.slice(1) : groupName;
+  const units = listUnitFiles();
+  const matched = [];
+  for (const unit of units) {
+    const meta = readAppMetadata(unit.name);
+    const itemGroup = meta?.group || 'default';
+    if (itemGroup.toLowerCase() === cleanGroup.toLowerCase()) {
+      matched.push(unit.name);
+    }
+  }
+  return matched;
+}
+
+export async function listServices(filterOpts = {}) {
   const units = listUnitFiles();
   const result = [];
+  const targetGroup = filterOpts.group
+    ? (filterOpts.group.startsWith('@') ? filterOpts.group.slice(1) : filterOpts.group).toLowerCase()
+    : null;
 
   for (const unit of units) {
+    const meta = readAppMetadata(unit.name);
+    const group = meta?.group || 'default';
+    const runtime = meta?.runtime || 'node';
+
+    if (targetGroup && group.toLowerCase() !== targetGroup) {
+      continue;
+    }
+
+    let commandSummary = '';
+    if (meta?.command) {
+      if (runtime === 'native') {
+        commandSummary = './' + path.basename(meta.command);
+      } else {
+        const cmdBase = path.basename(meta.command);
+        const argsStr = (meta.args || [])
+          .map(a => (a.startsWith('/') || a.startsWith('./') ? path.basename(a) : a))
+          .join(' ');
+        commandSummary = (cmdBase + (argsStr ? ' ' + argsStr : '')).trim();
+      }
+    } else if (meta?.script) {
+      commandSummary = `node ${path.basename(meta.script)}`;
+    } else {
+      commandSummary = 'unknown';
+    }
+
     try {
       const show = await getServiceShow(unit.name);
       const activeState = show.ActiveState || 'inactive';
@@ -458,17 +576,35 @@ export async function listServices() {
       }
 
       const enabled = unitFileState.startsWith('enabled') ? 'yes' : 'no';
+      const pid = show.MainPID && show.MainPID !== '0' ? show.MainPID : '-';
+      const restarts = show.NRestarts ?? '0';
+      const startedRaw = show.ActiveEnterTimestamp;
+      const uptime = startedRaw && startedRaw !== '0' && startedRaw !== 'n/a'
+        ? formatRelativeTime(startedRaw)
+        : 'never';
 
       result.push({
         name: unit.name,
+        runtime,
+        group,
         status,
-        enabled
+        enabled,
+        pid,
+        command: commandSummary,
+        uptime,
+        restarts
       });
     } catch {
       result.push({
         name: unit.name,
+        runtime,
+        group,
         status: 'unknown',
-        enabled: 'unknown'
+        enabled: 'unknown',
+        pid: '-',
+        command: commandSummary,
+        uptime: 'never',
+        restarts: '0'
       });
     }
   }
@@ -476,9 +612,79 @@ export async function listServices() {
   return result;
 }
 
+export async function inspectService(name) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  const meta = readAppMetadata(safeName);
+  const statusObj = await getServiceStatus(safeName);
+
+  const command = meta?.command || statusObj.command || statusObj.node || process.execPath;
+  const argsList = meta?.args || (statusObj.script ? [statusObj.script] : []);
+
+  return {
+    name: safeName,
+    runtime: meta?.runtime || 'node',
+    status: statusObj.status,
+    activeState: statusObj.activeState,
+    subState: statusObj.subState,
+    command,
+    arguments: argsList.join(' '),
+    args: argsList,
+    cwd: meta?.cwd || statusObj.cwd,
+    unit: getUnitFilename(safeName),
+    unitPath: getUnitPath(safeName),
+    group: meta?.group || 'default',
+    pid: statusObj.pid,
+    restarts: statusObj.restarts,
+    started: statusObj.started,
+    memory: statusObj.memory,
+    memoryPeak: statusObj.memoryPeak,
+    memoryHigh: statusObj.memoryHigh,
+    memoryMax: statusObj.memoryMax,
+    memorySwapMax: statusObj.memorySwapMax,
+    // Legacy fields for backward compatibility
+    script: meta?.script || statusObj.script,
+    node: meta?.node || command
+  };
+}
+
+export async function getServiceFailures() {
+  const allServices = await listServices();
+  const failures = [];
+
+  for (const item of allServices) {
+    if (item.status === 'failed') {
+      const show = await getServiceShow(item.name);
+      const exitCode = show.ExecMainStatus || show.ExecMainCode || '1';
+      failures.push({
+        name: item.name,
+        group: item.group,
+        status: 'failed',
+        exitCode: String(exitCode),
+        restarts: item.restarts,
+        uptime: item.uptime
+      });
+    }
+  }
+
+  return failures;
+}
+
 export async function runJournalctlLogs(name, opts = {}) {
   const safeName = sanitizeServiceName(name);
   const unitFilename = getUnitFilename(safeName);
+
+  if (opts.diskUsage) {
+    const res = await runCommand('journalctl', ['--disk-usage']);
+    if (res.code !== 0 && (res.stderr.toLowerCase().includes('permission') || res.stderr.toLowerCase().includes('root'))) {
+      throw new Error('Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.');
+    }
+    return res.stdout || res.stderr;
+  }
+
   const syslogId = `unitup-${safeName}`;
 
   const candidateArgSets = [
@@ -509,19 +715,27 @@ export async function runJournalctlLogs(name, opts = {}) {
   }
 
   const workingCandidate = chosenCandidate || ['--user', '-u', unitFilename];
+  const filterArgs = [...workingCandidate];
+
+  if (opts.since) filterArgs.push(`--since=${opts.since}`);
+  if (opts.until) filterArgs.push(`--until=${opts.until}`);
+  if (opts.priority) filterArgs.push(`--priority=${opts.priority}`);
+  if (opts.grep) filterArgs.push(`--grep=${opts.grep}`);
+  if (opts.boot) filterArgs.push('--boot');
+
+  if (opts.json) {
+    filterArgs.push('-o', 'json');
+  } else if (opts.cat || opts.output === 'cat') {
+    filterArgs.push('-o', 'cat');
+  } else if (opts.output) {
+    filterArgs.push('-o', opts.output);
+  }
 
   if (opts.follow) {
-    const followArgs = [...workingCandidate, '-f'];
-    if (opts.lines) {
-      followArgs.push('-n', String(opts.lines));
-    }
-    if (opts.cat || opts.output === 'cat') {
-      followArgs.push('-o', 'cat');
-    } else if (opts.output) {
-      followArgs.push('-o', opts.output);
-    }
+    filterArgs.push('-f');
+    if (opts.lines) filterArgs.push('-n', String(opts.lines));
     try {
-      const child = spawn('journalctl', followArgs, { stdio: 'inherit', shell: false });
+      const child = spawn('journalctl', filterArgs, { stdio: 'inherit', shell: false });
       child.on('error', () => {});
       return child;
     } catch {
@@ -529,15 +743,125 @@ export async function runJournalctlLogs(name, opts = {}) {
     }
   }
 
-  const staticArgs = [...workingCandidate, '--no-pager'];
-  if (opts.cat || opts.output === 'cat') {
-    staticArgs.push('-o', 'cat');
-  } else if (opts.output) {
-    staticArgs.push('-o', opts.output);
-  }
+  filterArgs.push('--no-pager');
   const lines = opts.lines ? String(opts.lines) : '100';
-  staticArgs.push('-n', lines);
+  filterArgs.push('-n', lines);
 
-  const res = await runCommand('journalctl', staticArgs);
+  const res = await runCommand('journalctl', filterArgs);
   return res.stdout || res.stderr || 'No logs found.';
 }
+
+export async function setServiceLimits(name, options = {}) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  const meta = readAppMetadata(safeName) || {};
+  const { validateMemorySize } = await import('./utils.js');
+
+  let memoryHigh = options.memoryHigh;
+  let memoryMax = options.memoryMax;
+  let memorySwapMax = options.memorySwapMax;
+
+  const resources = { ...(meta.resources || {}) };
+
+  if (options.resetMemory) {
+    delete resources.memoryHigh;
+    delete resources.memoryMax;
+    delete resources.memorySwapMax;
+    memoryHigh = undefined;
+    memoryMax = undefined;
+    memorySwapMax = undefined;
+  } else {
+    if (memoryHigh !== undefined) {
+      memoryHigh = validateMemorySize(memoryHigh, 'MemoryHigh');
+      resources.memoryHigh = memoryHigh;
+    }
+    if (memoryMax !== undefined) {
+      memoryMax = validateMemorySize(memoryMax, 'MemoryMax');
+      resources.memoryMax = memoryMax;
+    }
+    if (memorySwapMax !== undefined) {
+      memorySwapMax = validateMemorySize(memorySwapMax, 'MemorySwapMax');
+      resources.memorySwapMax = memorySwapMax;
+    }
+  }
+
+  const updatedMeta = {
+    ...meta,
+    name: safeName,
+    resources: Object.keys(resources).length > 0 ? resources : undefined,
+    memoryHigh: resources.memoryHigh,
+    memoryMax: resources.memoryMax,
+    memorySwapMax: resources.memorySwapMax
+  };
+
+  writeUnitFile(updatedMeta);
+
+  await runCommand('systemctl', ['--user', 'daemon-reload']);
+
+  const status = await getServiceStatus(safeName);
+  if (status.status === 'running') {
+    const setPropsArgs = ['--user', 'set-property', getUnitFilename(safeName)];
+    if (options.resetMemory) {
+      setPropsArgs.push('MemoryHigh=infinity', 'MemoryMax=infinity', 'MemorySwapMax=infinity');
+    } else {
+      if (resources.memoryHigh) setPropsArgs.push(`MemoryHigh=${resources.memoryHigh}`);
+      if (resources.memoryMax) setPropsArgs.push(`MemoryMax=${resources.memoryMax}`);
+      if (resources.memorySwapMax) setPropsArgs.push(`MemorySwapMax=${resources.memorySwapMax}`);
+    }
+
+    if (setPropsArgs.length > 3) {
+      try {
+        await runCommand('systemctl', setPropsArgs);
+      } catch {
+        // Graceful fallback if runtime property setting fails
+      }
+    }
+  }
+
+  return await inspectService(safeName);
+}
+
+export async function executeJournalctlMaintenance(action, opts = {}) {
+  const args = [];
+  if (action === 'disk-usage') {
+    args.push('--disk-usage');
+  } else if (action === 'rotate') {
+    args.push('--rotate');
+  } else if (action === 'vacuum') {
+    const { validateMemorySize } = await import('./utils.js');
+    if (opts.size) {
+      const validSize = validateMemorySize(opts.size, 'Vacuum size');
+      args.push(`--vacuum-size=${validSize}`);
+    } else if (opts.time) {
+      const timeStr = String(opts.time).trim();
+      if (/[;&|$`"'\n\r\t ]/.test(timeStr)) {
+        throw new Error(`Vacuum time contains invalid characters or shell injection: "${timeStr}".`);
+      }
+      args.push(`--vacuum-time=${timeStr}`);
+    } else if (opts.files) {
+      const filesNum = parseInt(opts.files, 10);
+      if (Number.isNaN(filesNum) || filesNum <= 0) {
+        throw new Error(`Invalid vacuum files count: "${opts.files}". Must be a positive integer.`);
+      }
+      args.push(`--vacuum-files=${filesNum}`);
+    } else {
+      throw new Error('Vacuum action requires one of --size, --time, or --files.');
+    }
+  } else {
+    throw new Error(`Unknown journal maintenance action: "${action}".`);
+  }
+
+  if (opts.dryRun) {
+    return `[dry-run] Would execute: journalctl ${args.join(' ')}`;
+  }
+
+  const res = await runCommand('journalctl', args);
+  if (res.code !== 0 && (res.stderr.toLowerCase().includes('permission') || res.stderr.toLowerCase().includes('root') || res.stderr.toLowerCase().includes('access denied'))) {
+    throw new Error('Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.');
+  }
+
+  return (res.stdout || res.stderr || 'Journal maintenance completed successfully.').trim();
+}