unitup 0.0.12 → 0.1.0

package/src/unit.js

@@ -4,12 +4,17 @@ import os from 'node:os';
 import {
   sanitizeServiceName,
   getUnitFilename,
+  getTimerFilename,
   getServiceNameFromUnit,
   formatSystemdEnv,
   escapeExecArg,
   resolveAbsolutePath,
   saveAppMetadata,
-  deleteAppMetadata
+  deleteAppMetadata,
+  saveScheduleMetadata,
+  deleteScheduleMetadata,
+  validateDuration,
+  resolveEffectiveMemoryLimits
 } from './utils.js';
 
 /**
@@ -106,9 +111,10 @@ 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;
+  const effectiveLimits = resolveEffectiveMemoryLimits(opts);
+  const memHigh = effectiveLimits.memoryHigh;
+  const memMax = effectiveLimits.memoryMax;
+  const memSwapMax = effectiveLimits.memorySwapMax;
 
   if (memHigh || memMax || memSwapMax) {
     serviceLines.push('MemoryAccounting=yes');
@@ -258,3 +264,223 @@ export function parseUnitContent(content) {
 
   return result;
 }
+
+/**
+ * Returns the full file path for a given timer unit.
+ * @param {string} name
+ * @returns {string}
+ */
+export function getTimerPath(name) {
+  const filename = getTimerFilename(name);
+  return path.join(getUserUnitDir(), filename);
+}
+
+/**
+ * Checks if a timer unit file exists for the given schedule name.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function timerFileExists(name) {
+  const timerPath = getTimerPath(name);
+  return fs.existsSync(timerPath);
+}
+
+/**
+ * Generates systemd service unit content for a scheduled oneshot task.
+ * @param {Object} opts
+ * @returns {string}
+ */
+export function generateScheduleServiceContent(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+  let commandExec = '';
+  let execArgs = [];
+
+  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 scheduled unit file.');
+  }
+
+  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 execStartTokens = [commandExec, ...execArgs];
+  const execStartLine = execStartTokens.map(escapeExecArg).join(' ');
+
+  const binDir = path.dirname(commandExec);
+  const defaultPath = [binDir, '/usr/local/bin', '/usr/bin', '/bin']
+    .filter((p, i, self) => p && self.indexOf(p) === i)
+    .join(':');
+
+  const serviceLines = [
+    '[Unit]',
+    `Description=unitup scheduled task: ${safeName}`,
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=oneshot',
+    `SyslogIdentifier=unitup-${safeName}`,
+    `WorkingDirectory=${cwd}`,
+    `ExecStart=${execStartLine}`,
+    'StandardOutput=journal',
+    'StandardError=journal'
+  ];
+
+  const effectiveLimits = resolveEffectiveMemoryLimits(opts);
+  const memHigh = effectiveLimits.memoryHigh;
+  const memMax = effectiveLimits.memoryMax;
+  const memSwapMax = effectiveLimits.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;
+  }
+
+  if (opts.envFile) {
+    const absEnvFile = resolveAbsolutePath(opts.envFile);
+    serviceLines.push(`EnvironmentFile=${absEnvFile}`);
+  }
+
+  for (const [key, val] of Object.entries(envObj)) {
+    serviceLines.push(`Environment=${formatSystemdEnv(key, val)}`);
+  }
+
+  serviceLines.push('');
+  return serviceLines.join('\n');
+}
+
+/**
+ * Generates systemd timer unit content.
+ * @param {Object} opts
+ * @returns {string}
+ */
+export function generateTimerContent(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+
+  const timerLines = [
+    '[Unit]',
+    `Description=unitup timer: ${safeName}`,
+    '',
+    '[Timer]'
+  ];
+
+  if (opts.every) {
+    const validEvery = validateDuration(opts.every, '--every');
+    const onActive = opts.onActive ? validateDuration(opts.onActive, '--on-active') : validEvery;
+    timerLines.push(`OnActiveSec=${onActive}`);
+    timerLines.push(`OnUnitActiveSec=${validEvery}`);
+  } else if (opts.onActive) {
+    const validActive = validateDuration(opts.onActive, '--on-active');
+    timerLines.push(`OnActiveSec=${validActive}`);
+  }
+
+  if (opts.calendar) {
+    if (typeof opts.calendar !== 'string' || !opts.calendar.trim()) {
+      throw new Error('Calendar expression cannot be empty.');
+    }
+    timerLines.push(`OnCalendar=${opts.calendar.trim()}`);
+  }
+
+  if (opts.onBoot) {
+    const validBoot = validateDuration(opts.onBoot, '--on-boot');
+    timerLines.push(`OnBootSec=${validBoot}`);
+  }
+
+  if (opts.randomDelay) {
+    const validDelay = validateDuration(opts.randomDelay, '--random-delay');
+    timerLines.push(`RandomizedDelaySec=${validDelay}`);
+  }
+
+  if (opts.persistent) {
+    timerLines.push('Persistent=true');
+  }
+
+  const serviceFilename = getUnitFilename(safeName);
+  timerLines.push(`Unit=${serviceFilename}`);
+
+  timerLines.push('', '[Install]', 'WantedBy=timers.target', '');
+
+  return timerLines.join('\n');
+}
+
+/**
+ * Creates or updates systemd service and timer files for a schedule on disk.
+ * @param {Object} opts
+ * @returns {{ servicePath: string, timerPath: string, serviceContent: string, timerContent: string }}
+ */
+export function writeScheduleUnitFiles(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+  const unitDir = getUserUnitDir();
+
+  if (!fs.existsSync(unitDir)) {
+    fs.mkdirSync(unitDir, { recursive: true });
+  }
+
+  const servicePath = getUnitPath(safeName);
+  const timerPath = getTimerPath(safeName);
+
+  const serviceContent = generateScheduleServiceContent({ ...opts, name: safeName });
+  const timerContent = generateTimerContent({ ...opts, name: safeName });
+
+  fs.writeFileSync(servicePath, serviceContent, 'utf8');
+  fs.writeFileSync(timerPath, timerContent, 'utf8');
+
+  saveScheduleMetadata({
+    name: safeName,
+    group: opts.group || 'default',
+    runtime: opts.runtime || 'node',
+    command: opts.command,
+    args: opts.args,
+    cwd: opts.cwd,
+    memoryHigh: opts.memoryHigh || opts.resources?.memoryHigh,
+    memoryMax: opts.memoryMax || opts.resources?.memoryMax,
+    memorySwapMax: opts.memorySwapMax || opts.resources?.memorySwapMax,
+    resources: opts.resources,
+    schedule: {
+      every: opts.every || null,
+      calendar: opts.calendar || null,
+      onBoot: opts.onBoot || null,
+      onActive: opts.onActive || null,
+      persistent: Boolean(opts.persistent),
+      randomDelay: opts.randomDelay || null
+    }
+  });
+
+  return { servicePath, timerPath, serviceContent, timerContent };
+}
+
+/**
+ * Removes service, timer, and metadata files for a schedule.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function deleteScheduleUnitFiles(name) {
+  const safeName = sanitizeServiceName(name);
+  deleteScheduleMetadata(safeName);
+  const servicePath = getUnitPath(safeName);
+  const timerPath = getTimerPath(safeName);
+
+  let removed = false;
+  if (fs.existsSync(timerPath)) {
+    fs.unlinkSync(timerPath);
+    removed = true;
+  }
+  if (fs.existsSync(servicePath)) {
+    fs.unlinkSync(servicePath);
+    removed = true;
+  }
+  return removed;
+}
+

package/src/utils.js

@@ -402,3 +402,256 @@ export function formatTable(data, columns) {
 
   return lines.join('\n');
 }
+
+/**
+ * Returns the directory for schedule metadata (~/.config/unitup/schedules).
+ * @returns {string}
+ */
+export function getSchedulesDir() {
+  return path.join(getUnitupDir(), 'schedules');
+}
+
+/**
+ * Returns the filepath for a specific schedule's metadata JSON file.
+ * @param {string} name
+ * @returns {string}
+ */
+export function getScheduleMetadataPath(name) {
+  const safeName = sanitizeServiceName(name);
+  return path.join(getSchedulesDir(), `${safeName}.json`);
+}
+
+/**
+ * Saves metadata JSON for a schedule.
+ * @param {object} meta
+ * @returns {object}
+ */
+export function saveScheduleMetadata(meta) {
+  const safeName = sanitizeServiceName(meta.name);
+  const dir = getSchedulesDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = getScheduleMetadataPath(safeName);
+
+  const command = meta.command ? resolveAbsolutePath(meta.command) : process.execPath;
+  const rawArgs = Array.isArray(meta.args) ? meta.args : [];
+  const args = rawArgs.map(a => (a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/')) ? resolveAbsolutePath(a) : a);
+
+  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,
+    group: meta.group || 'default',
+    type: 'timer',
+    runtime: meta.runtime || 'node',
+    command,
+    args,
+    cwd: meta.cwd ? resolveAbsolutePath(meta.cwd) : process.cwd(),
+    schedule: {
+      every: meta.schedule?.every || null,
+      calendar: meta.schedule?.calendar || null,
+      onBoot: meta.schedule?.onBoot || null,
+      onActive: meta.schedule?.onActive || null,
+      persistent: Boolean(meta.schedule?.persistent),
+      randomDelay: meta.schedule?.randomDelay || null
+    },
+    ...(Object.keys(resources).length > 0 ? { resources } : {}),
+    serviceUnit: `unitup-${safeName}.service`,
+    timerUnit: `unitup-${safeName}.timer`
+  };
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+  return payload;
+}
+
+/**
+ * Reads metadata JSON for a schedule.
+ * @param {string} name
+ * @returns {object|null}
+ */
+export function readScheduleMetadata(name) {
+  try {
+    const filePath = getScheduleMetadataPath(name);
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Deletes metadata JSON for a schedule if it exists.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function deleteScheduleMetadata(name) {
+  try {
+    const filePath = getScheduleMetadataPath(name);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+/**
+ * Returns the full systemd timer filename for a schedule name.
+ * @param {string} name
+ * @returns {string}
+ */
+export function getTimerFilename(name) {
+  const safeName = sanitizeServiceName(name);
+  return `unitup-${safeName}.timer`;
+}
+
+/**
+ * Validates systemd time span duration strings (e.g., 30s, 10m, 2h, 1d).
+ * @param {string|number} val
+ * @param {string} [paramName]
+ * @returns {string}
+ */
+export function validateDuration(val, paramName = 'Duration') {
+  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 tokens = str.split(/\s+/);
+  const tokenRegex = /^(\d+(?:\.\d+)?)(us|usec|ms|msec|s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|day|days?|w|week|weeks?|mth|months?|y|year|years?)$/i;
+
+  for (const token of tokens) {
+    if (!tokenRegex.test(token)) {
+      throw new Error(`Invalid ${paramName} format: "${str}". Expected values like 30s, 10m, 2h, 1d.`);
+    }
+  }
+
+  return str;
+}
+
+/**
+ * Formats a future date/timestamp into relative human readable string (e.g. "in 12 minutes", "tomorrow").
+ * @param {string|number|Date} dateVal
+ * @returns {string}
+ */
+export function formatFutureTime(dateVal) {
+  if (!dateVal || dateVal === 'n/a' || dateVal === '0' || dateVal === 'infinity') {
+    return 'n/a';
+  }
+  const date = new Date(typeof dateVal === 'number' && dateVal > 1e12 ? dateVal : (typeof dateVal === 'number' ? dateVal / 1000 : dateVal));
+  if (isNaN(date.getTime())) {
+    return String(dateVal);
+  }
+  const diffMs = date.getTime() - Date.now();
+  if (diffMs <= 0) return 'imminent';
+
+  const seconds = Math.floor(diffMs / 1000);
+  if (seconds < 60) return `in ${seconds} seconds`;
+
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `in ${minutes} minute${minutes === 1 ? '' : 's'}`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `in ${hours} hour${hours === 1 ? '' : 's'}`;
+
+  const days = Math.floor(hours / 24);
+  if (days === 1) return 'tomorrow';
+  return `in ${days} days`;
+}
+
+/**
+ * Returns the filepath to the global unitup config JSON file (~/.config/unitup/config.json).
+ * @returns {string}
+ */
+export function getConfigFilepath() {
+  return path.join(getUnitupDir(), 'config.json');
+}
+
+/**
+ * Reads global unitup configuration JSON file.
+ * @returns {object}
+ */
+export function readGlobalConfig() {
+  try {
+    const file = getConfigFilepath();
+    if (!fs.existsSync(file)) return {};
+    const content = fs.readFileSync(file, 'utf8');
+    return JSON.parse(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Saves global unitup configuration JSON file.
+ * @param {object} config
+ * @returns {object}
+ */
+export function saveGlobalConfig(config) {
+  const dir = getUnitupDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const file = getConfigFilepath();
+  const current = readGlobalConfig();
+  const updated = { ...current, ...config };
+  fs.writeFileSync(file, JSON.stringify(updated, null, 2), 'utf8');
+  return updated;
+}
+
+/**
+ * Resolves effective memory limits considering explicit options, env vars, and global config defaults (default: 1G).
+ * @param {object} opts
+ * @returns {{ memoryHigh?: string, memoryMax?: string, memorySwapMax?: string }}
+ */
+export function resolveEffectiveMemoryLimits(opts = {}) {
+  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) {
+    return {
+      ...(memHigh ? { memoryHigh: validateMemorySize(memHigh, 'MemoryHigh') } : {}),
+      ...(memMax ? { memoryMax: validateMemorySize(memMax, 'MemoryMax') } : {}),
+      ...(memSwapMax ? { memorySwapMax: validateMemorySize(memSwapMax, 'MemorySwapMax') } : {})
+    };
+  }
+
+  let defaultMem = opts.defaultMemory;
+
+  if (!defaultMem && process.env.UNITUP_DEFAULT_MEMORY) {
+    defaultMem = process.env.UNITUP_DEFAULT_MEMORY;
+  }
+
+  if (!defaultMem) {
+    const cfg = readGlobalConfig();
+    if (cfg.defaultMemory) {
+      defaultMem = cfg.defaultMemory;
+    }
+  }
+
+  if (defaultMem) {
+    const sizeStr = (typeof defaultMem === 'boolean' || defaultMem === 'true' || defaultMem === '') ? '1G' : String(defaultMem);
+    const validSize = validateMemorySize(sizeStr, 'Default memory limit');
+    return { memoryMax: validSize };
+  }
+
+  return {};
+}
+
+