@akash-chowdhury-24/deployhub 1.0.0

package/src/deployment/providers/platforms/aws-amplify.js

@@ -0,0 +1,164 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { createLogger } from '../../../logger/index.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  readPreviousPlatformDeployment,
+  checkUrlHealth,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createAwsAmplifyProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('aws-amplify');
+  const appId = environment?.appId || env.AMPLIFY_APP_ID;
+  const region = environment?.region || env.AWS_REGION || 'us-east-1';
+  const githubConnected = environment?.githubConnected ?? false;
+
+  async function deploy(artifactDir) {
+    if (!appId) throw new Error('AMPLIFY_APP_ID is required');
+
+    const awsEnv = {
+      AWS_ACCESS_KEY_ID: env.AWS_ACCESS_KEY_ID || '',
+      AWS_SECRET_ACCESS_KEY: env.AWS_SECRET_ACCESS_KEY || '',
+      AWS_DEFAULT_REGION: region,
+    };
+
+    if (githubConnected) {
+      log.info('Triggering Amplify release job (GitHub connected)...');
+      const result = await runCli(
+        `aws amplify start-job --app-id ${appId} --branch-name main --job-type RELEASE`,
+        process.cwd(),
+        awsEnv
+      );
+      if (result.exitCode !== 0) {
+        throw new Error(`Amplify start-job failed: ${result.stderr || result.stdout}`);
+      }
+
+      const jobMatch = (result.stdout || '').match(/"jobId":\s*"([^"]+)"/);
+      const jobId = jobMatch?.[1] || '';
+
+      await saveDeploymentRecord(
+        artifactDir,
+        {
+          platform: 'aws-amplify',
+          deploymentId: jobId,
+          appId,
+          method: 'github',
+        },
+        envName
+      );
+      log.success(`Amplify job started: ${jobId || 'RELEASE'}`);
+      return;
+    }
+
+    log.info('Uploading artifact zip to Amplify...');
+    const zipPath = path.join(artifactDir, 'artifact.zip');
+    if (!(await fs.pathExists(zipPath))) {
+      throw new Error('artifact.zip not found for Amplify upload');
+    }
+
+    const createResult = await runCli(
+      `aws amplify create-deployment --app-id ${appId} --branch-name main --output json`,
+      process.cwd(),
+      awsEnv
+    );
+    if (createResult.exitCode !== 0) {
+      throw new Error(`Amplify create-deployment failed: ${createResult.stderr}`);
+    }
+
+    const deployment = JSON.parse(createResult.stdout);
+    const jobId = deployment.jobId;
+    const zipUploadUrl = deployment.zipUploadUrl;
+
+    await execa('curl', ['-T', zipPath, zipUploadUrl], {
+      env: { ...process.env, ...awsEnv },
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    const startResult = await runCli(
+      `aws amplify start-deployment --app-id ${appId} --branch-name main --job-id ${jobId}`,
+      process.cwd(),
+      awsEnv
+    );
+    if (startResult.exitCode !== 0) {
+      throw new Error(`Amplify start-deployment failed: ${startResult.stderr}`);
+    }
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'aws-amplify',
+        deploymentId: jobId,
+        appId,
+        method: 'zip',
+      },
+      envName
+    );
+    log.success(`Amplify deployment started: job ${jobId}`);
+  }
+
+  async function rollback(artifactDir) {
+    if (!appId) throw new Error('AMPLIFY_APP_ID is required');
+
+    const previous = await readPreviousPlatformDeployment(artifactDir);
+    const jobId = previous?.deploymentId;
+    if (!jobId) {
+      throw new Error('No previous Amplify job ID found for rollback');
+    }
+
+    const awsEnv = {
+      AWS_ACCESS_KEY_ID: env.AWS_ACCESS_KEY_ID || '',
+      AWS_SECRET_ACCESS_KEY: env.AWS_SECRET_ACCESS_KEY || '',
+      AWS_DEFAULT_REGION: region,
+    };
+
+    log.info(`Re-triggering Amplify job ${jobId}...`);
+    const result = await runCli(
+      `aws amplify start-job --app-id ${appId} --branch-name main --job-id ${jobId} --job-type RETRY`,
+      process.cwd(),
+      awsEnv
+    );
+    if (result.exitCode !== 0) {
+      await runCli(
+        `aws amplify start-job --app-id ${appId} --branch-name main --job-type RELEASE`,
+        process.cwd(),
+        awsEnv
+      );
+    }
+    log.success('Amplify rollback triggered');
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!appId) throw new Error('AMPLIFY_APP_ID is required');
+    const result = await runCli(
+      `aws amplify get-app --app-id ${appId}`,
+      process.cwd(),
+      {
+        AWS_ACCESS_KEY_ID: env.AWS_ACCESS_KEY_ID || '',
+        AWS_SECRET_ACCESS_KEY: env.AWS_SECRET_ACCESS_KEY || '',
+        AWS_DEFAULT_REGION: region,
+      }
+    );
+    if (result.exitCode !== 0) {
+      throw new Error('Could not find Amplify app — check AMPLIFY_APP_ID and AWS credentials');
+    }
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createAwsAmplifyProvider };

package/src/deployment/providers/platforms/azure-static-web-apps.js

@@ -0,0 +1,68 @@
+import { createLogger } from '../../../logger/index.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  readPreviousPlatformDeployment,
+  checkUrlHealth,
+  resolveBuildOutputPath,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createAzureStaticWebAppsProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('azure-swa');
+  const token = env.AZURE_STATIC_WEB_APPS_TOKEN;
+  const resourceName = environment?.resourceName || config.project;
+
+  async function deploy(artifactDir) {
+    if (!token) throw new Error('AZURE_STATIC_WEB_APPS_TOKEN is required');
+
+    const buildDir = resolveBuildOutputPath(config);
+    log.info(`Deploying to Azure Static Web Apps (${resourceName})...`);
+
+    const result = await runCli(
+      `swa deploy "${buildDir}" --deployment-token=${token}`,
+      process.cwd()
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Azure SWA deploy failed: ${result.stderr || result.stdout}`);
+    }
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'azure-static-web-apps',
+        deploymentId: `swa-${Date.now()}`,
+        resourceName,
+        deploymentUrl: config.healthCheck?.url || '',
+      },
+      envName
+    );
+
+    log.success('Deployed to Azure Static Web Apps');
+  }
+
+  async function rollback(artifactDir) {
+    log.info('Azure SWA has no native rollback — re-deploying previous artifact...');
+    await deploy(artifactDir);
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!token) throw new Error('AZURE_STATIC_WEB_APPS_TOKEN is required');
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createAzureStaticWebAppsProvider };

package/src/deployment/providers/platforms/cloudflare-pages.js

@@ -0,0 +1,103 @@
+import axios from 'axios';
+import { createLogger } from '../../../logger/index.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  readPreviousPlatformDeployment,
+  checkUrlHealth,
+  resolveBuildOutputPath,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createCloudflarePagesProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('cloudflare-pages');
+  const apiToken = env.CLOUDFLARE_API_TOKEN;
+  const accountId = environment?.accountId || env.CLOUDFLARE_ACCOUNT_ID;
+  const projectName =
+    environment?.projectName || env.CF_PROJECT_NAME || config.project;
+
+  async function deploy(artifactDir) {
+    if (!apiToken || !accountId) {
+      throw new Error('CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID are required');
+    }
+
+    const buildDir = resolveBuildOutputPath(config);
+    log.info(`Deploying to Cloudflare Pages project "${projectName}"...`);
+
+    const result = await runCli(
+      `wrangler pages deploy "${buildDir}" --project-name=${projectName} --branch=main`,
+      process.cwd(),
+      {
+        CLOUDFLARE_API_TOKEN: apiToken,
+        CLOUDFLARE_ACCOUNT_ID: accountId,
+      }
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Cloudflare Pages deploy failed: ${result.stderr || result.stdout}`);
+    }
+
+    const urlMatch = (result.stdout || '').match(/https:\/\/[^\s]+\.pages\.dev/);
+    const deploymentUrl = urlMatch?.[0] || config.healthCheck?.url || '';
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'cloudflare-pages',
+        deploymentUrl,
+        deploymentId: deploymentUrl,
+        projectName,
+        accountId,
+      },
+      envName
+    );
+
+    log.success(`Deployed to Cloudflare Pages: ${deploymentUrl || projectName}`);
+  }
+
+  async function rollback(artifactDir) {
+    if (!apiToken || !accountId) {
+      throw new Error('CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID are required');
+    }
+
+    const previous = await readPreviousPlatformDeployment(artifactDir);
+    const deploymentId = previous?.deploymentId;
+    if (!deploymentId) {
+      throw new Error('No previous Cloudflare deployment ID found for rollback');
+    }
+
+    log.info('Rolling back Cloudflare Pages deployment...');
+    await axios.post(
+      `https://api.cloudflare.com/client/v4/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/rollback`,
+      {},
+      { headers: { Authorization: `Bearer ${apiToken}` } }
+    );
+    log.success('Cloudflare Pages rollback complete');
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!apiToken) throw new Error('CLOUDFLARE_API_TOKEN is required');
+    const response = await axios.get(
+      'https://api.cloudflare.com/client/v4/user/tokens/verify',
+      { headers: { Authorization: `Bearer ${apiToken}` } }
+    );
+    if (!response.data?.success) {
+      throw new Error('Invalid CLOUDFLARE_API_TOKEN');
+    }
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createCloudflarePagesProvider };

package/src/deployment/providers/platforms/firebase-app-hosting.js

@@ -0,0 +1,95 @@
+import { createLogger } from '../../../logger/index.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  checkUrlHealth,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createFirebaseAppHostingProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('firebase-app-hosting');
+  const token = env.FIREBASE_TOKEN;
+  const projectId = environment?.projectId || env.FIREBASE_PROJECT_ID;
+  const backendName =
+    environment?.backendName || env.FIREBASE_APP_HOSTING_BACKEND || config.project;
+
+  async function deploy(artifactDir) {
+    if (!token || !projectId) {
+      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
+    }
+
+    log.info(`Deploying to Firebase App Hosting (${projectId}/${backendName})...`);
+
+    const createResult = await runCli(
+      `firebase apphosting:backends:list --project=${projectId} --token=${token} --non-interactive`,
+      process.cwd()
+    );
+
+    const backendExists =
+      createResult.exitCode === 0 && createResult.stdout.includes(backendName);
+
+    if (!backendExists) {
+      log.info(`Creating App Hosting backend "${backendName}"...`);
+      await runCli(
+        `firebase apphosting:backends:create --project=${projectId} --token=${token} --backend=${backendName} --non-interactive`,
+        process.cwd()
+      );
+    }
+
+    const result = await runCli(
+      `firebase deploy --only apphosting --token=${token} --project=${projectId} --non-interactive`,
+      process.cwd()
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Firebase App Hosting deploy failed: ${result.stderr || result.stdout}`);
+    }
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'firebase-app-hosting',
+        deploymentId: `apphosting-${Date.now()}`,
+        projectId,
+        backendName,
+        deploymentUrl: config.healthCheck?.url || '',
+      },
+      envName
+    );
+
+    log.success('Deployed to Firebase App Hosting');
+  }
+
+  async function rollback(artifactDir) {
+    log.info('Firebase App Hosting rollback — re-deploying previous artifact...');
+    await deploy(artifactDir);
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!token || !projectId) {
+      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
+    }
+    const result = await runCli(
+      `firebase projects:list --token=${token} --non-interactive`,
+      process.cwd()
+    );
+    if (result.exitCode !== 0) {
+      throw new Error('Invalid FIREBASE_TOKEN');
+    }
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createFirebaseAppHostingProvider };

package/src/deployment/providers/platforms/firebase-hosting.js

@@ -0,0 +1,99 @@
+import { createLogger } from '../../../logger/index.js';
+import { ensureFirebaseJson } from '../../../utils/firebase-config-generator.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  readPreviousPlatformDeployment,
+  checkUrlHealth,
+  getBuildOutputDir,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createFirebaseHostingProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('firebase-hosting');
+  const token = env.FIREBASE_TOKEN;
+  const projectId = environment?.projectId || env.FIREBASE_PROJECT_ID;
+
+  async function deploy(artifactDir) {
+    if (!token || !projectId) {
+      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
+    }
+
+    const cwd = process.cwd();
+    const buildOutput = getBuildOutputDir(config);
+    await ensureFirebaseJson(buildOutput, cwd);
+
+    log.info(`Deploying to Firebase Hosting (${projectId})...`);
+    const result = await runCli(
+      `firebase deploy --only hosting --token=${token} --project=${projectId} --non-interactive`,
+      cwd
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Firebase deploy failed: ${result.stderr || result.stdout}`);
+    }
+
+    const urlMatch = (result.stdout || '').match(/Hosting URL:\s*(https:\/\/\S+)/i);
+    const deploymentUrl = urlMatch?.[1] || config.healthCheck?.url || '';
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'firebase-hosting',
+        deploymentUrl,
+        deploymentId: deploymentUrl,
+        projectId,
+      },
+      envName
+    );
+
+    log.success(`Deployed to Firebase Hosting: ${deploymentUrl || projectId}`);
+  }
+
+  async function rollback(artifactDir) {
+    if (!token || !projectId) {
+      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
+    }
+
+    log.info('Rolling back Firebase Hosting...');
+    const result = await runCli(
+      `firebase hosting:rollback --token=${token} --project=${projectId} --non-interactive`,
+      process.cwd()
+    );
+    if (result.exitCode !== 0) {
+      throw new Error(`Firebase rollback failed: ${result.stderr || result.stdout}`);
+    }
+    log.success('Firebase Hosting rollback complete');
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!token || !projectId) {
+      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
+    }
+    const result = await runCli(
+      `firebase projects:list --token=${token} --non-interactive`,
+      process.cwd()
+    );
+    if (result.exitCode !== 0) {
+      throw new Error('Invalid FIREBASE_TOKEN');
+    }
+    if (!result.stdout.includes(projectId)) {
+      throw new Error(`Firebase project "${projectId}" not accessible`);
+    }
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createFirebaseHostingProvider };

package/src/deployment/providers/platforms/index.js

@@ -0,0 +1,44 @@
+import { createVercelProvider } from './vercel.js';
+import { createNetlifyProvider } from './netlify.js';
+import { createCloudflarePagesProvider } from './cloudflare-pages.js';
+import { createAwsAmplifyProvider } from './aws-amplify.js';
+import { createAzureStaticWebAppsProvider } from './azure-static-web-apps.js';
+import { createFirebaseHostingProvider } from './firebase-hosting.js';
+import { createFirebaseAppHostingProvider } from './firebase-app-hosting.js';
+
+/** @type {Record<string, Function>} */
+const PLATFORM_FACTORIES = {
+  vercel: createVercelProvider,
+  netlify: createNetlifyProvider,
+  'cloudflare-pages': createCloudflarePagesProvider,
+  'aws-amplify': createAwsAmplifyProvider,
+  'azure-static-web-apps': createAzureStaticWebAppsProvider,
+  'firebase-hosting': createFirebaseHostingProvider,
+  'firebase-app-hosting': createFirebaseAppHostingProvider,
+};
+
+/**
+ * @param {string} platform
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createPlatformProvider(platform, config, envName, env = process.env) {
+  const factory = PLATFORM_FACTORIES[platform];
+  if (!factory) {
+    throw new Error(`Unknown platform: ${platform}`);
+  }
+  return factory(config, envName, env);
+}
+
+export {
+  createVercelProvider,
+  createNetlifyProvider,
+  createCloudflarePagesProvider,
+  createAwsAmplifyProvider,
+  createAzureStaticWebAppsProvider,
+  createFirebaseHostingProvider,
+  createFirebaseAppHostingProvider,
+};
+
+export default { createPlatformProvider, PLATFORM_FACTORIES };

package/src/deployment/providers/platforms/netlify.js

@@ -0,0 +1,102 @@
+import axios from 'axios';
+import { createLogger } from '../../../logger/index.js';
+import {
+  runCli,
+  saveDeploymentRecord,
+  readPreviousPlatformDeployment,
+  checkUrlHealth,
+  resolveBuildOutputPath,
+} from './_shared.js';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function createNetlifyProvider(config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  const log = createLogger('netlify');
+  const authToken = env.NETLIFY_AUTH_TOKEN;
+  const siteId = environment?.siteId || env.NETLIFY_SITE_ID;
+
+  async function deploy(artifactDir) {
+    if (!authToken || !siteId) {
+      throw new Error('NETLIFY_AUTH_TOKEN and NETLIFY_SITE_ID are required');
+    }
+
+    const buildDir = resolveBuildOutputPath(config);
+    log.info(`Deploying to Netlify from ${buildDir}...`);
+
+    const result = await runCli(
+      `netlify deploy --prod --dir="${buildDir}" --auth=${authToken} --site=${siteId}`,
+      process.cwd()
+    );
+
+    if (result.exitCode !== 0) {
+      throw new Error(`Netlify deploy failed: ${result.stderr || result.stdout}`);
+    }
+
+    const deployIdMatch = (result.stdout || '').match(/Deploy ID:\s*(\S+)/i);
+    const urlMatch = (result.stdout || '').match(/Website URL:\s*(https:\/\/\S+)/i);
+    const deployId = deployIdMatch?.[1] || '';
+    const deploymentUrl = urlMatch?.[1] || config.healthCheck?.url || '';
+
+    await saveDeploymentRecord(
+      artifactDir,
+      {
+        platform: 'netlify',
+        deploymentUrl,
+        deploymentId: deployId,
+        siteId,
+      },
+      envName
+    );
+
+    log.success(`Deployed to Netlify: ${deploymentUrl || siteId}`);
+  }
+
+  async function rollback(artifactDir) {
+    if (!authToken || !siteId) {
+      throw new Error('NETLIFY_AUTH_TOKEN and NETLIFY_SITE_ID are required');
+    }
+
+    const previous = await readPreviousPlatformDeployment(artifactDir);
+    const deployId = previous?.deploymentId;
+    if (!deployId) {
+      throw new Error('No previous Netlify deployment ID found for rollback');
+    }
+
+    log.info(`Restoring Netlify deploy ${deployId}...`);
+    await axios.post(
+      `https://api.netlify.com/api/v1/sites/${siteId}/deploys/${deployId}/restore`,
+      {},
+      { headers: { Authorization: `Bearer ${authToken}` } }
+    );
+    log.success('Netlify rollback complete');
+  }
+
+  async function healthCheck() {
+    const url = config.healthCheck?.url;
+    if (!url) return true;
+    return checkUrlHealth(url);
+  }
+
+  async function testConnection() {
+    if (!authToken) throw new Error('NETLIFY_AUTH_TOKEN is required');
+    const response = await axios.get('https://api.netlify.com/api/v1/user', {
+      headers: { Authorization: `Bearer ${authToken}` },
+    });
+    if (!response.data?.email) {
+      throw new Error('Invalid NETLIFY_AUTH_TOKEN');
+    }
+    if (siteId) {
+      await axios.get(`https://api.netlify.com/api/v1/sites/${siteId}`, {
+        headers: { Authorization: `Bearer ${authToken}` },
+      });
+    }
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createNetlifyProvider };