unitup 0.0.9 → 0.0.10

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,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();
 
@@ -431,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 {
@@ -465,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),
@@ -475,8 +498,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 +535,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 +585,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 +621,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 +676,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 +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 {
@@ -660,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();
+}

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();
     }
   }
 

package/src/utils.js

@@ -29,6 +29,101 @@ export function getAppMetadataPath(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
@@ -41,14 +136,32 @@ export function saveAppMetadata(meta) {
     fs.mkdirSync(dir, { recursive: true });
   }
   const filePath = getAppMetadataPath(safeName);
-  const scriptPath = resolveAbsolutePath(meta.script);
+
+  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,
-    cwd: meta.cwd ? resolveAbsolutePath(meta.cwd) : path.dirname(scriptPath),
-    node: meta.node ? resolveAbsolutePath(meta.node) : process.execPath
+    node: meta.node ? resolveAbsolutePath(meta.node) : command
   };
   fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
   return payload;
@@ -64,7 +177,29 @@ export function readAppMetadata(name) {
     const filePath = getAppMetadataPath(name);
     if (!fs.existsSync(filePath)) return null;
     const content = fs.readFileSync(filePath, 'utf8');
-    return JSON.parse(content);
+    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;
   }