@akash-chowdhury-24/deployhub 2.0.14 → 2.0.16

package/src/utils/kubernetes-manifests.js

@@ -1,5 +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
@@ -65,6 +67,11 @@ export function generateKubernetesManifests({
     ? `      imagePullSecrets:\n      - name: ${imagePullSecret}\n`
     : '';
 
+  // Service port stays 80 (Ingress-friendly cluster-facing port).
+  // containerPort / targetPort must match the container's listening port (EXPOSE).
+  const servicePort = 80;
+  const targetPort = port;
+
   const deploymentYaml = `apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -96,9 +103,6 @@ ${pullSecretBlock}      containers:
             cpu: "500m"
 `;
 
-  const servicePort = port === 80 ? 80 : 80;
-  const targetPort = port;
-
   const serviceYaml = `apiVersion: v1
 kind: Service
 metadata:
@@ -116,14 +120,32 @@ spec:
   return { deploymentYaml, serviceYaml };
 }
 
+/**
+ * Surgically update only containerPort / targetPort in manifest YAML.
+ * Does not change Service `port:`, replicas, resources, env, probes, etc.
+ *
+ * @param {string} yaml
+ * @param {number} port
+ * @returns {{ content: string, changed: boolean }}
+ */
+export function patchKubernetesManifestPorts(yaml, port) {
+  const next = String(yaml)
+    .replace(/^([ \t]*-?[ \t]*containerPort:[ \t]*)\d+[ \t]*$/gm, `$1${port}`)
+    .replace(/^([ \t]*targetPort:[ \t]*)\d+[ \t]*$/gm, `$1${port}`);
+
+  return { content: next, changed: next !== yaml };
+}
+
 /**
  * @param {import('../core/config.js').DeployHubConfig} config
  * @param {Record<string, Record<string, unknown>>} [environments]
+ * @param {{ port?: number }} [options]
  * @returns {{ appName: string, imageName: string, imageTag: string, port: number, namespace: string, imagePullSecret: string }}
  */
-export function resolveKubernetesManifestOptions(config, environments = {}) {
+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 =
@@ -142,13 +164,18 @@ export function resolveKubernetesManifestOptions(config, environments = {}) {
     process.env.KUBE_IMAGE_PULL_SECRET ||
     '';
 
-  let port = 3000;
-  if (config.projectType === 'both' && config.backend?.port) {
-    port = config.backend.port;
+  /** @type {number} */
+  let port;
+  if (typeof options.port === 'number' && Number.isFinite(options.port)) {
+    port = options.port;
+  } else if (config.projectType === 'both' && config.backend?.port) {
+    port = Number(config.backend.port);
   } else if (config.port) {
-    port = config.port;
+    port = Number(config.port);
   } else if (config.backend?.port) {
-    port = config.backend.port;
+    port = Number(config.backend.port);
+  } else {
+    port = 3000;
   }
 
   return {
@@ -161,9 +188,77 @@ export function resolveKubernetesManifestOptions(config, environments = {}) {
   };
 }
 
+/**
+ * Resolve manifest options with Dockerfile EXPOSE → config → fallback port.
+ *
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ */
+export async function resolveKubernetesManifestOptionsFromCwd(
+  cwd,
+  config,
+  environments = {}
+) {
+  const { port, source } = await resolveContainerPort(cwd, config);
+  return {
+    ...resolveKubernetesManifestOptions(config, environments, { port }),
+    portSource: source,
+  };
+}
+
+/**
+ * Paths DeployHub normally writes for Kubernetes starter manifests.
+ * @param {string} cwd
+ * @returns {{ deploymentPath: string, servicePath: string }}
+ */
+export function getDefaultKubernetesManifestPaths(cwd) {
+  const k8sDir = path.join(cwd, 'k8s');
+  return {
+    deploymentPath: path.join(k8sDir, 'deployment.yaml'),
+    servicePath: path.join(k8sDir, 'service.yaml'),
+  };
+}
+
+/**
+ * Patch containerPort/targetPort in existing k8s/deployment.yaml + service.yaml only.
+ *
+ * @param {string} cwd
+ * @param {number} port
+ * @returns {Promise<{ patched: string[], skipped: string[], port: number }>}
+ */
+export async function syncKubernetesManifestPorts(cwd, port) {
+  const { deploymentPath, servicePath } = getDefaultKubernetesManifestPaths(cwd);
+  /** @type {string[]} */
+  const patched = [];
+  /** @type {string[]} */
+  const skipped = [];
+
+  for (const filePath of [deploymentPath, servicePath]) {
+    if (!(await fs.pathExists(filePath))) {
+      skipped.push(path.relative(cwd, filePath));
+      continue;
+    }
+    const original = await fs.readFile(filePath, 'utf8');
+    const { content, changed } = patchKubernetesManifestPorts(original, port);
+    if (changed) {
+      await fs.writeFile(filePath, content);
+      patched.push(path.relative(cwd, filePath));
+    } else {
+      skipped.push(path.relative(cwd, filePath));
+    }
+  }
+
+  return { patched, skipped, port };
+}
+
 export default {
   sanitizeK8sName,
   hasKubernetesManifests,
   generateKubernetesManifests,
+  patchKubernetesManifestPorts,
   resolveKubernetesManifestOptions,
+  resolveKubernetesManifestOptionsFromCwd,
+  getDefaultKubernetesManifestPaths,
+  syncKubernetesManifestPorts,
 };

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

@@ -10,8 +10,9 @@ import {
 import {
   generateKubernetesManifests,
   hasKubernetesManifests,
-  resolveKubernetesManifestOptions,
+  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)
   );
 }
@@ -134,7 +135,11 @@ export async function ensureKubernetesManifests(
     return { generated: false };
   }
 
-  const manifestOptions = resolveKubernetesManifestOptions(config, environments);
+  const manifestOptions = await resolveKubernetesManifestOptionsFromCwd(
+    cwd,
+    config,
+    environments
+  );
   const { deploymentYaml, serviceYaml } = generateKubernetesManifests(manifestOptions);
 
   const k8sDir = path.join(cwd, 'k8s');