@akash-chowdhury-24/deployhub 2.0.15 → 2.0.16

package/src/commands/env.js

@@ -0,0 +1,326 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import {
+  loadConfig,
+  loadEnv,
+  saveConfig,
+} from '../core/config.js';
+import {
+  getEnvMethod,
+  getEnvTrigger,
+  isEnvEnabled,
+  resolveDefaultEnvironmentName,
+  validateEnvironmentName,
+} from '../core/environments.js';
+import { promptServerDeployment, buildServerEnvEntry } from '../deployment/init-prompts.js';
+import { writeWorkflowFile } from '../utils/github-actions.js';
+import { loadEnvArtifactHistory } from '../storage/index.js';
+import { createLogger } from '../logger/index.js';
+import {
+  envUsesPrefixedSecrets,
+  getDeploymentWorkflowSecretKeysForEnv,
+} from '../deployment/deployment-env.js';
+import {
+  envHistoryRemoteKey,
+  envLatestArtifactRemoteKey,
+} from '../utils/build-id.js';
+
+/**
+ * Best-effort last buildId for an env from per-env deploy history.
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @returns {Promise<string>}
+ */
+async function lastDeployedBuildId(config, envName) {
+  try {
+    const providers = config.storage || [];
+    if (providers.length === 0) return '—';
+    const { entries } = await loadEnvArtifactHistory(providers, config.project, envName, {
+      defaultEnvironment: resolveDefaultEnvironmentName(config),
+    });
+    if (entries[0]?.buildId) return entries[0].buildId;
+  } catch {
+    // list never crashes
+  }
+  return '—';
+}
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerEnvCommand(program) {
+  const env = program.command('env').description('Manage deployment environments');
+
+  env
+    .command('list')
+    .description('List configured environments')
+    .action(async () => {
+      loadEnv();
+      const config = await loadConfig();
+      const names = Object.keys(config.environments || {});
+      if (names.length === 0) {
+        console.log(chalk.yellow('No environments configured. Run: deployhub env add <name>'));
+        return;
+      }
+
+      const def = resolveDefaultEnvironmentName(config);
+      console.log('');
+      console.log(
+        chalk.bold(
+          `${'Name'.padEnd(18)} ${'Method'.padEnd(12)} ${'Status'.padEnd(10)} ${'Trigger'.padEnd(8)} Last deploy`
+        )
+      );
+      console.log(chalk.gray('─'.repeat(72)));
+
+      for (const name of names) {
+        const entry = config.environments[name];
+        const method = getEnvMethod(entry) || '?';
+        const status = isEnvEnabled(entry) ? 'enabled' : 'disabled';
+        const trigger = getEnvTrigger(entry);
+        const last = await lastDeployedBuildId(config, name);
+        const label = name === def ? `${name}*` : name;
+        console.log(
+          `${label.padEnd(18)} ${method.padEnd(12)} ${status.padEnd(10)} ${trigger.padEnd(8)} ${last}`
+        );
+      }
+      console.log('');
+      console.log(chalk.gray('* defaultEnvironment'));
+    });
+
+  env
+    .command('add <name>')
+    .description('Add a named deployment environment')
+    .option(
+      '--method <type>',
+      'Deployment method (ssh|docker|ec2|azure-vm|gcp-vm|kubernetes); skips the type prompt'
+    )
+    .option(
+      '--yes',
+      'Non-interactive: use defaults for the chosen --method (required with --yes)'
+    )
+    .action(async (rawName, opts) => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+      const log = createLogger('env');
+
+      const nameCheck = validateEnvironmentName(rawName, Object.keys(config.environments || {}));
+      if (!nameCheck.ok) {
+        console.error(chalk.red(nameCheck.error));
+        process.exit(1);
+      }
+      const name = nameCheck.name;
+
+      if (opts.yes && !opts.method) {
+        console.error(
+          chalk.red('Non-interactive --yes requires --method <ssh|docker|ec2|azure-vm|gcp-vm|kubernetes>.')
+        );
+        process.exit(1);
+      }
+
+      const projectType = config.projectType || 'frontend';
+      const backendConfig = config.backend || null;
+      const singleConfig =
+        projectType === 'both'
+          ? null
+          : {
+              framework: config.framework,
+              port: config.port,
+            };
+
+      const existingNames = Object.keys(config.environments || {});
+      // Permanently grandfather the original environment's unprefixed secrets.
+      if (!config.unprefixedSecretEnvironment && existingNames.length === 1) {
+        config.unprefixedSecretEnvironment = existingNames[0];
+      } else if (!config.unprefixedSecretEnvironment && existingNames.length === 0) {
+        // First env ever — this new one stays unprefixed.
+        config.unprefixedSecretEnvironment = name;
+      }
+
+      let deployAnswers;
+      try {
+        deployAnswers = await promptServerDeployment(
+          config.project,
+          projectType,
+          backendConfig,
+          {
+            envName: name,
+            existingEnvNames: Object.keys(config.environments || {}),
+            deployType: opts.method,
+            nonInteractive: Boolean(opts.yes),
+          }
+        );
+      } catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+
+      config.environments[name] = buildServerEnvEntry(
+        deployAnswers,
+        projectType,
+        config.project,
+        backendConfig,
+        singleConfig
+      );
+
+      if (!config.defaultEnvironment) {
+        config.defaultEnvironment = name;
+      }
+
+      config.pipeline = config.pipeline || {};
+      config.pipeline.deploy = true;
+
+      await saveConfig(config, cwd);
+
+      const enabledNames = Object.keys(config.environments).filter((n) =>
+        isEnvEnabled(config.environments[n])
+      );
+      await writeWorkflowFile(
+        config.storage || [],
+        enabledNames,
+        config.environments,
+        cwd,
+        config.cli?.source,
+        config
+      );
+
+      log.success(`Added environment "${name}" (${deployAnswers.deployType})`);
+      console.log(chalk.gray(`  defaultEnvironment: ${config.defaultEnvironment}`));
+      console.log(chalk.gray('  Workflows regenerated — commit .github/workflows if using CI.'));
+
+      const envCount = Object.keys(config.environments).length;
+      if (envCount >= 2 && envUsesPrefixedSecrets(name, config)) {
+        const original = config.unprefixedSecretEnvironment;
+        const method = getEnvMethod(config.environments[name]);
+        const newSecrets = method
+          ? getDeploymentWorkflowSecretKeysForEnv(name, method, config, config.environments)
+          : [];
+        const requiredNew = newSecrets.filter((k) => !k.includes('OPTIONAL'));
+        console.log('');
+        console.log(chalk.yellow(`⚠ You now have ${envCount} environments configured.`));
+        if (original) {
+          console.log(
+            chalk.yellow(
+              `  "${original}" keeps using its existing unprefixed secrets (e.g. SSH_HOST) — no action needed.`
+            )
+          );
+        }
+        console.log(
+          chalk.yellow(
+            `  "${name}" requires new secrets in CI: ${requiredNew.slice(0, 8).join(', ')}${
+              requiredNew.length > 8 ? ', …' : ''
+            }`
+          )
+        );
+        console.log(
+          chalk.yellow(
+            '  Add these to your GitHub repo secrets before running a deploy/rollback for this environment in CI.'
+          )
+        );
+        console.log(chalk.yellow('  Run `deployhub sync-workflows` after adding them (already regenerated).'));
+      }
+    });
+
+  env
+    .command('enable <name>')
+    .description('Enable an environment for deploy / --env all')
+    .action(async (name) => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+      if (!config.environments[name]) {
+        console.error(chalk.red(`Environment "${name}" not found.`));
+        process.exit(1);
+      }
+      config.environments[name].enabled = true;
+      await saveConfig(config, cwd);
+      console.log(chalk.green(`✓ Enabled environment "${name}"`));
+    });
+
+  env
+    .command('disable <name>')
+    .description('Disable an environment (deploy to it will fail until re-enabled)')
+    .action(async (name) => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+      if (!config.environments[name]) {
+        console.error(chalk.red(`Environment "${name}" not found.`));
+        process.exit(1);
+      }
+      config.environments[name].enabled = false;
+      await saveConfig(config, cwd);
+      console.log(chalk.yellow(`Disabled environment "${name}"`));
+    });
+
+  env
+    .command('remove <name>')
+    .description('Remove an environment and its rollback history reference')
+    .action(async (name) => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+      if (!config.environments[name]) {
+        console.error(chalk.red(`Environment "${name}" not found.`));
+        process.exit(1);
+      }
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Remove environment "${name}"? Its per-environment rollback history will no longer be tracked by DeployHub.`,
+          default: false,
+        },
+      ]);
+      if (!confirm) {
+        console.log(chalk.gray('Cancelled.'));
+        return;
+      }
+
+      if (config.defaultEnvironment === name) {
+        const remaining = Object.keys(config.environments).filter((n) => n !== name);
+        if (remaining.length > 0) {
+          console.error(
+            chalk.red(
+              `Cannot remove "${name}" while it is defaultEnvironment.\n` +
+                `  Set a new default first (edit defaultEnvironment in deployhub.config.json), ` +
+                `then run deployhub env remove ${name} again.`
+            )
+          );
+          process.exit(1);
+        }
+      }
+
+      const historyKey = envHistoryRemoteKey(config.project, name);
+      const latestKey = envLatestArtifactRemoteKey(config.project, name);
+
+      delete config.environments[name];
+      if (config.defaultEnvironment === name) {
+        config.defaultEnvironment = undefined;
+      }
+      await saveConfig(config, cwd);
+
+      const enabledNames = Object.keys(config.environments).filter((n) =>
+        isEnvEnabled(config.environments[n])
+      );
+      await writeWorkflowFile(
+        config.storage || [],
+        enabledNames,
+        config.environments,
+        cwd,
+        config.cli?.source,
+        config
+      );
+
+      console.log(chalk.green(`✓ Removed environment "${name}"`));
+      console.log(
+        chalk.yellow(
+          `  Storage not deleted (orphaned): ${historyKey}, ${latestKey}\n` +
+            '  Remove these manually from your storage provider if you no longer need rollback data.'
+        )
+      );
+    });
+}
+
+export default { registerEnvCommand };

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);