@akash-chowdhury-24/deployhub 2.0.0 → 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,6 +1,11 @@
 import fs from 'fs-extra';
 import path from 'path';
 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 */
 
@@ -22,23 +27,27 @@ 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 ENV_VAR_DEFAULTS = {
@@ -46,6 +55,7 @@ const ENV_VAR_DEFAULTS = {
   FTP_PORT: '21',
   FTP_PATH: '/uploads',
   SSH_DEPLOY_PATH: '/var/www/app',
+  SSH_SSH_PORT: '22',
   SMTP_PORT: '587',
 };
 
@@ -227,19 +237,10 @@ export function generateWorkflowYaml(
     const env = environments[envName];
     if (!env) continue;
 
-    const keys = PROVIDER_ENV_MAP[env.type] || [];
+    const keys = getDeploymentSecretKeys(env.type, config);
     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 envBlock = Array.from(envVars)
@@ -412,15 +413,8 @@ export function getRequiredSecrets(
     const env = environments[envName];
     if (!env) continue;
 
-    const keys = PROVIDER_ENV_MAP[env.type] || [];
+    const keys = getDeploymentSecretKeys(env.type, config);
     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));
-      }
-    }
   }
 
   return Array.from(secrets);
@@ -481,18 +475,11 @@ export function generateEnvExampleContent(
 
   for (const envName of deployEnvironments) {
     const env = environments[envName];
-    if (!env) 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/{rollback → utils/rollback}/engine.js

@@ -1,12 +1,12 @@
-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 { 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 {import('../../core/config.js').DeployHubConfig} config
  * @param {string} artifactDir
  * @param {string} envName
  */
@@ -24,7 +24,7 @@ async function rollbackTarget(config, artifactDir, envName) {
 }
 
 /**
- * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {import('../../core/config.js').DeployHubConfig} config
  * @param {string} version
  * @param {string} [cwd]
  */