unitup 0.1.5 → 0.3.0

package/src/index.js

@@ -1,78 +1,206 @@
+import { getDoctorInfo, runDoctor } from './doctor.js';
+import {
+  ExecutableNotFoundError,
+  InvalidServiceConfigError,
+  PermissionRequiredError,
+  ServiceAlreadyExistsError,
+  ServiceNotFoundError,
+  ServiceStartError,
+  ServiceStopError,
+  UnitupError,
+  UnsupportedPlatformError
+} from './errors.js';
+import { readServiceLogs } from './logs.js';
+import {
+  LinuxAdapter,
+  MacOSAdapter,
+  ServiceAdapter,
+  WindowsAdapter,
+  getAdapter,
+  getPlatformCapabilities
+} from './platform/index.js';
+import { WindowsServiceHost } from './platform/windows-host.js';
+import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
+import {
+  createSchedule,
+  disableSchedule,
+  enableSchedule,
+  getScheduleStatus,
+  listSchedules,
+  removeSchedule,
+  runSchedule,
+  validateCalendar
+} from './schedule.js';
+import { ServiceManager, defaultManager } from './service/manager.js';
+import { normalizeServiceConfig, resolveExecutable } from './service/normalize.js';
 import {
   addService,
-  startService,
-  stopService,
-  restartService,
-  removeService,
+  checkNodeDiagnostics,
+  checkUserLinger,
+  executeJournalctlMaintenance,
+  findNodeExecutable,
+  getAllServicesMemoryUsage,
+  getServiceFailures,
+  getServiceMemoryUsage,
   getServiceStatus,
   getServiceStatusRaw,
-  listServices,
-  inspectService,
-  getServiceFailures,
   getServicesByGroup,
-  runJournalctlLogs,
-  setServiceLimits,
-  executeJournalctlMaintenance,
+  inspectService,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
   isUserSystemdAvailable,
-  checkUserLinger,
-  checkNodeDiagnostics,
-  findNodeExecutable,
-  getServiceMemoryUsage,
-  getAllServicesMemoryUsage,
+  listServices,
+  removeService,
+  resetCommandRunner,
+  restartService,
+  runCommand,
+  runJournalctlLogs,
   setCommandRunner,
-  resetCommandRunner
+  setServiceLimits,
+  startService,
+  stopService
 } from './systemd.js';
-import { getDoctorInfo } from './doctor.js';
-import {
-  createSchedule,
-  listSchedules,
-  getScheduleStatus,
-  runSchedule,
-  enableSchedule,
-  disableSchedule,
-  removeSchedule,
-  validateCalendar
-} from './schedule.js';
 import {
-  getUserUnitDir,
-  getUnitPath,
+  generateScheduleServiceContent,
+  generateTimerContent,
   getTimerPath,
-  unitFileExists,
-  timerFileExists,
+  getUnitPath,
+  getUserUnitDir,
   parseUnitContent,
-  generateTimerContent,
-  generateScheduleServiceContent
+  timerFileExists,
+  unitFileExists
 } from './unit.js';
 import {
-  sanitizeServiceName,
-  getUnitFilename,
-  getTimerFilename,
-  getServiceNameFromUnit,
-  readAppMetadata,
+  findProjectConfig,
+  formatDuration,
+  formatMemoryBytes,
   getAppMetadataPath,
-  readScheduleMetadata,
+  getAppsDir,
+  getConfigFilepath,
   getScheduleMetadataPath,
+  getSchedulesDir,
+  getServiceNameFromUnit,
+  getTimerFilename,
+  getUnitFilename,
+  getUnitupDir,
+  readAppMetadata,
   readGlobalConfig,
-  saveGlobalConfig,
-  getConfigFilepath,
-  findProjectConfig,
   readProjectConfig,
-  saveProjectConfig,
+  readScheduleMetadata,
   resolveEffectiveMemoryLimits,
-  getSchedulesDir,
-  getAppsDir,
-  getUnitupDir,
-  validateMemorySize,
+  sanitizeServiceName,
+  saveGlobalConfig,
+  saveProjectConfig,
   validateDuration,
-  formatMemoryBytes
+  validateMemorySize
 } from './utils.js';
-import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
+import {
+  ProcessManager,
+  GenerationManager,
+  Router,
+  ReadinessChecker,
+  ReadinessTimeoutError,
+  ProcessStartupError,
+  PortMismatchError,
+  DrainManager,
+  DeploymentLock,
+  DeploymentLockError,
+  Supervisor,
+  IPCServer,
+  IPCClient,
+  findFreePort
+} from './core/index.js';
+import {
+  DeploymentManager,
+  DeploymentState,
+  defaultDeploymentManager,
+  RollbackManager,
+  defaultRollbackManager
+} from './deploy/index.js';
+
+// Aliases for unified cross-platform API
+const install = (opts) => defaultManager.install(opts);
+const uninstall = (name, opts) => defaultManager.uninstall(name, opts);
+const start = (name, opts) => defaultManager.start(name, opts);
+const stop = (name, opts) => defaultManager.stop(name, opts);
+const restart = (name, opts) => defaultManager.restart(name, opts);
+const deploy = (name, opts) => defaultDeploymentManager.deploy(name, {}, opts);
+const promote = (name, opts) => defaultDeploymentManager.promote(name, {}, opts);
+const rollback = (name, opts) => defaultRollbackManager.rollback(name, {}, opts);
+const generations = (name, opts) => new GenerationManager(opts).listGenerations(name);
+const status = (name, opts) => defaultManager.status(name, opts);
+const list = (opts) => defaultManager.list(opts);
+const inspect = (name, opts) => defaultManager.inspect(name, opts);
+const logs = (name, opts) => defaultManager.logs(name, opts);
+const enable = (name, opts) => defaultManager.enable(name, opts);
+const disable = (name, opts) => defaultManager.disable(name, opts);
+const platform = (targetPlatform) => getPlatformCapabilities(targetPlatform);
 
 export {
-  // Main programmatic service management API
+  // Unified cross-platform API
+  install,
+  uninstall,
+  start,
+  stop,
+  restart,
+  deploy,
+  promote,
+  rollback,
+  generations,
+  status,
+  list,
+  inspect,
+  logs,
+  enable,
+  disable,
+  platform,
+  ServiceManager,
+  defaultManager,
+  // Zero-Downtime Deployment & Orchestration
+  DeploymentManager,
+  DeploymentState,
+  defaultDeploymentManager,
+  RollbackManager,
+  defaultRollbackManager,
+  // Core Runtime Primitives
+  ProcessManager,
+  GenerationManager,
+  Router,
+  ReadinessChecker,
+  ReadinessTimeoutError,
+  ProcessStartupError,
+  PortMismatchError,
+  DrainManager,
+  DeploymentLock,
+  DeploymentLockError,
+  Supervisor,
+  IPCServer,
+  IPCClient,
+  findFreePort,
+  // Platform Adapters & Factory
+  ServiceAdapter,
+  LinuxAdapter,
+  MacOSAdapter,
+  WindowsAdapter,
+  WindowsServiceHost,
+  getAdapter,
+  getPlatformCapabilities,
+  // Normalization & Resolution
+  normalizeServiceConfig,
+  resolveExecutable,
+  readServiceLogs,
+  // Error hierarchy
+  UnitupError,
+  UnsupportedPlatformError,
+  ServiceNotFoundError,
+  ServiceAlreadyExistsError,
+  PermissionRequiredError,
+  ServiceStartError,
+  ServiceStopError,
+  InvalidServiceConfigError,
+  ExecutableNotFoundError,
+  // Main programmatic service management API (backward compatible)
   addService as createService,
   addService,
   startService,
@@ -88,9 +216,9 @@ export {
   setServiceLimits,
   getServiceMemoryUsage,
   getAllServicesMemoryUsage,
-  executeJournalctlMaintenance as executeJournalctlMaintenance,
+  executeJournalctlMaintenance,
   runJournalctlLogs as getServiceLogs,
-
+  runJournalctlLogs,
   // Programmatic schedule management API
   createSchedule,
   listSchedules,
@@ -100,16 +228,14 @@ export {
   disableSchedule,
   removeSchedule,
   validateCalendar,
-
   // Duration & Validation helpers
   validateMemorySize,
   validateDuration,
   formatMemoryBytes,
-
+  formatDuration,
   // Runtime detection & resolution
   detectRuntime,
   resolveRuntimeConfig,
-
   // Metadata & Config helpers
   readAppMetadata,
   getAppMetadataPath,
@@ -125,7 +251,6 @@ export {
   getSchedulesDir,
   getAppsDir,
   getUnitupDir,
-
   // System & Doctor checks
   isSystemctlAvailable as isSystemdAvailable,
   isSystemctlAvailable,
@@ -136,7 +261,7 @@ export {
   checkNodeDiagnostics,
   findNodeExecutable,
   getDoctorInfo,
-
+  runDoctor,
   // Unit file & path helpers
   getUserUnitDir,
   getUnitPath,
@@ -150,8 +275,10 @@ export {
   getUnitFilename,
   getTimerFilename,
   getServiceNameFromUnit,
-
   // Runner override for testing
   setCommandRunner,
-  resetCommandRunner
+  resetCommandRunner,
+  runCommand
 };
+
+export default defaultManager;

package/src/logs.js

@@ -0,0 +1,148 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+
+/**
+ * Reads lines from one or more log files with tailing, filtering, and follow support.
+ *
+ * @param {string|string[]} filePaths
+ * @param {object} [options]
+ * @param {number} [options.lines=100]
+ * @param {boolean} [options.follow=false]
+ * @param {string} [options.grep]
+ * @param {string} [options.since]
+ * @param {boolean} [options.json=false]
+ * @returns {Promise<string|EventEmitter>}
+ */
+export async function readServiceLogs(filePaths, options = {}) {
+  const allCandidatePaths = (Array.isArray(filePaths) ? filePaths : [filePaths]).filter(Boolean);
+  const existingPaths = allCandidatePaths.filter((p) => fs.existsSync(p));
+  existingPaths.sort((a, b) => {
+    try {
+      return fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+  const maxLines = typeof options.lines === 'number' && options.lines > 0 ? options.lines : 100;
+  const grepPattern = options.grep ? new RegExp(options.grep, 'i') : null;
+
+  // Collect all lines from currently existing files
+  const allEntries = [];
+  for (const filePath of existingPaths) {
+    try {
+      const stat = fs.statSync(filePath);
+      let content = '';
+
+      // If file is larger than 1MB, read only the tail chunk
+      if (stat.size > 1024 * 1024) {
+        const chunkSize = Math.min(stat.size, Math.max(1024 * 1024, maxLines * 2048));
+        const start = Math.max(0, stat.size - chunkSize);
+        const buffer = Buffer.alloc(stat.size - start);
+        const fd = fs.openSync(filePath, 'r');
+        fs.readSync(fd, buffer, 0, buffer.length, start);
+        fs.closeSync(fd);
+        content = buffer.toString('utf8');
+      } else {
+        content = fs.readFileSync(filePath, 'utf8');
+      }
+
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (!line && line.trim() === '') continue;
+        if (grepPattern && !grepPattern.test(line)) continue;
+        allEntries.push(line);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Slice tail lines
+  const sliced = allEntries.slice(-maxLines);
+
+  if (options.follow) {
+    const emitter = new EventEmitter();
+    const filePositions = new Map();
+
+    for (const p of allCandidatePaths) {
+      try {
+        if (fs.existsSync(p)) {
+          const stat = fs.statSync(p);
+          filePositions.set(p, stat.size);
+        } else {
+          filePositions.set(p, 0);
+        }
+      } catch {
+        filePositions.set(p, 0);
+      }
+    }
+
+    // Print initial existing lines
+    for (const l of sliced) {
+      console.log(l);
+      emitter.emit('line', l);
+    }
+
+    let isPolling = false;
+    const interval = setInterval(() => {
+      if (isPolling) return;
+      isPolling = true;
+
+      try {
+        for (const p of allCandidatePaths) {
+          try {
+            if (!fs.existsSync(p)) continue;
+            const stat = fs.statSync(p);
+            const lastPos = filePositions.get(p) || 0;
+
+            if (stat.size > lastPos) {
+              const stream = fs.createReadStream(p, { start: lastPos, end: stat.size, encoding: 'utf8' });
+              let buffer = '';
+              stream.on('data', (chunk) => {
+                buffer += chunk;
+              });
+              stream.on('end', () => {
+                filePositions.set(p, stat.size);
+                const newLines = buffer.split('\n');
+                for (const line of newLines) {
+                  if (!line || !line.trim()) continue;
+                  if (grepPattern && !grepPattern.test(line)) continue;
+                  console.log(line);
+                  emitter.emit('line', line);
+                }
+              });
+            } else if (stat.size < lastPos) {
+              // File truncated or rotated
+              filePositions.set(p, 0);
+            }
+          } catch {
+            // ignore
+          }
+        }
+      } finally {
+        isPolling = false;
+      }
+    }, 250);
+
+    emitter.stop = () => {
+      clearInterval(interval);
+      emitter.emit('close');
+    };
+
+    return emitter;
+  }
+
+  if (options.json) {
+    return JSON.stringify(
+      sliced.map((line) => ({ message: line })),
+      null,
+      2
+    );
+  }
+
+  if (sliced.length === 0) {
+    return 'No logs found.';
+  }
+
+  return sliced.join('\n');
+}

package/src/platform/base.js

@@ -0,0 +1,211 @@
+import { UnsupportedPlatformError } from '../errors.js';
+import { runCommand } from '../systemd.js';
+
+/**
+ * Base ServiceAdapter class defining the cross-platform contract for service management.
+ */
+export class ServiceAdapter {
+  /**
+   * @param {object} [options]
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Platform identifier name.
+   * @type {string}
+   */
+  get name() {
+    return 'base';
+  }
+
+  /**
+   * Platform capabilities metadata.
+   * @type {object}
+   */
+  get capabilities() {
+    return {
+      serviceManager: 'none',
+      supports: {
+        install: false,
+        uninstall: false,
+        start: false,
+        stop: false,
+        restart: false,
+        enable: false,
+        disable: false,
+        status: false,
+        logs: false,
+        restartPolicy: false,
+        userServices: false,
+        systemServices: false,
+        memoryLimits: false,
+        schedule: false
+      }
+    };
+  }
+
+  /**
+   * Executes a command using the configured command runner.
+   *
+   * @param {string} cmd
+   * @param {string[]} args
+   * @param {object} [opts]
+   * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
+   */
+  async run(cmd, args, opts) {
+    return runCommand(cmd, args, opts);
+  }
+
+  /**
+   * Generates the service definition (unit file, plist, etc.) from normalized config.
+   *
+   * @param {object} config - NormalizedServiceConfig
+   * @returns {string|object}
+   */
+  generateService(config) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Installs a service from normalized config.
+   *
+   * @param {object} config - NormalizedServiceConfig
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async install(config, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Uninstalls a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async uninstall(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Starts a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async start(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Stops a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async stop(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Restarts a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async restart(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Enables automatic startup for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async enable(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Disables automatic startup for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async disable(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Gets normalized status for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async status(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Inspects detailed configuration and runtime info for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async inspect(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Retrieves or streams logs for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<any>}
+   */
+  async logs(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Lists all services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async list(options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Checks if a service is installed.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>|boolean}
+   */
+  isInstalled(name, options = {}) {
+    return false;
+  }
+
+  /**
+   * Lists failed services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async failures(options = {}) {
+    return [];
+  }
+}

package/src/platform/index.js

@@ -0,0 +1,43 @@
+import { UnsupportedPlatformError } from '../errors.js';
+import { ServiceAdapter } from './base.js';
+import { LinuxAdapter } from './linux.js';
+import { MacOSAdapter } from './macos.js';
+import { WindowsAdapter } from './windows.js';
+
+export { ServiceAdapter, LinuxAdapter, MacOSAdapter, WindowsAdapter };
+
+/**
+ * Returns the appropriate platform service adapter for the given OS.
+ *
+ * @param {string} [platform]
+ * @param {object} [options]
+ * @returns {ServiceAdapter}
+ */
+export function getAdapter(platform, options = {}) {
+  const targetPlatform =
+    platform || process.env.UNITUP_PLATFORM || (process.env.XDG_CONFIG_HOME ? 'linux' : process.platform);
+
+  switch (targetPlatform) {
+    case 'linux':
+      return new LinuxAdapter(options);
+    case 'darwin':
+    case 'macos':
+      return new MacOSAdapter(options);
+    case 'win32':
+    case 'windows':
+      return new WindowsAdapter(options);
+    default:
+      throw new UnsupportedPlatformError(targetPlatform);
+  }
+}
+
+/**
+ * Returns platform capabilities for the target or current OS.
+ *
+ * @param {string} [platform]
+ * @returns {object}
+ */
+export function getPlatformCapabilities(platform) {
+  const adapter = getAdapter(platform);
+  return adapter.capabilities;
+}