unitup 0.1.5 → 0.2.0

package/src/schedule.js

@@ -1,31 +1,31 @@
-import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
+import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
+import { runCommand } from './systemd.js';
 import {
-  sanitizeServiceName,
-  getUnitFilename,
+  deleteScheduleUnitFiles,
+  getTimerPath,
+  getUnitPath,
+  getUserUnitDir,
+  timerFileExists,
+  unitFileExists,
+  writeScheduleUnitFiles
+} from './unit.js';
+import {
+  deleteScheduleMetadata,
+  formatFutureTime,
+  formatRelativeTime,
+  getSchedulesDir,
   getTimerFilename,
+  getUnitFilename,
+  readScheduleMetadata,
   resolveAbsolutePath,
   resolveWorkingDirectory,
-  validateDuration,
-  formatFutureTime,
-  formatRelativeTime,
+  sanitizeServiceName,
   saveScheduleMetadata,
-  readScheduleMetadata,
-  deleteScheduleMetadata,
-  getSchedulesDir
+  validateDuration
 } from './utils.js';
-import {
-  getUserUnitDir,
-  getUnitPath,
-  getTimerPath,
-  timerFileExists,
-  unitFileExists,
-  writeScheduleUnitFiles,
-  deleteScheduleUnitFiles
-} from './unit.js';
-import { runCommand } from './systemd.js';
-import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
 
 /**
  * Validates a systemd calendar expression using systemd-analyze if available.
@@ -53,7 +53,10 @@ export async function validateCalendar(expression) {
     }
     // If systemd-analyze binary is missing
     if (res.code === 127 || (res.stderr && res.stderr.includes('not found'))) {
-      return { valid: true, warning: 'systemd-analyze is not available; calendar expression could not be fully validated by systemd.' };
+      return {
+        valid: true,
+        warning: 'systemd-analyze is not available; calendar expression could not be fully validated by systemd.'
+      };
     }
   } catch (err) {
     if (err.message && err.message.startsWith('Invalid calendar expression')) {
@@ -360,7 +363,7 @@ export async function getScheduleStatus(name) {
   }
 
   // Parse NextElapse timestamp
-  let rawNext = timerProps.NextElapseUSecRealtime || timerProps.NextElapseUSec;
+  const rawNext = timerProps.NextElapseUSecRealtime || timerProps.NextElapseUSec;
   let nextRun = 'n/a';
 
   if (rawNext && rawNext !== '0' && rawNext !== '18446744073709551615') {
@@ -370,7 +373,11 @@ export async function getScheduleStatus(name) {
     } else {
       nextRun = formatFutureTime(rawNext);
     }
-  } else if (timerProps.NextElapseUSecMonotonic && timerProps.NextElapseUSecMonotonic !== '0' && timerProps.NextElapseUSecMonotonic !== '18446744073709551615') {
+  } else if (
+    timerProps.NextElapseUSecMonotonic &&
+    timerProps.NextElapseUSecMonotonic !== '0' &&
+    timerProps.NextElapseUSecMonotonic !== '18446744073709551615'
+  ) {
     const monoNum = Number(timerProps.NextElapseUSecMonotonic);
     if (!isNaN(monoNum) && monoNum > 0) {
       const currentMonoUSec = os.uptime() * 1000000;
@@ -385,7 +392,7 @@ export async function getScheduleStatus(name) {
   }
 
   // Parse LastTrigger timestamp
-  let rawLast = timerProps.LastTriggerUSec;
+  const rawLast = timerProps.LastTriggerUSec;
   let lastRun = 'never';
   if (rawLast && rawLast !== '0' && rawLast !== 'n/a') {
     const num = Number(rawLast);

package/src/service/config.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  findProjectConfig,
+  getConfigFilepath,
+  getUnitupDir,
+  readGlobalConfig,
+  readProjectConfig,
+  saveGlobalConfig,
+  saveProjectConfig
+} from '../utils.js';
+
+export {
+  findProjectConfig,
+  readProjectConfig,
+  saveProjectConfig,
+  readGlobalConfig,
+  saveGlobalConfig,
+  getConfigFilepath,
+  getUnitupDir
+};
+
+/**
+ * Merges raw CLI options with any found project configuration.
+ *
+ * @param {object} opts
+ * @returns {object} Merged options
+ */
+export function mergeConfigWithOptions(opts = {}) {
+  const targetCwd = opts.cwd ? path.resolve(process.cwd(), opts.cwd) : process.cwd();
+  const configPath = opts.config ? path.resolve(targetCwd, opts.config) : findProjectConfig(targetCwd);
+  const projectCfg = configPath ? readProjectConfig(configPath) : null;
+
+  if (!projectCfg) {
+    return { ...opts, cwd: targetCwd };
+  }
+
+  return {
+    name: opts.name || projectCfg.name,
+    group: opts.group || projectCfg.group || 'default',
+    script: opts.script || projectCfg.script,
+    command: opts.command || projectCfg.command,
+    runtime: opts.runtime || projectCfg.runtime,
+    runtimeArgs: opts.runtimeArgs && opts.runtimeArgs.length > 0 ? opts.runtimeArgs : projectCfg.runtimeArgs || [],
+    args: opts.args && opts.args.length > 0 ? opts.args : projectCfg.args || [],
+    envFile: opts.envFile || projectCfg.envFile,
+    restart: opts.restart && opts.restart !== 'on-failure' ? opts.restart : projectCfg.restart || 'on-failure',
+    memoryHigh: opts.memoryHigh || projectCfg?.resources?.memoryHigh || projectCfg?.memoryHigh || '',
+    memoryMax: opts.memoryMax || projectCfg?.resources?.memoryMax || projectCfg?.memoryMax || '',
+    memorySwapMax: opts.memorySwapMax || projectCfg?.resources?.memorySwapMax || projectCfg?.memorySwapMax || '',
+    ...opts,
+    env: { ...(projectCfg.env || {}), ...(opts.env || {}) },
+    cwd: targetCwd
+  };
+}

package/src/service/manager.js

@@ -0,0 +1,233 @@
+import { getAdapter } from '../platform/index.js';
+import { readAppMetadata, readScheduleMetadata, sanitizeServiceName } from '../utils.js';
+import { mergeConfigWithOptions } from './config.js';
+import { normalizeServiceConfig } from './normalize.js';
+
+/**
+ * ServiceManager orchestrates service operations across platforms.
+ */
+export class ServiceManager {
+  /**
+   * @param {object} [opts]
+   * @param {string} [opts.platform]
+   * @param {import('../platform/base.js').ServiceAdapter} [opts.adapter]
+   */
+  constructor(opts = {}) {
+    this.platformName = opts.platform;
+    this._adapter = opts.adapter;
+  }
+
+  get adapter() {
+    return this._adapter || getAdapter(this.platformName);
+  }
+
+  /**
+   * Gets the platform capabilities.
+   */
+  get capabilities() {
+    return this.adapter.capabilities;
+  }
+
+  /**
+   * Generates the native service file/config from options (dry-run mode).
+   *
+   * @param {object} rawOpts
+   * @returns {Promise<string|object>}
+   */
+  async generate(rawOpts = {}) {
+    const merged = mergeConfigWithOptions(rawOpts);
+    const normalized = await normalizeServiceConfig(merged);
+    return this.adapter.generateService(normalized);
+  }
+
+  /**
+   * Installs/registers a service.
+   *
+   * @param {object} rawOpts
+   * @returns {Promise<object>}
+   */
+  async install(rawOpts = {}) {
+    const merged = mergeConfigWithOptions(rawOpts);
+    const normalized = await normalizeServiceConfig(merged);
+    return this.adapter.install(normalized, {
+      force: !!rawOpts.force,
+      start: !!rawOpts.start,
+      system: !!rawOpts.system
+    });
+  }
+
+  /**
+   * Uninstalls/removes a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async uninstall(name, options = {}) {
+    if (name && typeof name === 'string' && name.startsWith('@')) {
+      const all = await this.list({ group: name });
+      if (all.length === 0) {
+        throw new Error(`No services found in group "${name}".`);
+      }
+      for (const item of all) {
+        await this.uninstall(item.name, options);
+      }
+      return true;
+    }
+    return this.adapter.uninstall(name, options);
+  }
+
+  /**
+   * Starts a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async start(name, options = {}) {
+    if (name && typeof name === 'string' && name.startsWith('@')) {
+      const all = await this.list({ group: name });
+      if (all.length === 0) {
+        throw new Error(`No services found in group "${name}".`);
+      }
+      for (const item of all) {
+        await this.start(item.name, options);
+      }
+      return true;
+    }
+    return this.adapter.start(name, options);
+  }
+
+  /**
+   * Stops a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async stop(name, options = {}) {
+    if (name && typeof name === 'string' && name.startsWith('@')) {
+      const all = await this.list({ group: name });
+      if (all.length === 0) {
+        throw new Error(`No services found in group "${name}".`);
+      }
+      for (const item of all) {
+        await this.stop(item.name, options);
+      }
+      return true;
+    }
+    return this.adapter.stop(name, options);
+  }
+
+  /**
+   * Restarts a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async restart(name, options = {}) {
+    if (name && typeof name === 'string' && name.startsWith('@')) {
+      const all = await this.list({ group: name });
+      if (all.length === 0) {
+        throw new Error(`No services found in group "${name}".`);
+      }
+      for (const item of all) {
+        await this.restart(item.name, options);
+      }
+      return true;
+    }
+    return this.adapter.restart(name, options);
+  }
+
+  /**
+   * Enables a service for automatic startup.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async enable(name, options = {}) {
+    return this.adapter.enable(name, options);
+  }
+
+  /**
+   * Disables automatic startup for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async disable(name, options = {}) {
+    return this.adapter.disable(name, options);
+  }
+
+  /**
+   * Gets normalized status for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async status(name, options = {}) {
+    return this.adapter.status(name, options);
+  }
+
+  /**
+   * Inspects detailed configuration and runtime info for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async inspect(name, options = {}) {
+    return this.adapter.inspect(name, options);
+  }
+
+  /**
+   * Retrieves or streams logs for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<any>}
+   */
+  async logs(name, options = {}) {
+    return this.adapter.logs(name, options);
+  }
+
+  /**
+   * Lists all services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async list(options = {}) {
+    return this.adapter.list(options);
+  }
+
+  /**
+   * Lists failed services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async failures(options = {}) {
+    return this.adapter.failures(options);
+  }
+
+  /**
+   * Checks if a service is installed.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>|boolean}
+   */
+  isInstalled(name, options = {}) {
+    return this.adapter.isInstalled(name, options);
+  }
+}
+
+/**
+ * Default global ServiceManager instance.
+ */
+export const defaultManager = new ServiceManager();

package/src/service/normalize.js

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ExecutableNotFoundError, InvalidServiceConfigError } from '../errors.js';
+import { detectRuntime, resolveRuntimeConfig } from '../runtimes/index.js';
+import { getUnitupDir, resolveEffectiveMemoryLimits, resolveWorkingDirectory, sanitizeServiceName } from '../utils.js';
+
+/**
+ * Resolves a binary or command name to an absolute executable path.
+ * Supports Windows PATHEXT extensions (.exe, .cmd, .bat, etc.) and Unix executable permissions.
+ *
+ * @param {string} binaryName
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]
+ * @param {string} [opts.pathEnv]
+ * @returns {string|null}
+ */
+export function resolveExecutable(binaryName, opts = {}) {
+  if (!binaryName || typeof binaryName !== 'string') {
+    return null;
+  }
+
+  const trimmed = binaryName.trim();
+  if (!trimmed) return null;
+
+  const baseDir = opts.cwd || process.cwd();
+  const isWin = process.platform === 'win32';
+  const pathext = isWin
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD;.VBS;.JS;.WSF;.WSC;.MSI').split(';').filter(Boolean)
+    : [''];
+
+  // Helper to check if a specific file is executable
+  function isExecutableFile(targetPath) {
+    try {
+      if (!fs.existsSync(targetPath)) return false;
+      const stat = fs.statSync(targetPath);
+      if (!stat.isFile()) return false;
+      if (isWin) return true;
+      fs.accessSync(targetPath, fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // 1. If path is absolute or explicit relative path (starts with ./, ../, /)
+  if (path.isAbsolute(trimmed) || trimmed.startsWith('./') || trimmed.startsWith('../') || trimmed.startsWith('~/')) {
+    const expanded = trimmed.startsWith('~/')
+      ? path.join(process.env.HOME || process.env.USERPROFILE || '', trimmed.slice(2))
+      : path.resolve(baseDir, trimmed);
+
+    if (isExecutableFile(expanded)) {
+      return fs.realpathSync(expanded);
+    }
+
+    if (isWin) {
+      for (const ext of pathext) {
+        const withExt = expanded + ext.toLowerCase();
+        if (isExecutableFile(withExt)) {
+          return fs.realpathSync(withExt);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // 2. Look in system PATH
+  const envPath = opts.pathEnv || process.env.PATH || '';
+  const searchDirs = envPath.split(path.delimiter).filter(Boolean);
+
+  for (const dir of searchDirs) {
+    const candidate = path.join(dir, trimmed);
+    if (isExecutableFile(candidate)) {
+      try {
+        return fs.realpathSync(candidate);
+      } catch {
+        return candidate;
+      }
+    }
+
+    if (isWin) {
+      for (const ext of pathext) {
+        const candidateWithExt = candidate + ext.toLowerCase();
+        if (isExecutableFile(candidateWithExt)) {
+          try {
+            return fs.realpathSync(candidateWithExt);
+          } catch {
+            return candidateWithExt;
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Normalizes input service options into a complete, validated NormalizedServiceConfig object.
+ *
+ * @param {object} rawOpts
+ * @returns {Promise<object>} NormalizedServiceConfig
+ */
+export async function normalizeServiceConfig(rawOpts = {}) {
+  if (!rawOpts || typeof rawOpts !== 'object') {
+    throw new InvalidServiceConfigError('Service configuration options must be an object.');
+  }
+
+  const name = rawOpts.name ? sanitizeServiceName(rawOpts.name) : '';
+  if (!name) {
+    throw new InvalidServiceConfigError('Service name is required.', 'name');
+  }
+
+  const cwd = resolveWorkingDirectory(rawOpts);
+  const runtimeConfig = await resolveRuntimeConfig({
+    ...rawOpts,
+    name,
+    cwd
+  });
+
+  const command = runtimeConfig.command;
+  if (!command) {
+    throw new ExecutableNotFoundError(
+      rawOpts.command || rawOpts.script || 'executable',
+      `Executable could not be resolved for service "${name}".`
+    );
+  }
+
+  const args = Array.isArray(runtimeConfig.args) ? [...runtimeConfig.args] : [];
+  const displayName = rawOpts.displayName || rawOpts.name || name;
+  const description = rawOpts.description || `unitup service: ${name}`;
+  const group = rawOpts.group || 'default';
+  const system = !!rawOpts.system;
+  const autostart = rawOpts.autostart !== undefined ? !!rawOpts.autostart : true;
+  const shutdownTimeout =
+    rawOpts.shutdownTimeout !== undefined &&
+    !Number.isNaN(Number(rawOpts.shutdownTimeout)) &&
+    Number(rawOpts.shutdownTimeout) > 0
+      ? Number(rawOpts.shutdownTimeout)
+      : 10000;
+
+  // Environment normalization
+  const env = {};
+  if (rawOpts.env && typeof rawOpts.env === 'object') {
+    for (const [k, v] of Object.entries(rawOpts.env)) {
+      if (v !== undefined && v !== null) {
+        env[k] = String(v);
+      }
+    }
+  }
+
+  // Restart policy normalization
+  let restartPolicy = 'on-failure';
+  let restartEnabled = true;
+  let restartDelay = 3000;
+  let maxRetries = null;
+  let resetAfter = null;
+
+  if (typeof rawOpts.restart === 'string') {
+    restartPolicy = rawOpts.restart;
+    restartEnabled = restartPolicy !== 'no';
+  } else if (rawOpts.restart && typeof rawOpts.restart === 'object') {
+    restartEnabled = rawOpts.restart.enabled !== false;
+    restartPolicy = rawOpts.restart.policy || (restartEnabled ? 'on-failure' : 'no');
+    if (rawOpts.restart.delay !== undefined && !Number.isNaN(Number(rawOpts.restart.delay))) {
+      restartDelay = Number(rawOpts.restart.delay);
+    }
+    if (rawOpts.restart.maxRetries !== undefined && !Number.isNaN(Number(rawOpts.restart.maxRetries))) {
+      maxRetries = Number(rawOpts.restart.maxRetries);
+    }
+    if (rawOpts.restart.resetAfter !== undefined && !Number.isNaN(Number(rawOpts.restart.resetAfter))) {
+      resetAfter = Number(rawOpts.restart.resetAfter);
+    }
+  }
+
+  // Logs normalization
+  const unitupDir = getUnitupDir();
+  const logsDir = path.join(unitupDir, 'logs');
+  const defaultStdout = path.join(logsDir, `${name}.log`);
+  const defaultStderr = path.join(logsDir, `${name}-error.log`);
+
+  const logs = {
+    stdout: rawOpts.logs?.stdout || rawOpts.stdout || defaultStdout,
+    stderr: rawOpts.logs?.stderr || rawOpts.stderr || defaultStderr
+  };
+
+  // Memory and resource limits
+  const resources = resolveEffectiveMemoryLimits(rawOpts);
+
+  return {
+    name,
+    displayName,
+    description,
+    runtime: runtimeConfig.runtime || 'custom',
+    command,
+    args,
+    script: rawOpts.script ? path.resolve(cwd, rawOpts.script) : undefined,
+    cwd,
+    env,
+    envFile: rawOpts.envFile ? path.resolve(cwd, rawOpts.envFile) : undefined,
+    autostart,
+    restart: {
+      enabled: restartEnabled,
+      policy: restartPolicy,
+      delay: restartDelay,
+      maxRetries,
+      resetAfter
+    },
+    logs,
+    group,
+    system,
+    shutdownTimeout,
+    resources,
+    raw: rawOpts
+  };
+}