@akash-chowdhury-24/deployhub 2.0.13 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akash-chowdhury-24/deployhub",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "description": "Zero-configuration deployment and artifact manager",
   "type": "module",
   "main": "./src/cli/index.js",

package/src/cli/index.js

@@ -13,6 +13,7 @@ import { registerDoctorCommand } from '../commands/doctor.js';
 import { registerVerifyCommand } from '../commands/verify.js';
 import { registerCleanCommand } from '../commands/clean.js';
 import { registerUpdateCommand } from '../commands/update.js';
+import { registerSyncWorkflowsCommand } from '../commands/sync-workflows.js';
 import { formatVersionOutput, printBanner, shouldShowBanner } from '../utils/author.js';
 
 loadEnv();
@@ -41,5 +42,6 @@ registerDoctorCommand(program);
 registerVerifyCommand(program);
 registerCleanCommand(program);
 registerUpdateCommand(program);
+registerSyncWorkflowsCommand(program);
 
 program.parse();

package/src/commands/artifact.js

@@ -55,10 +55,21 @@ export function registerArtifactCommand(program) {
       if (opts.remote) {
         console.log(chalk.bold('\nRemote history (storage):\n'));
         try {
-          const history = await loadArtifactHistory(config.storage || [], config.project);
+          const { entries: history, source } = await loadArtifactHistory(
+            config.storage || [],
+            config.project
+          );
           if (history.length === 0) {
-            console.log(chalk.yellow('  (no history.json found)'));
+            console.log(
+              chalk.yellow(
+                '  No artifact history found for this project — you may not have deployed any builds yet.'
+              )
+            );
           } else {
+            if (source) {
+              console.log(chalk.gray(`  Source: ${source}`));
+              console.log('');
+            }
             for (const e of history) {
               console.log(
                 `  ${chalk.cyan(e.buildId)}  semver=${e.semver}  ${e.uploadedAt || ''}`
@@ -67,11 +78,8 @@ export function registerArtifactCommand(program) {
             }
           }
         } catch (err) {
-          console.log(
-            chalk.yellow(
-              `  Could not load remote history: ${err instanceof Error ? err.message : String(err)}`
-            )
-          );
+          const detail = err instanceof Error ? err.message : String(err);
+          console.log(chalk.red(`  ${detail}`));
         }
       }
 
@@ -101,8 +109,8 @@ export function registerArtifactCommand(program) {
 
       const history = await loadArtifactHistory(config.storage || [], config.project);
       const histMatch =
-        history.find((e) => e.buildId === needle || e.buildId === versionOrBuildId) ||
-        history.find((e) => e.semver === needle);
+        history.entries.find((e) => e.buildId === needle || e.buildId === versionOrBuildId) ||
+        history.entries.find((e) => e.semver === needle);
 
       const restoreDir = path.join(cwd, '.deployhub-restore', `v${needle}`);
       await fs.ensureDir(restoreDir);

package/src/commands/doctor.js

@@ -7,7 +7,7 @@ import axios from 'axios';
 import { loadConfig, loadEnv } from '../core/config.js';
 import { testProvider } from '../storage/index.js';
 import { getDeploymentProvider } from '../deployment/index.js';
-import { PROVIDER_ENV_MAP } from '../utils/github-actions.js';
+import { PROVIDER_ENV_MAP, getRollbackWorkflowDoctorCheck } from '../utils/github-actions.js';
 import { printDoctorFooter } from '../utils/author.js';
 import { createLocalProvider } from '../storage/providers/local.js';
 import {
@@ -888,11 +888,28 @@ export function registerDoctorCommand(program) {
           return {
             name: 'GitHub Actions',
             pass: false,
-            message: 'Workflow file missing — run deployhub init',
+            message: 'Workflow file missing — run deployhub init or deployhub sync-workflows',
           };
         })
       );
 
+      const hasStorage = (config.storage || []).length > 0;
+      const hasDeploy = (config.deploy || []).length > 0;
+      if (hasStorage && hasDeploy) {
+        results.push(
+          await runCheck('Rollback workflow', async () => {
+            const check = await getRollbackWorkflowDoctorCheck(cwd, config);
+            return (
+              check || {
+                name: 'Rollback workflow',
+                pass: true,
+                message: 'Skipped',
+              }
+            );
+          })
+        );
+      }
+
       results.push(
         await runCheck('Storage write', async () => {
           const provider = createLocalProvider();

package/src/commands/init.js

@@ -535,6 +535,7 @@ export function registerInitCommand(program) {
       console.log(chalk.bold('Generated files:'));
       console.log('  • deployhub.config.json');
       console.log('  • .github/workflows/deployhub.yml');
+      console.log('  • .github/workflows/deployhub-rollback.yml');
       console.log('  • .env.example');
       console.log('');
       printAuthorFooter();

package/src/commands/sync-workflows.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import {
+  writeWorkflowFile,
+  DEPLOY_WORKFLOW_FILENAME,
+  ROLLBACK_WORKFLOW_FILENAME,
+} from '../utils/github-actions.js';
+
+/**
+ * Regenerate GitHub Actions workflows from deployhub.config.json (no interactive init).
+ * @param {import('commander').Command} program
+ */
+export function registerSyncWorkflowsCommand(program) {
+  program
+    .command('sync-workflows')
+    .description(
+      'Regenerate .github/workflows/deployhub.yml and deployhub-rollback.yml from deployhub.config.json'
+    )
+    .action(async () => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+
+      const storage = config.storage || [];
+      const deploy = config.deploy || [];
+      const environments = config.environments || {};
+      const cliSource = config.cli?.source;
+
+      await writeWorkflowFile(storage, deploy, environments, cwd, cliSource, config);
+
+      console.log(chalk.green('✓ Regenerated GitHub Actions workflows:'));
+      console.log(`  • .github/workflows/${DEPLOY_WORKFLOW_FILENAME}`);
+      console.log(`  • .github/workflows/${ROLLBACK_WORKFLOW_FILENAME}`);
+      console.log('');
+      console.log(
+        chalk.gray(
+          'Commit and push these files, then use Actions → DeployHub Rollback (workflow_dispatch) to roll back.'
+        )
+      );
+    });
+}
+
+export default { registerSyncWorkflowsCommand };

package/src/deployment/index.js

@@ -71,13 +71,14 @@ export async function deployToAll(config, artifactDir, envNames) {
  * @param {import('../core/config.js').DeployHubConfig} config
  * @param {string} artifactDir
  * @param {string[]} [envNames]
+ * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
  */
-export async function rollbackAll(config, artifactDir, envNames) {
+export async function rollbackAll(config, artifactDir, envNames, meta) {
   const targets = envNames || config.deploy || [];
   for (const envName of targets) {
     const envConfig = config.environments[envName];
     const provider = getDeploymentProvider(envConfig.type, config, envName);
-    await provider.rollback(artifactDir);
+    await provider.rollback(artifactDir, meta);
   }
 }
 

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

@@ -21,7 +21,8 @@ export function createAzureVmProvider(config, envName, env = process.env) {
 
     if (!subscriptionId || !resourceGroup || !vmName) {
       throw new Error(
-        'Azure VM host unknown. Set SSH_HOST to your VM public IP, or set AZURE_SUBSCRIPTION_ID, AZURE_RESOURCE_GROUP, and AZURE_VM_NAME for auto lookup.'
+        'Could not resolve host via Azure VM lookup, and no SSH_HOST was set — ' +
+          'provide SSH_HOST (VM public IP/DNS) or set AZURE_SUBSCRIPTION_ID, AZURE_RESOURCE_GROUP, and AZURE_VM_NAME for auto lookup.'
       );
     }
 
@@ -55,34 +56,54 @@ export function createAzureVmProvider(config, envName, env = process.env) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Could not resolve public IP for VM ${vmName} — ${msg}. Set SSH_HOST manually or run az login and verify resource group/VM name.`
+        `Could not resolve host via Azure VM lookup (${vmName}): ${msg}. ` +
+          'Set SSH_HOST to the VM public IP/DNS, or run az login and verify resource group/VM name.'
       );
     }
   }
 
-  const sshProvider = createSshProvider(config, envName, env);
-
-  async function connect() {
+  /**
+   * Resolve host (skipping cloud lookup when SSH_HOST/environment.host is set),
+   * then create an SSH provider that closes over the resolved host.
+   */
+  async function getSshProvider() {
     const host = await resolveHost();
+    if (!host) {
+      throw new Error(
+        '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) {
+    if (environment) {
       environment.host = host;
     }
-    if (!env.SSH_HOST) {
-      env.SSH_HOST = host;
-    }
-    return sshProvider.connect();
+    return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 
   return {
-    ...sshProvider,
-    connect,
-    deploy: sshProvider.deploy.bind(sshProvider),
-    rollback: sshProvider.rollback.bind(sshProvider),
-    healthCheck: sshProvider.healthCheck.bind(sshProvider),
-    testConnection: async () => {
-      const ssh = await connect();
-      ssh.dispose();
+    async connect() {
+      const ssh = await getSshProvider();
+      return ssh.connect();
+    },
+    async deploy(artifactDir, options) {
+      const ssh = await getSshProvider();
+      return ssh.deploy(artifactDir, options);
+    },
+    async rollback(artifactDir, meta) {
+      const ssh = await getSshProvider();
+      return ssh.rollback(artifactDir, meta);
+    },
+    async healthCheck() {
+      const ssh = await getSshProvider();
+      return ssh.healthCheck();
+    },
+    async testConnection() {
+      const ssh = await getSshProvider();
+      return ssh.testConnection();
+    },
+    async runRemoteCheck(command) {
+      const ssh = await getSshProvider();
+      return ssh.runRemoteCheck(command);
     },
   };
 }

package/src/deployment/providers/docker.js

@@ -1,6 +1,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';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -14,12 +15,17 @@ export function createDockerProvider(config, envName, env = process.env) {
 
   /**
    * @param {string} artifactDir
+   * @param {{ fullImage?: string, skipImageReuse?: boolean }} [options]
    */
-  async function deploy(artifactDir) {
-    log.info(`Deploying via Docker (image: ${fullImage})...`);
+  async function deploy(artifactDir, options = {}) {
+    const imageRef = options.fullImage || fullImage;
+    log.info(`Deploying via Docker (image: ${imageRef})...`);
     const dockerEnv = getDockerEnv();
 
-    const result = await ensureImageReadyForDeploy(artifactDir);
+    const result = await ensureImageReadyForDeploy(artifactDir, {
+      fullImage: options.fullImage,
+      skipImageReuse: options.skipImageReuse,
+    });
     if (result.ranCompose) {
       log.success('Docker deployment complete');
       return;
@@ -31,7 +37,7 @@ export function createDockerProvider(config, envName, env = process.env) {
       { stdio: 'pipe', env: dockerEnv }
     ).catch(() => {});
 
-    await execa('docker', ['run', '-d', '--rm', '--name', config.project, fullImage], {
+    await execa('docker', ['run', '-d', '--rm', '--name', config.project, imageRef], {
       stdio: 'inherit',
       env: dockerEnv,
     });
@@ -39,9 +45,25 @@ export function createDockerProvider(config, envName, env = process.env) {
     log.success('Docker deployment complete');
   }
 
-  async function rollback(artifactDir) {
-    log.info('Rolling back Docker deployment (redeploy previous artifact)...');
-    await deploy(artifactDir);
+  /**
+   * @param {string} artifactDir
+   * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
+   */
+  async function rollback(artifactDir, meta = {}) {
+    if (!meta.buildId) {
+      throw new Error(
+        'Docker rollback requires buildId from the restored artifact history entry'
+      );
+    }
+
+    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    log.info(
+      `Rolling back Docker to buildId=${meta.buildId} (image: ${rollbackImage})...`
+    );
+    await deploy(artifactDir, {
+      fullImage: rollbackImage,
+      skipImageReuse: true,
+    });
   }
 
   async function healthCheck() {

package/src/deployment/providers/ec2.js

@@ -20,7 +20,8 @@ export function createEc2Provider(config, envName, env = process.env) {
 
     if (!instanceId) {
       throw new Error(
-        'EC2 host unknown. Set SSH_HOST to your instance public IP, or set EC2_INSTANCE_ID with AWS credentials for auto lookup.'
+        'Could not resolve host via EC2 instance lookup, and no SSH_HOST was set — ' +
+          'provide SSH_HOST (instance public IP/DNS) or set EC2_INSTANCE_ID with AWS credentials for auto lookup.'
       );
     }
 
@@ -58,34 +59,54 @@ export function createEc2Provider(config, envName, env = process.env) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Could not resolve public IP for ${instanceId} — ${msg}. Set SSH_HOST manually or install/configure AWS CLI with ec2:DescribeInstances access.`
+        `Could not resolve host via EC2 instance lookup (${instanceId}): ${msg}. ` +
+          'Set SSH_HOST to the instance public IP/DNS, or fix AWS CLI credentials / ec2:DescribeInstances access.'
       );
     }
   }
 
-  const sshProvider = createSshProvider(config, envName, env);
-
-  async function connect() {
+  /**
+   * Resolve host (skipping cloud lookup when SSH_HOST/environment.host is set),
+   * then create an SSH provider that closes over the resolved host.
+   */
+  async function getSshProvider() {
     const host = await resolveHost();
+    if (!host) {
+      throw new Error(
+        '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) {
+    if (environment) {
       environment.host = host;
     }
-    if (!env.SSH_HOST) {
-      env.SSH_HOST = host;
-    }
-    return sshProvider.connect();
+    return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 
   return {
-    ...sshProvider,
-    connect,
-    deploy: sshProvider.deploy.bind(sshProvider),
-    rollback: sshProvider.rollback.bind(sshProvider),
-    healthCheck: sshProvider.healthCheck.bind(sshProvider),
-    testConnection: async () => {
-      const ssh = await connect();
-      ssh.dispose();
+    async connect() {
+      const ssh = await getSshProvider();
+      return ssh.connect();
+    },
+    async deploy(artifactDir, options) {
+      const ssh = await getSshProvider();
+      return ssh.deploy(artifactDir, options);
+    },
+    async rollback(artifactDir, meta) {
+      const ssh = await getSshProvider();
+      return ssh.rollback(artifactDir, meta);
+    },
+    async healthCheck() {
+      const ssh = await getSshProvider();
+      return ssh.healthCheck();
+    },
+    async testConnection() {
+      const ssh = await getSshProvider();
+      return ssh.testConnection();
+    },
+    async runRemoteCheck(command) {
+      const ssh = await getSshProvider();
+      return ssh.runRemoteCheck(command);
     },
   };
 }

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

@@ -21,7 +21,8 @@ export function createGcpVmProvider(config, envName, env = process.env) {
 
     if (!projectId || !zone || !instanceName) {
       throw new Error(
-        'GCP VM host unknown. Set SSH_HOST to your instance external IP, or set GCP_PROJECT_ID, GCP_ZONE, and GCP_INSTANCE_NAME for auto lookup.'
+        'Could not resolve host via GCP instance lookup, and no SSH_HOST was set — ' +
+          'provide SSH_HOST (instance external IP/DNS) or set GCP_PROJECT_ID, GCP_ZONE, and GCP_INSTANCE_NAME for auto lookup.'
       );
     }
 
@@ -59,34 +60,54 @@ export function createGcpVmProvider(config, envName, env = process.env) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `Could not resolve external IP for ${instanceName} — ${msg}. Set SSH_HOST manually or run gcloud auth login and verify project/zone/instance name.`
+        `Could not resolve host via GCP instance lookup (${instanceName}): ${msg}. ` +
+          'Set SSH_HOST to the instance external IP/DNS, or run gcloud auth login and verify project/zone/instance name.'
       );
     }
   }
 
-  const sshProvider = createSshProvider(config, envName, env);
-
-  async function connect() {
+  /**
+   * Resolve host (skipping cloud lookup when SSH_HOST/environment.host is set),
+   * then create an SSH provider that closes over the resolved host.
+   */
+  async function getSshProvider() {
     const host = await resolveHost();
+    if (!host) {
+      throw new Error(
+        '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) {
+    if (environment) {
       environment.host = host;
     }
-    if (!env.SSH_HOST) {
-      env.SSH_HOST = host;
-    }
-    return sshProvider.connect();
+    return createSshProvider(config, envName, { ...env, SSH_HOST: host });
   }
 
   return {
-    ...sshProvider,
-    connect,
-    deploy: sshProvider.deploy.bind(sshProvider),
-    rollback: sshProvider.rollback.bind(sshProvider),
-    healthCheck: sshProvider.healthCheck.bind(sshProvider),
-    testConnection: async () => {
-      const ssh = await connect();
-      ssh.dispose();
+    async connect() {
+      const ssh = await getSshProvider();
+      return ssh.connect();
+    },
+    async deploy(artifactDir, options) {
+      const ssh = await getSshProvider();
+      return ssh.deploy(artifactDir, options);
+    },
+    async rollback(artifactDir, meta) {
+      const ssh = await getSshProvider();
+      return ssh.rollback(artifactDir, meta);
+    },
+    async healthCheck() {
+      const ssh = await getSshProvider();
+      return ssh.healthCheck();
+    },
+    async testConnection() {
+      const ssh = await getSshProvider();
+      return ssh.testConnection();
+    },
+    async runRemoteCheck(command) {
+      const ssh = await getSshProvider();
+      return ssh.runRemoteCheck(command);
     },
   };
 }

package/src/deployment/providers/kubernetes.js

@@ -5,6 +5,7 @@ import os from 'os';
 import { createLogger } from '../../logger/index.js';
 import { sanitizeK8sName } from '../../utils/kubernetes-manifests.js';
 import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.js';
+import { resolveDockerImageRefForTag } from '../../utils/docker-image.js';
 import { ensureKubernetesNamespace } from '../../utils/kubernetes-namespace.js';
 import { syncKubernetesDeploymentImage } from '../../utils/kubernetes-deploy-image.js';
 
@@ -50,10 +51,24 @@ export function createKubernetesProvider(config, envName, env = process.env) {
 
   /**
    * @param {string} artifactDir
+   * @param {{ fullImage?: string, skipImageReuse?: boolean }} [options]
    */
-  async function deploy(artifactDir) {
+  async function deploy(artifactDir, options = {}) {
+    const imageRef = options.fullImage || imageOps.fullImage;
+    const isRollbackRedeploy = Boolean(options.skipImageReuse);
+
     log.info(`Deploying to Kubernetes (namespace: ${namespace}${context ? `, context: ${context}` : ''})...`);
 
+    // Rollback always rebuilds and must push — without registry creds the cluster
+    // cannot pull the new tag and would sit in ImagePullBackOff after a false success.
+    if (isRollbackRedeploy && !imageOps.hasRegistryCredentials()) {
+      throw new Error(
+        'Kubernetes rollback requires DOCKER_REGISTRY_USERNAME and DOCKER_REGISTRY_TOKEN ' +
+          `so the rebuilt image (${imageRef}) can be pushed for the cluster to pull. ` +
+          'Set those credentials and retry.'
+      );
+    }
+
     const manifestDir = artifactDir;
     const hasManifests =
       (await fs.pathExists(path.join(manifestDir, 'k8s'))) ||
@@ -65,8 +80,11 @@ export function createKubernetesProvider(config, envName, env = process.env) {
       );
     }
 
-    log.info(`Ensuring container image ${imageOps.fullImage} is built and pushed before apply...`);
-    const imageResult = await imageOps.ensureImageReadyForDeploy(artifactDir);
+    log.info(`Ensuring container image ${imageRef} is built and pushed before apply...`);
+    const imageResult = await imageOps.ensureImageReadyForDeploy(artifactDir, {
+      fullImage: options.fullImage,
+      skipImageReuse: options.skipImageReuse,
+    });
     if (imageResult.ranCompose) {
       log.warn(
         'docker compose was used — ensure the cluster can pull the resulting image from your registry.'
@@ -93,23 +111,60 @@ export function createKubernetesProvider(config, envName, env = process.env) {
     // If the live ref already equals fullImage, rollout restart so a new digest is pulled.
     await syncKubernetesDeploymentImage({
       deploymentName,
-      fullImage: imageOps.fullImage,
+      fullImage: imageRef,
       kubectlArgs,
       getKubectlEnv,
       log,
     });
 
+    // Rollback-only safety net: wait until pods are actually healthy (catches ImagePullBackOff).
+    if (isRollbackRedeploy) {
+      const timeout = '120s';
+      log.info(
+        `Waiting for deployment/${deploymentName} rollout to complete (timeout ${timeout})...`
+      );
+      try {
+        await execa(
+          'kubectl',
+          kubectlArgs([
+            'rollout',
+            'status',
+            `deployment/${deploymentName}`,
+            `--timeout=${timeout}`,
+          ]),
+          { stdio: 'inherit', env: getKubectlEnv() }
+        );
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Kubernetes rollback failed: deployment/${deploymentName} did not become healthy within ${timeout}. ` +
+            `The cluster may be unable to pull ${imageRef} (ImagePullBackOff) or pods are failing. ${detail}`
+        );
+      }
+    }
+
     log.success('Kubernetes deployment complete');
   }
 
-  async function rollback(artifactDir) {
-    log.info('Rolling back Kubernetes deployment...');
-    await execa('kubectl', kubectlArgs(['rollout', 'undo', `deployment/${deploymentName}`]), {
-      stdio: 'inherit',
-      env: getKubectlEnv(),
-    }).catch(async () => {
-      log.warn('kubectl rollout undo failed — redeploying previous artifact instead');
-      await deploy(artifactDir);
+  /**
+   * Artifact-based rollback: restore buildId X's code and image (not cluster undo history).
+   * @param {string} artifactDir
+   * @param {{ buildId?: string, semver?: string, remoteKey?: string }} [meta]
+   */
+  async function rollback(artifactDir, meta = {}) {
+    if (!meta.buildId) {
+      throw new Error(
+        'Kubernetes rollback requires buildId from the restored artifact history entry'
+      );
+    }
+
+    const rollbackImage = resolveDockerImageRefForTag(config, env, meta.buildId).fullImage;
+    log.info(
+      `Rolling back Kubernetes to buildId=${meta.buildId} (image: ${rollbackImage})...`
+    );
+    await deploy(artifactDir, {
+      fullImage: rollbackImage,
+      skipImageReuse: true,
     });
   }
 

package/src/deployment/providers/ssh.js

@@ -405,7 +405,7 @@ export function createSshProvider(config, envName, env = process.env) {
     return result.code === 0 && result.stdout.trim() === 'yes';
   }
 
-  async function rollback(artifactDir) {
+  async function rollback(artifactDir, _meta) {
     await deploy(artifactDir);
   }