@akash-chowdhury-24/deployhub 1.0.0

package/src/detectors/node.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  return fs.existsSync(path.join(cwd, 'package.json'));
+}
+
+function getInfo(cwd = process.cwd()) {
+  const pkg = fs.readJsonSync(path.join(cwd, 'package.json'));
+  const scripts = pkg.scripts || {};
+  let buildCommand = 'npm install';
+  if (scripts.build) {
+    buildCommand = 'npm run build';
+  } else if (scripts.start) {
+    buildCommand = 'npm install';
+  }
+  const outputCandidates = ['dist', 'build', 'out', 'public'];
+  const buildOutput =
+    outputCandidates.find((d) => fs.existsSync(path.join(cwd, d))) || 'dist';
+  return {
+    framework: 'node',
+    buildCommand,
+    buildOutput,
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/php.js

@@ -0,0 +1,17 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  return fs.existsSync(path.join(cwd, 'composer.json'));
+}
+
+function getInfo(cwd = process.cwd()) {
+  return {
+    framework: 'php',
+    buildCommand: 'composer install --no-dev --optimize-autoloader',
+    buildOutput: 'public',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/python.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  return (
+    fs.existsSync(path.join(cwd, 'requirements.txt')) ||
+    fs.existsSync(path.join(cwd, 'pyproject.toml')) ||
+    fs.existsSync(path.join(cwd, 'setup.py'))
+  );
+}
+
+function getInfo(cwd = process.cwd()) {
+  const hasDocker = fs.existsSync(path.join(cwd, 'Dockerfile'));
+  return {
+    framework: 'python',
+    buildCommand: 'pip install -r requirements.txt',
+    buildOutput: 'dist',
+    hasDocker,
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/react.js

@@ -0,0 +1,29 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {string} [cwd]
+ */
+function detect(cwd = process.cwd()) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) return false;
+  const pkg = fs.readJsonSync(pkgPath);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return !!(deps.react && !deps.next);
+}
+
+/**
+ * @param {string} [cwd]
+ */
+function getInfo(cwd = process.cwd()) {
+  const pkg = fs.readJsonSync(path.join(cwd, 'package.json'));
+  const scripts = pkg.scripts || {};
+  return {
+    framework: 'react',
+    buildCommand: scripts.build ? 'npm run build' : 'npm run build',
+    buildOutput: fs.existsSync(path.join(cwd, 'dist')) ? 'dist' : 'build',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/vue.js

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) return false;
+  const pkg = fs.readJsonSync(pkgPath);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return !!deps.vue;
+}
+
+function getInfo(cwd = process.cwd()) {
+  const pkg = fs.readJsonSync(path.join(cwd, 'package.json'));
+  const scripts = pkg.scripts || {};
+  return {
+    framework: 'vue',
+    buildCommand: scripts.build ? 'npm run build' : 'npm run build',
+    buildOutput: fs.existsSync(path.join(cwd, 'dist')) ? 'dist' : 'build',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/logger/index.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+
+/**
+ * @param {string} stage
+ * @returns {string}
+ */
+function timestamp() {
+  const now = new Date();
+  const h = String(now.getHours()).padStart(2, '0');
+  const m = String(now.getMinutes()).padStart(2, '0');
+  const s = String(now.getSeconds()).padStart(2, '0');
+  return `${h}:${m}:${s}`;
+}
+
+/**
+ * @param {string} stage
+ * @param {string} message
+ * @param {'info'|'success'|'warn'|'error'} level
+ */
+function log(stage, message, level = 'info') {
+  const prefix = chalk.gray(`[${timestamp()}]`) + chalk.cyan(` [${stage}]`);
+  const colors = {
+    info: chalk.white,
+    success: chalk.green,
+    warn: chalk.yellow,
+    error: chalk.red,
+  };
+  console.log(`${prefix} ${colors[level](message)}`);
+}
+
+/**
+ * @param {string} stage
+ * @returns {{ info: Function, success: Function, warn: Function, error: Function }}
+ */
+export function createLogger(stage) {
+  return {
+    info: (msg) => log(stage, msg, 'info'),
+    success: (msg) => log(stage, msg, 'success'),
+    warn: (msg) => log(stage, msg, 'warn'),
+    error: (msg) => log(stage, msg, 'error'),
+  };
+}
+
+export default { createLogger };

package/src/notifications/email.js

@@ -0,0 +1,53 @@
+import nodemailer from 'nodemailer';
+import { createLogger } from '../logger/index.js';
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ success: boolean, version: string, message?: string, deployUrl?: string, environment?: string }} result
+ */
+export async function sendEmailNotification(config, result) {
+  const log = createLogger('email');
+
+  const host = process.env.SMTP_HOST;
+  const port = parseInt(process.env.SMTP_PORT || '587', 10);
+  const user = process.env.SMTP_USER;
+  const pass = process.env.SMTP_PASS;
+  const to = process.env.NOTIFY_EMAIL_TO || process.env.NOTIFICATION_EMAIL;
+
+  if (!host || !to) {
+    throw new Error('SMTP_HOST and NOTIFY_EMAIL_TO (or NOTIFICATION_EMAIL) must be set');
+  }
+
+  const transporter = nodemailer.createTransport({
+    host,
+    port,
+    secure: port === 465,
+    auth: user && pass ? { user, pass } : undefined,
+  });
+
+  const status = result.success ? 'SUCCESS' : 'FAILED';
+  const environment = result.environment || process.env.DEPLOYHUB_ENV || 'production';
+  const deployUrl = result.deployUrl || config.healthCheck?.url || 'N/A';
+
+  const subject = `[DeployHub] ${status}: ${config.project} v${result.version} (${environment})`;
+  const body = [
+    `Project: ${config.project}`,
+    `Version: ${result.version}`,
+    `Environment: ${environment}`,
+    `Status: ${status}`,
+    `Deploy URL: ${deployUrl}`,
+    '',
+    result.message || (result.success ? 'Deployment completed successfully.' : 'Deployment failed.'),
+  ].join('\n');
+
+  await transporter.sendMail({
+    from: user || `deployhub@${host}`,
+    to,
+    subject,
+    text: body,
+  });
+
+  log.success(`Email notification sent to ${to}`);
+}
+
+export default { sendEmailNotification };

package/src/notifications/index.js

@@ -0,0 +1,34 @@
+import axios from 'axios';
+import { createLogger } from '../logger/index.js';
+import { sendSlackNotification } from './slack.js';
+import { sendEmailNotification } from './email.js';
+import { sendWebhookNotification } from './webhook.js';
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ success: boolean, version: string, message?: string, deployUrl?: string, environment?: string }} result
+ */
+export async function sendNotifications(config, result) {
+  const log = createLogger('notify');
+  const tasks = [];
+
+  if (config.notifications.slack) {
+    tasks.push(sendSlackNotification(result));
+  }
+  if (config.notifications.email) {
+    tasks.push(sendEmailNotification(config, result));
+  }
+  if (config.notifications.webhook) {
+    tasks.push(sendWebhookNotification(result));
+  }
+
+  if (tasks.length === 0) {
+    log.info('No notifications configured');
+    return;
+  }
+
+  await Promise.allSettled(tasks);
+  log.success('Notifications sent');
+}
+
+export default { sendNotifications };

package/src/notifications/slack.js

@@ -0,0 +1,18 @@
+import axios from 'axios';
+
+/**
+ * @param {{ success: boolean, version: string, message?: string }} result
+ */
+export async function sendSlackNotification(result) {
+  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+  if (!webhookUrl) {
+    throw new Error('SLACK_WEBHOOK_URL not set');
+  }
+
+  const status = result.success ? '✅' : '❌';
+  await axios.post(webhookUrl, {
+    text: `${status} DeployHub: v${result.version} — ${result.message || (result.success ? 'Deployment succeeded' : 'Deployment failed')}`,
+  });
+}
+
+export default { sendSlackNotification };

package/src/notifications/webhook.js

@@ -0,0 +1,21 @@
+import axios from 'axios';
+
+/**
+ * @param {{ success: boolean, version: string, message?: string }} result
+ */
+export async function sendWebhookNotification(result) {
+  const url = process.env.WEBHOOK_URL;
+  if (!url) {
+    throw new Error('WEBHOOK_URL not set');
+  }
+
+  await axios.post(url, {
+    event: 'deployhub.deployment',
+    success: result.success,
+    version: result.version,
+    message: result.message,
+    timestamp: new Date().toISOString(),
+  });
+}
+
+export default { sendWebhookNotification };

package/src/rollback/engine.js

@@ -0,0 +1,102 @@
+import { downloadFromFirst } from '../storage/index.js';
+import { createPlatformProvider } from '../deployment/providers/platforms/index.js';
+import { extractArtifact } from '../artifact/engine.js';
+import { createLogger } from '../logger/index.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} artifactDir
+ * @param {string} envName
+ */
+async function rollbackPlatformTarget(config, artifactDir, envName) {
+  const envConfig = config.environments[envName];
+  if (!envConfig) {
+    throw new Error(`Environment "${envName}" not found in config`);
+  }
+
+  const deploymentPath = path.join(artifactDir, 'deployment.json');
+  if (await fs.pathExists(deploymentPath)) {
+    const data = await fs.readJson(deploymentPath);
+    const deployments = data.deployments || data.platformDeployments || [];
+    const record = deployments.find((d) => d.environmentName === envName) || data.lastDeployment;
+    if (record?.platform) {
+      const log = createLogger('rollback');
+      log.info(
+        `Rolling back ${envName} on ${record.platform} (deploy ${record.deployId || record.deploymentId || 'previous'})...`
+      );
+    }
+  }
+
+  if (envConfig.deploymentType === 'platform' || envConfig.frontendDeploymentType === 'platform') {
+    const platform = envConfig.platform;
+    if (!platform) {
+      throw new Error(`No platform configured for environment "${envName}"`);
+    }
+    const provider = createPlatformProvider(platform, config, envName);
+    await provider.rollback(artifactDir);
+    return;
+  }
+
+  if (
+    envConfig.frontendDeploymentType === 'platform' &&
+    (envConfig.backendDeploymentType === 'server' || envConfig.type)
+  ) {
+    const platformProvider = createPlatformProvider(envConfig.platform, config, envName);
+    await platformProvider.rollback(artifactDir);
+    const { getDeploymentProvider } = await import('../deployment/index.js');
+    const serverProvider = getDeploymentProvider(envConfig.type, config, envName);
+    await serverProvider.rollback(artifactDir);
+    return;
+  }
+
+  const { getDeploymentProvider } = await import('../deployment/index.js');
+  const provider = getDeploymentProvider(envConfig.type, config, envName);
+  await provider.rollback(artifactDir);
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} version
+ * @param {string} [cwd]
+ */
+export async function rollbackToVersion(config, version, cwd = process.cwd()) {
+  const log = createLogger('rollback');
+  const remoteKey = `${config.project}/v${version}/artifact.zip`;
+  const restoreDir = path.join(cwd, '.deployhub-restore', `v${version}`);
+  const artifactDir = path.join(restoreDir, 'artifact');
+
+  log.info(`Downloading artifact v${version}...`);
+  await fs.emptyDir(restoreDir);
+  await fs.ensureDir(artifactDir);
+
+  const zipPath = path.join(artifactDir, 'artifact.zip');
+  await downloadFromFirst(config.storage, remoteKey, zipPath);
+
+  log.info('Extracting artifact for rollback...');
+  const extractedDir = path.join(artifactDir, '_extracted');
+  await fs.emptyDir(extractedDir);
+  await extractArtifact(artifactDir, extractedDir);
+
+  const extractedDeployment = path.join(extractedDir, 'deployment.json');
+  if (await fs.pathExists(extractedDeployment)) {
+    await fs.copy(extractedDeployment, path.join(artifactDir, 'deployment.json'));
+  }
+
+  const targets = config.deploy || [];
+  if (targets.length === 0) {
+    log.warn('No deployment targets configured');
+    return artifactDir;
+  }
+
+  log.info('Executing platform-specific rollback from deployment.json...');
+  for (const envName of targets) {
+    await rollbackPlatformTarget(config, artifactDir, envName);
+  }
+
+  log.success(`Rollback to v${version} complete`);
+  return artifactDir;
+}
+
+export default { rollbackToVersion };

package/src/storage/index.js

@@ -0,0 +1,109 @@
+import path from 'path';
+import { createLogger } from '../logger/index.js';
+import { createAwsProvider } from './providers/aws.js';
+import { createLocalProvider } from './providers/local.js';
+import { createAzureProvider } from './providers/azure.js';
+import { createGcpProvider } from './providers/gcp.js';
+import { createGdriveProvider } from './providers/gdrive.js';
+import { createDropboxProvider } from './providers/dropbox.js';
+import { createFtpProvider } from './providers/ftp.js';
+
+/** @type {Record<string, (env?: Record<string, string>) => import('./providers/aws.js').default>} */
+const PROVIDER_FACTORIES = {
+  aws: createAwsProvider,
+  local: createLocalProvider,
+  azure: createAzureProvider,
+  gcp: createGcpProvider,
+  gdrive: createGdriveProvider,
+  dropbox: createDropboxProvider,
+  ftp: createFtpProvider,
+};
+
+/**
+ * @param {string} name
+ * @param {Record<string, string>} [env]
+ */
+export function getStorageProvider(name, env = process.env) {
+  const factory = PROVIDER_FACTORIES[name];
+  if (!factory) {
+    throw new Error(`Unknown storage provider: ${name}`);
+  }
+  return factory(env);
+}
+
+/**
+ * @param {string[]} providers
+ * @param {string} zipPath
+ * @param {import('../core/config.js').DeployHubConfig} config
+ */
+export async function uploadToAll(providers, zipPath, config) {
+  const log = createLogger('storage');
+  const remoteKey = `${config.project}/v${config.version}/artifact.zip`;
+
+  const uploads = providers.map(async (name) => {
+    try {
+      const provider = getStorageProvider(name);
+      log.info(`Uploading to ${name}...`);
+      await provider.upload(zipPath, remoteKey);
+      log.success(`Uploaded to ${name}`);
+      return { name, success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Storage upload to ${name} failed: ${message}`);
+    }
+  });
+
+  return Promise.all(uploads);
+}
+
+/**
+ * @param {string[]} providers
+ * @param {string} remoteKey
+ * @param {string} localPath
+ */
+export async function downloadFromFirst(providers, remoteKey, localPath) {
+  for (const name of providers) {
+    const provider = getStorageProvider(name);
+    const exists = await provider.verify(remoteKey);
+    if (exists) {
+      await provider.download(remoteKey, localPath);
+      return name;
+    }
+  }
+  throw new Error(`Artifact not found in any configured storage provider`);
+}
+
+/**
+ * @param {string} name
+ */
+export async function testProvider(name) {
+  const provider = getStorageProvider(name);
+  await provider.testConnection();
+}
+
+/**
+ * @param {string[]} providers
+ */
+export async function testAllProviders(providers) {
+  const results = await Promise.allSettled(
+    providers.map(async (name) => {
+      await testProvider(name);
+      return { name, status: 'connected' };
+    })
+  );
+
+  return results.map((result, i) => {
+    const name = providers[i];
+    if (result.status === 'fulfilled') {
+      return { name, status: 'connected' };
+    }
+    return {
+      name,
+      status: 'error',
+      error: result.reason?.message || String(result.reason),
+    };
+  });
+}
+
+export { PROVIDER_FACTORIES };
+export default { getStorageProvider, uploadToAll, downloadFromFirst, testProvider, testAllProviders };

package/src/storage/providers/aws.js

@@ -0,0 +1,96 @@
+import { S3Client, HeadBucketCommand, DeleteObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {Record<string, string>} env
+ */
+export function createAwsProvider(env = process.env) {
+  const bucket = env.AWS_BUCKET;
+  const region = env.AWS_REGION || 'us-east-1';
+
+  if (!env.AWS_ACCESS_KEY_ID || !env.AWS_SECRET_ACCESS_KEY || !bucket) {
+    throw new Error(
+      'AWS credentials incomplete. Set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_BUCKET in .env'
+    );
+  }
+
+  const client = new S3Client({
+    region,
+    credentials: {
+      accessKeyId: env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: env.AWS_SECRET_ACCESS_KEY,
+    },
+  });
+
+  /**
+   * @param {string} localPath
+   * @param {string} [remoteKey]
+   */
+  async function upload(localPath, remoteKey) {
+    const key =
+      remoteKey ||
+      path.basename(localPath).replace(/\\/g, '/');
+
+    const fileStream = fs.createReadStream(localPath);
+    const upload = new Upload({
+      client,
+      params: {
+        Bucket: bucket,
+        Key: key,
+        Body: fileStream,
+      },
+    });
+    await upload.done();
+  }
+
+  /**
+   * @param {string} remoteKey
+   * @param {string} localPath
+   */
+  async function download(remoteKey, localPath) {
+    const response = await client.send(
+      new GetObjectCommand({ Bucket: bucket, Key: remoteKey })
+    );
+    await fs.ensureDir(path.dirname(localPath));
+    const body = response.Body;
+    if (!body) throw new Error('Empty response from S3');
+    const chunks = [];
+    for await (const chunk of body) {
+      chunks.push(chunk);
+    }
+    await fs.writeFile(localPath, Buffer.concat(chunks));
+  }
+
+  /**
+   * @param {string} remoteKey
+   */
+  async function verify(remoteKey) {
+    try {
+      await client.send(
+        new GetObjectCommand({ Bucket: bucket, Key: remoteKey })
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * @param {string} remoteKey
+   */
+  async function deleteObject(remoteKey) {
+    await client.send(
+      new DeleteObjectCommand({ Bucket: bucket, Key: remoteKey })
+    );
+  }
+
+  async function testConnection() {
+    await client.send(new HeadBucketCommand({ Bucket: bucket }));
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createAwsProvider };

package/src/storage/providers/azure.js

@@ -0,0 +1,45 @@
+import { BlobServiceClient } from '@azure/storage-blob';
+import fs from 'fs-extra';
+import path from 'path';
+
+export function createAzureProvider(env = process.env) {
+  const connectionString = env.AZURE_CONNECTION_STRING;
+  const container = env.AZURE_CONTAINER;
+
+  if (!connectionString || !container) {
+    throw new Error('Azure credentials incomplete. Set AZURE_CONNECTION_STRING and AZURE_CONTAINER.');
+  }
+
+  const client = BlobServiceClient.fromConnectionString(connectionString);
+  const containerClient = client.getContainerClient(container);
+
+  async function upload(localPath, remoteKey) {
+    const key = remoteKey || path.basename(localPath);
+    const blockBlob = containerClient.getBlockBlobClient(key);
+    await blockBlob.uploadFile(localPath);
+  }
+
+  async function download(remoteKey, localPath) {
+    const blockBlob = containerClient.getBlockBlobClient(remoteKey);
+    await fs.ensureDir(path.dirname(localPath));
+    await blockBlob.downloadToFile(localPath);
+  }
+
+  async function verify(remoteKey) {
+    const blockBlob = containerClient.getBlockBlobClient(remoteKey);
+    return blockBlob.exists();
+  }
+
+  async function deleteObject(remoteKey) {
+    const blockBlob = containerClient.getBlockBlobClient(remoteKey);
+    await blockBlob.deleteIfExists();
+  }
+
+  async function testConnection() {
+    await containerClient.getProperties();
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createAzureProvider };