@akash-chowdhury-24/deployhub 2.0.8 → 2.0.9

package/package.json

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

package/src/commands/doctor.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'path';
+import os from 'os';
 import axios from 'axios';
 import { loadConfig, loadEnv } from '../core/config.js';
 import { testProvider } from '../storage/index.js';
@@ -20,6 +21,7 @@ import {
 } from '../utils/shell-quote.js';
 import { formatPasswordlessSudoGuidance } from '../utils/nginx.js';
 import { checkImagePullability } from '../utils/docker-image-deploy.js';
+import { namespaceExists } from '../utils/kubernetes-namespace.js';
 
 /**
  * @typedef {{ name: string, pass: boolean, message: string }} CheckResult
@@ -412,6 +414,42 @@ async function runDeploymentChecks(config, envName, envConfig) {
       })
     );
 
+    checks.push(
+      await runCheck('Kubernetes namespace', async () => {
+        const ns = process.env.KUBE_NAMESPACE || config.project || 'default';
+        const kubeconfig =
+          process.env.KUBECONFIG || path.join(os.homedir(), '.kube', 'config');
+        const context = process.env.KUBE_CONTEXT || '';
+        const expanded = kubeconfig.replace(/^~/, os.homedir());
+        const kubectlEnv = { ...process.env, KUBECONFIG: path.resolve(expanded) };
+
+        /** @param {string[]} baseArgs */
+        function kubectlClusterArgs(baseArgs) {
+          const args = [...baseArgs];
+          if (context) args.push('--context', context);
+          return args;
+        }
+
+        const exists = await namespaceExists(ns, {
+          kubectlArgs: kubectlClusterArgs,
+          getKubectlEnv: () => kubectlEnv,
+        });
+
+        if (exists) {
+          return {
+            name: 'Kubernetes namespace',
+            pass: true,
+            message: `Namespace '${ns}' exists`,
+          };
+        }
+        return {
+          name: 'Kubernetes namespace',
+          pass: true,
+          message: `Namespace '${ns}' does not exist yet — deploy will prompt locally or auto-create in CI (kubectl create namespace ${ns})`,
+        };
+      })
+    );
+
     checks.push(
       await runCheck('Container image pullable', async () => {
         const result = await checkImagePullability(config, process.env);

package/src/deployment/deployment-env.js

@@ -309,7 +309,7 @@ export const DEPLOYMENT_ENV_DEFS = {
       optionalReason: 'defaults to your project name or "default" if unset',
       comment: [
         'Kubernetes namespace for your deployment.',
-        'Create one first if needed: kubectl create namespace my-app',
+        'If missing, deployhub deploy prompts to create it locally (or auto-creates in CI).',
       ],
       example: 'my-app',
       when: 'optional',
@@ -720,7 +720,7 @@ export const DEPLOYMENT_GUIDE = {
     ],
     after: [
       'Ensure your kubeconfig context points to the correct cluster.',
-      'Create namespace if needed: kubectl create namespace YOUR_NAMESPACE',
+      'Namespace is created on first deploy if missing (prompt locally; auto-create in CI). Or: kubectl create namespace YOUR_NAMESPACE',
       'Copy .env.example to .env and set DOCKER_IMAGE_NAME, DOCKER_REGISTRY_USERNAME, and DOCKER_REGISTRY_TOKEN.',
       'Skipping registry credentials will very likely cause ImagePullBackOff — the cluster cannot see local Docker images.',
       'For private registries: also create kubectl create secret docker-registry ... and set KUBE_IMAGE_PULL_SECRET.',

package/src/deployment/providers/kubernetes.js

@@ -5,6 +5,7 @@ import os from 'os';
 import { createLogger } from '../../logger/index.js';
 import { sanitizeK8sName } from '../../utils/kubernetes-manifests.js';
 import { createDockerImageDeployContext } from '../../utils/docker-image-deploy.js';
+import { ensureKubernetesNamespace } from '../../utils/kubernetes-namespace.js';
 
 /**
  * @param {import('../../core/config.js').DeployHubConfig} config
@@ -26,12 +27,22 @@ export function createKubernetesProvider(config, envName, env = process.env) {
   }
 
   /**
+   * Cluster-scoped kubectl args (context only). Used for Namespace get/create.
    * @param {string[]} baseArgs
    */
-  function kubectlArgs(baseArgs) {
+  function kubectlClusterArgs(baseArgs) {
     /** @type {string[]} */
     const args = [...baseArgs];
     if (context) args.push('--context', context);
+    return args;
+  }
+
+  /**
+   * @param {string[]} baseArgs
+   */
+  function kubectlArgs(baseArgs) {
+    /** @type {string[]} */
+    const args = kubectlClusterArgs(baseArgs);
     if (namespace) args.push('--namespace', namespace);
     return args;
   }
@@ -61,6 +72,13 @@ export function createKubernetesProvider(config, envName, env = process.env) {
       );
     }
 
+    await ensureKubernetesNamespace({
+      namespace,
+      log,
+      kubectlArgs: kubectlClusterArgs,
+      getKubectlEnv,
+    });
+
     const applyTarget = (await fs.pathExists(path.join(manifestDir, 'k8s')))
       ? path.join(manifestDir, 'k8s')
       : manifestDir;

package/src/utils/interactive.js

@@ -0,0 +1,27 @@
+/**
+ * Detect whether the CLI can safely prompt the user.
+ * Non-interactive when stdin is not a TTY, or when common CI env vars are set.
+ *
+ * @param {{ env?: NodeJS.ProcessEnv, stdinIsTTY?: boolean|null }} [options]
+ * @returns {boolean}
+ */
+export function isInteractive(options = {}) {
+  const env = options.env || process.env;
+  const stdinIsTTY =
+    options.stdinIsTTY !== undefined ? options.stdinIsTTY : Boolean(process.stdin.isTTY);
+
+  if (env.CI === 'true' || env.CI === '1') return false;
+  if (env.GITHUB_ACTIONS === 'true' || env.GITHUB_ACTIONS === '1') return false;
+  if (!stdinIsTTY) return false;
+  return true;
+}
+
+/**
+ * @param {{ env?: NodeJS.ProcessEnv, stdinIsTTY?: boolean|null }} [options]
+ * @returns {boolean}
+ */
+export function isNonInteractive(options = {}) {
+  return !isInteractive(options);
+}
+
+export default { isInteractive, isNonInteractive };

package/src/utils/kubernetes-namespace.js

@@ -0,0 +1,130 @@
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import { isInteractive } from './interactive.js';
+
+/**
+ * @param {unknown} err
+ * @returns {string}
+ */
+function kubectlErrorDetail(err) {
+  if (err && typeof err === 'object' && 'stderr' in err) {
+    const stderr = String(/** @type {{ stderr?: unknown }} */ (err).stderr || '').trim();
+    if (stderr) return stderr;
+  }
+  if (err instanceof Error && err.message) return err.message;
+  return String(err);
+}
+
+/**
+ * Check whether a namespace exists using a cluster-scoped get that exits 0 for
+ * both found and missing. Non-zero exits (auth, connectivity, bad kubeconfig)
+ * are rethrown — they must not be treated as "not found".
+ *
+ * @param {string} namespace
+ * @param {{
+ *   kubectlArgs?: (args: string[]) => string[],
+ *   getKubectlEnv?: () => NodeJS.ProcessEnv,
+ *   execaFn?: typeof execa,
+ * }} [options]
+ * @returns {Promise<boolean>}
+ */
+export async function namespaceExists(namespace, options = {}) {
+  const kubectlArgs = options.kubectlArgs || ((args) => args);
+  const getKubectlEnv = options.getKubectlEnv || (() => process.env);
+  const execaFn = options.execaFn || execa;
+
+  try {
+    const { stdout } = await execaFn(
+      'kubectl',
+      kubectlArgs(['get', 'namespace', namespace, '--ignore-not-found', '-o', 'name']),
+      {
+        stdio: 'pipe',
+        env: getKubectlEnv(),
+      }
+    );
+    return Boolean(stdout && String(stdout).trim());
+  } catch (err) {
+    throw new Error(
+      `Failed to check whether namespace '${namespace}' exists: ${kubectlErrorDetail(err)}`,
+      { cause: err instanceof Error ? err : undefined }
+    );
+  }
+}
+
+/**
+ * @param {string} namespace
+ * @returns {Promise<boolean>}
+ */
+async function defaultConfirmCreate(namespace) {
+  const { create } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'create',
+      message: `Namespace '${namespace}' does not exist. Create it now?`,
+      default: true,
+    },
+  ]);
+  return Boolean(create);
+}
+
+/**
+ * Ensure the target namespace exists before kubectl apply.
+ * Interactive: prompt to create. CI / non-TTY: auto-create with a clear log.
+ * Connectivity/auth failures from the existence check abort before create/prompt.
+ *
+ * @param {{
+ *   namespace: string,
+ *   log: { info: Function, warn: Function, success: Function, error?: Function },
+ *   kubectlArgs?: (args: string[]) => string[],
+ *   getKubectlEnv?: () => NodeJS.ProcessEnv,
+ *   execaFn?: typeof execa,
+ *   confirmFn?: (namespace: string) => Promise<boolean>,
+ *   interactive?: boolean,
+ * }} options
+ * @returns {Promise<{ existed: boolean, created: boolean }>}
+ */
+export async function ensureKubernetesNamespace(options) {
+  const {
+    namespace,
+    log,
+    kubectlArgs = (args) => args,
+    getKubectlEnv = () => process.env,
+    execaFn = execa,
+    confirmFn = defaultConfirmCreate,
+    interactive = isInteractive(),
+  } = options;
+
+  if (!namespace) {
+    throw new Error('Kubernetes namespace is empty — set KUBE_NAMESPACE or config.project.');
+  }
+
+  // Throws on auth/connectivity/kubeconfig errors — only false means genuine NotFound.
+  if (await namespaceExists(namespace, { kubectlArgs, getKubectlEnv, execaFn })) {
+    return { existed: true, created: false };
+  }
+
+  log.warn(`Namespace '${namespace}' was not found on the cluster.`);
+
+  let shouldCreate = true;
+  if (interactive) {
+    shouldCreate = await confirmFn(namespace);
+    if (!shouldCreate) {
+      throw new Error(
+        `Namespace '${namespace}' does not exist. Create it manually with: kubectl create namespace ${namespace}`
+      );
+    }
+  } else {
+    log.info(
+      `Non-interactive session detected — creating namespace '${namespace}' automatically.`
+    );
+  }
+
+  await execaFn('kubectl', kubectlArgs(['create', 'namespace', namespace]), {
+    stdio: 'inherit',
+    env: getKubectlEnv(),
+  });
+  log.success(`Created namespace '${namespace}'`);
+  return { existed: false, created: true };
+}
+
+export default { namespaceExists, ensureKubernetesNamespace };