@akash-chowdhury-24/deployhub 2.0.14 → 2.0.16

package/src/commands/init.js

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { saveConfig, appendEnv } from '../core/config.js';
+import { saveConfig, appendEnv, getEnvMethod, getEnvSettings } from '../core/config.js';
 import { detectFrontend, detectBackend } from '../detectors/index.js';
 import {
   getFrontendInfo,
@@ -174,10 +174,11 @@ async function promptBuildSettings(defaults, side) {
 async function generateProjectScaffold(config, environments, cwd) {
   const envList = Object.values(environments);
 
-  const usesFrontendSsh = envList.some(
-    (env) =>
-      SSH_BASED.includes(env.type) || env.deploymentType === 'server'
-  );
+  const usesFrontendSsh = envList.some((env) => {
+    const method = getEnvMethod(env);
+    const settings = getEnvSettings(env);
+    return SSH_BASED.includes(method) || settings.deploymentType === 'server';
+  });
 
   const isFrontendProject =
     config.projectType === 'frontend' || config.projectType === 'both';
@@ -343,84 +344,114 @@ export function registerInitCommand(program) {
       let dockerEnvToAppend = null;
 
       if (answers.configureDeploy) {
-        if (projectType === 'backend') {
+        const { envMode } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'envMode',
+            message:
+              'How many environments do you want to set up? (1 is fine — you can add more later)',
+            choices: [
+              { name: 'Just one environment', value: 'one' },
+              {
+                name: 'Multiple environments (e.g. development, testing, production)',
+                value: 'multi',
+              },
+            ],
+            default: 'one',
+          },
+        ]);
+
+        /**
+         * Shared single-round prompt used by init (loop) and env add.
+         * @param {{ envName?: string }} [opts]
+         */
+        async function promptAndStoreEnvironment(opts = {}) {
+          const deployTypeForPrompt =
+            projectType === 'both' ? 'both' : projectType;
           const deployAnswers = await promptServerDeployment(
             projectName,
-            projectType,
-            backendConfig
-          );
-          primaryDeployType = deployAnswers.deployType;
-          deploy.push(deployAnswers.envName);
-          environments[deployAnswers.envName] = buildServerEnvEntry(
-            deployAnswers,
-            projectType,
-            projectName,
+            deployTypeForPrompt,
             backendConfig,
-            singleConfig
-          );
-          if (deployAnswers.healthUrl) {
-            healthUrl = deployAnswers.healthUrl;
-          } else if (singleConfig?.port) {
-            healthUrl = `http://localhost:${singleConfig.port}/health`;
-          }
-          dockerEnvToAppend = getDockerEnvSecrets(deployAnswers);
-        } else if (projectType === 'frontend') {
-          const deployAnswers = await promptServerDeployment(
-            projectName,
-            projectType,
-            backendConfig
+            {
+              ...(opts.envName ? { envName: opts.envName } : {}),
+              existingEnvNames: Object.keys(environments),
+            }
           );
           primaryDeployType = deployAnswers.deployType;
-          deploy.push(deployAnswers.envName);
-          environments[deployAnswers.envName] = buildServerEnvEntry(
+          const name = deployAnswers.envName;
+          deploy.push(name);
+
+          let entry = buildServerEnvEntry(
             deployAnswers,
             projectType,
             projectName,
             backendConfig,
             singleConfig
           );
+
+          if (projectType === 'both' && entry.config) {
+            entry = {
+              ...entry,
+              config: {
+                ...entry.config,
+                backendDeploymentType: 'server',
+                frontendDeploymentType: 'server',
+                deploymentType: 'server',
+              },
+            };
+          }
+
+          environments[name] = entry;
+
           if (deployAnswers.healthUrl) {
             healthUrl = deployAnswers.healthUrl;
+          } else if (!healthUrl && (singleConfig?.port || backendConfig?.port)) {
+            healthUrl = `http://localhost:${singleConfig?.port || backendConfig?.port}/health`;
           }
-          dockerEnvToAppend = getDockerEnvSecrets(deployAnswers);
-        } else {
-          const backendDeployAnswers = await promptServerDeployment(
-            projectName,
-            'both',
-            backendConfig
-          );
-          primaryDeployType = backendDeployAnswers.deployType;
-          deploy.push(backendDeployAnswers.envName);
-
-          /** @type {Record<string, unknown>} */
-          const envEntry = {
-            backendDeploymentType: 'server',
-            frontendDeploymentType: 'server',
-            deploymentType: 'server',
-          };
-
-          Object.assign(
-            envEntry,
-            buildServerEnvEntry(
-              backendDeployAnswers,
-              'both',
-              projectName,
-              backendConfig,
-              singleConfig
-            )
-          );
 
-          if (backendDeployAnswers.healthUrl) {
-            healthUrl = backendDeployAnswers.healthUrl;
-          } else if (backendConfig?.port) {
-            healthUrl = `http://localhost:${backendConfig.port}/health`;
+          const secrets = getDockerEnvSecrets(deployAnswers);
+          if (secrets) {
+            dockerEnvToAppend = { ...(dockerEnvToAppend || {}), ...secrets };
           }
+          return name;
+        }
 
-          environments[backendDeployAnswers.envName] = envEntry;
-          dockerEnvToAppend = getDockerEnvSecrets(backendDeployAnswers);
+        if (envMode === 'one') {
+          // Transparent single env named "default" (visible later via env list).
+          await promptAndStoreEnvironment({ envName: 'default' });
+        } else {
+          let addMore = true;
+          while (addMore) {
+            await promptAndStoreEnvironment();
+            if (deploy.length >= 1) {
+              const again = await inquirer.prompt([
+                {
+                  type: 'confirm',
+                  name: 'more',
+                  message: 'Add another environment?',
+                  default: false,
+                },
+              ]);
+              addMore = again.more;
+            }
+          }
         }
       }
 
+      let defaultEnvironment = deploy[0];
+      if (deploy.length >= 2) {
+        const picked = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'defaultEnvironment',
+            message: 'Which environment is the default for `deployhub deploy`?',
+            choices: deploy,
+            default: deploy[0],
+          },
+        ]);
+        defaultEnvironment = picked.defaultEnvironment;
+      }
+
       const version = await getProjectVersion(cwd);
       let hasDocker =
         (detectedFrontend?.hasDocker || detectedBackend?.hasDocker) ?? false;
@@ -432,7 +463,9 @@ export function registerInitCommand(program) {
         projectType,
         artifact: true,
         storage: answers.storage.length > 0 ? answers.storage : ['local'],
-        deploy,
+        defaultEnvironment: defaultEnvironment || undefined,
+        unprefixedSecretEnvironment: defaultEnvironment || undefined,
+        legacyHistoryMigrated: true,
         environments,
         healthCheck: {
           url: healthUrl,

package/src/commands/rollback.js

@@ -1,6 +1,11 @@
 import chalk from 'chalk';
 import { loadConfig, loadEnv } from '../core/config.js';
-import { rollbackToVersion } from '../utils/rollback/engine.js';
+import { resolveEnvTargets } from '../core/environments.js';
+import {
+  rollbackToVersion,
+  formatRollbackAllSummary,
+} from '../utils/rollback/engine.js';
+import { createLogger } from '../logger/index.js';
 import axios from 'axios';
 
 /**
@@ -12,37 +17,92 @@ export function registerRollbackCommand(program) {
     .description(
       'Rollback to a previous artifact build (omit arg = previous build; use exact buildId if semver is ambiguous)'
     )
-    .action(async (versionOrBuildId) => {
+    .option(
+      '--env <name>',
+      'Environment to roll back (name, or "all" for every enabled environment independently)'
+    )
+    .action(async (versionOrBuildId, opts) => {
       loadEnv();
       const config = await loadConfig();
+      const log = createLogger('rollback');
 
+      let targets;
+      let skippedDisabled;
       try {
-        const { entry } = await rollbackToVersion(config, versionOrBuildId);
-        if (!versionOrBuildId) {
-          console.log(chalk.gray(`Rolled back to previous build: ${entry.buildId}`));
-        }
+        ({ targets, skippedDisabled } = resolveEnvTargets(config, opts.env));
+      } catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+
+      for (const name of skippedDisabled) {
+        log.info(`Skipping disabled environment "${name}"`);
+      }
+
+      if (targets.length === 0) {
+        console.error(chalk.red('No enabled environments to roll back.'));
+        process.exit(1);
+      }
 
-        if (config.healthCheck?.url) {
-          try {
-            const response = await axios.get(config.healthCheck.url, {
-              timeout: (config.healthCheck.timeout || 30) * 1000,
-              validateStatus: () => true,
-            });
-            if (response.status >= 200 && response.status < 400) {
-              console.log(chalk.green(`Health check passed: HTTP ${response.status}`));
-            } else {
-              console.log(chalk.yellow(`Health check returned HTTP ${response.status}`));
+      const isAll = opts.env === 'all';
+
+      try {
+        const { results, failures } = await rollbackToVersion(
+          config,
+          versionOrBuildId,
+          process.cwd(),
+          {
+            envNames: targets,
+            // --env all: attempt every enabled env independently; summarize at end.
+            continueOnError: isAll,
+          }
+        );
+
+        if (isAll) {
+          const summary = formatRollbackAllSummary(
+            results || [],
+            failures || [],
+            skippedDisabled
+          );
+          console.log('');
+          console.log(summary);
+          if ((failures || []).length > 0) {
+            process.exit(1);
+          }
+        } else {
+          for (const r of results || []) {
+            if (!versionOrBuildId) {
+              console.log(
+                chalk.gray(`Rolled back ${r.envName} to previous build: ${r.entry.buildId}`)
+              );
             }
-          } catch (err) {
-            console.log(
-              chalk.yellow(
-                `Health check failed: ${err instanceof Error ? err.message : String(err)}`
-              )
-            );
           }
-        }
 
-        console.log(chalk.green(`✓ Rolled back to ${entry.buildId}`));
+          if (config.healthCheck?.url) {
+            try {
+              const response = await axios.get(config.healthCheck.url, {
+                timeout: (config.healthCheck.timeout || 30) * 1000,
+                validateStatus: () => true,
+              });
+              if (response.status >= 200 && response.status < 400) {
+                console.log(chalk.green(`Health check passed: HTTP ${response.status}`));
+              } else {
+                console.log(chalk.yellow(`Health check returned HTTP ${response.status}`));
+              }
+            } catch (err) {
+              console.log(
+                chalk.yellow(
+                  `Health check failed: ${err instanceof Error ? err.message : String(err)}`
+                )
+              );
+            }
+          }
+
+          const summary = (results || [])
+            .map((r) => `${r.envName}→${r.entry.buildId}`)
+            .join(', ');
+          console.log(chalk.green(`✓ Rolled back: ${summary}`));
+        }
       } catch (err) {
         console.error(chalk.red(err instanceof Error ? err.message : String(err)));
         process.exit(1);

package/src/commands/sync-k8s-ports.js

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import { resolveContainerPort } from '../utils/dockerfile-expose.js';
+import {
+  getDefaultKubernetesManifestPaths,
+  syncKubernetesManifestPorts,
+} from '../utils/kubernetes-manifests.js';
+import fs from 'fs-extra';
+
+/**
+ * Surgically fix containerPort/targetPort in existing k8s manifests from Dockerfile EXPOSE.
+ * @param {import('commander').Command} program
+ */
+export function registerSyncK8sPortsCommand(program) {
+  program
+    .command('sync-k8s-ports')
+    .description(
+      'Update only containerPort/targetPort in k8s/deployment.yaml and k8s/service.yaml ' +
+        'from the Dockerfile EXPOSE port (or config/fallback). Does not change replicas, ' +
+        'resources, env, probes, or Service port. Heavily customized / multi-container ' +
+        'manifests may need a manual review.'
+    )
+    .action(async () => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+
+      const { deploymentPath, servicePath } = getDefaultKubernetesManifestPaths(cwd);
+      const hasDeployment = await fs.pathExists(deploymentPath);
+      const hasService = await fs.pathExists(servicePath);
+
+      if (!hasDeployment && !hasService) {
+        console.log(
+          chalk.yellow(
+            'No k8s/deployment.yaml or k8s/service.yaml found — nothing to patch. ' +
+              'Generate starter manifests via deployhub init, or add manifests under ./k8s/.'
+          )
+        );
+        return;
+      }
+
+      const { port, source } = await resolveContainerPort(cwd, config);
+      const result = await syncKubernetesManifestPorts(cwd, port);
+
+      console.log(
+        chalk.green(
+          `✓ Resolved container port ${port} (source: ${source})`
+        )
+      );
+
+      if (result.patched.length === 0) {
+        console.log(chalk.gray('  Port fields already match — no files changed.'));
+      } else {
+        for (const file of result.patched) {
+          console.log(chalk.gray(`  Updated ${file}`));
+        }
+      }
+
+      console.log('');
+      console.log(
+        chalk.yellow(
+          'Note: Only containerPort and targetPort are updated. Replicas, resources, env, ' +
+            'probes, and Service port: are left unchanged. If your manifests are heavily ' +
+            'customized (multiple containers, non-standard field layout), review the diff ' +
+            'manually before deploying.'
+        )
+      );
+    });
+}
+
+export default { registerSyncK8sPortsCommand };

package/src/commands/verify.js

@@ -1,6 +1,77 @@
 import chalk from 'chalk';
-import axios from 'axios';
 import { loadConfig, loadEnv } from '../core/config.js';
+import { resolveEnvTargets } from '../core/environments.js';
+import {
+  anyEnvHasResolvableHealthCheckUrl,
+  runHealthChecksForEnvs,
+  formatHealthCheckAllSummary,
+} from '../utils/health-check.js';
+
+/**
+ * Standalone verify — same per-env URL resolution and summary as the deploy pipeline stage.
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string|undefined} envFlag — omitted = defaultEnvironment; `"all"` = every enabled
+ * @param {{ httpGet?: (url: string, timeoutMs: number) => Promise<{ status: number }> }} [options]
+ * @returns {Promise<{ ok: boolean, targets: string[], results: object[], failures: object[], summary: string, message: string }>}
+ */
+export async function runVerify(config, envFlag, options = {}) {
+  const { targets, skippedDisabled } = resolveEnvTargets(config, envFlag);
+
+  if (targets.length === 0) {
+    return {
+      ok: false,
+      targets,
+      results: [],
+      failures: [],
+      summary: '',
+      message: 'No enabled environments to verify.',
+      skippedDisabled,
+    };
+  }
+
+  if (!anyEnvHasResolvableHealthCheckUrl(config, targets)) {
+    const label =
+      targets.length === 1
+        ? `environment "${targets[0]}"`
+        : 'the selected environment(s)';
+    return {
+      ok: false,
+      targets,
+      results: [],
+      failures: [],
+      summary: '',
+      message: `No health check URL configured for ${label}. Set healthCheck.url or environments.<name>.config.healthCheckUrl.`,
+      skippedDisabled,
+    };
+  }
+
+  const { results, failures } = await runHealthChecksForEnvs(config, targets, options);
+  const multi = targets.length > 1 || failures.length > 0;
+  const summary = multi ? formatHealthCheckAllSummary(results, failures) : '';
+
+  let message = '';
+  if (failures.length === 0 && results.length === 1 && !multi) {
+    const r = results[0];
+    message = `Health check passed (${r.envName}): HTTP ${r.status} (${r.elapsed}ms)`;
+  } else if (failures.length === 0 && results.length === 0) {
+    message = `No health check URL configured for the selected environment(s).`;
+  }
+
+  return {
+    ok: failures.length === 0 && results.length > 0,
+    targets,
+    results,
+    failures,
+    summary,
+    message:
+      message ||
+      (failures.length > 0
+        ? failures[0].error
+        : `All ${results.length} environment(s) passed health checks.`),
+    skippedDisabled,
+  };
+}
 
 /**
  * @param {import('commander').Command} program
@@ -8,48 +79,41 @@ import { loadConfig, loadEnv } from '../core/config.js';
 export function registerVerifyCommand(program) {
   program
     .command('verify')
-    .description('Run health check on configured endpoint')
-    .action(async () => {
+    .description('Run health check on configured endpoint (default environment, or --env)')
+    .option(
+      '--env <name>',
+      'Environment to verify (name, or "all" for every enabled environment)'
+    )
+    .action(async (opts) => {
       loadEnv();
       const config = await loadConfig();
-      const url = config.healthCheck?.url;
 
-      if (!url) {
-        console.error(chalk.red('No health check URL configured in deployhub.config.json'));
+      let outcome;
+      try {
+        outcome = await runVerify(config, opts.env);
+      } catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
         process.exit(1);
       }
 
-      const timeout = (config.healthCheck.timeout || 30) * 1000;
-      const start = Date.now();
+      for (const name of outcome.skippedDisabled || []) {
+        console.log(chalk.gray(`Skipping disabled environment "${name}"`));
+      }
+
+      if (outcome.summary) {
+        console.log('');
+        console.log(outcome.summary);
+      } else if (outcome.ok && outcome.message) {
+        console.log(chalk.green(`✓ ${outcome.message}`));
+      }
 
-      try {
-        const response = await axios.get(url, {
-          timeout,
-          validateStatus: () => true,
-        });
-        const elapsed = Date.now() - start;
-        const ok = response.status >= 200 && response.status < 400;
-
-        if (ok) {
-          console.log(
-            chalk.green(`✓ Health check passed: HTTP ${response.status} (${elapsed}ms)`)
-          );
-        } else {
-          console.log(
-            chalk.red(`✗ Health check failed: HTTP ${response.status} (${elapsed}ms)`)
-          );
-          process.exit(1);
+      if (!outcome.ok) {
+        if (!outcome.summary && outcome.message) {
+          console.error(chalk.red(`✗ ${outcome.message}`));
         }
-      } catch (err) {
-        const elapsed = Date.now() - start;
-        console.error(
-          chalk.red(
-            `✗ Health check failed: ${err instanceof Error ? err.message : String(err)} (${elapsed}ms)`
-          )
-        );
         process.exit(1);
       }
     });
 }
 
-export default { registerVerifyCommand };
+export default { registerVerifyCommand, runVerify };