@akash-chowdhury-24/deployhub 1.0.0

package/src/commands/artifact.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import {
+  createArtifact,
+  listLocalArtifacts,
+  extractArtifact,
+} from '../artifact/engine.js';
+import { downloadFromFirst } from '../storage/index.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerArtifactCommand(program) {
+  const artifact = program
+    .command('artifact')
+    .description('Manage deployment artifacts');
+
+  artifact
+    .command('create')
+    .description('Create artifact from current build output')
+    .action(async () => {
+      loadEnv();
+      const config = await loadConfig();
+      const result = await createArtifact(config, [], process.cwd());
+      console.log(chalk.green(`Artifact created: ${result.artifactDir}`));
+    });
+
+  artifact
+    .command('list')
+    .description('List all artifacts')
+    .action(async () => {
+      loadEnv();
+      const artifacts = await listLocalArtifacts();
+
+      if (artifacts.length === 0) {
+        console.log(chalk.yellow('No local artifacts found.'));
+        return;
+      }
+
+      console.log(chalk.bold('\nArtifacts:\n'));
+      for (const a of artifacts) {
+        const sizeMb = (a.size / 1024 / 1024).toFixed(2);
+        console.log(
+          `  ${chalk.cyan(a.version)}  ${a.date}  ${a.project}  ${sizeMb} MB`
+        );
+        console.log(chalk.gray(`    ${a.path}`));
+      }
+      console.log('');
+    });
+
+  artifact
+    .command('restore <version>')
+    .description('Download and extract an artifact by version')
+    .action(async (version) => {
+      loadEnv();
+      const config = await loadConfig();
+      const cwd = process.cwd();
+
+      const local = await listLocalArtifacts(cwd);
+      const localMatch = local.find((a) => a.version === version);
+
+      if (localMatch) {
+        const extractTo = path.join(cwd, '.deployhub-restore', `v${version}`);
+        await extractArtifact(localMatch.path, extractTo);
+        console.log(chalk.green(`Restored to ${extractTo}`));
+        return;
+      }
+
+      const remoteKey = `${config.project}/v${version}/artifact.zip`;
+      const restoreDir = path.join(cwd, '.deployhub-restore', `v${version}`);
+      await fs.ensureDir(restoreDir);
+      const zipPath = path.join(restoreDir, 'artifact.zip');
+
+      console.log(`Downloading v${version} from storage...`);
+      const provider = await downloadFromFirst(config.storage, remoteKey, zipPath);
+      console.log(chalk.gray(`Downloaded from ${provider}`));
+
+      const versionDir = path.join(restoreDir, 'artifact');
+      await fs.ensureDir(versionDir);
+      await fs.move(zipPath, path.join(versionDir, 'artifact.zip'));
+      await extractArtifact(versionDir, path.join(restoreDir, 'extracted'));
+      console.log(chalk.green(`Restored to ${restoreDir}`));
+    });
+}
+
+export default { registerArtifactCommand };

package/src/commands/build.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import { runPipeline } from '../core/pipeline.js';
+import { buildPipelineStages } from '../core/stages.js';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerBuildCommand(program) {
+  program
+    .command('build')
+    .description('Run the full build and deploy pipeline')
+    .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);
+      }
+
+      /** @type {Record<string, unknown>} */
+      const state = {};
+      const stages = buildPipelineStages(config, cwd, state);
+      const { completed, failure } = await runPipeline(stages, {
+        config,
+        cwd,
+        state,
+      });
+
+      if (failure) {
+        state.failure = failure.message;
+        console.error(chalk.red(`\nBuild failed: ${failure.message}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green(`\n✓ Pipeline complete (${completed.length} stages)`));
+    });
+}
+
+export default { registerBuildCommand };

package/src/commands/clean.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { loadConfig } from '../core/config.js';
+import { listLocalArtifacts } from '../artifact/engine.js';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerCleanCommand(program) {
+  program
+    .command('clean')
+    .description('Delete old local artifacts beyond retention count')
+    .option('-k, --keep <count>', 'Number of artifacts to keep', '')
+    .action(async (options) => {
+      const cwd = process.cwd();
+      let retention = 10;
+
+      try {
+        const config = await loadConfig(cwd);
+        retention = config.artifactRetention || 10;
+      } catch {
+        // use default
+      }
+
+      if (options.keep) {
+        retention = parseInt(options.keep, 10);
+      }
+
+      const artifacts = await listLocalArtifacts(cwd);
+      if (artifacts.length <= retention) {
+        console.log(
+          chalk.gray(`Nothing to clean (${artifacts.length} artifacts, keeping ${retention})`)
+        );
+        return;
+      }
+
+      const toRemove = artifacts.slice(retention);
+      for (const artifact of toRemove) {
+        await fs.remove(artifact.path);
+        console.log(chalk.gray(`Removed ${artifact.path}`));
+      }
+
+      console.log(
+        chalk.green(`✓ Cleaned ${toRemove.length} old artifact(s), kept ${retention}`)
+      );
+    });
+}
+
+export default { registerCleanCommand };

package/src/commands/deploy.js

@@ -0,0 +1,82 @@
+import chalk from 'chalk';
+import { loadConfig, loadEnv } from '../core/config.js';
+import { runPipeline } from '../core/pipeline.js';
+import { listLocalArtifacts } from '../artifact/engine.js';
+import { deployToAll } from '../deployment/index.js';
+import { sendNotifications } from '../notifications/index.js';
+import axios from 'axios';
+
+/**
+ * @param {import('commander').Command} program
+ */
+export function registerDeployCommand(program) {
+  program
+    .command('deploy')
+    .description('Deploy the latest artifact')
+    .action(async () => {
+      loadEnv();
+      const cwd = process.cwd();
+      const config = await loadConfig(cwd);
+
+      const artifacts = await listLocalArtifacts(cwd);
+      if (artifacts.length === 0) {
+        console.error(chalk.red('No artifacts found. Run deployhub build first.'));
+        process.exit(1);
+      }
+
+      const latest = artifacts[0];
+      /** @type {Record<string, unknown>} */
+      const state = { artifactDir: latest.path };
+
+      const stages = [
+        {
+          name: 'deploy',
+          async run(ctx) {
+            const deployed = await deployToAll(
+              ctx.config,
+              /** @type {string} */ (ctx.state.artifactDir)
+            );
+            ctx.state.deployedTargets = deployed;
+          },
+        },
+        {
+          name: 'verify',
+          enabled: (ctx) => !!ctx.config.healthCheck?.url,
+          async run(ctx) {
+            const url = ctx.config.healthCheck.url;
+            const timeout = (ctx.config.healthCheck.timeout || 30) * 1000;
+            const start = Date.now();
+            const response = await axios.get(url, {
+              timeout,
+              validateStatus: () => true,
+            });
+            const elapsed = Date.now() - start;
+            if (response.status < 200 || response.status >= 400) {
+              throw new Error(`Health check failed: HTTP ${response.status}`);
+            }
+            console.log(chalk.green(`Health check passed: ${response.status} (${elapsed}ms)`));
+          },
+        },
+        {
+          name: 'notify',
+          enabled: (ctx) => ctx.config.pipeline.notify === true,
+          async run(ctx) {
+            await sendNotifications(ctx.config, {
+              success: true,
+              version: latest.version,
+            });
+          },
+        },
+      ];
+
+      const { failure } = await runPipeline(stages, { config, cwd, state });
+      if (failure) {
+        console.error(chalk.red(`Deploy failed: ${failure.message}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('✓ Deployment complete'));
+    });
+}
+
+export default { registerDeployCommand };