unitup 0.2.0 → 0.4.0

package/src/deploy/rollback-manager.js

@@ -0,0 +1,187 @@
+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
+      const publicPort = options.publicPort || config.port;
+      this.router.switchBackend(serviceName, previous, publicPort);
+      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/index.js

@@ -1,3 +1,26 @@
+import {
+  DeploymentLock,
+  DeploymentLockError,
+  DrainManager,
+  GenerationManager,
+  IPCClient,
+  IPCServer,
+  PortMismatchError,
+  ProcessManager,
+  ProcessStartupError,
+  ReadinessChecker,
+  ReadinessTimeoutError,
+  Router,
+  Supervisor,
+  findFreePort
+} from './core/index.js';
+import {
+  DeploymentManager,
+  DeploymentState,
+  RollbackManager,
+  defaultDeploymentManager,
+  defaultRollbackManager
+} from './deploy/index.js';
 import { getDoctorInfo, runDoctor } from './doctor.js';
 import {
   ExecutableNotFoundError,
@@ -73,6 +96,7 @@ import {
 } from './unit.js';
 import {
   findProjectConfig,
+  formatDuration,
   formatMemoryBytes,
   getAppMetadataPath,
   getAppsDir,
@@ -101,6 +125,10 @@ 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);
@@ -116,6 +144,10 @@ export {
   start,
   stop,
   restart,
+  deploy,
+  promote,
+  rollback,
+  generations,
   status,
   list,
   inspect,
@@ -125,6 +157,27 @@ export {
   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,
@@ -179,6 +232,7 @@ export {
   validateMemorySize,
   validateDuration,
   formatMemoryBytes,
+  formatDuration,
   // Runtime detection & resolution
   detectRuntime,
   resolveRuntimeConfig,

package/src/platform/macos.js

@@ -13,6 +13,7 @@ import {
   deleteAppMetadata,
   formatRelativeTime,
   getAppsDir,
+  getUnitupBinPath,
   getUnitupDir,
   readAppMetadata,
   sanitizeServiceName,
@@ -175,7 +176,9 @@ export class MacOSAdapter extends ServiceAdapter {
     const safeName = sanitizeServiceName(config.name);
     const label = this.getLabel(safeName);
 
-    const programArguments = [config.command, ...(config.args || [])];
+    const programArguments = config.deploy?.zeroDowntime
+      ? [process.execPath, getUnitupBinPath(), 'supervisor', safeName]
+      : [config.command, ...(config.args || [])];
 
     // Ensure log directory exists
     const stdoutLog = config.logs?.stdout || path.join(getUnitupDir(), 'logs', `${safeName}.log`);

package/src/platform/windows-host.js

@@ -1,4 +1,4 @@
-import { spawn, execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';

package/src/platform/windows.js

@@ -14,6 +14,7 @@ import {
   deleteAppMetadata,
   formatRelativeTime,
   getAppsDir,
+  getUnitupBinPath,
   getUnitupDir,
   readAppMetadata,
   sanitizeServiceName,
@@ -75,7 +76,9 @@ export class WindowsAdapter extends ServiceAdapter {
     const safeName = sanitizeServiceName(config.name);
     const serviceName = this.getServiceName(safeName);
     const nodeExec = process.execPath;
-    const binPath = `"${nodeExec}" "${WINDOWS_HOST_PATH}" "${safeName}"`;
+    const hostScript = config.deploy?.zeroDowntime ? getUnitupBinPath() : WINDOWS_HOST_PATH;
+    const hostArg = config.deploy?.zeroDowntime ? `supervisor "${safeName}"` : `"${safeName}"`;
+    const binPath = `"${nodeExec}" "${hostScript}" ${hostArg}`;
     const startType = config.autostart !== false ? 'auto' : 'demand';
 
     return {

package/src/service/config.js

@@ -48,6 +48,14 @@ export function mergeConfigWithOptions(opts = {}) {
     memoryHigh: opts.memoryHigh || projectCfg?.resources?.memoryHigh || projectCfg?.memoryHigh || '',
     memoryMax: opts.memoryMax || projectCfg?.resources?.memoryMax || projectCfg?.memoryMax || '',
     memorySwapMax: opts.memorySwapMax || projectCfg?.resources?.memorySwapMax || projectCfg?.memorySwapMax || '',
+    port: opts.port !== undefined ? opts.port : projectCfg.port,
+    deploy: {
+      ...(projectCfg.deploy && typeof projectCfg.deploy === 'object' ? projectCfg.deploy : {}),
+      ...(opts.deploy && typeof opts.deploy === 'object' ? opts.deploy : {}),
+      ...(opts.zeroDowntime !== undefined ? { zeroDowntime: !!opts.zeroDowntime } : {}),
+      ...(opts.ready !== undefined ? { ready: opts.ready } : {}),
+      ...(opts.drain !== undefined ? { drain: opts.drain } : {})
+    },
     ...opts,
     env: { ...(projectCfg.env || {}), ...(opts.env || {}) },
     cwd: targetCwd

package/src/service/normalize.js

@@ -2,7 +2,13 @@ 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';
+import {
+  getUnitupDir,
+  parseDurationMs,
+  resolveEffectiveMemoryLimits,
+  resolveWorkingDirectory,
+  sanitizeServiceName
+} from '../utils.js';
 
 /**
  * Resolves a binary or command name to an absolute executable path.
@@ -187,6 +193,27 @@ export async function normalizeServiceConfig(rawOpts = {}) {
   // Memory and resource limits
   const resources = resolveEffectiveMemoryLimits(rawOpts);
 
+  // Port and Deploy normalization
+  const port =
+    rawOpts.port !== undefined && rawOpts.port !== null && rawOpts.port !== '' ? Number(rawOpts.port) : undefined;
+
+  const rawDeploy = rawOpts.deploy && typeof rawOpts.deploy === 'object' ? rawOpts.deploy : {};
+  const zeroDowntime = !!(rawOpts.deploy === true || rawDeploy.zeroDowntime || rawOpts.zeroDowntime);
+  const readyPath =
+    typeof rawDeploy.ready === 'string'
+      ? rawDeploy.ready
+      : typeof rawOpts.ready === 'string'
+        ? rawOpts.ready
+        : undefined;
+  const drainRaw = rawDeploy.drain !== undefined ? rawDeploy.drain : rawOpts.drain;
+  const drainTimeout = drainRaw !== undefined ? parseDurationMs(drainRaw) : 10000;
+  const deploy = {
+    zeroDowntime,
+    ready: readyPath,
+    drain: drainRaw,
+    drainTimeout
+  };
+
   return {
     name,
     displayName,
@@ -196,6 +223,8 @@ export async function normalizeServiceConfig(rawOpts = {}) {
     args,
     script: rawOpts.script ? path.resolve(cwd, rawOpts.script) : undefined,
     cwd,
+    port,
+    deploy,
     env,
     envFile: rawOpts.envFile ? path.resolve(cwd, rawOpts.envFile) : undefined,
     autostart,

package/src/unit.js

@@ -9,6 +9,7 @@ import {
   getServiceNameFromUnit,
   getTimerFilename,
   getUnitFilename,
+  getUnitupBinPath,
   resolveAbsolutePath,
   resolveEffectiveMemoryLimits,
   resolveWorkingDirectory,
@@ -73,7 +74,10 @@ export function generateUnitContent(opts) {
   let commandExec = '';
   let execArgs = [];
 
-  if (opts.command) {
+  if (opts.deploy?.zeroDowntime) {
+    commandExec = process.execPath;
+    execArgs = [getUnitupBinPath(), 'supervisor', safeName];
+  } else if (opts.command) {
     commandExec = resolveAbsolutePath(opts.command);
     execArgs = Array.isArray(opts.args) ? [...opts.args] : [];
   } else if (opts.script) {
@@ -95,6 +99,10 @@ export function generateUnitContent(opts) {
     .filter((p, i, self) => p && self.indexOf(p) === i)
     .join(':');
 
+  const logLevelMax = opts.logLevelMax || 'info';
+  const logRateLimitIntervalSec = opts.logRateLimitIntervalSec || '10s';
+  const logRateLimitBurst = opts.logRateLimitBurst !== undefined ? opts.logRateLimitBurst : 200;
+
   const serviceLines = [
     '[Unit]',
     `Description=unitup service: ${safeName}`,
@@ -108,7 +116,10 @@ export function generateUnitContent(opts) {
     `Restart=${restartPolicy}`,
     'RestartSec=3',
     'StandardOutput=journal',
-    'StandardError=journal'
+    'StandardError=journal',
+    `LogLevelMax=${logLevelMax}`,
+    `LogRateLimitIntervalSec=${logRateLimitIntervalSec}`,
+    `LogRateLimitBurst=${logRateLimitBurst}`
   ];
 
   const effectiveLimits = resolveEffectiveMemoryLimits(opts);
@@ -169,6 +180,8 @@ export function writeUnitFile(opts) {
     script: opts.script,
     cwd: opts.cwd,
     node: opts.nodePath,
+    port: opts.port,
+    deploy: opts.deploy,
     memoryHigh: opts.memoryHigh || opts.resources?.memoryHigh,
     memoryMax: opts.memoryMax || opts.resources?.memoryMax,
     memorySwapMax: opts.memorySwapMax || opts.resources?.memorySwapMax,
@@ -259,6 +272,12 @@ export function parseUnitContent(content) {
       result.memoryMax = trimmed.slice(10).trim();
     } else if (trimmed.startsWith('MemorySwapMax=')) {
       result.memorySwapMax = trimmed.slice(14).trim();
+    } else if (trimmed.startsWith('LogLevelMax=')) {
+      result.logLevelMax = trimmed.slice(12).trim();
+    } else if (trimmed.startsWith('LogRateLimitIntervalSec=')) {
+      result.logRateLimitIntervalSec = trimmed.slice(24).trim();
+    } else if (trimmed.startsWith('LogRateLimitBurst=')) {
+      result.logRateLimitBurst = Number.parseInt(trimmed.slice(18).trim(), 10);
     }
   }
 
@@ -316,6 +335,10 @@ export function generateScheduleServiceContent(opts) {
     .filter((p, i, self) => p && self.indexOf(p) === i)
     .join(':');
 
+  const logLevelMax = opts.logLevelMax || 'info';
+  const logRateLimitIntervalSec = opts.logRateLimitIntervalSec || '10s';
+  const logRateLimitBurst = opts.logRateLimitBurst !== undefined ? opts.logRateLimitBurst : 200;
+
   const serviceLines = [
     '[Unit]',
     `Description=unitup scheduled task: ${safeName}`,
@@ -327,7 +350,10 @@ export function generateScheduleServiceContent(opts) {
     `WorkingDirectory=${cwd}`,
     `ExecStart=${execStartLine}`,
     'StandardOutput=journal',
-    'StandardError=journal'
+    'StandardError=journal',
+    `LogLevelMax=${logLevelMax}`,
+    `LogRateLimitIntervalSec=${logRateLimitIntervalSec}`,
+    `LogRateLimitBurst=${logRateLimitBurst}`
   ];
 
   const effectiveLimits = resolveEffectiveMemoryLimits(opts);

package/src/utils.js

@@ -1,6 +1,16 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Returns the absolute path to the unitup CLI binary.
+ * @returns {string}
+ */
+export function getUnitupBinPath() {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(currentDir, '../bin/unitup.js');
+}
 
 /**
  * Returns the base unitup config directory (~/.config/unitup).
@@ -170,6 +180,8 @@ export function saveAppMetadata(meta) {
     args,
     cwd,
     group: meta.group || 'default',
+    ...(meta.port !== undefined ? { port: meta.port } : {}),
+    ...(meta.deploy ? { deploy: meta.deploy } : {}),
     // Optional resources section
     ...(Object.keys(resources).length > 0 ? { resources } : {}),
     // Backward compatibility fields
@@ -415,6 +427,32 @@ export function formatRelativeTime(timestamp) {
   return `${days} day${days === 1 ? '' : 's'} ago`;
 }
 
+/**
+ * Formats duration in milliseconds into a concise human-readable string (e.g. "23s", "2 mins", "3 hours", "2 days").
+ *
+ * @param {number} ms
+ * @returns {string}
+ */
+export function formatDuration(ms) {
+  if (typeof ms !== 'number' || isNaN(ms) || ms < 0) {
+    return '-';
+  }
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes} min${minutes === 1 ? '' : 's'}`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours} hour${hours === 1 ? '' : 's'}`;
+  }
+  const days = Math.floor(hours / 24);
+  return `${days} day${days === 1 ? '' : 's'}`;
+}
+
 /**
  * Formats data rows into a text table.
  *
@@ -603,6 +641,48 @@ export function validateDuration(val, paramName = 'Duration') {
   return str;
 }
 
+/**
+ * Parses a duration string (e.g. '30s', '500ms', '1m') into milliseconds.
+ * @param {string|number} val
+ * @param {number} [defaultMs=10000]
+ * @returns {number}
+ */
+export function parseDurationMs(val, defaultMs = 10000) {
+  if (typeof val === 'number') return val;
+  if (!val || typeof val !== 'string') return defaultMs;
+  const str = val.trim().toLowerCase();
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(ms|msec|s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|day|days?)?$/);
+  if (!match) return defaultMs;
+  const num = Number.parseFloat(match[1]);
+  const unit = match[2] || 's';
+  switch (unit) {
+    case 'ms':
+    case 'msec':
+      return num;
+    case 's':
+    case 'sec':
+    case 'second':
+    case 'seconds':
+      return num * 1000;
+    case 'm':
+    case 'min':
+    case 'minute':
+    case 'minutes':
+      return num * 60 * 1000;
+    case 'h':
+    case 'hr':
+    case 'hour':
+    case 'hours':
+      return num * 60 * 60 * 1000;
+    case 'd':
+    case 'day':
+    case 'days':
+      return num * 24 * 60 * 60 * 1000;
+    default:
+      return num * 1000;
+  }
+}
+
 /**
  * Formats a future date/timestamp into relative human readable string (e.g. "in 12 minutes", "tomorrow").
  * @param {string|number|Date} dateVal

package/SECURITY.md

@@ -1,21 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 5.1.x   | :white_check_mark: |
-| 5.0.x   | :x:                |
-| 4.0.x   | :white_check_mark: |
-| < 4.0   | :x:                |
-
-## Reporting a Vulnerability
-
-Use this section to tell people how to report a vulnerability.
-
-Tell them where to go, how often they can expect to get an update on a
-reported vulnerability, what to expect if the vulnerability is accepted or
-declined, etc.

package/biome.json

@@ -1,44 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "vcs": {
-    "enabled": true,
-    "clientKind": "git",
-    "useIgnoreFile": true
-  },
-  "files": {
-    "ignoreUnknown": true,
-    "ignore": ["node_modules", "dist", "coverage"]
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 120
-  },
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "style": {
-        "noUnusedTemplateLiteral": "off"
-      },
-      "complexity": {
-        "noForEach": "off"
-      },
-      "suspicious": {
-        "noEmptyBlockStatements": "off"
-      }
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "single",
-      "jsxQuoteStyle": "double",
-      "trailingCommas": "none",
-      "semicolons": "always"
-    }
-  }
-}