@akash-chowdhury-24/deployhub 2.0.15 → 2.0.16

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

package/src/core/config.js

@@ -2,6 +2,20 @@ import fs from 'fs-extra';
 import path from 'path';
 import { z } from 'zod';
 import dotenv from 'dotenv';
+import { createLogger } from '../logger/index.js';
+import { ensureLegacyHistoryCopiedToDefaultEnv } from '../storage/index.js';
+import {
+  isNewEnvironmentShape,
+  getEnvMethod,
+  getEnvSettings,
+  isEnvEnabled,
+  getEnvTrigger,
+  resolveDefaultEnvironmentName,
+  getEnabledEnvironmentNames,
+  buildEnvironmentEntry,
+  resolveEnvTargets,
+  mergeMethodSettingsIntoEnv,
+} from './environments.js';
 
 const SideConfigSchema = z.object({
   framework: z.string(),
@@ -12,36 +26,52 @@ const SideConfigSchema = z.object({
   port: z.number().optional(),
 });
 
+/** Method-specific non-secret settings (host, paths, namespace, image name, etc.). */
+const MethodConfigSchema = z
+  .object({
+    deploymentType: z.enum(['server']).optional(),
+    frontendDeploymentType: z.enum(['server']).optional(),
+    backendDeploymentType: z.enum(['server']).optional(),
+    host: z.string().optional(),
+    user: z.string().optional(),
+    path: z.string().optional(),
+    deployPath: z.string().optional(),
+    keyPath: z.string().optional(),
+    sshPort: z.number().optional(),
+    ec2InstanceId: z.string().optional(),
+    awsRegion: z.string().optional(),
+    azureSubscriptionId: z.string().optional(),
+    azureResourceGroup: z.string().optional(),
+    azureVmName: z.string().optional(),
+    gcpProjectId: z.string().optional(),
+    gcpZone: z.string().optional(),
+    gcpInstanceName: z.string().optional(),
+    kubeconfig: z.string().optional(),
+    kubeContext: z.string().optional(),
+    kubeNamespace: z.string().optional(),
+    dockerImageName: z.string().optional(),
+    dockerRegistryUrl: z.string().optional(),
+    dockerHost: z.string().optional(),
+    healthCheckUrl: z.string().optional(),
+    appName: z.string().optional(),
+    framework: z.string().optional(),
+    port: z.number().optional(),
+    frontendDeployPath: z.string().optional(),
+    backendDeployPath: z.string().optional(),
+  })
+  .passthrough();
+
+const DEPLOY_METHODS = ['ssh', 'docker', 'ec2', 'azure-vm', 'gcp-vm', 'kubernetes'];
+
+/**
+ * Per-environment entry. Storage (providers list / credentials) stays project-wide
+ * in this pass — per-env storage overrides are a future extension.
+ */
 const EnvironmentSchema = z.object({
-  type: z.string().optional(),
-  deploymentType: z.enum(['server']).optional(),
-  frontendDeploymentType: z.enum(['server']).optional(),
-  backendDeploymentType: z.enum(['server']).optional(),
-  host: z.string().optional(),
-  user: z.string().optional(),
-  path: z.string().optional(),
-  deployPath: z.string().optional(),
-  keyPath: z.string().optional(),
-  sshPort: z.number().optional(),
-  ec2InstanceId: z.string().optional(),
-  awsRegion: z.string().optional(),
-  azureSubscriptionId: z.string().optional(),
-  azureResourceGroup: z.string().optional(),
-  azureVmName: z.string().optional(),
-  gcpProjectId: z.string().optional(),
-  gcpZone: z.string().optional(),
-  gcpInstanceName: z.string().optional(),
-  kubeconfig: z.string().optional(),
-  kubeContext: z.string().optional(),
-  kubeNamespace: z.string().optional(),
-  dockerImageName: z.string().optional(),
-  dockerRegistryUrl: z.string().optional(),
-  dockerHost: z.string().optional(),
-  appName: z.string().optional(),
-  framework: z.string().optional(),
-  port: z.number().optional(),
-  frontendDeployPath: z.string().optional(),
-  backendDeployPath: z.string().optional(),
+  enabled: z.boolean().default(true),
+  method: z.string(),
+  trigger: z.enum(['push', 'manual']).default('manual'),
+  config: MethodConfigSchema.default({}),
 });
 
 const ConfigSchema = z.object({
@@ -60,8 +90,21 @@ const ConfigSchema = z.object({
   docker: z.boolean().default(false),
   artifact: z.boolean().default(true),
   storage: z.array(z.string()).default(['local']),
-  deploy: z.array(z.string()).default([]),
+  /** @deprecated Prefer environments.*.enabled + defaultEnvironment; kept optional for in-memory BC. */
+  deploy: z.array(z.string()).optional().default([]),
   environments: z.record(EnvironmentSchema).default({}),
+  defaultEnvironment: z.string().optional(),
+  /**
+   * Environment that keeps unprefixed CI secrets (SSH_HOST, not DEVELOPMENT_SSH_HOST).
+   * Set when the first environment is created; never silently changed when more envs are added.
+   */
+  unprefixedSecretEnvironment: z.string().optional(),
+  /**
+   * Set when a project is created via init or when a legacy flat config is silently
+   * migrated. Tells ensureLegacyHistoryCopiedToDefaultEnv not to copy the build catalog
+   * into the default env (multi-env-native projects never had pre-multi-env deploy history).
+   */
+  legacyHistoryMigrated: z.boolean().optional(),
   healthCheck: z
     .object({
       url: z.string().default(''),
@@ -93,9 +136,214 @@ const ConfigSchema = z.object({
 });
 
 /** @typedef {z.infer<typeof ConfigSchema>} DeployHubConfig */
+/** @typedef {z.infer<typeof EnvironmentSchema>} EnvironmentEntry */
+/** @typedef {z.infer<typeof MethodConfigSchema>} MethodConfig */
 
 const CONFIG_FILENAME = 'deployhub.config.json';
 
+/** Top-level keys that indicated a pre-environments flat deploy config. */
+const FLAT_DEPLOY_KEYS = [
+  'type',
+  'method',
+  'host',
+  'user',
+  'path',
+  'deployPath',
+  'keyPath',
+  'sshPort',
+  'ec2InstanceId',
+  'awsRegion',
+  'azureSubscriptionId',
+  'azureResourceGroup',
+  'azureVmName',
+  'gcpProjectId',
+  'gcpZone',
+  'gcpInstanceName',
+  'kubeconfig',
+  'kubeContext',
+  'kubeNamespace',
+  'dockerImageName',
+  'dockerRegistryUrl',
+  'dockerHost',
+  'appName',
+  'frontendDeployPath',
+  'backendDeployPath',
+  'deploymentType',
+];
+
+/**
+ * @param {unknown} entry
+ * @returns {boolean}
+ */
+// isNewEnvironmentShape imported from ./environments.js
+
+/**
+ * @param {Record<string, unknown>} entry
+ * @returns {Record<string, unknown>}
+ */
+function extractMethodConfig(entry) {
+  /** @type {Record<string, unknown>} */
+  const config = { ...(entry.config && typeof entry.config === 'object' ? entry.config : {}) };
+  for (const [key, value] of Object.entries(entry)) {
+    if (
+      key === 'enabled' ||
+      key === 'method' ||
+      key === 'trigger' ||
+      key === 'config' ||
+      key === 'type'
+    ) {
+      continue;
+    }
+    if (value !== undefined) {
+      config[key] = value;
+    }
+  }
+  return config;
+}
+
+/**
+ * @param {Record<string, unknown>} raw
+ * @returns {boolean}
+ */
+export function needsConfigMigration(raw) {
+  if (!raw || typeof raw !== 'object') return false;
+
+  const envs = raw.environments;
+  if (!envs || typeof envs !== 'object' || Array.isArray(envs)) {
+    return FLAT_DEPLOY_KEYS.some((k) => raw[k] !== undefined);
+  }
+
+  const entries = Object.values(envs);
+  if (entries.some((e) => e && typeof e === 'object' && !isNewEnvironmentShape(e))) {
+    return true;
+  }
+
+  // Legacy deploy[] without defaultEnvironment (even when env shapes are already new)
+  if (Array.isArray(raw.deploy) && raw.deploy.length > 0 && !raw.defaultEnvironment) {
+    return true;
+  }
+
+  if (entries.length > 0 && !raw.defaultEnvironment) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Migrate legacy flat / type-at-top-level environment configs to
+ * `{ enabled, method, trigger, config }` + `defaultEnvironment`.
+ * Idempotent: already-migrated configs are returned unchanged.
+ *
+ * @param {Record<string, unknown>} raw
+ * @returns {{ config: Record<string, unknown>, migrated: boolean, reason: string|null }}
+ */
+export function migrateConfigToEnvironments(raw) {
+  if (!needsConfigMigration(raw)) {
+    return { config: raw, migrated: false, reason: null };
+  }
+
+  /** @type {Record<string, unknown>} */
+  const next = { ...raw };
+  const legacyDeploy = Array.isArray(raw.deploy) ? raw.deploy.map(String) : [];
+
+  /** @type {Record<string, Record<string, unknown>>} */
+  const newEnvironments = {};
+
+  const rawEnvs =
+    raw.environments && typeof raw.environments === 'object' && !Array.isArray(raw.environments)
+      ? /** @type {Record<string, Record<string, unknown>>} */ (raw.environments)
+      : null;
+
+  if (rawEnvs && Object.keys(rawEnvs).length > 0) {
+    for (const [name, entry] of Object.entries(rawEnvs)) {
+      if (!entry || typeof entry !== 'object') continue;
+      if (isNewEnvironmentShape(entry)) {
+        newEnvironments[name] = {
+          enabled: entry.enabled !== false,
+          method: String(entry.method),
+          trigger: entry.trigger === 'push' ? 'push' : 'manual',
+          config: extractMethodConfig(entry),
+        };
+        continue;
+      }
+
+      const method = String(entry.method || entry.type || 'ssh');
+      const enabled =
+        legacyDeploy.length === 0 ? true : legacyDeploy.includes(name);
+      newEnvironments[name] = {
+        enabled,
+        method,
+        trigger: entry.trigger === 'push' ? 'push' : 'manual',
+        config: extractMethodConfig(entry),
+      };
+    }
+  } else {
+    // Truly flat single-environment config (method/type + settings at top level).
+    const method = String(raw.method || raw.type || 'ssh');
+    /** @type {Record<string, unknown>} */
+    const flatConfig = {};
+    for (const key of FLAT_DEPLOY_KEYS) {
+      if (key === 'type' || key === 'method') continue;
+      if (raw[key] !== undefined) flatConfig[key] = raw[key];
+    }
+    newEnvironments.default = {
+      enabled: true,
+      method,
+      trigger: 'manual',
+      config: flatConfig,
+    };
+    for (const key of FLAT_DEPLOY_KEYS) {
+      delete next[key];
+    }
+  }
+
+  let defaultEnvironment =
+    typeof raw.defaultEnvironment === 'string' && raw.defaultEnvironment
+      ? raw.defaultEnvironment
+      : null;
+
+  if (!defaultEnvironment || !newEnvironments[defaultEnvironment]) {
+    if (legacyDeploy[0] && newEnvironments[legacyDeploy[0]]) {
+      defaultEnvironment = legacyDeploy[0];
+    } else if (newEnvironments.default) {
+      defaultEnvironment = 'default';
+    } else if (newEnvironments.production) {
+      defaultEnvironment = 'production';
+    } else {
+      const enabledNames = Object.entries(newEnvironments)
+        .filter(([, e]) => e.enabled !== false)
+        .map(([n]) => n);
+      defaultEnvironment =
+        enabledNames[0] || Object.keys(newEnvironments)[0] || 'default';
+    }
+  }
+
+  if (!newEnvironments[defaultEnvironment] && Object.keys(newEnvironments).length === 0) {
+    newEnvironments[defaultEnvironment] = {
+      enabled: true,
+      method: 'ssh',
+      trigger: 'manual',
+      config: {},
+    };
+  }
+
+  next.environments = newEnvironments;
+  next.defaultEnvironment = defaultEnvironment;
+  if (!next.unprefixedSecretEnvironment) {
+    next.unprefixedSecretEnvironment = defaultEnvironment;
+  }
+  // deploy[] is superseded by enabled + defaultEnvironment
+  delete next.deploy;
+
+  const reason =
+    !rawEnvs || Object.keys(rawEnvs).length === 0
+      ? 'flat'
+      : 'legacy-environments';
+
+  return { config: next, migrated: true, reason };
+}
+
 /**
  * @param {string} [cwd]
  * @returns {string}
@@ -104,6 +352,20 @@ export function getConfigPath(cwd = process.cwd()) {
   return path.join(cwd, CONFIG_FILENAME);
 }
 
+/**
+ * @param {DeployHubConfig} config
+ */
+export function validateConfigConsistency(config) {
+  const envs = config.environments || {};
+  const def = config.defaultEnvironment;
+  if (typeof def === 'string' && def && !envs[def]) {
+    throw new Error(
+      `defaultEnvironment "${def}" is not defined in environments. ` +
+        'Fix deployhub.config.json (typo?) or run deployhub env list.'
+    );
+  }
+}
+
 /**
  * @param {string} [cwd]
  * @returns {Promise<DeployHubConfig>}
@@ -116,7 +378,43 @@ export async function loadConfig(cwd = process.cwd()) {
     );
   }
   const raw = await fs.readJson(configPath);
-  const parsed = ConfigSchema.parse(raw);
+  const { config: migratedRaw, migrated, reason } = migrateConfigToEnvironments(raw);
+
+  if (migrated) {
+    const log = createLogger('config');
+    if (reason === 'flat') {
+      log.warn('Old single-environment config detected.');
+      log.warn('  Migrating to environments.default using your existing settings.');
+      log.warn(
+        '  Nothing changes in behavior — this just adds room for more environments later.'
+      );
+    } else {
+      log.warn('Legacy environment config format detected.');
+      log.warn(
+        '  Migrating to enabled/method/trigger/config shape (defaultEnvironment set).'
+      );
+      log.warn(
+        '  Nothing changes in behavior — this just adds room for more environments later.'
+      );
+    }
+    await fs.writeJson(configPath, migratedRaw, { spaces: 2 });
+
+    const storage = /** @type {string[]|undefined} */ (migratedRaw.storage);
+    if (
+      Array.isArray(storage) &&
+      storage.length > 0 &&
+      migratedRaw.project &&
+      migratedRaw.defaultEnvironment
+    ) {
+      await ensureLegacyHistoryCopiedToDefaultEnv(
+        storage,
+        String(migratedRaw.project),
+        String(migratedRaw.defaultEnvironment)
+      );
+    }
+  }
+
+  const parsed = ConfigSchema.parse(migratedRaw);
 
   if (!parsed.framework && parsed.projectType === 'frontend') {
     parsed.framework = 'node';
@@ -131,6 +429,27 @@ export async function loadConfig(cwd = process.cwd()) {
     parsed.version = '0.0.0';
   }
 
+  if (!parsed.defaultEnvironment) {
+    parsed.defaultEnvironment = resolveDefaultEnvironmentName(parsed) || undefined;
+  }
+
+  // Grandfather unprefixed CI secrets for the original environment (in-memory;
+  // persisted on next saveConfig / env add / migration rewrite).
+  if (!parsed.unprefixedSecretEnvironment) {
+    const envNames = Object.keys(parsed.environments || {});
+    if (envNames.length >= 1) {
+      parsed.unprefixedSecretEnvironment =
+        parsed.defaultEnvironment && parsed.environments[parsed.defaultEnvironment]
+          ? parsed.defaultEnvironment
+          : envNames[0];
+    }
+  }
+
+  // Keep deploy[] in sync for code paths that still read it (pipeline, doctor, workflows).
+  parsed.deploy = getEnabledEnvironmentNames(parsed);
+
+  validateConfigConsistency(parsed);
+
   return parsed;
 }
 
@@ -140,7 +459,11 @@ export async function loadConfig(cwd = process.cwd()) {
  */
 export async function saveConfig(config, cwd = process.cwd()) {
   const configPath = getConfigPath(cwd);
-  await fs.writeJson(configPath, config, { spaces: 2 });
+  /** @type {Record<string, unknown>} */
+  const toWrite = { ...config };
+  // Persist new shape only — deploy[] is derived at load time.
+  delete toWrite.deploy;
+  await fs.writeJson(configPath, toWrite, { spaces: 2 });
 }
 
 /**
@@ -171,4 +494,19 @@ export async function appendEnv(vars, cwd = process.cwd()) {
   await fs.appendFile(envPath, `${separator}${lines.join('\n')}\n`);
 }
 
-export { ConfigSchema };
+export {
+  ConfigSchema,
+  EnvironmentSchema,
+  MethodConfigSchema,
+  DEPLOY_METHODS,
+  isNewEnvironmentShape,
+  getEnvMethod,
+  getEnvSettings,
+  isEnvEnabled,
+  getEnvTrigger,
+  resolveDefaultEnvironmentName,
+  getEnabledEnvironmentNames,
+  buildEnvironmentEntry,
+  resolveEnvTargets,
+  mergeMethodSettingsIntoEnv,
+};