@akash-chowdhury-24/deployhub 2.0.21 → 2.0.23

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,
     });
   }

package/src/deployment/providers/ssh.js

@@ -12,6 +12,7 @@ import {
 } from '../../utils/nginx.js';
 import { resolvePm2AppName } from '../../utils/pm2-app-name.js';
 import { shellQuote, formatRemoteCommandFailure } from '../../utils/shell-quote.js';
+import { extractGunicornTarget } from '../../utils/python-app-target.js';
 
 /** @type {Set<string>} */
 const NODE_FRAMEWORKS = new Set(['express', 'nestjs', 'fastify', 'koa', 'nextjs', 'node']);
@@ -54,6 +55,14 @@ export function createSshProvider(config, envName, env = process.env) {
 
   const log = createLogger('ssh');
 
+  // Defense-in-depth: never let a stuck SSH channel hang CI indefinitely.
+  // Override with DEPLOYHUB_SSH_EXEC_TIMEOUT_MS (ms). Backend start/stop uses a shorter bound.
+  const defaultExecTimeoutMs = Number(env.DEPLOYHUB_SSH_EXEC_TIMEOUT_MS) || 120_000;
+  const startStopTimeoutMs = Math.min(
+    defaultExecTimeoutMs,
+    Number(env.DEPLOYHUB_SSH_START_TIMEOUT_MS) || 60_000
+  );
+
   async function connect() {
     if (!host || !user) {
       throw new Error(
@@ -94,10 +103,33 @@ export function createSshProvider(config, envName, env = process.env) {
   /**
    * @param {import('node-ssh').NodeSSH} ssh
    * @param {string} command
+   * @param {{ timeoutMs?: number }} [opts]
    */
-  async function exec(ssh, command) {
+  async function exec(ssh, command, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? defaultExecTimeoutMs;
     log.info(`$ ${command}`);
-    const result = await ssh.execCommand(command);
+
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new Error(
+            `SSH command timed out after ${timeoutMs}ms on ${user}@${host}. ` +
+              `The remote command may still be running — check the server. ` +
+              `Command: ${command.length > 240 ? `${command.slice(0, 240)}…` : command}`
+          )
+        );
+      }, timeoutMs);
+    });
+
+    let result;
+    try {
+      result = await Promise.race([ssh.execCommand(command), timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+
     if (result.code !== 0 && result.code !== null) {
       const message = formatRemoteCommandFailure(
         command,
@@ -111,6 +143,47 @@ export function createSshProvider(config, envName, env = process.env) {
     return result;
   }
 
+  /**
+   * Exact marker match in a null-delimited /proc file (cmdline or environ).
+   * Uses grep -xF so DEPLOYHUB_APP=myapi does not match DEPLOYHUB_APP=myapi-staging.
+   *
+   * @param {string} procFileExpr — e.g. `/proc/$pid/environ` or `$proc/cmdline`
+   * @param {string} marker — already shell-quoted
+   */
+  function procHasExactMarker(procFileExpr, marker) {
+    return (
+      `tr '\\0' '\\n' < ${procFileExpr} 2>/dev/null | grep -qxF ${marker}`
+    );
+  }
+
+  /**
+   * Kill every process whose environ or cmdline contains our exact env/JVM marker.
+   * Replaces `pkill -f DEPLOYHUB_APP=…` which only searches cmdline — and
+   * `VAR=value nohup cmd` puts the marker in environ only, so orphans from
+   * interrupted deploys (no pidfile) were never found.
+   *
+   * Safe against PID reuse: an unrelated process will not carry our marker.
+   *
+   * @param {string} markerEnvQ — shell-quoted `DEPLOYHUB_APP=…`
+   * @param {string} markerJvmQ — shell-quoted `deployhub.app=…`
+   * @param {string} markerJvmFlagQ — shell-quoted `-Ddeployhub.app=…`
+   */
+  function killByExactMarkersCmd(markerEnvQ, markerJvmQ, markerJvmFlagQ) {
+    return (
+      `for proc in /proc/[0-9]*; do ` +
+        `pid="\${proc##*/}"; ` +
+        `matched=0; ` +
+        `if [ -r "$proc/environ" ] && ${procHasExactMarker('"$proc/environ"', markerEnvQ)}; then matched=1; fi; ` +
+        `if [ "$matched" -eq 0 ] && [ -r "$proc/cmdline" ]; then ` +
+          `if ${procHasExactMarker('"$proc/cmdline"', markerEnvQ)} ` +
+          `|| ${procHasExactMarker('"$proc/cmdline"', markerJvmFlagQ)} ` +
+          `|| ${procHasExactMarker('"$proc/cmdline"', markerJvmQ)}; then matched=1; fi; ` +
+        `fi; ` +
+        `if [ "$matched" -eq 1 ]; then kill "$pid" 2>/dev/null || true; fi; ` +
+      `done`
+    );
+  }
+
   /**
    * @param {import('node-ssh').NodeSSH} ssh
    */
@@ -140,7 +213,9 @@ export function createSshProvider(config, envName, env = process.env) {
    * PID-file kill is gated: we only signal a PID if /proc shows our
    * DEPLOYHUB_APP / deployhub.app marker in cmdline or environ. A stale PID
    * reused by an unrelated process is left alone (file still removed).
-   * Marker-based pkill remains the primary stop for live processes.
+   *
+   * Fallback scans /proc/[pid]/environ (and cmdline) for the exact marker -
+   * `pkill -f` cannot see env-only markers from `VAR=value cmd` starts.
    *
    * @param {import('node-ssh').NodeSSH} ssh
    * @param {string} targetPath
@@ -149,30 +224,75 @@ export function createSshProvider(config, envName, env = process.env) {
     const pidFile = `${targetPath}/.deployhub.pid`;
     const markerEnv = `DEPLOYHUB_APP=${appName}`;
     const markerJvm = `deployhub.app=${appName}`;
-    // Verify-then-kill: only signal a PID if /proc shows our marker in cmdline
-    // or environ. A stale PID reused by an unrelated process is left alone
-    // (the pidfile is still removed so the next start writes a fresh one).
+    const markerEnvQ = sh(markerEnv);
+    const markerJvmQ = sh(markerJvm);
+    const markerJvmFlagQ = sh(`-D${markerJvm}`);
+
+    // Verify-then-kill: only signal a PID if /proc shows our exact marker.
+    // Exact (-xF) match so DEPLOYHUB_APP=myapi does not hit myapi-staging.
     await exec(
       ssh,
       `if [ -f ${sh(pidFile)} ]; then ` +
         `pid="$(cat ${sh(pidFile)} 2>/dev/null | tr -cd '0-9')"; ` +
-        `if [ -n "$pid" ] && [ -r "/proc/$pid/cmdline" ]; then ` +
-          `if tr '\\0' ' ' < "/proc/$pid/cmdline" 2>/dev/null | grep -q -F ${sh(markerEnv)} ` +
-          `|| tr '\\0' ' ' < "/proc/$pid/cmdline" 2>/dev/null | grep -q -F ${sh(markerJvm)} ` +
-          `|| { [ -r "/proc/$pid/environ" ] && tr '\\0' ' ' < "/proc/$pid/environ" 2>/dev/null | grep -q -F ${sh(markerEnv)}; }; then ` +
-            `kill "$pid" 2>/dev/null || true; ` +
+        `if [ -n "$pid" ] && [ -d "/proc/$pid" ]; then ` +
+          `matched=0; ` +
+          `if [ -r "/proc/$pid/environ" ] && ${procHasExactMarker(`"/proc/$pid/environ"`, markerEnvQ)}; then matched=1; fi; ` +
+          `if [ "$matched" -eq 0 ] && [ -r "/proc/$pid/cmdline" ]; then ` +
+            `if ${procHasExactMarker(`"/proc/$pid/cmdline"`, markerEnvQ)} ` +
+            `|| ${procHasExactMarker(`"/proc/$pid/cmdline"`, markerJvmFlagQ)} ` +
+            `|| ${procHasExactMarker(`"/proc/$pid/cmdline"`, markerJvmQ)}; then matched=1; fi; ` +
           `fi; ` +
+          `if [ "$matched" -eq 1 ]; then kill "$pid" 2>/dev/null || true; fi; ` +
         `fi; ` +
         `rm -f ${sh(pidFile)}; ` +
-      `fi`
+      `fi`,
+      { timeoutMs: startStopTimeoutMs }
     );
-    // Marker match — covers lost PID files / processes without a readable pidfile.
-    await exec(ssh, `pkill -f ${sh(markerEnv)} || true`);
-    await exec(ssh, `pkill -f ${sh(markerJvm)} || true`);
+
+    // Orphan fallback: no/stale pidfile — find by exact marker in environ or cmdline.
+    await exec(ssh, killByExactMarkersCmd(markerEnvQ, markerJvmQ, markerJvmFlagQ), {
+      timeoutMs: startStopTimeoutMs,
+    });
+  }
+
+  /**
+   * After starting a backend, wait briefly and confirm the PID file's process
+   * is still alive. Not a health check — only catches immediate crash.
+   * `port` is closed over from createSshProvider (settings.port / config.port).
+   *
+   * @param {import('node-ssh').NodeSSH} ssh
+   * @param {string} targetPath
+   * @param {string} [logFile] — defaults to targetPath/app.log
+   */
+  async function assertPidAliveAfterStart(ssh, targetPath, logFile) {
+    const pidFile = `${targetPath}/.deployhub.pid`;
+    const log = logFile || `${targetPath}/app.log`;
+    const verifyCmd =
+      `sleep 2; ` +
+      `pid="$(cat ${sh(pidFile)} 2>/dev/null | tr -cd '0-9')"; ` +
+      `if [ -z "$pid" ] || [ ! -d "/proc/$pid" ]; then ` +
+      `echo "DEPLOYHUB_PROCESS_DIED: process exited immediately after start (pidfile=${sh(pidFile)}). Last lines of ${sh(log)}:"; ` +
+      `tail -n 40 ${sh(log)} 2>/dev/null || echo "(no app.log)"; ` +
+      `exit 1; ` +
+      `fi`;
+
+    try {
+      await exec(ssh, verifyCmd, { timeoutMs: startStopTimeoutMs });
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Backend process for "${appName}" died immediately after start at ${targetPath}. ` +
+          `Check dependencies, entrypoint, and port ${port}.\n${detail}`
+      );
+    }
   }
 
   /**
    * Start a nohup process with DEPLOYHUB_APP marker and write PID file.
+   * Marker is set in environ AND embedded as argv0 via `bash exec -a` so it
+   * appears in /proc/cmdline (pkill -f / cmdline scans can see it). Plain
+   * `VAR=value cmd` alone only puts the marker in environ.
+   *
    * @param {import('node-ssh').NodeSSH} ssh
    * @param {string} targetPath
    * @param {string} command — command body after `nohup` (no trailing &)
@@ -180,10 +300,15 @@ export function createSshProvider(config, envName, env = process.env) {
   async function startScopedNohup(ssh, targetPath, command) {
     const pidFile = `${targetPath}/.deployhub.pid`;
     const dir = sh(targetPath);
+    const markerArg = sh(`DEPLOYHUB_APP=${appName}`);
+    // stdin from /dev/null + redirects: avoid SSH waiting on leftover FDs.
+    // bash exec -a puts DEPLOYHUB_APP=… in argv0 of the real process after exec.
     await exec(
       ssh,
-      `cd ${dir} && DEPLOYHUB_APP=${sh(appName)} nohup ${command} > app.log 2>&1 & echo $! > ${sh(pidFile)}`
+      `cd ${dir} && DEPLOYHUB_APP=${sh(appName)} nohup bash -c 'exec -a "$0" "$@"' ${markerArg} ${command} > app.log 2>&1 </dev/null & echo $! > ${sh(pidFile)}`,
+      { timeoutMs: startStopTimeoutMs }
     );
+    await assertPidAliveAfterStart(ssh, targetPath);
   }
 
   /**
@@ -234,13 +359,22 @@ export function createSshProvider(config, envName, env = process.env) {
           `uvicorn main:app --host 0.0.0.0 --port ${port}`
         );
       } else {
-        // gunicorn --daemon writes its own PID; still set DEPLOYHUB_APP for pkill fallback.
-        const appTarget =
+        // gunicorn --daemon writes the master PID to --pid (same .deployhub.pid).
+        // --error-logfile + --capture-output give us a log to surface on immediate death
+        // (daemonized stdout/stderr otherwise vanish).
+        const logFile = `${targetPath}/app.log`;
+        const fallbackTarget =
           framework === 'django' ? 'config.wsgi:application' : 'app:app';
+        const appTarget =
+          extractGunicornTarget(startCommand) || fallbackTarget;
         await exec(
           ssh,
-          `cd ${dir} && DEPLOYHUB_APP=${sh(appName)} gunicorn ${appTarget} --name ${sh(`deployhub-${appName}`)} --bind 0.0.0.0:${port} --pid ${sh(pidFile)} --daemon`
+          `cd ${dir} && DEPLOYHUB_APP=${sh(appName)} gunicorn ${appTarget} ` +
+            `--name ${sh(`deployhub-${appName}`)} --bind 0.0.0.0:${port} ` +
+            `--pid ${sh(pidFile)} --error-logfile ${sh(logFile)} --capture-output --daemon`,
+          { timeoutMs: startStopTimeoutMs }
         );
+        await assertPidAliveAfterStart(ssh, targetPath, logFile);
       }
       return;
     }
@@ -261,7 +395,7 @@ export function createSshProvider(config, envName, env = process.env) {
     if (framework === 'spring' || framework === 'java') {
       await stopScopedBackendProcess(ssh, targetPath);
       // -Ddeployhub.app= embeds the env-scoped identity in the JVM command line
-      // so pkill -f DEPLOYHUB_APP=… and the PID file both target only this env.
+      // so cmdline marker scans and the PID file both target only this env.
       await startScopedNohup(
         ssh,
         targetPath,

package/src/detectors/backend.detector.js

@@ -1,5 +1,9 @@
 import fs from 'fs-extra';
 import path from 'path';
+import {
+  detectDjangoWsgiTarget,
+  detectFlaskAppTarget,
+} from '../utils/python-app-target.js';
 
 /**
  * @typedef {Object} BackendDetectorResult
@@ -76,6 +80,7 @@ const FRAMEWORKS = {
     defaults: {
       language: 'python',
       buildCommand: null,
+      // Fallback only — getBackendInfo overrides via detectDjangoWsgiTarget(cwd)
       startCommand: 'gunicorn config.wsgi:application --bind 0.0.0.0:8000',
       buildOutput: '.',
       testCommand: 'python manage.py test',
@@ -87,6 +92,7 @@ const FRAMEWORKS = {
     defaults: {
       language: 'python',
       buildCommand: null,
+      // Fallback only — getBackendInfo overrides via detectFlaskAppTarget(cwd)
       startCommand: 'gunicorn app:app --bind 0.0.0.0:5000',
       buildOutput: '.',
       testCommand: 'pytest',
@@ -261,6 +267,7 @@ export function getBackendInfo(framework, cwd = process.cwd()) {
   let buildCommand = def.defaults.buildCommand;
   let startCommand = def.defaults.startCommand;
   let testCommand = def.defaults.testCommand;
+  const port = def.defaults.port;
 
   if (def.defaults.language === 'node') {
     if (scripts.build) buildCommand = 'npm run build';
@@ -268,6 +275,14 @@ export function getBackendInfo(framework, cwd = process.cwd()) {
     if (scripts.test) testCommand = 'npm test';
   }
 
+  if (framework === 'django') {
+    const target = detectDjangoWsgiTarget(cwd);
+    startCommand = `gunicorn ${target} --bind 0.0.0.0:${port}`;
+  } else if (framework === 'flask') {
+    const target = detectFlaskAppTarget(cwd);
+    startCommand = `gunicorn ${target} --bind 0.0.0.0:${port}`;
+  }
+
   return {
     projectType: 'backend',
     framework,
@@ -277,7 +292,7 @@ export function getBackendInfo(framework, cwd = process.cwd()) {
     buildOutput: def.defaults.buildOutput,
     testCommand,
     hasDocker,
-    port: def.defaults.port,
+    port,
   };
 }
 

package/src/detectors/php.js

@@ -6,10 +6,11 @@ function detect(cwd = process.cwd()) {
 }
 
 function getInfo(cwd = process.cwd()) {
+  // Composer install belongs in the install stage, not a compile/build step.
   return {
     framework: 'php',
-    buildCommand: 'composer install --no-dev --optimize-autoloader',
-    buildOutput: 'public',
+    buildCommand: null,
+    buildOutput: '.',
     hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
   };
 }

package/src/detectors/python.js

@@ -11,10 +11,11 @@ function detect(cwd = process.cwd()) {
 
 function getInfo(cwd = process.cwd()) {
   const hasDocker = fs.existsSync(path.join(cwd, 'Dockerfile'));
+  // Deps install belongs in the install stage (pip), not a compile/build step.
   return {
     framework: 'python',
-    buildCommand: 'pip install -r requirements.txt',
-    buildOutput: 'dist',
+    buildCommand: null,
+    buildOutput: '.',
     hasDocker,
   };
 }

package/src/utils/docker-image-deploy.js

@@ -319,9 +319,17 @@ export function createDockerImageDeployContext(config, env = process.env, log) {
 
     let reused = false;
     if (!options.skipImageReuse) {
+      // Normal deploy: prefer pipeline image (exact tag, then :latest retag).
       reused = await ensureImageFromPipeline(imageRef);
+    } else if (await imageExistsLocally(imageRef)) {
+      // Rollback: never retag :latest onto an older buildId, but DO use the
+      // exact restored buildId image if it is already present locally.
+      log.info(`Using restored image ${imageRef} (skipImageReuse — no :latest retag)`);
+      reused = true;
     } else {
-      log.info(`Skipping local image reuse — rebuilding ${imageRef} from artifact`);
+      log.info(
+        `Target image ${imageRef} not found locally — attempting rebuild from artifact`
+      );
     }
 
     let ranCompose = false;