@akash-chowdhury-24/deployhub 2.0.15 → 2.0.17

package/src/utils/health-check.js

@@ -0,0 +1,158 @@
+import axios from 'axios';
+import { getEnvSettings } from '../core/environments.js';
+
+/**
+ * Per-environment health URL: `environments.{env}.config.healthCheckUrl`, else top-level fallback.
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @returns {string}
+ */
+export function resolveEnvHealthCheckUrl(config, envName) {
+  const env = config.environments?.[envName];
+  const settings = getEnvSettings(env);
+  const override = settings.healthCheckUrl;
+  if (typeof override === 'string' && override.trim()) {
+    return override.trim();
+  }
+  const fallback = config.healthCheck?.url;
+  return typeof fallback === 'string' && fallback.trim() ? fallback.trim() : '';
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string[]} envNames
+ * @returns {boolean}
+ */
+export function anyEnvHasResolvableHealthCheckUrl(config, envNames) {
+  return (envNames || []).some((name) => Boolean(resolveEnvHealthCheckUrl(config, name)));
+}
+
+/**
+ * @param {number} status
+ * @returns {boolean}
+ */
+export function isHealthyHttpStatus(status) {
+  return status >= 200 && status < 400;
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {{ httpGet?: (url: string, timeoutMs: number) => Promise<{ status: number }> }} [options]
+ * @returns {Promise<{ ok: true, envName: string, url: string, status: number, elapsed: number } | { ok: false, envName: string, url: string, error: string }>}
+ */
+export async function checkEnvHealth(config, envName, options = {}) {
+  const url = resolveEnvHealthCheckUrl(config, envName);
+  if (!url) {
+    return { ok: false, envName, url: '', error: `No health check URL configured for environment "${envName}"` };
+  }
+
+  const timeoutMs = (config.healthCheck?.timeout || 30) * 1000;
+  const httpGet =
+    options.httpGet ||
+    (async (target, ms) => {
+      const response = await axios.get(target, {
+        timeout: ms,
+        validateStatus: () => true,
+      });
+      return { status: response.status };
+    });
+
+  const start = Date.now();
+  try {
+    const { status } = await httpGet(url, timeoutMs);
+    const elapsed = Date.now() - start;
+    if (!isHealthyHttpStatus(status)) {
+      return {
+        ok: false,
+        envName,
+        url,
+        error: `Health check failed for ${envName}: HTTP ${status} (${elapsed}ms) — ${url}`,
+      };
+    }
+    return { ok: true, envName, url, status, elapsed };
+  } catch (err) {
+    const elapsed = Date.now() - start;
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      envName,
+      url,
+      error: `Health check failed for ${envName}: ${detail} (${elapsed}ms) — ${url}`,
+    };
+  }
+}
+
+/**
+ * Run health checks for each deployed environment independently (checks all, then summarizes).
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string[]} envNames
+ * @param {{ httpGet?: (url: string, timeoutMs: number) => Promise<{ status: number }> }} [options]
+ */
+export async function runHealthChecksForEnvs(config, envNames, options = {}) {
+  /** @type {{ envName: string, url: string, status: number, elapsed: number }[]} */
+  const results = [];
+  /** @type {{ envName: string, url: string, error: string }[]} */
+  const failures = [];
+
+  for (const envName of envNames || []) {
+    const url = resolveEnvHealthCheckUrl(config, envName);
+    if (!url) continue;
+
+    const outcome = await checkEnvHealth(config, envName, options);
+    if (outcome.ok) {
+      results.push({
+        envName: outcome.envName,
+        url: outcome.url,
+        status: outcome.status,
+        elapsed: outcome.elapsed,
+      });
+    } else {
+      failures.push({
+        envName: outcome.envName,
+        url: outcome.url,
+        error: outcome.error,
+      });
+    }
+  }
+
+  return { results, failures };
+}
+
+/**
+ * @param {{ envName: string, url: string, status: number, elapsed: number }[]} results
+ * @param {{ envName: string, url: string, error: string }[]} failures
+ * @returns {string}
+ */
+export function formatHealthCheckAllSummary(results, failures) {
+  const lines = ['Health check summary:'];
+  for (const r of results) {
+    lines.push(
+      `  ✓ ${r.envName.padEnd(14)} → HTTP ${r.status} (${r.elapsed}ms) ${r.url}`
+    );
+  }
+  for (const f of failures) {
+    lines.push(`  ✗ ${f.envName.padEnd(14)} → FAILED: ${f.error}`);
+  }
+  lines.push('');
+  if (failures.length === 0) {
+    lines.push(`All ${results.length} environment(s) passed health checks.`);
+  } else {
+    const total = results.length + failures.length;
+    lines.push(
+      `${failures.length} of ${total} environment(s) failed health checks. See above for details.`
+    );
+  }
+  return lines.join('\n');
+}
+
+export default {
+  resolveEnvHealthCheckUrl,
+  anyEnvHasResolvableHealthCheckUrl,
+  isHealthyHttpStatus,
+  checkEnvHealth,
+  runHealthChecksForEnvs,
+  formatHealthCheckAllSummary,
+};

package/src/utils/kubernetes-manifests.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { resolveContainerPort } from './dockerfile-expose.js';
+import { getEnvMethod, getEnvSettings } from '../core/environments.js';
 
 /**
  * @param {string} name
@@ -143,7 +144,8 @@ export function patchKubernetesManifestPorts(yaml, port) {
  */
 export function resolveKubernetesManifestOptions(config, environments = {}, options = {}) {
   const envList = Object.values(environments);
-  const k8sEnv = envList.find((env) => env.type === 'kubernetes') || {};
+  const k8sRaw = envList.find((env) => getEnvMethod(env) === 'kubernetes') || {};
+  const k8sEnv = getEnvSettings(k8sRaw);
 
   const appName = config.project || 'app';
   const imageName =

package/src/utils/nginx.js

@@ -7,6 +7,54 @@ export function sanitizeNginxProjectName(projectName) {
   return projectName.replace(/[^a-zA-Z0-9_-]/g, '-');
 }
 
+/**
+ * Site filename for Nginx activation. Grandfathered envs keep legacy `{project}` only;
+ * additional environments use `{project}-{env}` so same-host multi-env deploys don't clobber.
+ *
+ * @param {string} projectName
+ * @param {string} envName
+ * @param {boolean} isGrandfathered
+ * @returns {string}
+ */
+export function sanitizeNginxSiteName(projectName, envName, isGrandfathered) {
+  const base = sanitizeNginxProjectName(projectName);
+  if (isGrandfathered) {
+    // Avoid breaking existing single-env servers that already have sites-available/{project}.
+    return base;
+  }
+  return `${base}-${sanitizeNginxProjectName(envName)}`;
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @returns {boolean}
+ */
+export function isGrandfatheredNginxEnv(config, envName) {
+  const envs = config.environments || {};
+  if (Object.keys(envs).length <= 1) {
+    return true;
+  }
+  const grandfather =
+    config.unprefixedSecretEnvironment || config.defaultEnvironment || null;
+  return Boolean(grandfather && envName === grandfather);
+}
+
+/**
+ * Resolve the Nginx site filename for an environment deploy.
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @returns {string}
+ */
+export function resolveNginxSiteName(config, envName) {
+  return sanitizeNginxSiteName(
+    config.project || 'app',
+    envName,
+    isGrandfatheredNginxEnv(config, envName)
+  );
+}
+
 /**
  * Generate nginx server block config for SPA frontend deployments.
  *
@@ -32,38 +80,38 @@ export function generateNginxConfig(projectName, deployPath, buildOutput = 'dist
 }
 
 /**
- * Debian/Ubuntu: sites-available path for this project.
- * @param {string} projectName
+ * Debian/Ubuntu: sites-available path for this site name.
+ * @param {string} siteName — output of resolveNginxSiteName / sanitizeNginxSiteName
  * @returns {string}
  */
-export function getNginxSitesAvailablePath(projectName) {
-  return `/etc/nginx/sites-available/${sanitizeNginxProjectName(projectName)}`;
+export function getNginxSitesAvailablePath(siteName) {
+  return `/etc/nginx/sites-available/${siteName}`;
 }
 
 /**
- * Debian/Ubuntu: sites-enabled symlink path for this project.
- * @param {string} projectName
+ * Debian/Ubuntu: sites-enabled symlink path for this site name.
+ * @param {string} siteName
  * @returns {string}
  */
-export function getNginxSitesEnabledPath(projectName) {
-  return `/etc/nginx/sites-enabled/${sanitizeNginxProjectName(projectName)}`;
+export function getNginxSitesEnabledPath(siteName) {
+  return `/etc/nginx/sites-enabled/${siteName}`;
 }
 
 /**
- * RHEL/Amazon Linux: conf.d drop-in path for this project.
- * @param {string} projectName
+ * RHEL/Amazon Linux: conf.d drop-in path for this site name.
+ * @param {string} siteName
  * @returns {string}
  */
-export function getNginxConfDPath(projectName) {
-  return `/etc/nginx/conf.d/${sanitizeNginxProjectName(projectName)}.conf`;
+export function getNginxConfDPath(siteName) {
+  return `/etc/nginx/conf.d/${siteName}.conf`;
 }
 
 /**
- * @param {string} projectName
+ * @param {string} siteName
  * @returns {string}
  */
-export function getNginxSitePath(projectName) {
-  return getNginxSitesAvailablePath(projectName);
+export function getNginxSitePath(siteName) {
+  return getNginxSitesAvailablePath(siteName);
 }
 
 /**
@@ -83,6 +131,9 @@ export function formatPasswordlessSudoGuidance(sshUser) {
 export default {
   generateNginxConfig,
   sanitizeNginxProjectName,
+  sanitizeNginxSiteName,
+  isGrandfatheredNginxEnv,
+  resolveNginxSiteName,
   getNginxSitesAvailablePath,
   getNginxSitesEnabledPath,
   getNginxConfDPath,

package/src/utils/rollback/engine.js

@@ -1,4 +1,4 @@
-import { downloadArtifactEntry, loadArtifactHistory } from '../../storage/index.js';
+import { downloadArtifactEntry, ensureLegacyHistoryCopiedToDefaultEnv, loadEnvArtifactHistory } from '../../storage/index.js';
 import { getDeploymentProvider } from '../../deployment/index.js';
 import { extractArtifact } from '../../artifact/engine.js';
 import { createLogger } from '../../logger/index.js';
@@ -6,6 +6,11 @@ import {
   formatAmbiguousRollbackMatches,
   resolveRollbackTarget,
 } from '../artifact-history.js';
+import {
+  getEnabledEnvironmentNames,
+  getEnvMethod,
+  resolveDefaultEnvironmentName,
+} from '../../core/environments.js';
 import fs from 'fs-extra';
 import path from 'path';
 
@@ -21,72 +26,174 @@ async function rollbackTarget(config, artifactDir, envName, meta) {
     throw new Error(`Environment "${envName}" not found in config`);
   }
 
+  const method = getEnvMethod(envConfig) || 'server';
   const log = createLogger('rollback');
-  log.info(`Rolling back ${envName} (${envConfig.type || 'server'})...`);
+  log.info(`Rolling back ${envName} (${method})...`);
 
-  const provider = getDeploymentProvider(envConfig.type, config, envName);
+  const provider = getDeploymentProvider(method, config, envName);
   await provider.rollback(artifactDir, meta);
 }
 
 /**
+ * Map resolveRollbackTarget failures to env-scoped messages.
+ * @param {string} envName
+ * @param {{ reason: string, message: string, matches?: unknown[] }} resolved
+ */
+function formatEnvRollbackError(envName, resolved) {
+  if (resolved.reason === 'no-previous') {
+    return `No previous build found for environment "${envName}" (only one deploy in that environment's history). Deploy again before rolling back.`;
+  }
+  if (resolved.reason === 'empty') {
+    return `No previous build found for environment "${envName}" — that environment has no deploy history yet. Deploy at least once first.`;
+  }
+  if (resolved.reason === 'ambiguous' && resolved.matches) {
+    return `[${envName}] ${resolved.message}\n${formatAmbiguousRollbackMatches(
+      /** @type {import('../artifact-history.js').ArtifactHistoryEntry[]} */ (resolved.matches)
+    )}`;
+  }
+  return `[${envName}] ${resolved.message}`;
+}
+
+/**
+ * Rollback one or more environments. Each target resolves against THAT
+ * environment's `envs/{env}/history.json` ONLY — never the project-wide
+ * build catalog (`{project}/history.json`) and never another env's history.
+ *
  * @param {import('../../core/config.js').DeployHubConfig} config
  * @param {string} [versionOrBuildId]
  * @param {string} [cwd]
+ * @param {{ envNames?: string[], continueOnError?: boolean }} [options]
+ * @returns {Promise<{
+ *   artifactDir: string|null,
+ *   entry: import('../artifact-history.js').ArtifactHistoryEntry|null,
+ *   results: { envName: string, entry: import('../artifact-history.js').ArtifactHistoryEntry, artifactDir: string }[],
+ *   failures: { envName: string, error: string }[],
+ * }>}
  */
-export async function rollbackToVersion(config, versionOrBuildId, cwd = process.cwd()) {
+export async function rollbackToVersion(
+  config,
+  versionOrBuildId,
+  cwd = process.cwd(),
+  options = {}
+) {
   const log = createLogger('rollback');
   const providers = config.storage || [];
   if (providers.length === 0) {
     throw new Error('No storage providers configured — cannot download artifact for rollback');
   }
 
-  const { entries: history } = await loadArtifactHistory(providers, config.project);
-  const resolved = resolveRollbackTarget(history, versionOrBuildId);
+  const targets = options.envNames || getEnabledEnvironmentNames(config);
+  if (targets.length === 0) {
+    log.warn('No deployment targets configured');
+    return { artifactDir: null, entry: null, results: [], failures: [] };
+  }
+
+  const continueOnError = options.continueOnError === true;
 
-  if (!resolved.ok) {
-    if (resolved.reason === 'ambiguous' && resolved.matches) {
-      throw new Error(
-        `${resolved.message}\n${formatAmbiguousRollbackMatches(resolved.matches)}`
+  /** @type {{ envName: string, entry: import('../artifact-history.js').ArtifactHistoryEntry, artifactDir: string }[]} */
+  const results = [];
+  /** @type {{ envName: string, error: string }[]} */
+  const failures = [];
+
+  for (const envName of targets) {
+    try {
+      const defaultEnv = resolveDefaultEnvironmentName(config);
+      if (defaultEnv && envName === defaultEnv) {
+        await ensureLegacyHistoryCopiedToDefaultEnv(
+          providers,
+          config.project,
+          defaultEnv,
+          { legacyHistoryMigrated: config.legacyHistoryMigrated === true }
+        );
+      }
+
+      // CRITICAL: allowLegacyFallback: false — never read project-wide history.json
+      // (build catalog) during rollback. Isolation is absolute per environment.
+      const { entries: history } = await loadEnvArtifactHistory(
+        providers,
+        config.project,
+        envName,
+        { allowLegacyFallback: false }
       );
-    }
-    throw new Error(resolved.message);
-  }
 
-  const entry = resolved.entry;
-  const restoreDir = path.join(cwd, '.deployhub-restore', `v${entry.buildId}`);
-  const artifactDir = path.join(restoreDir, 'artifact');
+      const resolved = resolveRollbackTarget(history, versionOrBuildId);
 
-  log.info(`Downloading artifact buildId=${entry.buildId} (semver=${entry.semver})...`);
-  await fs.emptyDir(restoreDir);
-  await fs.ensureDir(artifactDir);
+      if (!resolved.ok) {
+        throw new Error(formatEnvRollbackError(envName, resolved));
+      }
 
-  const zipPath = path.join(artifactDir, 'artifact.zip');
-  await downloadArtifactEntry(providers, config, entry, zipPath);
+      const entry = resolved.entry;
+      const restoreDir = path.join(cwd, '.deployhub-restore', envName, `v${entry.buildId}`);
+      const artifactDir = path.join(restoreDir, 'artifact');
 
-  // Extract into artifactDir itself so layout matches a normal build artifact:
-  // top-level contents (k8s/, dist/, metadata.json, …) alongside artifact.zip.
-  log.info('Extracting artifact for rollback...');
-  await extractArtifact(artifactDir, artifactDir);
+      log.info(
+        `Downloading artifact buildId=${entry.buildId} for env "${envName}" (semver=${entry.semver})...`
+      );
+      await fs.emptyDir(restoreDir);
+      await fs.ensureDir(artifactDir);
 
-  const targets = config.deploy || [];
-  if (targets.length === 0) {
-    log.warn('No deployment targets configured');
-    return { artifactDir, entry };
+      const zipPath = path.join(artifactDir, 'artifact.zip');
+      await downloadArtifactEntry(providers, config, entry, zipPath);
+
+      log.info(`Extracting artifact for rollback (${envName})...`);
+      await extractArtifact(artifactDir, artifactDir);
+
+      const meta = {
+        buildId: entry.buildId,
+        semver: entry.semver,
+        remoteKey: entry.remoteKey,
+      };
+
+      await rollbackTarget(config, artifactDir, envName, meta);
+      results.push({ envName, entry, artifactDir });
+      log.success(`Rollback of ${envName} to buildId=${entry.buildId} complete`);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      if (!continueOnError) {
+        throw err instanceof Error ? err : new Error(error);
+      }
+      failures.push({ envName, error });
+      log.error(`Rollback of ${envName} failed: ${error}`);
+    }
   }
 
-  const meta = {
-    buildId: entry.buildId,
-    semver: entry.semver,
-    remoteKey: entry.remoteKey,
+  const last = results[results.length - 1];
+  return {
+    artifactDir: last?.artifactDir || null,
+    entry: last?.entry || null,
+    results,
+    failures,
   };
+}
 
-  log.info('Redeploying previous artifact to server targets...');
-  for (const envName of targets) {
-    await rollbackTarget(config, artifactDir, envName, meta);
+/**
+ * Format the continue-on-error summary for `--env all`.
+ * @param {{ envName: string, entry: { buildId: string } }[]} results
+ * @param {{ envName: string, error: string }[]} failures
+ * @param {string[]} [skippedDisabled]
+ * @returns {string}
+ */
+export function formatRollbackAllSummary(results, failures, skippedDisabled = []) {
+  const lines = ['Rollback summary (--env all):'];
+  for (const r of results) {
+    lines.push(`  ✓ ${r.envName.padEnd(14)} → rolled back to ${r.entry.buildId}`);
   }
-
-  log.success(`Rollback to buildId=${entry.buildId} complete`);
-  return { artifactDir, entry };
+  for (const f of failures) {
+    lines.push(`  ✗ ${f.envName.padEnd(14)} → FAILED: ${f.error}`);
+  }
+  for (const name of skippedDisabled) {
+    lines.push(`  – ${name.padEnd(14)} → skipped (disabled)`);
+  }
+  lines.push('');
+  if (failures.length === 0) {
+    lines.push(`All ${results.length} environment(s) rolled back successfully.`);
+  } else {
+    const total = results.length + failures.length;
+    lines.push(
+      `${failures.length} of ${total} environments failed to roll back. See above for details.`
+    );
+  }
+  return lines.join('\n');
 }
 
-export default { rollbackToVersion };
+export default { rollbackToVersion, formatRollbackAllSummary };

package/src/utils/scaffold.js

@@ -12,6 +12,7 @@ import {
   hasKubernetesManifests,
   resolveKubernetesManifestOptionsFromCwd,
 } from './kubernetes-manifests.js';
+import { getEnvMethod } from '../core/environments.js';
 
 /**
  * @param {Record<string, Record<string, unknown>>} environments
@@ -20,7 +21,7 @@ import {
 export function getDeployTypes(environments) {
   return new Set(
     Object.values(environments)
-      .map((env) => /** @type {string} */ (env.type))
+      .map((env) => getEnvMethod(env))
       .filter(Boolean)
   );
 }