unitup 0.0.8 → 0.0.10

package/src/unit.js

@@ -4,9 +4,12 @@ import os from 'node:os';
 import {
   sanitizeServiceName,
   getUnitFilename,
+  getServiceNameFromUnit,
   formatSystemdEnv,
   escapeExecArg,
-  resolveAbsolutePath
+  resolveAbsolutePath,
+  saveAppMetadata,
+  deleteAppMetadata
 } from './utils.js';
 
 /**
@@ -49,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(':');
 
@@ -93,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;
@@ -130,6 +154,20 @@ export function writeUnitFile(opts) {
   const content = generateUnitContent({ ...opts, name: safeName });
 
   fs.writeFileSync(unitPath, content, 'utf8');
+  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,
+    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 };
 }
@@ -141,7 +179,9 @@ export function writeUnitFile(opts) {
  * @returns {boolean} True if file existed and was removed
  */
 export function deleteUnitFile(name) {
-  const unitPath = getUnitPath(name);
+  const safeName = sanitizeServiceName(name);
+  deleteAppMetadata(safeName);
+  const unitPath = getUnitPath(safeName);
   if (fs.existsSync(unitPath)) {
     fs.unlinkSync(unitPath);
     return true;
@@ -178,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 = {};
@@ -194,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();
     }
   }
 

package/src/utils.js

@@ -1,5 +1,225 @@
 import path from 'node:path';
 import os from 'node:os';
+import fs from 'node:fs';
+
+/**
+ * Returns the base unitup config directory (~/.config/unitup).
+ * @returns {string}
+ */
+export function getUnitupDir() {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return path.join(configHome, 'unitup');
+}
+
+/**
+ * Returns the directory for app metadata (~/.config/unitup/apps).
+ * @returns {string}
+ */
+export function getAppsDir() {
+  return path.join(getUnitupDir(), 'apps');
+}
+
+/**
+ * Returns the filepath for a specific service's metadata JSON file.
+ * @param {string} name
+ * @returns {string}
+ */
+export function getAppMetadataPath(name) {
+  const safeName = sanitizeServiceName(name);
+  return path.join(getAppsDir(), `${safeName}.json`);
+}
+
+/**
+ * Validates systemd memory limit sizes (128K, 256M, 1G, 2T, infinity, max, or raw bytes).
+ * @param {string|number} val
+ * @param {string} paramName
+ * @returns {string} Normalized memory limit string
+ */
+export function validateMemorySize(val, paramName = 'Memory limit') {
+  if (val === null || val === undefined || val === '') {
+    throw new Error(`${paramName} cannot be empty.`);
+  }
+
+  const str = String(val).trim();
+
+  // Prevent shell injection and unsafe characters
+  if (/[;&|$`"'\n\r\t ]/.test(str)) {
+    throw new Error(`${paramName} contains invalid characters or shell injection attempt: "${str}".`);
+  }
+
+  // Reject negative numbers
+  if (str.startsWith('-')) {
+    throw new Error(`${paramName} cannot be negative: "${str}".`);
+  }
+
+  const lower = str.toLowerCase();
+  if (lower === 'infinity' || lower === 'max') {
+    return 'infinity';
+  }
+
+  // Matches numbers with optional K, M, G, T, P unit suffix (with optional 'b' or 'B')
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*([kmgtp]?[bb]?)?$/i);
+  if (!match) {
+    throw new Error(`Invalid ${paramName} format: "${str}". Expected values like 128K, 256M, 1G, or infinity.`);
+  }
+
+  const num = match[1];
+  const unit = (match[2] || '').toUpperCase().replace(/B$/, '');
+
+  return `${num}${unit}`;
+}
+
+/**
+ * Formats byte values or systemd memory limit markers into human readable strings.
+ * @param {number|string} bytes
+ * @returns {string} Formatted memory string e.g. "284 MB", "infinity", "unavailable"
+ */
+export function formatMemoryBytes(bytes) {
+  if (bytes === null || bytes === undefined || bytes === '' || bytes === 'unavailable' || bytes === '[unavailable]' || bytes === '-') {
+    return 'unavailable';
+  }
+
+  const str = String(bytes).trim().toLowerCase();
+  if (str === 'infinity' || str === 'max' || str === '18446744073709551615') {
+    return 'infinity';
+  }
+
+  const num = Number(bytes);
+  if (Number.isNaN(num) || num < 0) {
+    // If it's already a formatted string like "400M" or "400 MB"
+    if (/^\d+\s*[a-zA-Z]+$/.test(str)) {
+      const match = str.match(/^(\d+)\s*([a-zA-Z]+)$/);
+      if (match) {
+        const u = match[2].toUpperCase().replace(/B$/, '');
+        return `${match[1]} ${u === 'M' ? 'MB' : u === 'G' ? 'GB' : u === 'K' ? 'KB' : u}`;
+      }
+    }
+    return 'unavailable';
+  }
+
+  if (num === 0) return '0 MB';
+
+  const kb = 1024;
+  const mb = kb * 1024;
+  const gb = mb * 1024;
+  const tb = gb * 1024;
+
+  if (num >= tb) {
+    const val = num / tb;
+    return `${Number.isInteger(val) ? val : val.toFixed(1)} TB`;
+  }
+  if (num >= gb) {
+    const val = num / gb;
+    return `${Number.isInteger(val) ? val : val.toFixed(1)} GB`;
+  }
+  if (num >= mb) {
+    const val = num / mb;
+    return `${Number.isInteger(val) ? val : Math.round(val)} MB`;
+  }
+  if (num >= kb) {
+    const val = num / kb;
+    return `${Number.isInteger(val) ? val : Math.round(val)} KB`;
+  }
+
+  return `${num} B`;
+}
+
+/**
+ * Saves metadata JSON for a service.
+ * @param {object} meta
+ * @returns {object}
+ */
+export function saveAppMetadata(meta) {
+  const safeName = sanitizeServiceName(meta.name);
+  const dir = getAppsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = getAppMetadataPath(safeName);
+
+  const command = meta.command ? resolveAbsolutePath(meta.command) : (meta.node ? resolveAbsolutePath(meta.node) : process.execPath);
+  const rawArgs = Array.isArray(meta.args) ? meta.args : (meta.script ? [meta.script] : []);
+  const args = rawArgs.map(a => (a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/')) ? resolveAbsolutePath(a) : a);
+  const scriptPath = meta.script ? resolveAbsolutePath(meta.script) : (args[0] ? resolveAbsolutePath(args[0]) : command);
+  const cwd = meta.cwd ? resolveAbsolutePath(meta.cwd) : path.dirname(scriptPath || command);
+
+  // Extract memory resources if present
+  const resources = meta.resources || {};
+  if (meta.memoryHigh) resources.memoryHigh = validateMemorySize(meta.memoryHigh, 'MemoryHigh');
+  if (meta.memoryMax) resources.memoryMax = validateMemorySize(meta.memoryMax, 'MemoryMax');
+  if (meta.memorySwapMax) resources.memorySwapMax = validateMemorySize(meta.memorySwapMax, 'MemorySwapMax');
+
+  const payload = {
+    name: safeName,
+    unit: getUnitFilename(safeName),
+    runtime: meta.runtime || 'node',
+    command,
+    args,
+    cwd,
+    group: meta.group || 'default',
+    // Optional resources section
+    ...(Object.keys(resources).length > 0 ? { resources } : {}),
+    // Backward compatibility fields
+    script: scriptPath,
+    node: meta.node ? resolveAbsolutePath(meta.node) : command
+  };
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+  return payload;
+}
+
+/**
+ * Reads metadata JSON for a service.
+ * @param {string} name
+ * @returns {object|null}
+ */
+export function readAppMetadata(name) {
+  try {
+    const filePath = getAppMetadataPath(name);
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const data = JSON.parse(content);
+    if (!data) return null;
+
+    // Normalization for legacy metadata format
+    const command = data.command || data.node || process.execPath;
+    const args = data.args || (data.script ? [data.script] : []);
+    const runtime = data.runtime || 'node';
+    const script = data.script || args[0] || command;
+    const cwd = data.cwd || (script ? path.dirname(script) : process.cwd());
+
+    return {
+      ...data,
+      name: data.name || sanitizeServiceName(name),
+      unit: data.unit || getUnitFilename(name),
+      runtime,
+      command,
+      args,
+      cwd,
+      group: data.group || 'default',
+      resources: data.resources || undefined,
+      script,
+      node: data.node || command
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Deletes metadata JSON for a service if it exists.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function deleteAppMetadata(name) {
+  try {
+    const filePath = getAppMetadataPath(name);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch {}
+  return false;
+}
 
 /**
  * Sanitizes a service name to ensure it is safe for systemd unit filenames.