@akash-chowdhury-24/deployhub 2.0.21 → 2.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akash-chowdhury-24/deployhub",
-  "version": "2.0.21",
+  "version": "2.0.23",
   "description": "Zero-configuration deployment and artifact manager",
   "type": "module",
   "main": "./src/cli/index.js",

package/src/adapters/dotnet.adapter.js

@@ -23,8 +23,13 @@ function create(config, cwd) {
     },
 
     async build() {
-      log.info(`Running: ${config.buildCommand}`);
-      const [cmd, ...args] = config.buildCommand.split(' ');
+      const buildCommand = config.buildCommand;
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      log.info(`Running: ${buildCommand}`);
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/go.adapter.js

@@ -22,8 +22,13 @@ function create(config, cwd) {
     },
 
     async build() {
-      log.info(`Running: ${config.buildCommand}`);
-      const [cmd, ...args] = config.buildCommand.split(' ');
+      const buildCommand = config.buildCommand;
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      log.info(`Running: ${buildCommand}`);
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/java.adapter.js

@@ -28,8 +28,13 @@ function create(config, cwd) {
     },
 
     async build() {
-      log.info(`Running: ${config.buildCommand}`);
-      const [cmd, ...args] = config.buildCommand.split(' ');
+      const buildCommand = config.buildCommand;
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      log.info(`Running: ${buildCommand}`);
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/node.adapter.js

@@ -50,13 +50,13 @@ function create(config, cwd) {
         (config.projectType === 'both' ? config.frontend?.buildCommand : null) ||
         (config.projectType === 'backend' ? config.backend?.buildCommand : null);
 
-      if (!buildCommand) {
-        log.info('No build command configured, skipping');
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
         return;
       }
 
       log.info(`Running build: ${buildCommand}`);
-      const [cmd, ...args] = buildCommand.split(' ');
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/php.adapter.js

@@ -25,8 +25,13 @@ function create(config, cwd) {
     },
 
     async build() {
-      log.info(`Running: ${config.buildCommand}`);
-      const [cmd, ...args] = config.buildCommand.split(' ');
+      const buildCommand = config.buildCommand;
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      log.info(`Running: ${buildCommand}`);
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/python.adapter.js

@@ -34,8 +34,13 @@ function create(config, cwd) {
     },
 
     async build() {
-      log.info(`Running: ${config.buildCommand}`);
-      const [cmd, ...args] = config.buildCommand.split(' ');
+      const buildCommand = config.buildCommand;
+      if (buildCommand == null || String(buildCommand).trim() === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      log.info(`Running: ${buildCommand}`);
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

package/src/adapters/rails.adapter.js

@@ -40,13 +40,20 @@ function create(config, cwd) {
     },
 
     async build() {
-      const buildCommand = config.buildCommand || 'bundle exec rails assets:precompile';
-      if (!buildCommand) {
-        log.info('No build command configured, skipping');
+      // Explicit null/"" means skip (API-only Rails, etc.). Undefined keeps the
+      // conventional assets:precompile default from the Rails detector.
+      if (config.buildCommand === null || config.buildCommand === '') {
+        log.info('No build step required — skipping');
+        return;
+      }
+      const buildCommand =
+        config.buildCommand || 'bundle exec rails assets:precompile';
+      if (!String(buildCommand).trim()) {
+        log.info('No build step required — skipping');
         return;
       }
       log.info(`Running build: ${buildCommand}`);
-      const [cmd, ...args] = buildCommand.split(' ');
+      const [cmd, ...args] = String(buildCommand).split(' ');
       await execa(cmd, args, { cwd, stdio: 'inherit', shell: true });
     },
 

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 || {};