unitup 0.1.5 → 0.3.0

package/src/deploy/rollback-manager.js

@@ -0,0 +1,186 @@
+import { DrainManager } from '../core/drain-manager.js';
+import { GenerationManager } from '../core/generation-manager.js';
+import { IPCClient } from '../core/ipc.js';
+import { DeploymentLock } from '../core/lock.js';
+import { ProcessManager } from '../core/process-manager.js';
+import { ReadinessChecker } from '../core/readiness.js';
+import { Router } from '../core/router.js';
+import { readAppMetadata } from '../utils.js';
+
+/**
+ * RollbackManager provides orchestration for reverting traffic to a previous generation.
+ * It strictly composes the Unitup core primitives.
+ */
+export class RollbackManager {
+  /**
+   * @param {object} [options]
+   * @param {import('../core/generation-manager.js').GenerationManager} [options.generationManager]
+   * @param {import('../core/router.js').Router} [options.router]
+   * @param {import('../core/readiness.js').ReadinessChecker} [options.readiness]
+   * @param {import('../core/drain-manager.js').DrainManager} [options.drainManager]
+   * @param {import('../core/process-manager.js').ProcessManager} [options.processManager]
+   * @param {import('../core/lock.js').DeploymentLock} [options.lock]
+   */
+  constructor(options = {}) {
+    this.generationManager = options.generationManager;
+    this.router = options.router;
+    this.readiness = options.readiness;
+    this.drainManager = options.drainManager;
+    this.processManager = options.processManager;
+    this.lock = options.lock;
+  }
+
+  _ensurePrimitives(serviceName, options = {}) {
+    if (!this.processManager) {
+      this.processManager = new ProcessManager();
+    }
+    if (!this.generationManager) {
+      this.generationManager = new GenerationManager({
+        processManager: this.processManager,
+        stateDir: options.stateDir
+      });
+    }
+    if (!this.router) {
+      this.router = new Router();
+    }
+    if (!this.readiness) {
+      this.readiness = new ReadinessChecker({ processManager: this.processManager });
+    }
+    if (!this.drainManager) {
+      this.drainManager = new DrainManager({
+        router: this.router,
+        processManager: this.processManager
+      });
+    }
+    if (!this.lock) {
+      this.lock = new DeploymentLock({
+        lockDir: options.lockDir,
+        processManager: this.processManager
+      });
+    }
+  }
+
+  /**
+   * Rolls back a service to its previous generation.
+   *
+   * @param {string} serviceName
+   * @param {object} [serviceConfig]
+   * @param {object} [options]
+   * @param {string} [options.readyPath]
+   * @param {number} [options.drainTimeout]
+   * @param {function(object): void} [options.onProgress]
+   * @returns {Promise<object>} Rollback summary
+   */
+  async rollback(serviceName, serviceConfig = {}, options = {}) {
+    if (!serviceName) {
+      throw new Error('Service name is required for rollback.');
+    }
+
+    // Check if a supervisor daemon is running for this service via IPC
+    const ipcClient = new IPCClient(serviceName, options.ipcDir);
+    const isRemote = await ipcClient.isAlive();
+    if (isRemote) {
+      return ipcClient.send(
+        {
+          action: 'rollback',
+          options: { ...options, ...serviceConfig }
+        },
+        options.onProgress
+      );
+    }
+
+    this._ensurePrimitives(serviceName, options);
+
+    const config =
+      serviceConfig && (serviceConfig.command || serviceConfig.script)
+        ? serviceConfig
+        : readAppMetadata(serviceName) || serviceConfig || {};
+
+    await this.lock.acquire(serviceName);
+
+    try {
+      // Check if a canary generation is running: if so, abort canary and preserve active
+      const canary = this.generationManager.getCanary(serviceName);
+      if (canary) {
+        if (options.onProgress) {
+          options.onProgress({ state: 'ABORTING_CANARY', canaryGeneration: canary.id });
+        }
+        this.router.clearCanary(serviceName);
+        const drainTimeout = options.drainTimeout || config.deploy?.drainTimeout || 5000;
+        await this.drainManager.drain(canary, { timeout: drainTimeout, stopProcess: true });
+        this.generationManager.remove(canary, false);
+
+        const active = this.generationManager.getActive(serviceName);
+        return {
+          service: serviceName,
+          abortedCanary: canary.id,
+          activeGeneration: active ? active.id : null,
+          status: 'canary_aborted'
+        };
+      }
+
+      const current = this.generationManager.getActive(serviceName);
+      const previous = this.generationManager.getPrevious(serviceName);
+
+      if (!previous) {
+        throw new Error(`No previous generation available to roll back to for service "${serviceName}".`);
+      }
+
+      if (options.onProgress) {
+        options.onProgress({ state: 'CHECKING_PREVIOUS', previous: previous.id });
+      }
+
+      // Check if previous is alive
+      if (!this.processManager.isAlive(previous.pid)) {
+        throw new Error(
+          `Previous generation #${previous.id} (PID ${previous.pid}) is no longer running and cannot be rolled back to.`
+        );
+      }
+
+      // Ensure previous generation is still ready
+      const isReady = await this.readiness.ensure(previous, {
+        path: options.readyPath || config.deploy?.ready
+      });
+
+      if (!isReady) {
+        throw new Error(`Previous generation #${previous.id} failed readiness verification.`);
+      }
+
+      if (options.onProgress) {
+        options.onProgress({ state: 'SWITCHING', targetGeneration: previous.id });
+      }
+
+      // Switch router to previous generation
+      this.router.switchBackend(serviceName, previous);
+      this.generationManager.markActive(previous);
+
+      // Drain and stop the rolled-back current generation
+      if (current && current.id !== previous.id) {
+        if (options.onProgress) {
+          options.onProgress({ state: 'DRAINING_CURRENT', generation: current.id });
+        }
+        this.generationManager.markDraining(current);
+        const drainTimeout = options.drainTimeout || config.deploy?.drainTimeout || 10000;
+        await this.drainManager.drain(current, { timeout: drainTimeout, stopProcess: true });
+        this.generationManager.remove(current, false);
+      }
+
+      const result = {
+        service: serviceName,
+        rolledBackFrom: current?.id ?? null,
+        activeGeneration: previous.id,
+        status: 'rolled_back'
+      };
+
+      if (options.onProgress) {
+        options.onProgress({ state: 'COMPLETE', ...result });
+      }
+
+      return result;
+    } finally {
+      await this.lock.release(serviceName);
+    }
+  }
+}
+
+export const defaultRollbackManager = new RollbackManager();

package/src/doctor.js

@@ -1,15 +1,18 @@
+import fs from 'node:fs';
 import os from 'node:os';
+import { findRuntimeExecutable } from './runtimes/common.js';
 import {
+  checkNodeDiagnostics,
+  checkUserLinger,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
   isUserSystemdAvailable,
   isUserUnitDirWritable,
-  checkUserLinger,
-  checkNodeDiagnostics
+  runCommand
 } from './systemd.js';
 import { getUserUnitDir } from './unit.js';
-import { findRuntimeExecutable } from './runtimes/common.js';
+import { getUnitupDir } from './utils.js';
 
 /**
  * Runs system diagnostic checks and returns structured data.
@@ -17,6 +20,7 @@ import { findRuntimeExecutable } from './runtimes/common.js';
  * @returns {Promise<Object>}
  */
 export async function getDoctorInfo() {
+  const platform = process.platform;
   const linux = isLinux();
   const systemctl = await isSystemctlAvailable();
   const pid1 = await isSystemdPID1();
@@ -25,6 +29,32 @@ export async function getDoctorInfo() {
   const lingering = await checkUserLinger();
   const nodeDiag = await checkNodeDiagnostics();
 
+  // macOS specific checks
+  let launchctlAvailable = false;
+  if (platform === 'darwin') {
+    try {
+      const res = await runCommand('launchctl', ['version']);
+      launchctlAvailable = res.code === 0 || (res.stdout && res.stdout.length > 0) || !res.stderr.includes('not found');
+    } catch {
+      launchctlAvailable = false;
+    }
+  }
+
+  // Windows specific checks
+  let windowsScmAvailable = false;
+  let isAdmin = false;
+  if (platform === 'win32') {
+    try {
+      const res = await runCommand('sc.exe', ['query']);
+      windowsScmAvailable = res.code === 0 || !res.stderr.includes('not found');
+      // Simple admin check: net session or whoami /priv
+      const adminRes = await runCommand('net', ['session']);
+      isAdmin = adminRes.code === 0;
+    } catch {
+      windowsScmAvailable = false;
+    }
+  }
+
   const nodePath = nodeDiag.execPath || (await findRuntimeExecutable(['node']));
   const pythonPath = await findRuntimeExecutable(['python3', 'python']);
   const rubyPath = await findRuntimeExecutable(['ruby']);
@@ -36,13 +66,13 @@ export async function getDoctorInfo() {
 
   const runtimes = {
     'Node.js': nodePath,
-    'Python': pythonPath,
-    'Ruby': rubyPath,
-    'PHP': phpPath,
-    'Bun': bunPath,
-    'Deno': denoPath,
-    'Go': goPath,
-    'Elixir': elixirPath
+    Python: pythonPath,
+    Ruby: rubyPath,
+    PHP: phpPath,
+    Bun: bunPath,
+    Deno: denoPath,
+    Go: goPath,
+    Elixir: elixirPath
   };
 
   let cgroupV2 = false;
@@ -60,11 +90,20 @@ export async function getDoctorInfo() {
   const memoryMaxSupported = linux && (cgroupV2 || userSystemd);
   const memorySwapMaxSupported = linux && cgroupV2 && memoryController;
 
+  let serviceManager = 'systemd';
+  if (platform === 'darwin') serviceManager = 'launchd';
+  else if (platform === 'win32') serviceManager = 'Windows Service Manager';
+
   return {
+    platform,
+    serviceManager,
     linux,
     systemctl,
     systemdRunning: pid1,
     userSystemdAvailable: userSystemd,
+    launchctlAvailable,
+    windowsScmAvailable,
+    isAdmin,
     cgroupV2,
     memoryController,
     memoryMaxSupported,
@@ -74,6 +113,7 @@ export async function getDoctorInfo() {
     nodeVersion: nodeDiag.version,
     runtimes,
     unitDir: getUserUnitDir(),
+    unitupDataDir: getUnitupDir(),
     unitDirWritable,
     lingering,
     username: os.userInfo().username
@@ -89,27 +129,49 @@ export async function runDoctor() {
   const info = await getDoctorInfo();
 
   if (info.linux) {
+    console.log('Platform: Linux');
+    console.log('Service manager: systemd');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
     console.log('✓ Linux detected');
-  } else {
-    console.log('✗ Non-Linux OS detected (systemd requires Linux)');
-  }
 
-  if (info.systemctl) {
-    console.log('✓ systemctl available');
-  } else {
-    console.log('✗ systemctl command not found');
-  }
+    if (info.systemctl) {
+      console.log('✓ systemctl available');
+    } else {
+      console.log('✗ systemctl command not found');
+    }
 
-  if (info.systemdRunning) {
-    console.log('✓ systemd is running');
-  } else {
-    console.log('! systemd is not running as PID 1');
-  }
+    if (info.systemdRunning) {
+      console.log('✓ systemd is running');
+    } else {
+      console.log('! systemd is not running as PID 1');
+    }
 
-  if (info.userSystemdAvailable) {
-    console.log('✓ systemd user services available');
+    if (info.userSystemdAvailable) {
+      console.log('✓ systemd user services available');
+    } else {
+      console.log('! systemd user services unavailable');
+    }
+  } else if (info.platform === 'darwin') {
+    console.log('Platform: macOS');
+    console.log('Service manager: launchd');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
+    console.log('! Non-Linux OS detected (macOS uses launchd)');
+    console.log('✓ launchctl: available');
+    console.log('✓ Permissions: user services supported');
+  } else if (info.platform === 'win32') {
+    console.log('Platform: Windows');
+    console.log('Service manager: Windows Service Manager');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
+    console.log('! Non-Linux OS detected (Windows uses Windows Services)');
+    console.log(`Administrator: ${info.isAdmin ? 'yes' : 'no'}`);
+    if (!info.isAdmin) {
+      console.log('! Service installation requires Administrator privileges');
+    }
   } else {
-    console.log('! systemd user services unavailable');
+    console.log(`✗ Non-Linux OS detected (${info.platform})`);
   }
 
   console.log('\nDetected runtimes:');
@@ -121,48 +183,53 @@ export async function runDoctor() {
     }
   }
 
-  console.log('\nMemory Controller Diagnostics:');
-  if (info.cgroupV2) {
-    console.log('✓ cgroup v2 detected');
-  } else {
-    console.log('- cgroup v2 unavailable');
-  }
+  if (info.linux) {
+    console.log('\nMemory Controller Diagnostics:');
+    if (info.cgroupV2) {
+      console.log('✓ cgroup v2 detected');
+    } else {
+      console.log('- cgroup v2 unavailable');
+    }
 
-  if (info.memoryController) {
-    console.log('✓ Memory controller available');
-  } else {
-    console.log('- Memory controller unavailable');
-  }
+    if (info.memoryController) {
+      console.log('✓ Memory controller available');
+    } else {
+      console.log('- Memory controller unavailable');
+    }
 
-  if (info.memoryMaxSupported) {
-    console.log('✓ MemoryMax supported');
-  } else {
-    console.log('- MemoryMax unavailable');
-  }
+    if (info.memoryMaxSupported) {
+      console.log('✓ MemoryMax supported');
+    } else {
+      console.log('- MemoryMax unavailable');
+    }
 
-  if (info.memorySwapMaxSupported) {
-    console.log('✓ MemorySwapMax supported');
-  } else {
-    console.log('- MemorySwapMax unavailable');
-  }
+    if (info.memorySwapMaxSupported) {
+      console.log('✓ MemorySwapMax supported');
+    } else {
+      console.log('- MemorySwapMax unavailable');
+    }
 
-  console.log('');
+    console.log('');
 
-  if (info.unitDirWritable) {
-    console.log('✓ Unit directory writable');
-  } else {
-    console.log(`! Unit directory not writable (${info.unitDir})`);
+    if (info.unitDirWritable) {
+      console.log('✓ Unit directory writable');
+    } else {
+      console.log(`! Unit directory not writable (${info.unitDir})`);
+    }
   }
 
   if (info.lingering) {
     console.log('✓ User lingering is enabled');
   } else {
     console.log('! User lingering is disabled');
-    console.log('\nUser lingering is disabled.');
-    console.log('The service may stop after logout.');
-    console.log('\nEnable it manually:');
-    console.log(`  loginctl enable-linger ${info.username}\n`);
+    if (info.linux) {
+      console.log('\nUser lingering is disabled.');
+      console.log('The service may stop after logout.');
+      console.log('\nEnable it manually:');
+      console.log(`  loginctl enable-linger ${info.username}\n`);
+    }
   }
 
+  console.log('\n✓ Unitup can manage services on this machine');
   return info;
 }

package/src/errors.js

@@ -0,0 +1,131 @@
+/**
+ * Base error class for all Unitup errors.
+ */
+export class UnitupError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} [code]
+   */
+  constructor(message, code = 'UNITUP_ERROR') {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+/**
+ * Thrown when an unsupported platform is encountered.
+ */
+export class UnsupportedPlatformError extends UnitupError {
+  /**
+   * @param {string} [platform]
+   */
+  constructor(platform = process.platform) {
+    super(`Platform "${platform}" is not supported by Unitup.`, 'ERR_UNSUPPORTED_PLATFORM');
+    this.platform = platform;
+  }
+}
+
+/**
+ * Thrown when a specified service is not found.
+ */
+export class ServiceNotFoundError extends UnitupError {
+  /**
+   * @param {string} name
+   */
+  constructor(name) {
+    super(`Service "${name}" does not exist.`, 'ERR_SERVICE_NOT_FOUND');
+    this.serviceName = name;
+  }
+}
+
+/**
+ * Thrown when attempting to create a service that already exists without overwrite/force.
+ */
+export class ServiceAlreadyExistsError extends UnitupError {
+  /**
+   * @param {string} name
+   */
+  constructor(name) {
+    super(`Service "${name}" already exists. Use --force to overwrite.`, 'ERR_SERVICE_ALREADY_EXISTS');
+    this.serviceName = name;
+  }
+}
+
+/**
+ * Thrown when elevated administrator or root privileges are required for an action.
+ */
+export class PermissionRequiredError extends UnitupError {
+  /**
+   * @param {string} message
+   * @param {string} [action]
+   */
+  constructor(message = 'Administrator/root privileges are required to perform this action.', action) {
+    super(message, 'ERR_PERMISSION_REQUIRED');
+    this.action = action;
+  }
+}
+
+/**
+ * Thrown when a service fails to start.
+ */
+export class ServiceStartError extends UnitupError {
+  /**
+   * @param {string} name
+   * @param {string} [reason]
+   */
+  constructor(name, reason) {
+    super(`Failed to start service "${name}"${reason ? `: ${reason}` : ''}`, 'ERR_SERVICE_START');
+    this.serviceName = name;
+    this.reason = reason;
+  }
+}
+
+/**
+ * Thrown when a service fails to stop.
+ */
+export class ServiceStopError extends UnitupError {
+  /**
+   * @param {string} name
+   * @param {string} [reason]
+   */
+  constructor(name, reason) {
+    super(`Failed to stop service "${name}"${reason ? `: ${reason}` : ''}`, 'ERR_SERVICE_STOP');
+    this.serviceName = name;
+    this.reason = reason;
+  }
+}
+
+/**
+ * Thrown when service configuration is invalid.
+ */
+export class InvalidServiceConfigError extends UnitupError {
+  /**
+   * @param {string} message
+   * @param {string} [field]
+   */
+  constructor(message, field) {
+    super(message, 'ERR_INVALID_CONFIG');
+    this.field = field;
+  }
+}
+
+/**
+ * Thrown when a required binary executable cannot be resolved.
+ */
+export class ExecutableNotFoundError extends UnitupError {
+  /**
+   * @param {string} executable
+   * @param {string} [message]
+   */
+  constructor(executable, message) {
+    super(
+      message || `Executable "${executable}" could not be found in PATH or at specified path.`,
+      'ERR_EXECUTABLE_NOT_FOUND'
+    );
+    this.executable = executable;
+  }
+}