@akash-chowdhury-24/deployhub 2.0.20 → 2.0.22

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']);
@@ -171,8 +172,43 @@ export function createSshProvider(config, envName, env = process.env) {
     await exec(ssh, `pkill -f ${sh(markerJvm)} || true`);
   }
 
+  /**
+   * 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);
+    } 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.
+   * After launch, wait briefly and confirm the PID is still alive — otherwise
+   * surface app.log and fail the deploy (nohup+echo $! alone always "succeeds").
+   *
    * @param {import('node-ssh').NodeSSH} ssh
    * @param {string} targetPath
    * @param {string} command — command body after `nohup` (no trailing &)
@@ -184,6 +220,7 @@ export function createSshProvider(config, envName, env = process.env) {
       ssh,
       `cd ${dir} && DEPLOYHUB_APP=${sh(appName)} nohup ${command} > app.log 2>&1 & echo $! > ${sh(pidFile)}`
     );
+    await assertPidAliveAfterStart(ssh, targetPath);
   }
 
   /**
@@ -234,13 +271,21 @@ 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`
         );
+        await assertPidAliveAfterStart(ssh, targetPath, logFile);
       }
       return;
     }

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;

package/src/utils/python-app-target.js

@@ -0,0 +1,247 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/** Directories to skip when walking for wsgi.py / Flask entrypoints. */
+const SKIP_DIRS = new Set([
+  'venv',
+  '.venv',
+  'env',
+  '.env',
+  'node_modules',
+  '__pycache__',
+  '.git',
+  '.tox',
+  'site-packages',
+  'dist',
+  'build',
+  '.eggs',
+]);
+
+/**
+ * @param {string} startCommand
+ * @returns {string|null} e.g. `myapp.wsgi:application` or `app:app`
+ */
+export function extractGunicornTarget(startCommand) {
+  if (!startCommand || typeof startCommand !== 'string') return null;
+  const tokens = startCommand.trim().split(/\s+/);
+  const gIdx = tokens.findIndex((t) => t === 'gunicorn' || t.endsWith('/gunicorn'));
+  if (gIdx < 0) return null;
+  for (let i = gIdx + 1; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.startsWith('-')) {
+      // skip flag and its value when it looks like `--bind 0.0.0.0:8000`
+      if (
+        t === '-b' ||
+        t === '--bind' ||
+        t === '-c' ||
+        t === '--config' ||
+        t === '-n' ||
+        t === '--name' ||
+        t === '-p' ||
+        t === '--pid' ||
+        t === '-w' ||
+        t === '--workers' ||
+        t === '--chdir' ||
+        t === '-e' ||
+        t === '--env' ||
+        t === '--error-logfile' ||
+        t === '--access-logfile' ||
+        t === '--log-file'
+      ) {
+        i += 1;
+      }
+      continue;
+    }
+    // gunicorn app target is module:callable
+    if (/^[A-Za-z_][\w.]*:[A-Za-z_]\w*$/.test(t)) {
+      return t;
+    }
+  }
+  return null;
+}
+
+/**
+ * Walk cwd for files named `wsgi.py`, skipping venvs etc.
+ * @param {string} cwd
+ * @param {number} [maxDepth]
+ * @returns {string[]} absolute paths
+ */
+function findWsgiFiles(cwd, maxDepth = 4) {
+  /** @type {string[]} */
+  const found = [];
+
+  /**
+   * @param {string} dir
+   * @param {number} depth
+   */
+  function walk(dir, depth) {
+    if (depth > maxDepth || found.length >= 20) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (ent.name.startsWith('.') && ent.name !== '.venv') {
+        // skip hidden except we already skip .venv via SKIP_DIRS
+        if (ent.isDirectory()) continue;
+      }
+      const full = path.join(dir, ent.name);
+      if (ent.isDirectory()) {
+        if (SKIP_DIRS.has(ent.name)) continue;
+        walk(full, depth + 1);
+      } else if (ent.isFile() && ent.name === 'wsgi.py') {
+        found.push(full);
+      }
+    }
+  }
+
+  walk(cwd, 0);
+  return found;
+}
+
+/**
+ * Convert absolute wsgi.py path under cwd to gunicorn target `pkg.wsgi:application`.
+ * @param {string} cwd
+ * @param {string} wsgiAbs
+ * @returns {string|null}
+ */
+export function wsgiPathToGunicornTarget(cwd, wsgiAbs) {
+  const rel = path.relative(cwd, wsgiAbs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  const noExt = rel.replace(/\.py$/i, '');
+  const parts = noExt.split(/[/\\]/).filter(Boolean);
+  if (parts.length === 0) return null;
+  // Invalid if any segment is not a Python identifier
+  if (parts.some((p) => !/^[A-Za-z_]\w*$/.test(p))) return null;
+  return `${parts.join('.')}:application`;
+}
+
+/**
+ * Package directory containing wsgi.py relative to cwd (e.g. `myapp`), or null if root wsgi.py.
+ * @param {string} cwd
+ * @returns {string|null} relative dir name, or '' for root-level wsgi.py, or null if none
+ */
+export function detectDjangoWsgiPackageDir(cwd) {
+  const wsgiAbs = pickPreferredWsgiFile(cwd);
+  if (!wsgiAbs) return null;
+  const rel = path.relative(cwd, path.dirname(wsgiAbs));
+  if (!rel || rel === '.') return '';
+  // Only copy the top-level package segment (myapp/wsgi.py → myapp)
+  const top = rel.split(/[/\\]/)[0];
+  return top || '';
+}
+
+/**
+ * Prefer standard startproject layout (one level down from manage.py), then config/, then any.
+ * @param {string} cwd
+ * @returns {string|null} absolute path to wsgi.py
+ */
+function pickPreferredWsgiFile(cwd) {
+  const files = findWsgiFiles(cwd);
+  if (files.length === 0) return null;
+
+  const hasManage = fs.existsSync(path.join(cwd, 'manage.py'));
+
+  // Prefer <pkg>/wsgi.py directly under cwd when manage.py exists (django-admin startproject)
+  if (hasManage) {
+    const oneLevel = files.filter((f) => {
+      const rel = path.relative(cwd, f);
+      const parts = rel.split(/[/\\]/);
+      return parts.length === 2 && parts[1] === 'wsgi.py';
+    });
+    if (oneLevel.length === 1) return oneLevel[0];
+    // Prefer config/wsgi.py when present among one-level candidates (cookiecutter)
+    const configOne = oneLevel.find((f) => path.basename(path.dirname(f)) === 'config');
+    if (configOne) return configOne;
+    if (oneLevel.length > 0) return oneLevel[0];
+  }
+
+  const configWsgi = files.find((f) => {
+    const rel = path.relative(cwd, f).replace(/\\/g, '/');
+    return rel === 'config/wsgi.py';
+  });
+  if (configWsgi) return configWsgi;
+
+  const rootWsgi = files.find((f) => path.dirname(f) === path.resolve(cwd));
+  if (rootWsgi) return rootWsgi;
+
+  return files[0];
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string} gunicorn target, e.g. `myapp.wsgi:application`
+ */
+export function detectDjangoWsgiTarget(cwd = process.cwd()) {
+  const wsgiAbs = pickPreferredWsgiFile(cwd);
+  if (!wsgiAbs) return 'config.wsgi:application';
+  return wsgiPathToGunicornTarget(cwd, wsgiAbs) || 'config.wsgi:application';
+}
+
+/**
+ * @param {string} filePath
+ * @returns {'app'|'application'|null}
+ */
+function detectFlaskCallableName(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+  // Prefer explicit assignment / factory patterns for `app` then `application`
+  if (
+    /\bapp\s*=\s*/.test(content) ||
+    /\bcreate_app\s*\(/.test(content) ||
+    /\bFlask\s*\(/.test(content)
+  ) {
+    // If both exist, prefer `application` only when `app` is absent as assignment
+    if (/\bapp\s*=\s*/.test(content) || /\bFlask\s*\(/.test(content)) {
+      if (/\bapplication\s*=\s*/.test(content) && !/\bapp\s*=\s*/.test(content)) {
+        return 'application';
+      }
+      return 'app';
+    }
+  }
+  if (/\bapplication\s*=\s*/.test(content)) return 'application';
+  return null;
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string} gunicorn target, e.g. `app:app`
+ */
+export function detectFlaskAppTarget(cwd = process.cwd()) {
+  const candidates = ['app.py', 'wsgi.py', 'application.py'];
+  for (const name of candidates) {
+    const full = path.join(cwd, name);
+    if (!fs.existsSync(full)) continue;
+    const callable = detectFlaskCallableName(full);
+    if (callable) {
+      const mod = name.replace(/\.py$/i, '');
+      return `${mod}:${callable}`;
+    }
+  }
+  // Module package app/__init__.py or app/app.py
+  const pkgInit = path.join(cwd, 'app', '__init__.py');
+  if (fs.existsSync(pkgInit)) {
+    const callable = detectFlaskCallableName(pkgInit);
+    if (callable) return `app:${callable}`;
+  }
+  const pkgApp = path.join(cwd, 'app', 'app.py');
+  if (fs.existsSync(pkgApp)) {
+    const callable = detectFlaskCallableName(pkgApp);
+    if (callable) return `app.app:${callable}`;
+  }
+  return 'app:app';
+}
+
+export default {
+  extractGunicornTarget,
+  detectDjangoWsgiTarget,
+  detectFlaskAppTarget,
+  detectDjangoWsgiPackageDir,
+  wsgiPathToGunicornTarget,
+};