unitup 0.0.9 → 0.0.11

package/src/systemd.js

@@ -264,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) {
@@ -278,7 +280,36 @@ export async function resetFailed() {
 
 export async function addService(opts) {
   const safeName = sanitizeServiceName(opts.name);
-  const { path: unitPath } = writeUnitFile({ ...opts, name: safeName });
+
+  if (unitFileExists(safeName)) {
+    try {
+      const show = await getServiceShow(safeName);
+      if (show.ActiveState === 'active') {
+        if (!opts.force) {
+          throw new Error(
+            `Service "${safeName}" is currently running.\n` +
+            `Use --force (-f) to overwrite running services, or stop it first:\n` +
+            `  unitup stop ${safeName}`
+          );
+        }
+      }
+    } catch (err) {
+      if (err.message.includes('currently running')) {
+        throw err;
+      }
+    }
+  }
+
+  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();
 
@@ -365,14 +396,16 @@ export async function restartService(name) {
   return true;
 }
 
-export async function removeService(name) {
+export async function removeService(name, opts = {}) {
+  const force = typeof opts === 'boolean' ? opts : !!opts?.force;
+
   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);
+      await removeService(s, { force });
     }
     return true;
   }
@@ -382,6 +415,23 @@ export async function removeService(name) {
     throw new Error(`Service "${safeName}" does not exist.`);
   }
 
+  try {
+    const show = await getServiceShow(safeName);
+    if (show.ActiveState === 'active') {
+      if (!force) {
+        throw new Error(
+          `Service "${safeName}" is currently running.\n` +
+          `Use --force (-f) to remove running services, or stop it first:\n` +
+          `  unitup stop ${safeName}`
+        );
+      }
+    }
+  } catch (err) {
+    if (err.message.includes('currently running')) {
+      throw err;
+    }
+  }
+
   // Attempt disable and stop
   await runCommand('systemctl', ['--user', 'disable', '--now', getUnitFilename(safeName)]);
 
@@ -431,11 +481,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 {
@@ -465,6 +516,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),
@@ -475,8 +537,16 @@ export async function getServiceStatus(name) {
     restarts,
     started,
     startedRaw,
+    command,
+    arguments: argsList.join(' '),
+    args: argsList,
     script,
-    cwd
+    cwd,
+    memory: memoryCurrent,
+    memoryPeak,
+    memoryHigh,
+    memoryMax,
+    memorySwapMax
   };
 }
 
@@ -504,11 +574,29 @@ export async function listServices(filterOpts = {}) {
   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';
@@ -536,20 +624,24 @@ export async function listServices(filterOpts = {}) {
 
       result.push({
         name: unit.name,
+        runtime,
         group,
         status,
         enabled,
         pid,
+        command: commandSummary,
         uptime,
         restarts
       });
     } catch {
       result.push({
         name: unit.name,
+        runtime,
         group,
         status: 'unknown',
         enabled: 'unknown',
         pid: '-',
+        command: commandSummary,
         uptime: 'never',
         restarts: '0'
       });
@@ -568,20 +660,33 @@ export async function inspectService(name) {
   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,
-    unit: getUnitFilename(safeName),
-    unitPath: getUnitPath(safeName),
-    group: meta?.group || 'default',
-    script: meta?.script || statusObj.script,
-    cwd: meta?.cwd || statusObj.cwd,
-    node: meta?.node || process.execPath,
+    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
+    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
   };
 }
 
@@ -610,6 +715,15 @@ export async function getServiceFailures() {
 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 = [
@@ -640,19 +754,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 {
@@ -660,15 +782,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();
+}

package/src/unit.js

@@ -52,31 +52,41 @@ export function unitFileExists(name) {
  *
  * @param {Object} opts
  * @param {string} opts.name - Service name
- * @param {string} opts.script - Absolute path to script
+ * @param {string} [opts.command] - Absolute path to binary executable
+ * @param {Array<string>} [opts.args] - Command arguments
+ * @param {string} [opts.script] - Absolute path to script (legacy support)
  * @param {string} [opts.cwd] - Working directory path
- * @param {string} [opts.nodePath] - Absolute path to Node executable
+ * @param {string} [opts.nodePath] - Absolute path to Node executable (legacy support)
  * @param {Record<string, string>} [opts.env] - Environment variables object
  * @param {string} [opts.envFile] - Path to environment file
  * @param {string} [opts.restart] - Restart policy (default: 'on-failure')
- * @param {Array<string>} [opts.args] - Extra script arguments
  * @returns {string}
  */
 export function generateUnitContent(opts) {
   const safeName = sanitizeServiceName(opts.name);
-  const scriptPath = resolveAbsolutePath(opts.script);
-  const cwd = opts.cwd ? resolveAbsolutePath(opts.cwd) : path.dirname(scriptPath);
-  const nodeExec = opts.nodePath ? resolveAbsolutePath(opts.nodePath) : process.execPath;
-  const restartPolicy = opts.restart || 'on-failure';
+  let commandExec = '';
+  let execArgs = [];
 
-  const execArgs = [nodeExec, scriptPath];
-  if (Array.isArray(opts.args) && opts.args.length > 0) {
-    execArgs.push(...opts.args);
+  if (opts.command) {
+    commandExec = resolveAbsolutePath(opts.command);
+    execArgs = Array.isArray(opts.args) ? [...opts.args] : [];
+  } else if (opts.script) {
+    const scriptPath = resolveAbsolutePath(opts.script);
+    commandExec = opts.nodePath ? resolveAbsolutePath(opts.nodePath) : process.execPath;
+    execArgs = [scriptPath, ...(Array.isArray(opts.args) ? opts.args : [])];
+  } else {
+    throw new Error('Either "command" or "script" must be provided to generate systemd unit file.');
   }
 
-  const execStartLine = execArgs.map(escapeExecArg).join(' ');
+  const scriptOrCmdPath = opts.script ? resolveAbsolutePath(opts.script) : (execArgs[0] && (execArgs[0].startsWith('/') || execArgs[0].startsWith('./')) ? resolveAbsolutePath(execArgs[0]) : commandExec);
+  const cwd = opts.cwd ? resolveAbsolutePath(opts.cwd) : path.dirname(scriptOrCmdPath || commandExec);
+  const restartPolicy = opts.restart || 'on-failure';
+
+  const execStartTokens = [commandExec, ...execArgs];
+  const execStartLine = execStartTokens.map(escapeExecArg).join(' ');
 
-  const nodeBinDir = path.dirname(nodeExec);
-  const defaultPath = [nodeBinDir, '/usr/local/bin', '/usr/bin', '/bin']
+  const binDir = path.dirname(commandExec);
+  const defaultPath = [binDir, '/usr/local/bin', '/usr/bin', '/bin']
     .filter((p, i, self) => p && self.indexOf(p) === i)
     .join(':');
 
@@ -96,6 +106,17 @@ export function generateUnitContent(opts) {
     'StandardError=journal'
   ];
 
+  const memHigh = opts.memoryHigh || opts.resources?.memoryHigh;
+  const memMax = opts.memoryMax || opts.resources?.memoryMax;
+  const memSwapMax = opts.memorySwapMax || opts.resources?.memorySwapMax;
+
+  if (memHigh || memMax || memSwapMax) {
+    serviceLines.push('MemoryAccounting=yes');
+    if (memHigh) serviceLines.push(`MemoryHigh=${memHigh}`);
+    if (memMax) serviceLines.push(`MemoryMax=${memMax}`);
+    if (memSwapMax) serviceLines.push(`MemorySwapMax=${memSwapMax}`);
+  }
+
   const envObj = opts.env && typeof opts.env === 'object' ? { ...opts.env } : {};
   if (!envObj.PATH) {
     envObj.PATH = defaultPath;
@@ -136,9 +157,16 @@ export function writeUnitFile(opts) {
   saveAppMetadata({
     name: safeName,
     group: opts.group || 'default',
+    runtime: opts.runtime || 'node',
+    command: opts.command,
+    args: opts.args,
     script: opts.script,
     cwd: opts.cwd,
-    node: opts.nodePath
+    node: opts.nodePath,
+    memoryHigh: opts.memoryHigh || opts.resources?.memoryHigh,
+    memoryMax: opts.memoryMax || opts.resources?.memoryMax,
+    memorySwapMax: opts.memorySwapMax || opts.resources?.memorySwapMax,
+    resources: opts.resources
   });
 
   return { path: unitPath, content };
@@ -190,10 +218,10 @@ export function listUnitFiles() {
 }
 
 /**
- * Parses basic information (Script, WorkingDirectory) from a unit file content.
+ * Parses basic information (Command, Arguments, Script, WorkingDirectory) from a unit file content.
  *
  * @param {string} content
- * @returns {{ script?: string, cwd?: string, restart?: string }}
+ * @returns {{ command?: string, args?: string[], script?: string, cwd?: string, restart?: string }}
  */
 export function parseUnitContent(content) {
   const result = {};
@@ -206,15 +234,25 @@ export function parseUnitContent(content) {
       result.cwd = trimmed.slice(17).trim();
     } else if (trimmed.startsWith('ExecStart=')) {
       const execVal = trimmed.slice(10).trim();
-      // Extract script from ExecStart (usually second token if node executable is first)
       const parts = execVal.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
-      if (parts.length >= 2) {
-        result.script = parts[1].replace(/^"|"$/g, '');
-      } else if (parts.length === 1) {
-        result.script = parts[0].replace(/^"|"$/g, '');
+      const cleanParts = parts.map(p => p.replace(/^"|"$/g, ''));
+      if (cleanParts.length > 0) {
+        result.command = cleanParts[0];
+        result.args = cleanParts.slice(1);
+        if (cleanParts.length >= 2) {
+          result.script = cleanParts[1];
+        } else {
+          result.script = cleanParts[0];
+        }
       }
     } else if (trimmed.startsWith('Restart=')) {
       result.restart = trimmed.slice(8).trim();
+    } else if (trimmed.startsWith('MemoryHigh=')) {
+      result.memoryHigh = trimmed.slice(11).trim();
+    } else if (trimmed.startsWith('MemoryMax=')) {
+      result.memoryMax = trimmed.slice(10).trim();
+    } else if (trimmed.startsWith('MemorySwapMax=')) {
+      result.memorySwapMax = trimmed.slice(14).trim();
     }
   }