@akash-chowdhury-24/deployhub 1.0.16 → 2.0.2

package/src/deployment/providers/ec2.js

@@ -1,7 +1,93 @@
+import { execa } from 'execa';
 import { createSshProvider } from './ssh.js';
+import { createLogger } from '../../logger/index.js';
 
-export function createEc2Provider(config, envName, env) {
-  return createSshProvider(config, envName, env);
+/**
+ * @param {import('../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+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';
+
+  async function resolveHost() {
+    const environment = config.environments[envName];
+    if (environment?.host || env.SSH_HOST) {
+      return environment?.host || env.SSH_HOST;
+    }
+
+    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.'
+      );
+    }
+
+    log.info(`Looking up public IP for instance ${instanceId}...`);
+
+    /** @type {Record<string, string>} */
+    const awsEnv = { ...process.env };
+    if (env.AWS_ACCESS_KEY_ID) awsEnv.AWS_ACCESS_KEY_ID = env.AWS_ACCESS_KEY_ID;
+    if (env.AWS_SECRET_ACCESS_KEY) awsEnv.AWS_SECRET_ACCESS_KEY = env.AWS_SECRET_ACCESS_KEY;
+    awsEnv.AWS_DEFAULT_REGION = region;
+
+    try {
+      const { stdout } = await execa(
+        'aws',
+        [
+          'ec2',
+          'describe-instances',
+          '--instance-ids',
+          instanceId,
+          '--query',
+          'Reservations[0].Instances[0].PublicIpAddress',
+          '--output',
+          'text',
+          '--region',
+          region,
+        ],
+        { stdio: 'pipe', env: awsEnv }
+      );
+      const publicIp = stdout.trim();
+      if (!publicIp || publicIp === 'None') {
+        throw new Error('No public IP returned');
+      }
+      log.info(`Resolved EC2 host: ${publicIp}`);
+      return publicIp;
+    } 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.`
+      );
+    }
+  }
+
+  const sshProvider = createSshProvider(config, envName, env);
+
+  async function connect() {
+    const host = await resolveHost();
+    const environment = config.environments[envName];
+    if (environment && !environment.host) {
+      environment.host = host;
+    }
+    if (!env.SSH_HOST) {
+      env.SSH_HOST = host;
+    }
+    return sshProvider.connect();
+  }
+
+  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();
+    },
+  };
 }
 
 export default { createEc2Provider };

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

@@ -1,7 +1,94 @@
+import { execa } from 'execa';
 import { createSshProvider } from './ssh.js';
+import { createLogger } from '../../logger/index.js';
 
-export function createGcpVmProvider(config, envName, env) {
-  return createSshProvider(config, envName, env);
+/**
+ * @param {import('../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+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;
+
+  async function resolveHost() {
+    const environment = config.environments[envName];
+    if (environment?.host || env.SSH_HOST) {
+      return environment?.host || env.SSH_HOST;
+    }
+
+    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.'
+      );
+    }
+
+    log.info(`Looking up external IP for GCP instance ${instanceName}...`);
+
+    /** @type {Record<string, string>} */
+    const gcpEnv = { ...process.env };
+    if (env.GCP_KEY_FILE) {
+      gcpEnv.GOOGLE_APPLICATION_CREDENTIALS = env.GCP_KEY_FILE;
+    }
+
+    try {
+      const { stdout } = await execa(
+        'gcloud',
+        [
+          'compute',
+          'instances',
+          'describe',
+          instanceName,
+          '--zone',
+          zone,
+          '--project',
+          projectId,
+          '--format',
+          'get(networkInterfaces[0].accessConfigs[0].natIP)',
+        ],
+        { stdio: 'pipe', env: gcpEnv }
+      );
+      const publicIp = stdout.trim();
+      if (!publicIp) {
+        throw new Error('No external IP returned');
+      }
+      log.info(`Resolved GCP VM host: ${publicIp}`);
+      return publicIp;
+    } 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.`
+      );
+    }
+  }
+
+  const sshProvider = createSshProvider(config, envName, env);
+
+  async function connect() {
+    const host = await resolveHost();
+    const environment = config.environments[envName];
+    if (environment && !environment.host) {
+      environment.host = host;
+    }
+    if (!env.SSH_HOST) {
+      env.SSH_HOST = host;
+    }
+    return sshProvider.connect();
+  }
+
+  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();
+    },
+  };
 }
 
 export default { createGcpVmProvider };

package/src/deployment/providers/kubernetes.js

@@ -1,27 +1,124 @@
 import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
 import { createLogger } from '../../logger/index.js';
 
-export function createKubernetesProvider(config, envName) {
+/**
+ * @param {import('../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createKubernetesProvider(config, envName, env = process.env) {
   const log = createLogger('kubernetes');
 
+  const kubeconfig = env.KUBECONFIG || path.join(os.homedir(), '.kube', 'config');
+  const context = env.KUBE_CONTEXT || '';
+  const namespace = env.KUBE_NAMESPACE || config.project || 'default';
+
+  function getKubectlEnv() {
+    const expanded = kubeconfig.replace(/^~/, os.homedir());
+    return { ...process.env, KUBECONFIG: path.resolve(expanded) };
+  }
+
+  /**
+   * @param {string[]} baseArgs
+   */
+  function kubectlArgs(baseArgs) {
+    /** @type {string[]} */
+    const args = [...baseArgs];
+    if (context) args.push('--context', context);
+    if (namespace) args.push('--namespace', namespace);
+    return args;
+  }
+
+  /**
+   * @param {string} artifactDir
+   */
   async function deploy(artifactDir) {
-    log.info('Deploying to Kubernetes...');
-    await execa('kubectl', ['apply', '-f', '.'], {
-      cwd: artifactDir,
+    log.info(`Deploying to Kubernetes (namespace: ${namespace}${context ? `, context: ${context}` : ''})...`);
+
+    const manifestDir = artifactDir;
+    const hasManifests =
+      (await fs.pathExists(path.join(manifestDir, 'k8s'))) ||
+      (await fs.readdir(manifestDir)).some((f) => /\.ya?ml$/.test(f));
+
+    if (!hasManifests) {
+      throw new Error(
+        'No Kubernetes manifests found in artifact. Add .yaml files or a k8s/ directory to your project.'
+      );
+    }
+
+    const applyTarget = (await fs.pathExists(path.join(manifestDir, 'k8s')))
+      ? path.join(manifestDir, 'k8s')
+      : manifestDir;
+
+    await execa('kubectl', kubectlArgs(['apply', '-f', applyTarget]), {
       stdio: 'inherit',
+      env: getKubectlEnv(),
     });
+
+    const imageName = env.DOCKER_IMAGE_NAME;
+    const imageTag = env.DOCKER_IMAGE_TAG || config.version || 'latest';
+    if (imageName && config.project) {
+      await execa(
+        'kubectl',
+        kubectlArgs([
+          'set',
+          'image',
+          `deployment/${config.project}`,
+          `${config.project}=${imageName}:${imageTag}`,
+        ]),
+        { stdio: 'pipe', env: getKubectlEnv() }
+      ).catch(() => {
+        log.warn('kubectl set image skipped (deployment name may differ from project name)');
+      });
+    }
+
+    log.success('Kubernetes deployment complete');
   }
 
   async function rollback(artifactDir) {
-    await deploy(artifactDir);
+    log.info('Rolling back Kubernetes deployment...');
+    await execa('kubectl', kubectlArgs(['rollout', 'undo', `deployment/${config.project}`]), {
+      stdio: 'inherit',
+      env: getKubectlEnv(),
+    }).catch(async () => {
+      log.warn('kubectl rollout undo failed — redeploying previous artifact instead');
+      await deploy(artifactDir);
+    });
   }
 
   async function healthCheck() {
-    return true;
+    const url = config.healthCheck?.url;
+    if (url) {
+      try {
+        const { stdout } = await execa('curl', ['-sf', '-o', '/dev/null', '-w', '%{http_code}', url], {
+          stdio: 'pipe',
+        });
+        return stdout.trim().startsWith('2');
+      } catch {
+        return false;
+      }
+    }
+
+    try {
+      await execa(
+        'kubectl',
+        kubectlArgs(['rollout', 'status', `deployment/${config.project}`, '--timeout=30s']),
+        { stdio: 'pipe', env: getKubectlEnv() }
+      );
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   async function testConnection() {
-    await execa('kubectl', ['cluster-info'], { stdio: 'pipe' });
+    await execa('kubectl', kubectlArgs(['cluster-info']), {
+      stdio: 'pipe',
+      env: getKubectlEnv(),
+    });
   }
 
   return { deploy, rollback, healthCheck, testConnection };

package/src/deployment/providers/ssh.js

@@ -39,27 +39,44 @@ export function createSshProvider(config, envName, env = process.env) {
   const port = environment.port || config.port || Number(env.SSH_PORT) || 3000;
   const sshKey = env.SSH_KEY;
   const keyPath = environment.keyPath || env.SSH_KEY_PATH;
+  const sshPort = Number(env.SSH_SSH_PORT) || environment.sshPort || 22;
 
   const log = createLogger('ssh');
 
   async function connect() {
     if (!host || !user) {
-      throw new Error('SSH host and user are required. Set SSH_HOST and SSH_USER in .env');
+      throw new Error(
+        'SSH host and user are required. Set SSH_HOST and SSH_USER in .env (see .env.example comments).'
+      );
+    }
+
+    if (!sshKey && !keyPath) {
+      throw new Error(
+        'SSH authentication required. Set SSH_KEY_PATH (local) or SSH_KEY (CI secret) in .env — see .env.example.'
+      );
     }
 
     const ssh = new NodeSSH();
     /** @type {import('node-ssh').SSHConnectOptions} */
-    const connectOpts = { host, username: user };
+    const connectOpts = { host, username: user, port: sshPort };
 
     if (sshKey) {
       const tmpKeyPath = path.join(os.tmpdir(), 'deployhub-ssh-key');
       await fs.writeFile(tmpKeyPath, sshKey, { mode: 0o600 });
       connectOpts.privateKeyPath = tmpKeyPath;
     } else if (keyPath) {
-      connectOpts.privateKeyPath = keyPath;
+      const expanded = keyPath.replace(/^~/, os.homedir());
+      connectOpts.privateKeyPath = path.resolve(expanded);
     }
 
-    await ssh.connect(connectOpts);
+    try {
+      await ssh.connect(connectOpts);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `SSH connection failed to ${user}@${host}:${sshPort} — ${msg}. Check SSH_HOST, SSH_USER, SSH_KEY_PATH, and that port ${sshPort} is open in your firewall/security group.`
+      );
+    }
     return ssh;
   }
 

package/src/utils/github-actions.js

@@ -1,12 +1,11 @@
 import fs from 'fs-extra';
 import path from 'path';
-import {
-  PLATFORM_ENV_MAP,
-  PLATFORM_CLI_MAP,
-  PLATFORM_CHOICES,
-  getPlatformEnvExample,
-} from './platform-env.js';
 import { getWorkflowHeaderComment } from './author.js';
+import {
+  generateDeploymentEnvSection,
+  getDeploymentSecretKeys,
+  DEPLOYMENT_ENV_KEYS,
+} from '../deployment/deployment-env.js';
 
 /** @typedef {'aws'|'azure'|'gcp'|'gdrive'|'dropbox'|'local'|'ftp'|'ssh'} ProviderEnvKey */
 
@@ -28,34 +27,35 @@ const PROVIDER_ENV_MAP = {
   dropbox: ['DROPBOX_ACCESS_TOKEN'],
   local: [],
   ftp: ['FTP_HOST', 'FTP_USER', 'FTP_PASSWORD'],
-  ssh: ['SSH_HOST', 'SSH_USER', 'SSH_KEY'],
+  ssh: DEPLOYMENT_ENV_KEYS.ssh,
+  docker: DEPLOYMENT_ENV_KEYS.docker,
+  ec2: DEPLOYMENT_ENV_KEYS.ec2,
+  'azure-vm': DEPLOYMENT_ENV_KEYS['azure-vm'],
+  'gcp-vm': DEPLOYMENT_ENV_KEYS['gcp-vm'],
+  kubernetes: DEPLOYMENT_ENV_KEYS.kubernetes,
 };
 
-const BACKEND_SSH_ENV_VARS = [
-  'SSH_DEPLOY_PATH',
-  'SSH_APP_NAME',
-  'SSH_PORT',
-];
-
 const PROVIDER_LABELS = {
   aws: 'AWS S3',
   azure: 'Azure Blob',
-  gcp: 'GCP',
+  gcp: 'GCP Storage',
   gdrive: 'Google Drive',
   dropbox: 'Dropbox',
   ftp: 'FTP',
   ssh: 'SSH Deployment',
+  docker: 'Docker Deployment',
+  ec2: 'AWS EC2 Deployment',
+  'azure-vm': 'Azure VM Deployment',
+  'gcp-vm': 'GCP VM Deployment',
+  kubernetes: 'Kubernetes Deployment',
 };
 
-const PLATFORM_LABELS = Object.fromEntries(
-  PLATFORM_CHOICES.map(({ name, value }) => [value, name])
-);
-
 const ENV_VAR_DEFAULTS = {
   AWS_REGION: 'us-east-1',
   FTP_PORT: '21',
   FTP_PATH: '/uploads',
   SSH_DEPLOY_PATH: '/var/www/app',
+  SSH_SSH_PORT: '22',
   SMTP_PORT: '587',
 };
 
@@ -208,54 +208,6 @@ function getBackendSetupSteps(config) {
   return steps;
 }
 
-/**
- * @param {Record<string, unknown>[]} environments
- * @returns {string[]}
- */
-function getPlatformInstallSteps(environments) {
-  /** @type {Set<string>} */
-  const steps = new Set();
-
-  for (const env of environments) {
-    if (env.deploymentType !== 'platform' && env.frontendDeploymentType !== 'platform') {
-      continue;
-    }
-    const platform = env.platform;
-    if (!platform) continue;
-    const cli = PLATFORM_CLI_MAP[platform];
-    if (cli?.globalInstall) {
-      steps.add(`      - name: Install ${platform} CLI\n        run: ${cli.globalInstall}`);
-    }
-  }
-
-  return Array.from(steps);
-}
-
-/**
- * @param {string[]} deployEnvironments
- * @param {Record<string, Record<string, unknown>>} environments
- */
-function collectPlatformEnvVars(deployEnvironments, environments) {
-  /** @type {Set<string>} */
-  const envVars = new Set();
-
-  for (const envName of deployEnvironments) {
-    const env = environments[envName];
-    if (!env) continue;
-
-    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
-      const platform = env.platform;
-      if (!platform) continue;
-      const keys = PLATFORM_ENV_MAP[platform] || [];
-      for (const key of keys) {
-        envVars.add(`${key}: \${{ secrets.${key} }}`);
-      }
-    }
-  }
-
-  return envVars;
-}
-
 /**
  * @param {string[]} storageProviders
  * @param {string[]} deployEnvironments
@@ -285,27 +237,12 @@ export function generateWorkflowYaml(
     const env = environments[envName];
     if (!env) continue;
 
-    if (env.deploymentType !== 'platform') {
-      const keys = PROVIDER_ENV_MAP[env.type] || [];
-      for (const key of keys) {
-        envVars.add(`${key}: \${{ secrets.${key} }}`);
-      }
-    }
-
-    if (env.type === 'ssh' && config) {
-      const projectType = config.projectType || 'frontend';
-      if (projectType === 'backend' || projectType === 'both') {
-        for (const key of BACKEND_SSH_ENV_VARS) {
-          envVars.add(`${key}: \${{ secrets.${key} }}`);
-        }
-      }
+    const keys = getDeploymentSecretKeys(env.type, config);
+    for (const key of keys) {
+      envVars.add(`${key}: \${{ secrets.${key} }}`);
     }
   }
 
-  for (const line of collectPlatformEnvVars(deployEnvironments, environments)) {
-    envVars.add(line);
-  }
-
   const envBlock = Array.from(envVars)
     .map((line) => `          ${line}`)
     .join('\n');
@@ -317,11 +254,6 @@ export function generateWorkflowYaml(
     ? `${getGithubGitConfigStep()}\n`
     : '';
 
-  const envList = deployEnvironments
-    .map((name) => environments[name])
-    .filter(Boolean);
-  const platformSteps = getPlatformInstallSteps(envList).join('\n');
-
   const projectType = config?.projectType || 'frontend';
   const installDepsCommand =
     projectType === 'backend' || projectType === 'both'
@@ -342,7 +274,7 @@ ${uniqueBackendSteps ? `${uniqueBackendSteps}\n` : ''}      - uses: actions/setu
           node-version: '20'
 ${githubGitConfigStep}      - name: Install project dependencies
         run: ${installDepsCommand}
-${platformSteps ? `${platformSteps}\n` : ''}      - name: Install DeployHub CLI
+      - name: Install DeployHub CLI
         run: npm install ${installSpec} --no-save
       - run: ${getCliBuildCommand()}
         env:
@@ -481,23 +413,8 @@ export function getRequiredSecrets(
     const env = environments[envName];
     if (!env) continue;
 
-    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
-      const platform = env.platform;
-      if (platform) {
-        const keys = PLATFORM_ENV_MAP[platform] || [];
-        keys.forEach((k) => secrets.add(k));
-      }
-    } else {
-      const keys = PROVIDER_ENV_MAP[env.type] || [];
-      keys.forEach((k) => secrets.add(k));
-    }
-
-    if (env.type === 'ssh' && config) {
-      const projectType = config.projectType || 'frontend';
-      if (projectType === 'backend' || projectType === 'both') {
-        BACKEND_SSH_ENV_VARS.forEach((k) => secrets.add(k));
-      }
-    }
+    const keys = getDeploymentSecretKeys(env.type, config);
+    keys.forEach((k) => secrets.add(k));
   }
 
   return Array.from(secrets);
@@ -558,31 +475,11 @@ export function generateEnvExampleContent(
 
   for (const envName of deployEnvironments) {
     const env = environments[envName];
-    if (!env) continue;
-
-    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
-      const platform = env.platform;
-      if (platform) {
-        const examples = getPlatformEnvExample(platform);
-        addSection(
-          PLATFORM_LABELS[platform] || platform,
-          Object.keys(examples),
-          examples
-        );
-      }
-      continue;
-    }
-
-    const keys = PROVIDER_ENV_MAP[env.type] || [];
-    if (keys.length > 0) {
-      addSection(PROVIDER_LABELS[env.type] || env.type, keys);
-    }
+    if (!env?.type) continue;
 
-    if (env.type === 'ssh' && config) {
-      const projectType = config.projectType || 'frontend';
-      if (projectType === 'backend' || projectType === 'both') {
-        addSection('SSH Deployment (backend)', BACKEND_SSH_ENV_VARS);
-      }
+    const deploySection = generateDeploymentEnvSection(env.type, config, environments);
+    if (deploySection) {
+      sections.push(`${deploySection}\n`);
     }
   }
 

package/src/utils/rollback/engine.js

@@ -0,0 +1,69 @@
+import { downloadFromFirst } from '../../storage/index.js';
+import { getDeploymentProvider } from '../../deployment/index.js';
+import { extractArtifact } from '../../artifact/engine.js';
+import { createLogger } from '../../logger/index.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {import('../../core/config.js').DeployHubConfig} config
+ * @param {string} artifactDir
+ * @param {string} envName
+ */
+async function rollbackTarget(config, artifactDir, envName) {
+  const envConfig = config.environments[envName];
+  if (!envConfig) {
+    throw new Error(`Environment "${envName}" not found in config`);
+  }
+
+  const log = createLogger('rollback');
+  log.info(`Rolling back ${envName} (${envConfig.type || 'server'})...`);
+
+  const provider = getDeploymentProvider(envConfig.type, config, envName);
+  await provider.rollback(artifactDir);
+}
+
+/**
+ * @param {import('../../core/config.js').DeployHubConfig} config
+ * @param {string} version
+ * @param {string} [cwd]
+ */
+export async function rollbackToVersion(config, version, cwd = process.cwd()) {
+  const log = createLogger('rollback');
+  const remoteKey = `${config.project}/v${version}/artifact.zip`;
+  const restoreDir = path.join(cwd, '.deployhub-restore', `v${version}`);
+  const artifactDir = path.join(restoreDir, 'artifact');
+
+  log.info(`Downloading artifact v${version}...`);
+  await fs.emptyDir(restoreDir);
+  await fs.ensureDir(artifactDir);
+
+  const zipPath = path.join(artifactDir, 'artifact.zip');
+  await downloadFromFirst(config.storage, remoteKey, zipPath);
+
+  log.info('Extracting artifact for rollback...');
+  const extractedDir = path.join(artifactDir, '_extracted');
+  await fs.emptyDir(extractedDir);
+  await extractArtifact(artifactDir, extractedDir);
+
+  const extractedDeployment = path.join(extractedDir, 'deployment.json');
+  if (await fs.pathExists(extractedDeployment)) {
+    await fs.copy(extractedDeployment, path.join(artifactDir, 'deployment.json'));
+  }
+
+  const targets = config.deploy || [];
+  if (targets.length === 0) {
+    log.warn('No deployment targets configured');
+    return artifactDir;
+  }
+
+  log.info('Redeploying previous artifact to server targets...');
+  for (const envName of targets) {
+    await rollbackTarget(config, artifactDir, envName);
+  }
+
+  log.success(`Rollback to v${version} complete`);
+  return artifactDir;
+}
+
+export default { rollbackToVersion };