@akash-chowdhury-24/deployhub 2.0.14 → 2.0.16

package/src/commands/doctor.js

@@ -4,14 +4,21 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import axios from 'axios';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadConfig, loadEnv, getEnvMethod, getEnvSettings } from '../core/config.js';
+import {
+  isEnvEnabled,
+  resolveDefaultEnvironmentName,
+} from '../core/environments.js';
+import { loadEnvArtifactHistory } from '../storage/index.js';
 import { testProvider } from '../storage/index.js';
 import { getDeploymentProvider } from '../deployment/index.js';
-import { PROVIDER_ENV_MAP, getRollbackWorkflowDoctorCheck } from '../utils/github-actions.js';
+import { PROVIDER_ENV_MAP, getRollbackWorkflowDoctorCheck, getWorkflowDriftDoctorChecks } from '../utils/github-actions.js';
 import { printDoctorFooter } from '../utils/author.js';
 import { createLocalProvider } from '../storage/providers/local.js';
 import {
   getDeploymentEnvKeys,
+  getDeploymentSecretKeysForEnv,
+  envUsesPrefixedSecrets,
   getDeploymentSecretKeys,
 } from '../deployment/deployment-env.js';
 import { testSshConnectivity, validateSshKeyForDoctor, testSshHostReachability } from '../deployment/init-helpers.js';
@@ -27,6 +34,62 @@ import { namespaceExists } from '../utils/kubernetes-namespace.js';
  * @typedef {{ name: string, pass: boolean, message: string }} CheckResult
  */
 
+/**
+ * Whether doctor should `process.exit(1)` — only blocking (non-informational) failures count.
+ * @param {CheckResult[]} results
+ * @param {Set<string>} informationalCheckNames
+ * @returns {boolean}
+ */
+export function doctorHasBlockingFailures(results, informationalCheckNames) {
+  const blocking = results.filter((r) => !informationalCheckNames.has(r.name));
+  return blocking.some((r) => !r.pass);
+}
+
+/**
+ * Run per-env deployment checks with try/catch isolation (one env crash does not abort others).
+ * Disabled env failures are marked informational when `includeDisabled` is true.
+ *
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string[]} envNames
+ * @param {{ includeDisabled?: boolean, runChecks?: typeof runDeploymentChecks }} [options]
+ * @returns {Promise<{ results: CheckResult[], informationalCheckNames: Set<string> }>}
+ */
+export async function collectEnvDeploymentChecks(config, envNames, options = {}) {
+  const includeDisabled = options.includeDisabled === true;
+  const runChecks = options.runChecks || runDeploymentChecks;
+  /** @type {CheckResult[]} */
+  const results = [];
+  /** @type {Set<string>} */
+  const informationalCheckNames = new Set();
+
+  for (const envName of envNames) {
+    const env = config.environments?.[envName];
+    if (!env) continue;
+    const enabled = isEnvEnabled(env);
+    if (!enabled && !includeDisabled) continue;
+
+    try {
+      const deployChecks = await runChecks(config, envName, env);
+      for (const c of deployChecks) {
+        c.name = `${envName}/${c.name}`;
+        results.push(c);
+        if (!enabled) informationalCheckNames.add(c.name);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const name = `${envName}/checks`;
+      results.push({
+        name,
+        pass: false,
+        message: `Check aborted: ${message}`,
+      });
+      if (!enabled) informationalCheckNames.add(name);
+    }
+  }
+
+  return { results, informationalCheckNames };
+}
+
 /** @type {Set<string>} */
 const NODE_FRAMEWORKS = new Set(['express', 'nestjs', 'fastify', 'koa', 'nextjs', 'node']);
 /** @type {Set<string>} */
@@ -102,9 +165,10 @@ function needsNginxActivationForDeploy(config) {
  * @param {Record<string, unknown>} envConfig
  * @returns {Promise<CheckResult[]>}
  */
-async function runDeploymentChecks(config, envName, envConfig) {
-  const deployType = envConfig.type;
+export async function runDeploymentChecks(config, envName, envConfig) {
+  const deployType = getEnvMethod(envConfig);
   if (!deployType || typeof deployType !== 'string') return [];
+  const settings = getEnvSettings(envConfig);
 
   /** @type {CheckResult[]} */
   const checks = [];
@@ -134,10 +198,10 @@ async function runDeploymentChecks(config, envName, envConfig) {
   );
 
   if (SSH_DEPLOY_TYPES.has(deployType)) {
-    const host = envConfig.host || process.env.SSH_HOST;
-    const user = envConfig.user || process.env.SSH_USER;
-    const keyPath = envConfig.keyPath || process.env.SSH_KEY_PATH;
-    const sshPort = Number(process.env.SSH_SSH_PORT || envConfig.sshPort) || 22;
+    const host = settings.host || process.env.SSH_HOST;
+    const user = settings.user || process.env.SSH_USER;
+    const keyPath = settings.keyPath || process.env.SSH_KEY_PATH;
+    const sshPort = Number(process.env.SSH_SSH_PORT || settings.sshPort) || 22;
 
     checks.push(
       await runCheck('SSH key', async () => {
@@ -171,7 +235,7 @@ async function runDeploymentChecks(config, envName, envConfig) {
       })
     );
 
-    const deployPaths = resolveSshDeployPaths(config, envConfig);
+    const deployPaths = resolveSshDeployPaths(config, settings);
     const sshUser = String(user || process.env.SSH_USER || 'your-user');
 
     for (const deployPath of deployPaths) {
@@ -634,11 +698,17 @@ export function registerDoctorCommand(program) {
   program
     .command('doctor')
     .description('Run pre-flight checks before deploying')
-    .action(async () => {
+    .option(
+      '--all',
+      'Also run method checks for disabled environments (failures are informational only)'
+    )
+    .action(async (opts) => {
       loadEnv();
       const cwd = process.cwd();
       /** @type {CheckResult[]} */
       const results = [];
+      /** @type {Set<string>} names of checks that must not fail the summary */
+      const informationalCheckNames = new Set();
 
       results.push(
         await runCheck('Git', async () => {
@@ -801,14 +871,49 @@ export function registerDoctorCommand(program) {
           }
         }
 
-        for (const envName of config.deploy || []) {
-          const env = config.environments[envName];
-          if (!env) continue;
-
-          const deployChecks = await runDeploymentChecks(config, envName, env);
-          results.push(...deployChecks);
+        // Per-environment summary + method checks (enabled by default; --all includes disabled)
+        const envNames = Object.keys(config.environments || {});
+        if (envNames.length > 0) {
+          console.log('');
+          console.log(chalk.bold('Environments:'));
+          for (const envName of envNames) {
+            const env = config.environments[envName];
+            const method = getEnvMethod(env) || '?';
+            const enabled = isEnvEnabled(env);
+            const status = enabled ? 'enabled' : 'disabled';
+            let last = 'never';
+            try {
+              const { entries } = await loadEnvArtifactHistory(
+                config.storage || [],
+                config.project,
+                envName,
+                { defaultEnvironment: resolveDefaultEnvironmentName(config) }
+              );
+              if (entries[0]?.buildId) {
+                last = entries[0].buildId;
+              }
+            } catch {
+              // doctor never crashes
+            }
+            const icon = enabled ? chalk.green('✓') : chalk.gray('–');
+            const hint = enabled
+              ? `last deploy: ${last}`
+              : `run \`deployhub env enable ${envName}\``;
+            console.log(
+              `  ${icon} ${envName.padEnd(14)} (${method})`.padEnd(36) +
+                `${status.padEnd(10)} — ${hint}`
+            );
+          }
+          console.log('');
         }
 
+        const { results: envResults, informationalCheckNames: envInfo } =
+          await collectEnvDeploymentChecks(config, envNames, {
+            includeDisabled: Boolean(opts.all),
+          });
+        results.push(...envResults);
+        for (const name of envInfo) informationalCheckNames.add(name);
+
         results.push(
           await runCheck('Health endpoint', async () => {
             const url = config.healthCheck?.url;
@@ -851,10 +956,13 @@ export function registerDoctorCommand(program) {
             const keys = PROVIDER_ENV_MAP[provider] || [];
             required.push(...keys);
           }
-          for (const envName of config.deploy || []) {
+          for (const envName of Object.keys(config.environments || {})) {
             const env = config.environments[envName];
-            if (!env?.type) continue;
-            required.push(...getDeploymentSecretKeys(env.type, config));
+            if (!isEnvEnabled(env)) continue;
+            const method = getEnvMethod(env);
+            if (!method) continue;
+            // Local/.env uses unprefixed names; prefixed CI names are checked separately below.
+            required.push(...getDeploymentSecretKeys(method, config));
           }
 
           const unique = [...new Set(required)];
@@ -871,10 +979,65 @@ export function registerDoctorCommand(program) {
               message: `Missing: ${missing.join(', ')}`,
             };
           }
-          return { name: 'Secrets', pass: true, message: 'All required env vars present' };
+          return { name: 'Secrets', pass: true, message: 'All required secrets present' };
         })
       );
 
+      // Explicit CI-prefixed secret reminders for non-grandfathered environments
+      if (config) {
+        const inCi = process.env.GITHUB_ACTIONS === 'true' || process.env.CI === 'true';
+        for (const envName of Object.keys(config.environments || {})) {
+          const env = config.environments[envName];
+          if (!isEnvEnabled(env)) continue;
+          if (!envUsesPrefixedSecrets(envName, config)) continue;
+          const method = getEnvMethod(env);
+          if (!method) continue;
+
+          const prefixedKeys = getDeploymentSecretKeysForEnv(
+            envName,
+            method,
+            config,
+            config.environments
+          );
+          const baseKeys = getDeploymentSecretKeys(method, config);
+
+          for (let i = 0; i < baseKeys.length; i++) {
+            const base = baseKeys[i];
+            const prefixed = prefixedKeys[i] || base;
+            if (prefixed === base) continue;
+
+            const checkName = `CI secret ${prefixed}`;
+            results.push(
+              await runCheck(checkName, async () => {
+                if (process.env[prefixed]) {
+                  return {
+                    name: checkName,
+                    pass: true,
+                    message: `Present for environment "${envName}"`,
+                  };
+                }
+                const localFallback =
+                  base === 'SSH_KEY'
+                    ? process.env.SSH_KEY || process.env.SSH_KEY_PATH
+                    : process.env[base];
+                if (!inCi && localFallback) {
+                  return {
+                    name: checkName,
+                    pass: false,
+                    message: `Add GitHub Actions secret "${prefixed}" for env "${envName}" (local has ${base}, but CI needs the prefixed name)`,
+                  };
+                }
+                return {
+                  name: checkName,
+                  pass: false,
+                  message: `Missing — add GitHub Actions secret "${prefixed}" for environment "${envName}"`,
+                };
+              })
+            );
+          }
+        }
+      }
+
       results.push(
         await runCheck('GitHub Actions', async () => {
           const workflowPath = path.join(cwd, '.github', 'workflows', 'deployhub.yml');
@@ -910,6 +1073,13 @@ export function registerDoctorCommand(program) {
         );
       }
 
+      if (config) {
+        const driftChecks = await getWorkflowDriftDoctorChecks(cwd, config);
+        for (const check of driftChecks) {
+          results.push(await runCheck(check.name, async () => check));
+        }
+      }
+
       results.push(
         await runCheck('Storage write', async () => {
           const provider = createLocalProvider();
@@ -928,14 +1098,21 @@ export function registerDoctorCommand(program) {
       );
 
       console.log('');
-      const pad = (name) => name.padEnd(22);
+      const pad = (name) => name.padEnd(28);
       for (const r of results) {
-        const icon = r.pass ? chalk.green('✓') : chalk.red('✗');
-        console.log(`  Checking ${pad(r.name)}...  ${icon} ${r.message}`);
+        const info = informationalCheckNames.has(r.name);
+        const icon = r.pass
+          ? chalk.green('✓')
+          : info
+            ? chalk.yellow('!')
+            : chalk.red('✗');
+        const suffix = info && !r.pass ? chalk.gray(' (informational — disabled env)') : '';
+        console.log(`  Checking ${pad(r.name)}...  ${icon} ${r.message}${suffix}`);
       }
 
-      const passed = results.filter((r) => r.pass).length;
-      const total = results.length;
+      const blocking = results.filter((r) => !informationalCheckNames.has(r.name));
+      const passed = blocking.filter((r) => r.pass).length;
+      const total = blocking.length;
       console.log('');
       if (passed === total) {
         console.log(chalk.green.bold(`  ✓ Ready to deploy (${passed}/${total} checks passed)`));
@@ -950,7 +1127,16 @@ export function registerDoctorCommand(program) {
       console.log('');
       printDoctorFooter();
       console.log('');
+
+      if (doctorHasBlockingFailures(results, informationalCheckNames)) {
+        process.exit(1);
+      }
     });
 }
 
-export default { registerDoctorCommand };
+export default {
+  registerDoctorCommand,
+  runDeploymentChecks,
+  doctorHasBlockingFailures,
+  collectEnvDeploymentChecks,
+};

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