@akash-chowdhury-24/deployhub 1.0.0

package/src/commands/logs.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { listLocalArtifacts } from '../artifact/engine.js';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerLogsCommand(program) {
+  program
+    .command('logs')
+    .description('Show logs from the last deployment')
+    .action(async () => {
+      const artifacts = await listLocalArtifacts();
+      if (artifacts.length === 0) {
+        console.log(chalk.yellow('No deployment logs found.'));
+        return;
+      }
+
+      const latest = artifacts[0];
+      const logsPath = path.join(latest.path, 'logs.txt');
+
+      if (await fs.pathExists(logsPath)) {
+        const content = await fs.readFile(logsPath, 'utf-8');
+        console.log(chalk.bold(`\nDeployment logs (v${latest.version}):\n`));
+        console.log(content);
+      } else {
+        console.log(chalk.yellow('No logs.txt found in latest artifact.'));
+      }
+    });
+}
+
+export default { registerLogsCommand };

package/src/commands/rollback.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import { rollbackToVersion } from '../rollback/engine.js';
+import axios from 'axios';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerRollbackCommand(program) {
+  program
+    .command('rollback [version]')
+    .description('Rollback to a previous artifact version')
+    .action(async (version) => {
+      loadEnv();
+      const config = await loadConfig();
+
+      if (!version) {
+        const { listLocalArtifacts } = await import('../artifact/engine.js');
+        const artifacts = await listLocalArtifacts();
+        if (artifacts.length < 2) {
+          console.error(chalk.red('No previous version available for rollback'));
+          process.exit(1);
+        }
+        version = artifacts[1].version;
+        console.log(chalk.gray(`Rolling back to previous version: v${version}`));
+      }
+
+      await rollbackToVersion(config, version);
+
+      if (config.healthCheck?.url) {
+        try {
+          const response = await axios.get(config.healthCheck.url, {
+            timeout: (config.healthCheck.timeout || 30) * 1000,
+            validateStatus: () => true,
+          });
+          if (response.status >= 200 && response.status < 400) {
+            console.log(chalk.green(`Health check passed: HTTP ${response.status}`));
+          } else {
+            console.log(chalk.yellow(`Health check returned HTTP ${response.status}`));
+          }
+        } catch (err) {
+          console.log(chalk.yellow(`Health check failed: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+
+      console.log(chalk.green(`✓ Rolled back to v${version}`));
+    });
+}
+
+export default { registerRollbackCommand };

package/src/commands/storage.js

@@ -0,0 +1,116 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { appendEnv, loadEnv } from '../core/config.js';
+import { testProvider, testAllProviders } from '../storage/index.js';
+
+const PROVIDER_PROMPTS = {
+  aws: [
+    { key: 'AWS_ACCESS_KEY_ID', message: 'AWS Access Key ID:' },
+    { key: 'AWS_SECRET_ACCESS_KEY', message: 'AWS Secret Access Key:', type: 'password' },
+    { key: 'AWS_BUCKET', message: 'AWS Bucket name:' },
+    { key: 'AWS_REGION', message: 'AWS Region:', default: 'us-east-1' },
+  ],
+  azure: [
+    { key: 'AZURE_CONNECTION_STRING', message: 'Azure Connection String:', type: 'password' },
+    { key: 'AZURE_CONTAINER', message: 'Azure Container name:' },
+  ],
+  gcp: [
+    { key: 'GCP_PROJECT_ID', message: 'GCP Project ID:' },
+    { key: 'GCP_KEY_FILE', message: 'Path to GCP key file:' },
+    { key: 'GCP_BUCKET', message: 'GCP Bucket name:' },
+  ],
+  gdrive: [
+    { key: 'GDRIVE_CLIENT_ID', message: 'Google Drive Client ID:' },
+    { key: 'GDRIVE_CLIENT_SECRET', message: 'Google Drive Client Secret:', type: 'password' },
+    { key: 'GDRIVE_REFRESH_TOKEN', message: 'Google Drive Refresh Token:', type: 'password' },
+    { key: 'GDRIVE_FOLDER_ID', message: 'Google Drive Folder ID (optional):' },
+  ],
+  dropbox: [
+    { key: 'DROPBOX_ACCESS_TOKEN', message: 'Dropbox Access Token:', type: 'password' },
+  ],
+  ftp: [
+    { key: 'FTP_HOST', message: 'FTP Host:' },
+    { key: 'FTP_USER', message: 'FTP User:' },
+    { key: 'FTP_PASSWORD', message: 'FTP Password:', type: 'password' },
+    { key: 'FTP_PORT', message: 'FTP Port:', default: '21' },
+  ],
+  local: [],
+};
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerStorageCommand(program) {
+  const storage = program
+    .command('storage')
+    .description('Manage storage providers');
+
+  storage
+    .command('add <provider>')
+    .description('Add credentials for a storage provider')
+    .action(async (provider) => {
+      loadEnv();
+      const prompts = PROVIDER_PROMPTS[provider];
+      if (!prompts) {
+        console.error(chalk.red(`Unknown provider: ${provider}`));
+        console.log('Available: aws, azure, gcp, gdrive, dropbox, local, ftp');
+        process.exit(1);
+      }
+
+      if (prompts.length === 0) {
+        console.log(chalk.green('Local storage requires no credentials.'));
+        return;
+      }
+
+      const questions = prompts.map((p) => ({
+        type: p.type || 'input',
+        name: p.key,
+        message: p.message,
+        default: p.default,
+      }));
+
+      const answers = await inquirer.prompt(questions);
+      await appendEnv(answers);
+
+      for (const [key, value] of Object.entries(answers)) {
+        process.env[key] = value;
+      }
+
+      console.log('Testing connection...');
+      try {
+        await testProvider(provider);
+        console.log(chalk.green(`✓ ${provider} connected successfully`));
+      } catch (err) {
+        console.error(
+          chalk.red(`✗ Connection failed: ${err instanceof Error ? err.message : String(err)}`)
+        );
+        process.exit(1);
+      }
+    });
+
+  storage
+    .command('list')
+    .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 results = await testAllProviders(config.storage);
+      console.log(chalk.bold('\nStorage Providers:\n'));
+      for (const r of results) {
+        const icon = r.status === 'connected' ? chalk.green('✓') : chalk.red('✗');
+        const extra = r.error ? chalk.gray(` (${r.error})`) : '';
+        console.log(`  ${icon} ${r.name}${extra}`);
+      }
+      console.log('');
+    });
+}
+
+export default { registerStorageCommand };

package/src/commands/update.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { execa } from 'execa';
+import semver from 'semver';
+
+const PACKAGE_NAME = 'deployhub';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerUpdateCommand(program) {
+  program
+    .command('update')
+    .description('Check for and install updates to DeployHub')
+    .action(async () => {
+      console.log(chalk.gray('Checking for updates...'));
+
+      let latest;
+      try {
+        const { stdout } = await execa('npm', ['view', PACKAGE_NAME, 'version'], {
+          stdio: 'pipe',
+        });
+        latest = stdout.trim();
+      } catch {
+        console.log(
+          chalk.yellow(
+            'Could not check npm registry. DeployHub may not be published yet.'
+          )
+        );
+        return;
+      }
+
+      const current = '1.0.0';
+
+      if (!semver.gt(latest, current)) {
+        console.log(chalk.green(`✓ DeployHub is up to date (v${current})`));
+        return;
+      }
+
+      console.log(chalk.yellow(`Update available: v${current} → v${latest}`));
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Install deployhub@${latest}?`,
+          default: true,
+        },
+      ]);
+
+      if (!confirm) {
+        console.log(chalk.gray('Update cancelled.'));
+        return;
+      }
+
+      await execa('npm', ['install', '-g', `${PACKAGE_NAME}@${latest}`], {
+        stdio: 'inherit',
+      });
+      console.log(chalk.green(`✓ Updated to v${latest}`));
+    });
+}
+
+export default { registerUpdateCommand };

package/src/commands/verify.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import axios from 'axios';
+import { loadConfig, loadEnv } from '../core/config.js';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerVerifyCommand(program) {
+  program
+    .command('verify')
+    .description('Run health check on configured endpoint')
+    .action(async () => {
+      loadEnv();
+      const config = await loadConfig();
+      const url = config.healthCheck?.url;
+
+      if (!url) {
+        console.error(chalk.red('No health check URL configured in deployhub.config.json'));
+        process.exit(1);
+      }
+
+      const timeout = (config.healthCheck.timeout || 30) * 1000;
+      const start = Date.now();
+
+      try {
+        const response = await axios.get(url, {
+          timeout,
+          validateStatus: () => true,
+        });
+        const elapsed = Date.now() - start;
+        const ok = response.status >= 200 && response.status < 400;
+
+        if (ok) {
+          console.log(
+            chalk.green(`✓ Health check passed: HTTP ${response.status} (${elapsed}ms)`)
+          );
+        } else {
+          console.log(
+            chalk.red(`✗ Health check failed: HTTP ${response.status} (${elapsed}ms)`)
+          );
+          process.exit(1);
+        }
+      } catch (err) {
+        const elapsed = Date.now() - start;
+        console.error(
+          chalk.red(
+            `✗ Health check failed: ${err instanceof Error ? err.message : String(err)} (${elapsed}ms)`
+          )
+        );
+        process.exit(1);
+      }
+    });
+}
+
+export default { registerVerifyCommand };

package/src/core/config.js

@@ -0,0 +1,168 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { z } from 'zod';
+import dotenv from 'dotenv';
+
+const SideConfigSchema = z.object({
+  framework: z.string(),
+  language: z.string().optional(),
+  buildCommand: z.string().nullable().optional(),
+  startCommand: z.string().nullable().optional(),
+  buildOutput: z.string().optional(),
+  port: z.number().optional(),
+});
+
+const EnvironmentSchema = z.object({
+  type: z.string().optional(),
+  deploymentType: z.enum(['platform', 'server']).optional(),
+  platform: z.string().optional(),
+  projectName: z.string().optional(),
+  siteId: z.string().optional(),
+  accountId: z.string().optional(),
+  appId: z.string().optional(),
+  region: z.string().optional(),
+  githubConnected: z.boolean().optional(),
+  resourceName: z.string().optional(),
+  projectId: z.string().optional(),
+  backendName: z.string().optional(),
+  frontendDeploymentType: z.enum(['platform', 'server']).optional(),
+  backendDeploymentType: z.enum(['server']).optional(),
+  host: z.string().optional(),
+  user: z.string().optional(),
+  path: z.string().optional(),
+  deployPath: z.string().optional(),
+  keyPath: z.string().optional(),
+  appName: z.string().optional(),
+  framework: z.string().optional(),
+  port: z.number().optional(),
+  frontendDeployPath: z.string().optional(),
+  backendDeployPath: z.string().optional(),
+});
+
+const ConfigSchema = z.object({
+  project: z.string(),
+  version: z.string().optional(),
+  projectType: z.enum(['frontend', 'backend', 'both']).default('frontend'),
+  framework: z.string().optional(),
+  language: z.string().optional(),
+  buildCommand: z.string().nullable().optional(),
+  startCommand: z.string().nullable().optional(),
+  buildOutput: z.string().optional(),
+  port: z.number().optional(),
+  frontend: SideConfigSchema.optional(),
+  backend: SideConfigSchema.optional(),
+  docker: z.boolean().default(false),
+  artifact: z.boolean().default(true),
+  storage: z.array(z.string()).default(['local']),
+  deploy: z.array(z.string()).default([]),
+  environments: z.record(EnvironmentSchema).default({}),
+  healthCheck: z
+    .object({
+      url: z.string().default(''),
+      timeout: z.number().default(30),
+    })
+    .default({}),
+  notifications: z
+    .object({
+      slack: z.boolean().default(false),
+      email: z.boolean().default(false),
+      webhook: z.boolean().default(false),
+    })
+    .default({}),
+  pipeline: z
+    .object({
+      test: z.boolean().default(true),
+      docker: z.boolean().default(false),
+      deploy: z.boolean().default(false),
+      verify: z.boolean().default(true),
+      notify: z.boolean().default(false),
+    })
+    .default({}),
+  artifactRetention: z.number().default(10),
+  cli: z
+    .object({
+      source: z.string().default('npm:deployhub'),
+    })
+    .default({}),
+});
+
+/** @typedef {z.infer<typeof ConfigSchema>} DeployHubConfig */
+
+const CONFIG_FILENAME = 'deployhub.config.json';
+
+/**
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export function getConfigPath(cwd = process.cwd()) {
+  return path.join(cwd, CONFIG_FILENAME);
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {Promise<DeployHubConfig>}
+ */
+export async function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!(await fs.pathExists(configPath))) {
+    throw new Error(
+      `Config not found at ${configPath}. Run "deployhub init" first.`
+    );
+  }
+  const raw = await fs.readJson(configPath);
+  const parsed = ConfigSchema.parse(raw);
+
+  if (!parsed.framework && parsed.projectType === 'frontend') {
+    parsed.framework = 'node';
+  }
+  if (parsed.buildCommand === undefined && parsed.projectType !== 'backend') {
+    parsed.buildCommand = 'npm run build';
+  }
+  if (!parsed.buildOutput) {
+    parsed.buildOutput = parsed.projectType === 'backend' ? '.' : 'dist';
+  }
+  if (!parsed.version) {
+    parsed.version = '0.0.0';
+  }
+
+  return parsed;
+}
+
+/**
+ * @param {DeployHubConfig} config
+ * @param {string} [cwd]
+ */
+export async function saveConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+/**
+ * @param {string} [cwd]
+ */
+export function loadEnv(cwd = process.cwd()) {
+  dotenv.config({ path: path.join(cwd, '.env') });
+}
+
+/**
+ * @param {Record<string, string>} vars
+ * @param {string} [cwd]
+ */
+export async function appendEnv(vars, cwd = process.cwd()) {
+  const envPath = path.join(cwd, '.env');
+  const lines = [];
+  for (const [key, value] of Object.entries(vars)) {
+    if (value) {
+      lines.push(`${key}=${value}`);
+    }
+  }
+  if (lines.length === 0) return;
+
+  const existing = (await fs.pathExists(envPath))
+    ? await fs.readFile(envPath, 'utf-8')
+    : '';
+  const separator = existing && !existing.endsWith('\n') ? '\n' : '';
+  await fs.appendFile(envPath, `${separator}${lines.join('\n')}\n`);
+}
+
+export { ConfigSchema };

package/src/core/pipeline.js

@@ -0,0 +1,77 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { createLogger } from '../logger/index.js';
+
+/**
+ * @typedef {Object} PipelineContext
+ * @property {import('./config.js').DeployHubConfig} config
+ * @property {string} cwd
+ * @property {Record<string, unknown>} state
+ */
+
+/**
+ * @typedef {Object} PipelineStage
+ * @property {string} name
+ * @property {function(PipelineContext): Promise<void>} run
+ * @property {function(PipelineContext): boolean} [enabled]
+ */
+
+/** @type {string[]} */
+export const ALL_STAGES = [
+  'detect',
+  'install',
+  'test',
+  'build',
+  'docker',
+  'artifact',
+  'storage',
+  'deploy',
+  'verify',
+  'notify',
+];
+
+/**
+ * @param {PipelineStage[]} stages
+ * @param {PipelineContext} context
+ */
+export async function runPipeline(stages, context) {
+  const log = createLogger('pipeline');
+  /** @type {string[]} */
+  const completed = [];
+  /** @type {Error|null} */
+  let failure = null;
+
+  for (const stage of stages) {
+    if (stage.enabled && !stage.enabled(context)) {
+      log.info(`Skipping stage: ${stage.name} (disabled)`);
+      continue;
+    }
+
+    if (stage.name === 'deploy' && !completed.includes('storage')) {
+      throw new Error(
+        'Deploy requires storage upload to complete first. Configure at least one storage provider.'
+      );
+    }
+
+    const spinner = ora({
+      text: `Running ${stage.name}...`,
+      color: 'cyan',
+    }).start();
+
+    try {
+      await stage.run(context);
+      spinner.succeed(chalk.green(`${stage.name} complete`));
+      completed.push(stage.name);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      spinner.fail(chalk.red(`${stage.name} failed: ${message}`));
+      failure = err instanceof Error ? err : new Error(message);
+      log.error(`Pipeline stopped at stage: ${stage.name}`);
+      break;
+    }
+  }
+
+  return { completed, failure };
+}
+
+export default { runPipeline, ALL_STAGES };