@akash-chowdhury-24/deployhub 2.0.20 → 2.0.22

package/src/artifact/engine.js

@@ -19,6 +19,7 @@ import {
   getEnvSettings,
   resolveDefaultEnvironmentName,
 } from '../core/config.js';
+import { detectDjangoWsgiPackageDir } from '../utils/python-app-target.js';
 
 /**
  * @param {string} cwd
@@ -71,21 +72,26 @@ function resolveArtifactType(config) {
  */
 function resolveBuildSettings(config) {
   if (config.projectType === 'both' && config.backend) {
+    const buildCommand = config.backend.buildCommand ?? null;
     return {
       buildOutput: config.backend.buildOutput || '.',
       framework: config.backend.framework,
       startCommand: config.backend.startCommand || null,
       port: config.backend.port || 3000,
-      buildCommand: config.backend.buildCommand ?? null,
+      buildCommand,
     };
   }
 
+  const buildCommand = config.buildCommand ?? null;
+  const isBackend = config.projectType === 'backend';
   return {
-    buildOutput: config.buildOutput || 'dist',
+    // Backend packages are source trees (or compiled jars/binaries under a known
+    // output dir when set). Never default backends to frontend-style "dist".
+    buildOutput: config.buildOutput || (isBackend ? '.' : 'dist'),
     framework: config.framework || 'node',
     startCommand: config.startCommand || null,
     port: config.port || 3000,
-    buildCommand: config.buildCommand ?? null,
+    buildCommand,
   };
 }
 
@@ -194,14 +200,47 @@ async function stageBackendArtifact(cwd, stagingDir, config) {
 
   if (['express', 'nestjs', 'fastify', 'koa', 'nextjs'].includes(framework)) {
     await copyIfExists(cwd, stagingDir, 'package.json');
-  } else if (['fastapi', 'django', 'flask'].includes(framework)) {
+    await copyIfExists(cwd, stagingDir, 'package-lock.json');
+  } else if (['fastapi', 'django', 'flask', 'python'].includes(framework)) {
+    // Source-only packages: root entrypoints + manifests (no dist/).
     await copyIfExists(cwd, stagingDir, 'requirements.txt');
-    if (framework === 'django' && (await fs.pathExists(path.join(cwd, 'manage.py')))) {
-      await copyIfExists(cwd, stagingDir, 'manage.py');
+    await copyIfExists(cwd, stagingDir, 'pyproject.toml');
+    await copyIfExists(cwd, stagingDir, 'Pipfile');
+    await copyIfExists(cwd, stagingDir, 'Pipfile.lock');
+    await copyIfExists(cwd, stagingDir, 'setup.py');
+    await copyIfExists(cwd, stagingDir, 'manage.py');
+    await copyIfExists(cwd, stagingDir, 'main.py');
+    await copyIfExists(cwd, stagingDir, 'app.py');
+    await copyIfExists(cwd, stagingDir, 'wsgi.py');
+    await copyIfExists(cwd, stagingDir, 'asgi.py');
+    await copyDirectoryIfExists(cwd, stagingDir, 'app');
+    await copyDirectoryIfExists(cwd, stagingDir, 'apps');
+    // Django project package often sits next to manage.py (e.g. config/, mysite/).
+    // `config/` is already copied above for all backends; also copy the detected
+    // package that owns wsgi.py when it is not config/app/apps.
+    if (framework === 'django') {
+      await copyDirectoryIfExists(cwd, stagingDir, 'templates');
+      await copyDirectoryIfExists(cwd, stagingDir, 'static');
+      const wsgiPkg = detectDjangoWsgiPackageDir(cwd);
+      if (
+        wsgiPkg &&
+        !['app', 'apps', 'config', 'templates', 'static', 'src'].includes(wsgiPkg)
+      ) {
+        await copyDirectoryIfExists(cwd, stagingDir, wsgiPkg);
+      }
     }
-  } else if (['laravel', 'symfony'].includes(framework)) {
+  } else if (['laravel', 'symfony', 'php'].includes(framework)) {
     await copyIfExists(cwd, stagingDir, 'composer.json');
     await copyIfExists(cwd, stagingDir, 'composer.lock');
+    await copyIfExists(cwd, stagingDir, 'artisan');
+    await copyDirectoryIfExists(cwd, stagingDir, 'app');
+    await copyDirectoryIfExists(cwd, stagingDir, 'bootstrap');
+    await copyDirectoryIfExists(cwd, stagingDir, 'public');
+    await copyDirectoryIfExists(cwd, stagingDir, 'routes');
+    await copyDirectoryIfExists(cwd, stagingDir, 'database');
+    await copyDirectoryIfExists(cwd, stagingDir, 'resources');
+    await copyDirectoryIfExists(cwd, stagingDir, 'storage');
+    await copyDirectoryIfExists(cwd, stagingDir, 'bin');
   } else if (framework === 'spring') {
     await copyIfExists(cwd, stagingDir, 'pom.xml');
     const targetDir = path.join(cwd, 'target');
@@ -226,11 +265,19 @@ async function stageBackendArtifact(cwd, stagingDir, config) {
     await copyIfExists(cwd, stagingDir, 'Gemfile');
     await copyIfExists(cwd, stagingDir, 'Gemfile.lock');
     await copyIfExists(cwd, stagingDir, 'config.ru');
+    await copyIfExists(cwd, stagingDir, 'Rakefile');
+    await copyDirectoryIfExists(cwd, stagingDir, 'app');
+    await copyDirectoryIfExists(cwd, stagingDir, 'bin');
+    await copyDirectoryIfExists(cwd, stagingDir, 'lib');
+    await copyDirectoryIfExists(cwd, stagingDir, 'db');
+    await copyDirectoryIfExists(cwd, stagingDir, 'public');
   } else {
     await copyIfExists(cwd, stagingDir, 'package.json');
     await copyIfExists(cwd, stagingDir, 'requirements.txt');
   }
 
+  // Only copy a named build-output dir when it actually exists (compiled langs).
+  // Skip '.' / 'src' — source is already staged above; never invent an empty dist/.
   if (settings.buildOutput && settings.buildOutput !== '.' && settings.buildOutput !== 'src') {
     const built = path.join(cwd, settings.buildOutput);
     if (await fs.pathExists(built) && !['target', 'bin', 'publish'].includes(settings.buildOutput)) {
@@ -309,6 +356,7 @@ export async function createArtifact(config, deployedTargets = [], cwd = process
     projectType: artifactType,
     framework: settings.framework,
     buildOutput: settings.buildOutput,
+    buildCommand: settings.buildCommand,
     startCommand: settings.startCommand,
     port: settings.port,
     generatedBy: getGeneratedByMetadata(),
@@ -320,6 +368,8 @@ export async function createArtifact(config, deployedTargets = [], cwd = process
     metadata.frontend = frontend;
     metadata.backend = {
       framework: settings.framework,
+      buildOutput: settings.buildOutput,
+      buildCommand: settings.buildCommand,
       startCommand: settings.startCommand,
       port: settings.port,
     };

package/src/cli/fatal-error.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+
+/**
+ * Format an unexpected CLI error for the user — message only, never a stack
+ * or pkg snapshot paths like `C:\snapshot\...` / `/snapshot/...`.
+ *
+ * @param {unknown} err
+ * @returns {string}
+ */
+export function formatFatalCliError(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  const message = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !/[/\\]snapshot[/\\]/i.test(line) && !/^\s*at\s+/.test(line))
+    .join(' ')
+    .trim() || 'Unknown error';
+
+  return (
+    `Unexpected error: ${message}\n` +
+    `  If this persists, open an issue with the command you ran.`
+  );
+}
+
+/**
+ * @param {unknown} err
+ * @param {(msg: string) => void} [write]
+ */
+export function reportFatalCliError(err, write = console.error) {
+  write(chalk.red(formatFatalCliError(err)));
+}
+
+/**
+ * Last-resort handlers so unexpected failures never dump a raw Node stack
+ * (especially ugly under pkg: `C:\\snapshot\\DeployHub\\...`).
+ */
+export function installCliFatalHandlers() {
+  process.on('uncaughtException', (err) => {
+    reportFatalCliError(err);
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason) => {
+    reportFatalCliError(reason instanceof Error ? reason : new Error(String(reason)));
+    process.exit(1);
+  });
+}

package/src/cli/index.js

@@ -17,7 +17,12 @@ import { registerSyncWorkflowsCommand } from '../commands/sync-workflows.js';
 import { registerSyncK8sPortsCommand } from '../commands/sync-k8s-ports.js';
 import { registerEnvCommand } from '../commands/env.js';
 import { formatVersionOutput, printBanner, shouldShowBanner } from '../utils/author.js';
+import {
+  installCliFatalHandlers,
+  reportFatalCliError,
+} from './fatal-error.js';
 
+installCliFatalHandlers();
 loadEnv();
 
 const program = new Command();
@@ -48,4 +53,7 @@ registerSyncWorkflowsCommand(program);
 registerSyncK8sPortsCommand(program);
 registerEnvCommand(program);
 
-program.parse();
+program.parseAsync(process.argv).catch((err) => {
+  reportFatalCliError(err);
+  process.exit(1);
+});

package/src/commands/artifact.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import {
   createArtifact,
   listLocalArtifacts,
@@ -25,7 +26,7 @@ export function registerArtifactCommand(program) {
     .description('Create artifact from current build output')
     .action(async () => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
       const result = await createArtifact(config, [], process.cwd());
       console.log(chalk.green(`Artifact created: ${result.artifactDir}`));
     });
@@ -36,7 +37,7 @@ export function registerArtifactCommand(program) {
     .option('--remote', 'Also list builds from remote history.json')
     .action(async (opts) => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
       const artifacts = await listLocalArtifacts();
 
       console.log(chalk.bold('\nLocal artifacts:\n'));
@@ -91,7 +92,7 @@ export function registerArtifactCommand(program) {
     .description('Download and extract an artifact by buildId or legacy semver')
     .action(async (versionOrBuildId) => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
       const cwd = process.cwd();
       const needle = String(versionOrBuildId).replace(/^v/i, '');
 

package/src/commands/build.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { runPipeline } from '../core/pipeline.js';
 import { buildPipelineStages } from '../core/stages.js';
 
@@ -13,14 +14,7 @@ export function registerBuildCommand(program) {
     .action(async () => {
       loadEnv();
       const cwd = process.cwd();
-
-      let config;
-      try {
-        config = await loadConfig(cwd);
-      } catch (err) {
-        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-        process.exit(1);
-      }
+      const config = await loadConfigOrExit(cwd);
 
       /** @type {Record<string, unknown>} */
       const state = {};

package/src/commands/deploy.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { resolveEnvTargets } from '../core/environments.js';
 import { runPipeline } from '../core/pipeline.js';
 import { listLocalArtifacts } from '../artifact/engine.js';
@@ -26,7 +27,7 @@ export function registerDeployCommand(program) {
     .action(async (opts) => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
       const log = createLogger('deploy');
 
       let targets;

package/src/commands/doctor.js

@@ -4,7 +4,8 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import axios from 'axios';
-import { loadConfig, loadEnv, getEnvMethod, getEnvSettings } from '../core/config.js';
+import { loadEnv, getEnvMethod, getEnvSettings } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import {
   isEnvEnabled,
   resolveDefaultEnvironmentName,
@@ -612,6 +613,41 @@ async function runBackendProcessChecks(config, envName, deployType = 'ssh') {
   }
 
   if (PYTHON_FRAMEWORKS.has(framework)) {
+    checks.push(
+      await runCheck('Python 3', async () => {
+        const result = await provider.runRemoteCheck('command -v python3');
+        if (result.pass) {
+          return { name: 'Python 3', pass: true, message: 'python3 found on PATH' };
+        }
+        return {
+          name: 'Python 3',
+          pass: false,
+          message:
+            'python3 not found on PATH — install it on the server ' +
+            '(Amazon Linux: sudo yum install -y python3; Ubuntu: sudo apt-get install -y python3)',
+        };
+      })
+    );
+
+    checks.push(
+      await runCheck('pip', async () => {
+        // Deploy runs `pip install -r requirements.txt`; accept pip3 or pip.
+        const result = await provider.runRemoteCheck(
+          'command -v pip3 >/dev/null 2>&1 || command -v pip >/dev/null 2>&1'
+        );
+        if (result.pass) {
+          return { name: 'pip', pass: true, message: 'pip3 or pip found on PATH' };
+        }
+        return {
+          name: 'pip',
+          pass: false,
+          message:
+            'pip/pip3 not found on PATH — install it on the server ' +
+            '(Amazon Linux: sudo yum install -y python3-pip; Ubuntu: sudo apt-get install -y python3-pip)',
+        };
+      })
+    );
+
     checks.push(
       await runCheck('gunicorn', async () => {
         const result = await provider.runRemoteCheck('which gunicorn || gunicorn --version');
@@ -705,6 +741,8 @@ export function registerDoctorCommand(program) {
     .action(async (opts) => {
       loadEnv();
       const cwd = process.cwd();
+      // Doctor requires a project config — fail cleanly before any checks (no null.storage crash).
+      const config = await loadConfigOrExit(cwd);
       /** @type {CheckResult[]} */
       const results = [];
       /** @type {Set<string>} names of checks that must not fail the summary */
@@ -746,17 +784,6 @@ export function registerDoctorCommand(program) {
 
       results.push(
         await runCheck('Build command', async () => {
-          let config;
-          try {
-            config = await loadConfig(cwd);
-          } catch {
-            return {
-              name: 'Build command',
-              pass: false,
-              message: 'deployhub.config.json not found — run deployhub init',
-            };
-          }
-
           if (config.projectType === 'backend' && !config.buildCommand) {
             return {
               name: 'Build command',
@@ -794,14 +821,7 @@ export function registerDoctorCommand(program) {
         })
       );
 
-      let config = null;
-      try {
-        config = await loadConfig(cwd);
-      } catch {
-        // handled above
-      }
-
-      if (config) {
+      {
         for (const provider of config.storage || []) {
           const label = provider.charAt(0).toUpperCase() + provider.slice(1);
           if (provider === 'aws') {
@@ -946,10 +966,6 @@ export function registerDoctorCommand(program) {
 
       results.push(
         await runCheck('Secrets', async () => {
-          if (!config) {
-            return { name: 'Secrets', pass: false, message: 'No config found' };
-          }
-
           /** @type {string[]} */
           const required = [];
           for (const provider of config.storage || []) {
@@ -984,7 +1000,7 @@ export function registerDoctorCommand(program) {
       );
 
       // Explicit CI-prefixed secret reminders for non-grandfathered environments
-      if (config) {
+      {
         const inCi = process.env.GITHUB_ACTIONS === 'true' || process.env.CI === 'true';
         for (const envName of Object.keys(config.environments || {})) {
           const env = config.environments[envName];

package/src/commands/env.js

@@ -1,10 +1,10 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import {
-  loadConfig,
   loadEnv,
   saveConfig,
 } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import {
   getEnabledEnvironmentNames,
   getEnvMethod,
@@ -72,7 +72,7 @@ export function registerEnvCommand(program) {
     .description('List configured environments')
     .action(async () => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
       const names = Object.keys(config.environments || {});
       if (names.length === 0) {
         console.log(chalk.yellow('No environments configured. Run: deployhub env add <name>'));
@@ -117,7 +117,7 @@ export function registerEnvCommand(program) {
     .action(async (rawName, opts) => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
       const log = createLogger('env');
 
       const nameCheck = validateEnvironmentName(rawName, Object.keys(config.environments || {}));
@@ -233,7 +233,7 @@ export function registerEnvCommand(program) {
     .action(async (name) => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
       if (!config.environments[name]) {
         console.error(chalk.red(`Environment "${name}" not found.`));
         process.exit(1);
@@ -251,7 +251,7 @@ export function registerEnvCommand(program) {
     .action(async (name) => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
       if (!config.environments[name]) {
         console.error(chalk.red(`Environment "${name}" not found.`));
         process.exit(1);
@@ -269,7 +269,7 @@ export function registerEnvCommand(program) {
     .action(async (name) => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
       if (!config.environments[name]) {
         console.error(chalk.red(`Environment "${name}" not found.`));
         process.exit(1);

package/src/commands/rollback.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { resolveEnvTargets } from '../core/environments.js';
 import {
   rollbackToVersion,
@@ -23,7 +24,7 @@ export function registerRollbackCommand(program) {
     )
     .action(async (versionOrBuildId, opts) => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
       const log = createLogger('rollback');
 
       let targets;

package/src/commands/storage.js

@@ -93,14 +93,8 @@ export function registerStorageCommand(program) {
     .description('List configured storage providers and status')
     .action(async () => {
       loadEnv();
-      let config;
-      try {
-        const { loadConfig } = await import('../core/config.js');
-        config = await loadConfig();
-      } catch {
-        console.error(chalk.red('Run deployhub init first'));
-        process.exit(1);
-      }
+      const { loadConfigOrExit } = await import('../core/load-config-or-exit.js');
+      const config = await loadConfigOrExit();
 
       const results = await testAllProviders(config.storage);
       console.log(chalk.bold('\nStorage Providers:\n'));

package/src/commands/sync-k8s-ports.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { resolveContainerPort } from '../utils/dockerfile-expose.js';
 import {
   getDefaultKubernetesManifestPaths,
@@ -23,7 +24,7 @@ export function registerSyncK8sPortsCommand(program) {
     .action(async () => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
 
       const { deploymentPath, servicePath } = getDefaultKubernetesManifestPaths(cwd);
       const hasDeployment = await fs.pathExists(deploymentPath);

package/src/commands/sync-workflows.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { getEnabledEnvironmentNames } from '../core/environments.js';
 import {
   writeWorkflowFile,
@@ -20,7 +21,7 @@ export function registerSyncWorkflowsCommand(program) {
     .action(async () => {
       loadEnv();
       const cwd = process.cwd();
-      const config = await loadConfig(cwd);
+      const config = await loadConfigOrExit(cwd);
 
       const storage = config.storage || [];
       const environments = config.environments || {};

package/src/commands/verify.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { loadConfig, loadEnv } from '../core/config.js';
+import { loadEnv } from '../core/config.js';
+import { loadConfigOrExit } from '../core/load-config-or-exit.js';
 import { resolveEnvTargets } from '../core/environments.js';
 import {
   anyEnvHasResolvableHealthCheckUrl,
@@ -86,7 +87,7 @@ export function registerVerifyCommand(program) {
     )
     .action(async (opts) => {
       loadEnv();
-      const config = await loadConfig();
+      const config = await loadConfigOrExit();
 
       let outcome;
       try {

package/src/core/load-config-or-exit.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import { loadConfig } from './config.js';
+
+/**
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+export function isConfigMissingError(err) {
+  return err instanceof Error && /Config not found/i.test(err.message);
+}
+
+/**
+ * User-facing missing-config message (no stack, no snapshot paths).
+ */
+export function printMissingConfigError() {
+  console.error(chalk.red('✗ No deployhub.config.json found in this directory.'));
+  console.error(chalk.red("  Run 'deployhub init' first to set up your project."));
+}
+
+/**
+ * Load config or print a clean error and exit (never throws to the caller).
+ * @param {string} [cwd]
+ * @returns {Promise<import('./config.js').DeployHubConfig>}
+ */
+export async function loadConfigOrExit(cwd = process.cwd()) {
+  try {
+    return await loadConfig(cwd);
+  } catch (err) {
+    if (isConfigMissingError(err)) {
+      printMissingConfigError();
+    } else {
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+    }
+    process.exit(1);
+    throw err;
+  }
+}

package/src/core/stages.js

@@ -144,6 +144,8 @@ export function buildPipelineStages(config, cwd, state) {
           return;
         }
 
+        // Adapters themselves null-guard buildCommand; this stage always
+        // invokes build() so interpreted backends can log the skip cleanly.
         const adapter = getAdapter(ctx.config.framework, ctx.config, ctx.cwd);
         await adapter.build();
       },

package/src/deployment/init-prompts.js

@@ -24,6 +24,32 @@ export const SERVER_DEPLOY_TYPES = [
 
 const SSH_BASED = ['ssh', 'ec2', 'azure-vm', 'gcp-vm'];
 
+const NODE_PM2_FRAMEWORKS = new Set([
+  'express',
+  'nestjs',
+  'fastify',
+  'koa',
+  'nextjs',
+  'node',
+]);
+
+/**
+ * User-facing label for the backend process identity field (`appName`).
+ * Node backends use PM2; other languages use DEPLOYHUB_APP + PID files.
+ *
+ * @param {string|undefined|null} framework
+ * @param {string} projectName
+ * @param {'frontend'|'backend'|'both'} projectType
+ * @returns {string}
+ */
+export function backendProcessNamePromptMessage(framework, projectName, projectType) {
+  const backendFramework = String(framework || '').toLowerCase();
+  const usesPm2 = !backendFramework || NODE_PM2_FRAMEWORKS.has(backendFramework);
+  const example = projectType === 'both' ? `${projectName}-api` : projectName;
+  return usesPm2
+    ? `PM2 process name for your backend (e.g. ${example}):`
+    : `Process name for your backend (identifies this app's process on the server, e.g. ${example}):`;
+}
 /**
  * Prompt for one environment's deployment method + method-specific config.
  * Shared by `deployhub init` and `deployhub env add`.
@@ -427,7 +453,11 @@ async function promptSshBasedDeployment(base, projectName, projectType, backendC
     questions.push({
       type: 'input',
       name: 'appName',
-      message: `PM2 process name for your backend (e.g. ${projectName}-api):`,
+      message: backendProcessNamePromptMessage(
+        /** @type {string|undefined} */ (backendConfig?.framework),
+        projectName,
+        projectType
+      ),
       default: projectType === 'both' ? `${projectName}-api` : projectName,
     });
   }