@akash-chowdhury-24/deployhub 2.0.15 → 2.0.17

package/src/deployment/index.js

@@ -5,6 +5,15 @@ import { createAzureVmProvider } from './providers/azure-vm.js';
 import { createGcpVmProvider } from './providers/gcp-vm.js';
 import { createKubernetesProvider } from './providers/kubernetes.js';
 import { createLogger } from '../logger/index.js';
+import {
+  getEnabledEnvironmentNames,
+  getEnvMethod,
+} from '../core/environments.js';
+import { applyEnvSecretOverlay } from './deployment-env.js';
+import { recordEnvDeployment } from '../storage/index.js';
+import { buildArtifactRemoteKey } from '../utils/build-id.js';
+import path from 'path';
+import fs from 'fs-extra';
 
 /** @type {Record<string, Function>} */
 const PROVIDER_FACTORIES = {
@@ -28,12 +37,13 @@ export function getDeploymentProvider(type, config, envName, env = process.env)
     throw new Error(`Environment "${envName}" not found in config`);
   }
 
-  const providerType = type || environment.type;
+  const providerType = type || getEnvMethod(environment);
   const factory = PROVIDER_FACTORIES[providerType];
   if (!factory) {
     throw new Error(`Unknown deployment provider: ${providerType}`);
   }
-  return factory(config, envName, env);
+  const resolvedEnv = applyEnvSecretOverlay(envName, config, env);
+  return factory(config, envName, resolvedEnv);
 }
 
 /**
@@ -43,13 +53,26 @@ export function getDeploymentProvider(type, config, envName, env = process.env)
  */
 export async function deployToAll(config, artifactDir, envNames) {
   const log = createLogger('deploy');
-  const targets = envNames || config.deploy || [];
+  const targets = envNames || getEnabledEnvironmentNames(config);
 
   if (targets.length === 0) {
     log.warn('No deployment targets configured, skipping');
     return [];
   }
 
+  const buildId =
+    config.buildId ||
+    (await fs.readJson(path.join(artifactDir, 'metadata.json')).catch(() => ({}))).buildId;
+  if (buildId) {
+    config.buildId = String(buildId);
+  }
+
+  const zipCandidates = [
+    path.join(artifactDir, 'artifact.zip'),
+    path.join(artifactDir, `${config.project || 'artifact'}.zip`),
+  ];
+  let zipPath = zipCandidates.find((p) => fs.existsSync(p)) || null;
+
   const deployed = [];
   for (const envName of targets) {
     const envConfig = config.environments[envName];
@@ -57,11 +80,39 @@ export async function deployToAll(config, artifactDir, envNames) {
       throw new Error(`Environment "${envName}" not found in config`);
     }
 
-    const provider = getDeploymentProvider(envConfig.type, config, envName);
-    log.info(`Deploying to ${envName} (${envConfig.type})...`);
+    const method = getEnvMethod(envConfig);
+    const provider = getDeploymentProvider(method, config, envName);
+    log.info(`Deploying to ${envName} (${method})...`);
     await provider.deploy(artifactDir);
     deployed.push(envName);
     log.success(`Deployed to ${envName}`);
+
+    // Per-env deploy history (isolated). Shared builds/{buildId} is unchanged.
+    if (config.buildId && (config.storage || []).length > 0) {
+      try {
+        if (!zipPath || !(await fs.pathExists(zipPath))) {
+          const files = await fs.readdir(artifactDir).catch(() => []);
+          const found = files.find((f) => f.endsWith('.zip'));
+          zipPath = found ? path.join(artifactDir, found) : zipPath;
+        }
+        await recordEnvDeployment(
+          config.storage,
+          zipPath || '',
+          config,
+          envName,
+          {
+            buildId: String(config.buildId),
+            semver: config.version,
+            remoteKey: buildArtifactRemoteKey(config.project, String(config.buildId)),
+          }
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Deploy to ${envName} succeeded but recording env history failed: ${msg}`
+        );
+      }
+    }
   }
 
   return deployed;
@@ -74,10 +125,10 @@ export async function deployToAll(config, artifactDir, envNames) {
  * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
  */
 export async function rollbackAll(config, artifactDir, envNames, meta) {
-  const targets = envNames || config.deploy || [];
+  const targets = envNames || getEnabledEnvironmentNames(config);
   for (const envName of targets) {
     const envConfig = config.environments[envName];
-    const provider = getDeploymentProvider(envConfig.type, config, envName);
+    const provider = getDeploymentProvider(getEnvMethod(envConfig), config, envName);
     await provider.rollback(artifactDir, meta);
   }
 }

package/src/deployment/init-prompts.js

@@ -1,5 +1,6 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import { createEnvNamePromptValidate } from '../core/environments.js';
 import {
   suggestSshUser,
   listKubeContexts,
@@ -24,27 +25,73 @@ export const SERVER_DEPLOY_TYPES = [
 const SSH_BASED = ['ssh', 'ec2', 'azure-vm', 'gcp-vm'];
 
 /**
+ * Prompt for one environment's deployment method + method-specific config.
+ * Shared by `deployhub init` and `deployhub env add`.
+ *
  * @param {string} projectName
  * @param {'frontend'|'backend'|'both'} projectType
  * @param {Record<string, unknown>|null} backendConfig
+ * @param {{
+ *   envName?: string,
+ *   existingEnvNames?: string[],
+ *   deployType?: string,
+ *   nonInteractive?: boolean,
+ * }} [options]
+ *   — when envName is set, skip the name prompt; existingEnvNames blocks in-session / config duplicates
+ *   — deployType skips the method list; nonInteractive uses defaults (requires deployType)
  */
-export async function promptServerDeployment(projectName, projectType, backendConfig) {
-  const isBackend = projectType === 'backend' || projectType === 'both';
+export async function promptServerDeployment(
+  projectName,
+  projectType,
+  backendConfig,
+  options = {}
+) {
+  const existingEnvNames = options.existingEnvNames || [];
+  const allowedMethods = new Set(SERVER_DEPLOY_TYPES.map((c) => c.value));
+
+  if (options.nonInteractive) {
+    if (!options.deployType || !allowedMethods.has(options.deployType)) {
+      throw new Error(
+        'Non-interactive env add requires --method <ssh|docker|ec2|azure-vm|gcp-vm|kubernetes>.'
+      );
+    }
+    return buildNonInteractiveDeployAnswers(options.deployType, projectName, options.envName);
+  }
 
-  const base = await inquirer.prompt([
-    {
+  /** @type {import('inquirer').QuestionCollection} */
+  const questions = [];
+
+  if (!options.deployType) {
+    questions.push({
       type: 'list',
       name: 'deployType',
       message: 'Deployment type:',
       choices: SERVER_DEPLOY_TYPES,
-    },
-    {
+    });
+  } else if (!allowedMethods.has(options.deployType)) {
+    throw new Error(
+      `Unknown deployment method "${options.deployType}". Use: ${[...allowedMethods].join(', ')}`
+    );
+  }
+
+  if (!options.envName) {
+    questions.push({
       type: 'input',
       name: 'envName',
       message: 'Environment name (e.g. production, staging):',
       default: 'production',
-    },
-  ]);
+      validate: createEnvNamePromptValidate(existingEnvNames),
+    });
+  }
+
+  const base =
+    questions.length > 0 ? await inquirer.prompt(questions) : {};
+  if (options.envName) {
+    base.envName = options.envName;
+  }
+  if (options.deployType) {
+    base.deployType = options.deployType;
+  }
 
   const deployType = base.deployType;
 
@@ -59,6 +106,50 @@ export async function promptServerDeployment(projectName, projectType, backendCo
   return promptSshBasedDeployment(base, projectName, projectType, backendConfig, deployType);
 }
 
+/**
+ * Defaults for `deployhub env add <name> --method <type> --yes` (no prompts).
+ * @param {string} deployType
+ * @param {string} projectName
+ * @param {string} [envName]
+ */
+function buildNonInteractiveDeployAnswers(deployType, projectName, envName) {
+  const base = { deployType, envName: envName || 'default' };
+  if (deployType === 'docker') {
+    return {
+      ...base,
+      dockerImageName: projectName,
+      dockerRegistryUrl: '',
+      dockerRegistryUsername: '',
+      dockerRegistryToken: '',
+      dockerHost: '',
+      healthUrl: '',
+    };
+  }
+  if (deployType === 'kubernetes') {
+    return {
+      ...base,
+      kubeconfig: '~/.kube/config',
+      kubeContext: '',
+      kubeNamespace: projectName,
+      dockerImageName: projectName,
+      dockerRegistryUrl: '',
+      dockerRegistryUsername: '',
+      dockerRegistryToken: '',
+      healthUrl: '',
+    };
+  }
+  // ssh / ec2 / azure-vm / gcp-vm — host/user left empty (filled via secrets / env)
+  return {
+    ...base,
+    host: '',
+    user: 'deploy',
+    keyPath: '',
+    sshPort: '22',
+    deployPath: `/var/www/${projectName}`,
+    osHint: '',
+  };
+}
+
 /**
  * @param {Record<string, string>} base
  * @param {string} projectName
@@ -376,62 +467,127 @@ export function buildServerEnvEntry(
   singleConfig
 ) {
   /** @type {Record<string, unknown>} */
-  const envEntry = {
+  const settings = {
     deploymentType: 'server',
-    type: deployAnswers.deployType,
   };
 
   if (deployAnswers.deployType === 'kubernetes') {
-    envEntry.kubeconfig = deployAnswers.kubeconfig;
-    envEntry.kubeContext = deployAnswers.kubeContext;
-    envEntry.kubeNamespace = deployAnswers.kubeNamespace || projectName;
-    envEntry.dockerImageName = deployAnswers.dockerImageName || projectName;
-    envEntry.dockerRegistryUrl = deployAnswers.dockerRegistryUrl || '';
-    return envEntry;
+    settings.kubeconfig = deployAnswers.kubeconfig;
+    settings.kubeContext = deployAnswers.kubeContext;
+    settings.kubeNamespace = deployAnswers.kubeNamespace || projectName;
+    settings.dockerImageName = deployAnswers.dockerImageName || projectName;
+    settings.dockerRegistryUrl = deployAnswers.dockerRegistryUrl || '';
+    return {
+      enabled: true,
+      method: 'kubernetes',
+      trigger: 'manual',
+      config: settings,
+    };
   }
 
   if (deployAnswers.deployType === 'docker') {
-    envEntry.dockerImageName = deployAnswers.dockerImageName || projectName;
-    envEntry.dockerRegistryUrl = deployAnswers.dockerRegistryUrl || '';
-    envEntry.dockerHost = deployAnswers.dockerHost || '';
-    return envEntry;
+    settings.dockerImageName = deployAnswers.dockerImageName || projectName;
+    settings.dockerRegistryUrl = deployAnswers.dockerRegistryUrl || '';
+    settings.dockerHost = deployAnswers.dockerHost || '';
+    return {
+      enabled: true,
+      method: 'docker',
+      trigger: 'manual',
+      config: settings,
+    };
   }
 
-  envEntry.host = deployAnswers.host || '';
-  envEntry.user = deployAnswers.user || '';
-  envEntry.keyPath = deployAnswers.keyPath || '';
-  envEntry.sshPort = Number(deployAnswers.sshPort) || 22;
+  settings.host = deployAnswers.host || '';
+  settings.user = deployAnswers.user || '';
+  settings.keyPath = deployAnswers.keyPath || '';
+  settings.sshPort = Number(deployAnswers.sshPort) || 22;
 
-  if (deployAnswers.ec2InstanceId) envEntry.ec2InstanceId = deployAnswers.ec2InstanceId;
-  if (deployAnswers.awsRegion) envEntry.awsRegion = deployAnswers.awsRegion;
-  if (deployAnswers.azureSubscriptionId) envEntry.azureSubscriptionId = deployAnswers.azureSubscriptionId;
-  if (deployAnswers.azureResourceGroup) envEntry.azureResourceGroup = deployAnswers.azureResourceGroup;
-  if (deployAnswers.azureVmName) envEntry.azureVmName = deployAnswers.azureVmName;
-  if (deployAnswers.gcpProjectId) envEntry.gcpProjectId = deployAnswers.gcpProjectId;
-  if (deployAnswers.gcpZone) envEntry.gcpZone = deployAnswers.gcpZone;
-  if (deployAnswers.gcpInstanceName) envEntry.gcpInstanceName = deployAnswers.gcpInstanceName;
+  if (deployAnswers.ec2InstanceId) settings.ec2InstanceId = deployAnswers.ec2InstanceId;
+  if (deployAnswers.awsRegion) settings.awsRegion = deployAnswers.awsRegion;
+  if (deployAnswers.azureSubscriptionId) settings.azureSubscriptionId = deployAnswers.azureSubscriptionId;
+  if (deployAnswers.azureResourceGroup) settings.azureResourceGroup = deployAnswers.azureResourceGroup;
+  if (deployAnswers.azureVmName) settings.azureVmName = deployAnswers.azureVmName;
+  if (deployAnswers.gcpProjectId) settings.gcpProjectId = deployAnswers.gcpProjectId;
+  if (deployAnswers.gcpZone) settings.gcpZone = deployAnswers.gcpZone;
+  if (deployAnswers.gcpInstanceName) settings.gcpInstanceName = deployAnswers.gcpInstanceName;
 
   if (projectType === 'both') {
-    envEntry.frontendDeployPath =
+    settings.frontendDeployPath =
       deployAnswers.frontendDeployPath || `/var/www/${projectName}/public`;
-    envEntry.backendDeployPath =
+    settings.backendDeployPath =
       deployAnswers.backendDeployPath || `/var/www/${projectName}/api`;
-    envEntry.appName = deployAnswers.appName || `${projectName}-api`;
-    envEntry.framework = backendConfig?.framework || 'express';
-    envEntry.path = envEntry.backendDeployPath;
-    envEntry.backendDeploymentType = 'server';
+    settings.appName = deployAnswers.appName || `${projectName}-api`;
+    settings.framework = backendConfig?.framework || 'express';
+    settings.path = settings.backendDeployPath;
+    settings.backendDeploymentType = 'server';
   } else if (projectType === 'backend') {
-    envEntry.deployPath = deployAnswers.deployPath || `/var/www/${projectName}`;
-    envEntry.path = envEntry.deployPath;
-    envEntry.appName = deployAnswers.appName || projectName;
-    envEntry.framework = singleConfig?.framework || 'express';
-    envEntry.port = singleConfig?.port || 3000;
+    settings.deployPath = deployAnswers.deployPath || `/var/www/${projectName}`;
+    settings.path = settings.deployPath;
+    settings.appName = deployAnswers.appName || projectName;
+    settings.framework = singleConfig?.framework || 'express';
+    settings.port = singleConfig?.port || 3000;
   } else {
-    envEntry.deployPath = deployAnswers.deployPath || `/var/www/${projectName}`;
-    envEntry.path = envEntry.deployPath;
+    settings.deployPath = deployAnswers.deployPath || `/var/www/${projectName}`;
+    settings.path = settings.deployPath;
   }
 
-  return envEntry;
+  return {
+    enabled: true,
+    method: deployAnswers.deployType,
+    trigger: 'manual',
+    config: settings,
+  };
+}
+
+/**
+ * Apply init-time trigger defaults after environments are collected.
+ * - Exactly one env → always `push` (git push = auto-deploy).
+ * - Two or more → grandfathered/default gets `push`; all others stay `manual`.
+ *
+ * @param {Record<string, { trigger?: string }>} environments
+ * @param {string[]} deployNames
+ * @param {string|undefined|null} defaultEnvironment
+ */
+export function applyInitTriggerDefaults(environments, deployNames, defaultEnvironment) {
+  if (deployNames.length === 1 && environments[deployNames[0]]) {
+    environments[deployNames[0]].trigger = 'push';
+    return;
+  }
+  if (deployNames.length >= 2 && defaultEnvironment) {
+    for (const name of deployNames) {
+      if (!environments[name]) continue;
+      environments[name].trigger =
+        name === defaultEnvironment ? 'push' : 'manual';
+    }
+  }
+}
+
+/**
+ * End-of-init reminder for multi-env setups (grandfathered = push, others = manual).
+ * @param {string} grandfathered
+ * @param {string[]} allEnvNames
+ * @returns {string}
+ */
+export function formatMultiEnvTriggerReminder(grandfathered, allEnvNames) {
+  const others = allEnvNames.filter((n) => n !== grandfathered);
+  const otherList =
+    others.length > 0 ? others.map((n) => `"${n}"`).join(', ') : '(none)';
+  const exampleEnv = others[0] || '<env-name>';
+  return [
+    '─────────────────────────────────────────────',
+    `By default, only your first environment ("${grandfathered}")`,
+    `auto-deploys on push. Your other environment(s) — ${otherList} — are set to manual and will only deploy via:`,
+    '  deployhub deploy --env <name>',
+    'or GitHub Actions → Run workflow.',
+    '',
+    'To make an environment auto-deploy on push instead, open',
+    'deployhub.config.json and change its "trigger" to "push":',
+    '  "environments": {',
+    `    "${exampleEnv}": { "trigger": "push", ... }`,
+    '  }',
+    'Then run: deployhub sync-workflows',
+    '─────────────────────────────────────────────',
+  ].join('\n');
 }
 
 /**

package/src/deployment/providers/azure-vm.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { createSshProvider } from './ssh.js';
 import { createLogger } from '../../logger/index.js';
+import { getEnvSettings } from '../../core/config.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -9,14 +10,14 @@ import { createLogger } from '../../logger/index.js';
  */
 export function createAzureVmProvider(config, envName, env = process.env) {
   const log = createLogger('azure-vm');
-  const subscriptionId = env.AZURE_SUBSCRIPTION_ID;
-  const resourceGroup = env.AZURE_RESOURCE_GROUP;
-  const vmName = env.AZURE_VM_NAME;
+  const settings = getEnvSettings(config.environments[envName]);
+  const subscriptionId = env.AZURE_SUBSCRIPTION_ID || settings.azureSubscriptionId;
+  const resourceGroup = env.AZURE_RESOURCE_GROUP || settings.azureResourceGroup;
+  const vmName = env.AZURE_VM_NAME || settings.azureVmName;
 
   async function resolveHost() {
-    const environment = config.environments[envName];
-    if (environment?.host || env.SSH_HOST) {
-      return environment?.host || env.SSH_HOST;
+    if (settings.host || env.SSH_HOST) {
+      return settings.host || env.SSH_HOST;
     }
 
     if (!subscriptionId || !resourceGroup || !vmName) {
@@ -73,10 +74,7 @@ export function createAzureVmProvider(config, envName, env = process.env) {
         'Could not resolve host via Azure VM lookup, and no SSH_HOST was set — provide one or the other.'
       );
     }
-    const environment = config.environments[envName];
-    if (environment) {
-      environment.host = host;
-    }
+    settings.host = host;
     return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 

package/src/deployment/providers/docker.js

@@ -2,6 +2,7 @@ import { execa } from 'execa';
 import { createLogger } from '../../logger/index.js';
 import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.js';
 import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
+import { getEnvSettings, mergeMethodSettingsIntoEnv } from '../../core/environments.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -10,7 +11,9 @@ import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
  */
 export function createDockerProvider(config, envName, env = process.env) {
   const log = createLogger('docker');
-  const imageOps = createDockerImageDeployContext(config, env, log);
+  const settings = getEnvSettings(config.environments?.[envName]);
+  const effectiveEnv = mergeMethodSettingsIntoEnv(env, settings);
+  const imageOps = createDockerImageDeployContext(config, effectiveEnv, log);
   const { fullImage, getDockerEnv, ensureImageReadyForDeploy } = imageOps;
 
   /**
@@ -56,7 +59,12 @@ export function createDockerProvider(config, envName, env = process.env) {
       );
     }
 
-    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    // Tag stays buildId-based; env only scopes which history informed this buildId.
+    const rollbackImage = resolveDockerImageRefForTag(
+      config,
+      effectiveEnv,
+      meta.buildId
+    ).fullImage;
     log.info(
       `Rolling back Docker to buildId=${meta.buildId} (image: ${rollbackImage})...`
     );

package/src/deployment/providers/ec2.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { createSshProvider } from './ssh.js';
 import { createLogger } from '../../logger/index.js';
+import { getEnvSettings } from '../../core/config.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -9,13 +10,13 @@ import { createLogger } from '../../logger/index.js';
  */
 export function createEc2Provider(config, envName, env = process.env) {
   const log = createLogger('ec2');
-  const instanceId = env.EC2_INSTANCE_ID;
-  const region = env.AWS_REGION || 'us-east-1';
+  const settings = getEnvSettings(config.environments[envName]);
+  const instanceId = env.EC2_INSTANCE_ID || settings.ec2InstanceId;
+  const region = env.AWS_REGION || settings.awsRegion || 'us-east-1';
 
   async function resolveHost() {
-    const environment = config.environments[envName];
-    if (environment?.host || env.SSH_HOST) {
-      return environment?.host || env.SSH_HOST;
+    if (settings.host || env.SSH_HOST) {
+      return settings.host || env.SSH_HOST;
     }
 
     if (!instanceId) {
@@ -76,10 +77,7 @@ export function createEc2Provider(config, envName, env = process.env) {
         'Could not resolve host via EC2 instance lookup, and no SSH_HOST was set — provide one or the other.'
       );
     }
-    const environment = config.environments[envName];
-    if (environment) {
-      environment.host = host;
-    }
+    settings.host = host;
     return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 

package/src/deployment/providers/gcp-vm.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { createSshProvider } from './ssh.js';
 import { createLogger } from '../../logger/index.js';
+import { getEnvSettings } from '../../core/config.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -9,14 +10,14 @@ import { createLogger } from '../../logger/index.js';
  */
 export function createGcpVmProvider(config, envName, env = process.env) {
   const log = createLogger('gcp-vm');
-  const projectId = env.GCP_PROJECT_ID;
-  const zone = env.GCP_ZONE;
-  const instanceName = env.GCP_INSTANCE_NAME;
+  const settings = getEnvSettings(config.environments[envName]);
+  const projectId = env.GCP_PROJECT_ID || settings.gcpProjectId;
+  const zone = env.GCP_ZONE || settings.gcpZone;
+  const instanceName = env.GCP_INSTANCE_NAME || settings.gcpInstanceName;
 
   async function resolveHost() {
-    const environment = config.environments[envName];
-    if (environment?.host || env.SSH_HOST) {
-      return environment?.host || env.SSH_HOST;
+    if (settings.host || env.SSH_HOST) {
+      return settings.host || env.SSH_HOST;
     }
 
     if (!projectId || !zone || !instanceName) {
@@ -77,10 +78,7 @@ export function createGcpVmProvider(config, envName, env = process.env) {
         'Could not resolve host via GCP instance lookup, and no SSH_HOST was set — provide one or the other.'
       );
     }
-    const environment = config.environments[envName];
-    if (environment) {
-      environment.host = host;
-    }
+    settings.host = host;
     return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 

package/src/deployment/providers/kubernetes.js

@@ -8,6 +8,7 @@ import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.
 import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
 import { ensureKubernetesNamespace } from '../../utils/kubernetes-namespace.js';
 import { syncKubernetesDeploymentImage } from '../../utils/kubernetes-deploy-image.js';
+import { getEnvSettings, mergeMethodSettingsIntoEnv } from '../../core/environments.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -16,11 +17,15 @@ import { syncKubernetesDeploymentImage } from '../../utils/kubernetes-deploy-ima
  */
 export function createKubernetesProvider(config, envName, env = process.env) {
   const log = createLogger('kubernetes');
-  const imageOps = createDockerImageDeployContext(config, env, log);
-
-  const kubeconfig = env.KUBECONFIG || path.join(os.homedir(), '.kube', 'config');
-  const context = env.KUBE_CONTEXT || '';
-  const namespace = env.KUBE_NAMESPACE || config.project || 'default';
+  const settings = getEnvSettings(config.environments?.[envName]);
+  const effectiveEnv = mergeMethodSettingsIntoEnv(env, settings);
+  const imageOps = createDockerImageDeployContext(config, effectiveEnv, log);
+
+  const kubeconfig =
+    effectiveEnv.KUBECONFIG || path.join(os.homedir(), '.kube', 'config');
+  const context = effectiveEnv.KUBE_CONTEXT || '';
+  const namespace =
+    effectiveEnv.KUBE_NAMESPACE || config.project || 'default';
   const deploymentName = sanitizeK8sName(config.project || 'app');
 
   function getKubectlEnv() {
@@ -158,7 +163,11 @@ export function createKubernetesProvider(config, envName, env = process.env) {
       );
     }
 
-    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    const rollbackImage = resolveDockerImageRefForTag(
+      config,
+      effectiveEnv,
+      meta.buildId
+    ).fullImage;
     log.info(
       `Rolling back Kubernetes to buildId=${meta.buildId} (image: ${rollbackImage})...`
     );