@akash-chowdhury-24/deployhub 1.0.16 → 2.0.2

package/src/commands/init.js

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { saveConfig } from '../core/config.js';
+import { saveConfig, appendEnv } from '../core/config.js';
 import { detectFrontend, detectBackend } from '../detectors/index.js';
 import {
   getFrontendInfo,
@@ -18,16 +18,15 @@ import {
   addDeployhubToPackageJson,
   DEFAULT_NPM_CLI_SOURCE,
 } from '../utils/github-actions.js';
-import {
-  promptPlatformQuestions,
-  appendPlatformEnvExample,
-  showPlatformComparison,
-  suggestHealthUrl,
-  PLATFORM_CHOICES,
-} from '../utils/init-platform.js';
 import { printAuthorFooter } from '../utils/author.js';
-import { ensureFirebaseJson } from '../utils/firebase-config-generator.js';
 import { generateNginxConfig } from '../utils/nginx.js';
+import {
+  promptServerDeployment,
+  buildServerEnvEntry,
+  getDockerEnvSecrets,
+  SSH_BASED,
+} from '../deployment/init-prompts.js';
+import { printDeploymentNextSteps } from '../deployment/deployment-env.js';
 
 const FRONTEND_CHOICES = [
   { name: 'React', value: 'react' },
@@ -159,136 +158,6 @@ async function promptBuildSettings(defaults, side) {
   return inquirer.prompt(questions);
 }
 
-const SERVER_DEPLOY_TYPES = [
-  'ssh',
-  'docker',
-  'ec2',
-  'azure-vm',
-  'gcp-vm',
-  'kubernetes',
-];
-
-/**
- * @param {string} projectName
- * @param {'frontend'|'backend'|'both'} projectType
- * @param {Record<string, unknown>|null} backendConfig
- * @param {Record<string, unknown>|null} singleConfig
- */
-async function promptServerDeployment(projectName, projectType, backendConfig, singleConfig) {
-  return inquirer.prompt([
-    {
-      type: 'list',
-      name: 'deployType',
-      message: 'Deployment type:',
-      choices: SERVER_DEPLOY_TYPES,
-    },
-    {
-      type: 'input',
-      name: 'envName',
-      message: 'Environment name:',
-      default: 'production',
-    },
-    {
-      type: 'input',
-      name: 'host',
-      message: 'Host (for SSH-based targets):',
-      when: (a) => ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType),
-    },
-    {
-      type: 'input',
-      name: 'user',
-      message: 'SSH user:',
-      when: (a) => ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType),
-    },
-    {
-      type: 'input',
-      name: 'deployPath',
-      message: 'Deploy path:',
-      default: `/var/www/${projectName}`,
-      when: (a) =>
-        ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType) &&
-        projectType !== 'both',
-    },
-    {
-      type: 'input',
-      name: 'frontendDeployPath',
-      message: 'Frontend deploy path:',
-      default: `/var/www/${projectName}/public`,
-      when: (a) =>
-        ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType) &&
-        projectType === 'both',
-    },
-    {
-      type: 'input',
-      name: 'backendDeployPath',
-      message: 'Backend deploy path:',
-      default: `/var/www/${projectName}/api`,
-      when: (a) =>
-        ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType) &&
-        projectType === 'both',
-    },
-    {
-      type: 'input',
-      name: 'appName',
-      message: 'App name (for PM2):',
-      default: projectType === 'both' ? `${projectName}-api` : projectName,
-      when: (a) =>
-        ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType) &&
-        (projectType === 'backend' || projectType === 'both'),
-    },
-    {
-      type: 'input',
-      name: 'healthUrl',
-      message: 'Health check URL (optional):',
-    },
-  ]);
-}
-
-/**
- * @param {Awaited<ReturnType<typeof promptServerDeployment>>} deployAnswers
- * @param {'frontend'|'backend'|'both'} projectType
- * @param {string} projectName
- * @param {Record<string, unknown>|null} backendConfig
- * @param {Record<string, unknown>|null} singleConfig
- */
-function buildServerEnvEntry(
-  deployAnswers,
-  projectType,
-  projectName,
-  backendConfig,
-  singleConfig
-) {
-  /** @type {Record<string, unknown>} */
-  const envEntry = {
-    deploymentType: 'server',
-    type: deployAnswers.deployType,
-    host: deployAnswers.host || '',
-    user: deployAnswers.user || '',
-  };
-
-  if (projectType === 'both') {
-    envEntry.frontendDeployPath =
-      deployAnswers.frontendDeployPath || `/var/www/${projectName}/public`;
-    envEntry.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';
-  } 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;
-  } else {
-    envEntry.deployPath = deployAnswers.deployPath || `/var/www/${projectName}`;
-    envEntry.path = envEntry.deployPath;
-  }
-
-  return envEntry;
-}
-
 /**
  * @param {Record<string, unknown>} config
  * @param {Record<string, Record<string, unknown>>} environments
@@ -297,24 +166,11 @@ function buildServerEnvEntry(
 async function generateProjectScaffold(config, environments, cwd) {
   const envList = Object.values(environments);
 
-  const usesFirebase = envList.some(
+  const usesFrontendSsh = envList.some(
     (env) =>
-      env.platform === 'firebase-hosting' || env.platform === 'firebase-app-hosting'
+      SSH_BASED.includes(env.type) || env.deploymentType === 'server'
   );
 
-  if (usesFirebase && !(await fs.pathExists(path.join(cwd, 'firebase.json')))) {
-    const buildOutput =
-      config.frontend?.buildOutput || config.buildOutput || 'dist';
-    await ensureFirebaseJson(buildOutput, cwd);
-    console.log(chalk.gray('  • firebase.json (auto-generated)'));
-  }
-
-  const usesFrontendSsh = envList.some((env) => {
-    if (env.frontendDeploymentType === 'platform') return false;
-    if (env.deploymentType === 'platform' && !env.type) return false;
-    return env.type === 'ssh' || env.deploymentType === 'server';
-  });
-
   const isFrontendProject =
     config.projectType === 'frontend' || config.projectType === 'both';
 
@@ -453,18 +309,19 @@ export function registerInitCommand(program) {
       /** @type {string[]} */
       const deploy = [];
       let healthUrl = '';
+      /** @type {string|undefined} */
+      let primaryDeployType;
+      /** @type {Record<string, string>|null} */
+      let dockerEnvToAppend = null;
 
       if (answers.configureDeploy) {
-        const buildOutput =
-          frontendConfig?.buildOutput || singleConfig?.buildOutput || 'dist';
-
         if (projectType === 'backend') {
           const deployAnswers = await promptServerDeployment(
             projectName,
             projectType,
-            backendConfig,
-            singleConfig
+            backendConfig
           );
+          primaryDeployType = deployAnswers.deployType;
           deploy.push(deployAnswers.envName);
           environments[deployAnswers.envName] = buildServerEnvEntry(
             deployAnswers,
@@ -478,218 +335,61 @@ export function registerInitCommand(program) {
           } else if (singleConfig?.port) {
             healthUrl = `http://localhost:${singleConfig.port}/health`;
           }
+          dockerEnvToAppend = getDockerEnvSecrets(deployAnswers);
         } else if (projectType === 'frontend') {
-          const { deployMethod } = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'deployMethod',
-              message: 'How do you want to deploy?',
-              choices: [
-                {
-                  name: 'Managed platform (Vercel, Netlify, Cloudflare Pages, etc.)',
-                  value: 'platform',
-                },
-                {
-                  name: 'Self-hosted server (SSH, Docker, EC2, etc.)',
-                  value: 'server',
-                },
-              ],
-            },
-          ]);
-
-          const { envName } = await inquirer.prompt([
-            {
-              type: 'input',
-              name: 'envName',
-              message: 'Environment name:',
-              default: 'production',
-            },
-          ]);
-          deploy.push(envName);
-
-          if (deployMethod === 'platform') {
-            showPlatformComparison();
-            const { platform } = await inquirer.prompt([
-              {
-                type: 'list',
-                name: 'platform',
-                message: 'Select platform:',
-                choices: PLATFORM_CHOICES,
-              },
-            ]);
-
-            const platformConfig = await promptPlatformQuestions(
-              platform,
-              projectName,
-              buildOutput,
-              cwd
-            );
-            await appendPlatformEnvExample(platform, cwd);
-
-            const { healthUrlInput } = await inquirer.prompt([
-              {
-                type: 'input',
-                name: 'healthUrlInput',
-                message: 'Health check URL (optional):',
-                default: suggestHealthUrl(platform, projectName),
-              },
-            ]);
-
-            environments[envName] = {
-              deploymentType: 'platform',
-              ...platformConfig,
-            };
-            healthUrl = healthUrlInput || suggestHealthUrl(platform, projectName);
-          } else {
-            const deployAnswers = await promptServerDeployment(
-              projectName,
-              projectType,
-              backendConfig,
-              singleConfig
-            );
-            deployAnswers.envName = envName;
-            environments[envName] = buildServerEnvEntry(
-              deployAnswers,
-              projectType,
-              projectName,
-              backendConfig,
-              singleConfig
-            );
-            if (deployAnswers.healthUrl) healthUrl = deployAnswers.healthUrl;
+          const deployAnswers = await promptServerDeployment(
+            projectName,
+            projectType,
+            backendConfig
+          );
+          primaryDeployType = deployAnswers.deployType;
+          deploy.push(deployAnswers.envName);
+          environments[deployAnswers.envName] = buildServerEnvEntry(
+            deployAnswers,
+            projectType,
+            projectName,
+            backendConfig,
+            singleConfig
+          );
+          if (deployAnswers.healthUrl) {
+            healthUrl = deployAnswers.healthUrl;
           }
+          dockerEnvToAppend = getDockerEnvSecrets(deployAnswers);
         } else {
-          const { frontendDeployMethod } = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'frontendDeployMethod',
-              message: 'How do you want to deploy the frontend?',
-              choices: [
-                {
-                  name: 'Managed platform (Vercel, Netlify, Cloudflare Pages, etc.)',
-                  value: 'platform',
-                },
-                {
-                  name: 'Self-hosted server (SSH, Docker, EC2, etc.)',
-                  value: 'server',
-                },
-              ],
-            },
-          ]);
-
-          const { envName } = await inquirer.prompt([
-            {
-              type: 'input',
-              name: 'envName',
-              message: 'Environment name:',
-              default: 'production',
-            },
-          ]);
-          deploy.push(envName);
+          const backendDeployAnswers = await promptServerDeployment(
+            projectName,
+            'both',
+            backendConfig
+          );
+          primaryDeployType = backendDeployAnswers.deployType;
+          deploy.push(backendDeployAnswers.envName);
 
           /** @type {Record<string, unknown>} */
-          const envEntry = { backendDeploymentType: 'server' };
-
-          if (frontendDeployMethod === 'platform') {
-            showPlatformComparison();
-            const { platform } = await inquirer.prompt([
-              {
-                type: 'list',
-                name: 'platform',
-                message: 'Select frontend platform:',
-                choices: PLATFORM_CHOICES,
-              },
-            ]);
-
-            const platformConfig = await promptPlatformQuestions(
-              platform,
+          const envEntry = {
+            backendDeploymentType: 'server',
+            frontendDeploymentType: 'server',
+            deploymentType: 'server',
+          };
+
+          Object.assign(
+            envEntry,
+            buildServerEnvEntry(
+              backendDeployAnswers,
+              'both',
               projectName,
-              buildOutput,
-              cwd
-            );
-            await appendPlatformEnvExample(platform, cwd);
-
-            Object.assign(envEntry, {
-              frontendDeploymentType: 'platform',
-              deploymentType: 'platform',
-              ...platformConfig,
-            });
-            healthUrl = suggestHealthUrl(platform, projectName);
-          } else {
-            envEntry.frontendDeploymentType = 'server';
-          }
-
-          console.log(chalk.gray('\nBackend will be deployed to a self-hosted server.'));
-          const backendDeployAnswers = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'deployType',
-              message: 'Backend deployment type:',
-              choices: SERVER_DEPLOY_TYPES,
-              default: 'ssh',
-            },
-            {
-              type: 'input',
-              name: 'host',
-              message: 'Host (for SSH-based targets):',
-              when: (a) => ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType),
-            },
-            {
-              type: 'input',
-              name: 'user',
-              message: 'SSH user:',
-              when: (a) => ['ssh', 'ec2', 'azure-vm', 'gcp-vm'].includes(a.deployType),
-            },
-            {
-              type: 'input',
-              name: 'backendDeployPath',
-              message: 'Backend deploy path:',
-              default: `/var/www/${projectName}/api`,
-            },
-            {
-              type: 'input',
-              name: 'appName',
-              message: 'App name (for PM2):',
-              default: `${projectName}-api`,
-            },
-          ]);
-
-          Object.assign(envEntry, {
-            type: backendDeployAnswers.deployType,
-            host: backendDeployAnswers.host || '',
-            user: backendDeployAnswers.user || '',
-            backendDeployPath:
-              backendDeployAnswers.backendDeployPath || `/var/www/${projectName}/api`,
-            appName: backendDeployAnswers.appName || `${projectName}-api`,
-            framework: backendConfig?.framework || 'express',
-            path: backendDeployAnswers.backendDeployPath || `/var/www/${projectName}/api`,
-          });
-
-          if (frontendDeployMethod === 'server') {
-            const { frontendDeployPath } = await inquirer.prompt([
-              {
-                type: 'input',
-                name: 'frontendDeployPath',
-                message: 'Frontend deploy path:',
-                default: `/var/www/${projectName}/public`,
-              },
-            ]);
-            envEntry.frontendDeployPath = frontendDeployPath;
-          }
+              backendConfig,
+              singleConfig
+            )
+          );
 
-          const { healthUrlInput } = await inquirer.prompt([
-            {
-              type: 'input',
-              name: 'healthUrlInput',
-              message: 'Health check URL (optional):',
-              default: healthUrl || '',
-            },
-          ]);
-          if (healthUrlInput) healthUrl = healthUrlInput;
-          else if (!healthUrl && backendConfig?.port) {
+          if (backendDeployAnswers.healthUrl) {
+            healthUrl = backendDeployAnswers.healthUrl;
+          } else if (backendConfig?.port) {
             healthUrl = `http://localhost:${backendConfig.port}/health`;
           }
 
-          environments[envName] = envEntry;
+          environments[backendDeployAnswers.envName] = envEntry;
+          dockerEnvToAppend = getDockerEnvSecrets(backendDeployAnswers);
         }
       }
 
@@ -742,6 +442,9 @@ export function registerInitCommand(program) {
       }
 
       await saveConfig(config, cwd);
+      if (dockerEnvToAppend) {
+        await appendEnv(dockerEnvToAppend, cwd);
+      }
       await addDeployhubToPackageJson(cliSource, cwd);
       await writeWorkflowFile(
         config.storage,
@@ -766,22 +469,28 @@ export function registerInitCommand(program) {
       const secrets = getRequiredSecrets(config.storage, deploy, environments, config);
 
       console.log('');
-      console.log(chalk.green.bold('✓ DeployHub initialized successfully!'));
+      if (primaryDeployType) {
+        console.log(chalk.green.bold(`✔ Config generated for ${primaryDeployType} deployment.`));
+        printDeploymentNextSteps(primaryDeployType, secrets);
+      } else {
+        console.log(chalk.green.bold('✓ DeployHub initialized successfully!'));
+        console.log('');
+        console.log(chalk.bold('Next steps:'));
+        console.log('  1. Copy .env.example to .env and fill in credentials');
+        if (secrets.length > 0) {
+          console.log('  2. Add these secrets to GitHub (Settings → Secrets):');
+          secrets.forEach((s) => console.log(`     • ${s}`));
+        }
+        console.log(`  ${secrets.length > 0 ? '3' : '2'}. Run ${chalk.cyan('deployhub doctor')} to verify your setup`);
+        console.log(`  ${secrets.length > 0 ? '4' : '3'}. Push to main — GitHub Actions will run ${chalk.cyan('deployhub build')} automatically`);
+      }
+
       console.log('');
       console.log(chalk.bold('Generated files:'));
       console.log('  • deployhub.config.json');
       console.log('  • .github/workflows/deployhub.yml');
       console.log('  • .env.example');
       console.log('');
-      console.log(chalk.bold('Next steps:'));
-      console.log('  1. Copy .env.example to .env and fill in credentials');
-      if (secrets.length > 0) {
-        console.log('  2. Add these secrets to GitHub (Settings → Secrets):');
-        secrets.forEach((s) => console.log(`     • ${s}`));
-      }
-      console.log(`  ${secrets.length > 0 ? '3' : '2'}. Run ${chalk.cyan('deployhub doctor')} to verify your setup`);
-      console.log(`  ${secrets.length > 0 ? '4' : '3'}. Push to main — GitHub Actions will run ${chalk.cyan('deployhub build')} automatically`);
-      console.log('');
       printAuthorFooter();
     });
 }

package/src/commands/rollback.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { loadConfig, loadEnv } from '../core/config.js';
-import { rollbackToVersion } from '../rollback/engine.js';
+import { rollbackToVersion } from '../utils/rollback/engine.js';
 import axios from 'axios';
 
 /**

package/src/core/config.js

@@ -14,25 +14,29 @@ const SideConfigSchema = z.object({
 
 const EnvironmentSchema = z.object({
   type: z.string().optional(),
-  deploymentType: z.enum(['platform', 'server']).optional(),
-  platform: z.string().optional(),
-  projectName: z.string().optional(),
-  siteId: z.string().optional(),
-  accountId: z.string().optional(),
-  appId: z.string().optional(),
-  region: z.string().optional(),
-  branch: z.string().optional(),
-  githubConnected: z.boolean().optional(),
-  resourceName: z.string().optional(),
-  projectId: z.string().optional(),
-  backendName: z.string().optional(),
-  frontendDeploymentType: z.enum(['platform', 'server']).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(),

package/src/core/stages.js

@@ -5,8 +5,6 @@ import { uploadToAll } from '../storage/index.js';
 import { deployToAll } from '../deployment/index.js';
 import { sendNotifications } from '../notifications/index.js';
 import axios from 'axios';
-import fs from 'fs-extra';
-import path from 'path';
 import { getProjectVersion } from '../utils/version.js';
 
 /**
@@ -149,15 +147,6 @@ export function buildPipelineStages(config, cwd, state) {
         const deployed = await deployToAll(ctx.config, artifactDir);
         ctx.state.deployedTargets = deployed;
 
-        const deploymentPath = path.join(artifactDir, 'deployment.json');
-        if (await fs.pathExists(deploymentPath)) {
-          const data = await fs.readJson(deploymentPath);
-          const last = data.lastDeployment;
-          if (last?.deployUrl || last?.deploymentUrl) {
-            ctx.state.lastDeployUrl = last.deployUrl || last.deploymentUrl;
-          }
-        }
-
         await repackArtifactZip(artifactDir);
         const zipPath = /** @type {string} */ (ctx.state.zipPath);
         if (zipPath) {