@howlil/ez-agents 3.4.2 → 4.0.0

package/bin/lib/deploy/deploy-pre-flight.cjs

@@ -0,0 +1,57 @@
+/**
+ * Deploy Pre-Flight — Runs tests + lint before deploy
+ * Blocks deploy if either fails
+ */
+
+const { execSync } = require('child_process');
+
+class DeployPreFlight {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+  }
+
+  /**
+   * Run pre-flight checks (tests + lint)
+   * @returns {Object} Result { passed, tests, lint, errors }
+   */
+  runPreFlight() {
+    const result = {
+      passed: true,
+      tests: false,
+      lint: false,
+      errors: []
+    };
+
+    // Run tests
+    try {
+      execSync('npm test', { cwd: this.cwd, stdio: 'pipe' });
+      result.tests = true;
+    } catch (e) {
+      result.passed = false;
+      result.errors.push(`Tests failed: ${e.message}`);
+    }
+
+    // Run lint
+    try {
+      execSync('npm run lint', { cwd: this.cwd, stdio: 'pipe' });
+      result.lint = true;
+    } catch (e) {
+      result.passed = false;
+      result.errors.push(`Lint failed: ${e.message}`);
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Run pre-flight checks
+ * @param {string} cwd - Working directory
+ * @returns {Object} Result { passed, tests, lint, errors }
+ */
+function runPreFlight(cwd) {
+  const preFlight = new DeployPreFlight(cwd);
+  return preFlight.runPreFlight();
+}
+
+module.exports = { DeployPreFlight, runPreFlight };

package/bin/lib/deploy/deploy-rollback.cjs

@@ -0,0 +1,72 @@
+/**
+ * Deploy Rollback — Rolls back to previous version
+ * Supports vercel rollback, fly rollback, and git revert
+ */
+
+const { execSync } = require('child_process');
+
+class DeployRollback {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+  }
+
+  /**
+   * Rollback deployment to previous version
+   * @param {string} platform - Platform name
+   * @returns {Object} Rollback result
+   */
+  async rollback(platform) {
+    try {
+      if (platform === 'vercel') {
+        return this.rollbackVercel();
+      } else if (platform === 'fly.io') {
+        return this.rollbackFly();
+      } else {
+        return this.rollbackGit();
+      }
+    } catch (e) {
+      throw new Error(`Rollback failed: ${e.message}`);
+    }
+  }
+
+  /**
+   * Rollback Vercel deployment
+   * @returns {Object} Result
+   */
+  rollbackVercel() {
+    execSync('vercel rollback', { stdio: 'inherit' });
+    return { success: true, platform: 'vercel' };
+  }
+
+  /**
+   * Rollback Fly.io deployment
+   * @returns {Object} Result
+   */
+  rollbackFly() {
+    execSync('fly rollback', { stdio: 'inherit' });
+    return { success: true, platform: 'fly.io' };
+  }
+
+  /**
+   * Generic git revert rollback
+   * @returns {Object} Result
+   */
+  rollbackGit() {
+    execSync('git revert HEAD --no-edit', { cwd: this.cwd, stdio: 'inherit' });
+    execSync('git push origin main', { cwd: this.cwd, stdio: 'inherit' });
+    return { success: true, platform: 'git' };
+  }
+}
+
+/**
+ * Rollback deployment
+ * @param {string} platform - Platform name
+ * @param {string} cwd - Working directory
+ * @returns {Object} Rollback result
+ */
+async function rollback(platform, cwd) {
+  const rollbacker = new DeployRollback(cwd);
+  return rollbacker.rollback(platform);
+}
+
+module.exports = { DeployRollback, rollback };

package/bin/lib/deploy/deploy-runner.cjs

@@ -0,0 +1,97 @@
+/**
+ * Deploy Runner — Executes one-command deploy for multiple platforms
+ * Spawns platform CLI (vercel, flyctl, heroku, railway)
+ */
+
+const { spawn } = require('child_process');
+
+class DeployRunner {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+  }
+
+  /**
+   * Run deployment for specified platform
+   * @param {string} platform - Platform name (vercel, fly.io, heroku, railway)
+   * @param {Object} options - Deploy options
+   * @returns {Promise} Deploy result
+   */
+  async run(platform, options = {}) {
+    const commands = {
+      vercel: ['vercel', '--prod', ...(options.env ? ['--env', options.env] : [])],
+      'fly.io': ['fly', 'deploy', ...(options.env ? ['--env', options.env] : [])],
+      heroku: ['git', 'push', 'heroku', 'main'],
+      railway: ['railway', 'up', ...(options.env ? ['--environment', options.env] : [])]
+    };
+
+    const cmdArgs = commands[platform];
+    if (!cmdArgs) {
+      throw new Error(`Unknown platform: ${platform}`);
+    }
+
+    const [cmd, ...args] = cmdArgs;
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cmd, args, { 
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: this.cwd,
+        timeout: 300000 // 5 minute timeout
+      });
+
+      let output = '';
+      proc.stdout.on('data', (data) => {
+        output += data.toString();
+        if (options.onOutput) options.onOutput(data.toString());
+      });
+      proc.stderr.on('data', (data) => {
+        output += data.toString();
+        if (options.onOutput) options.onOutput(data.toString());
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ success: true, output });
+        } else {
+          reject(new Error(`Deploy failed with code ${code}`));
+        }
+      });
+
+      proc.on('error', reject);
+    });
+  }
+
+  /**
+   * Check if platform CLI is installed
+   * @param {string} platform - Platform name
+   * @returns {boolean} True if installed
+   */
+  isCliInstalled(platform) {
+    const commands = {
+      vercel: 'vercel',
+      'fly.io': 'fly',
+      heroku: 'heroku',
+      railway: 'railway'
+    };
+
+    try {
+      const { execSync } = require('child_process');
+      execSync(`${commands[platform]} --version`, { stdio: 'ignore' });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Run deployment
+ * @param {string} platform - Platform name
+ * @param {Object} options - Deploy options
+ * @returns {Promise} Deploy result
+ */
+async function run(platform, options = {}) {
+  const runner = new DeployRunner();
+  return runner.run(platform, options);
+}
+
+module.exports = { DeployRunner, run };

package/bin/lib/deploy/deploy-status.cjs

@@ -0,0 +1,74 @@
+/**
+ * Deploy Status — Polls deployment status until completion
+ * Polls at 5-second intervals with configurable timeout
+ */
+
+class DeployStatus {
+  constructor() {
+    this.pollInterval = 5000; // 5 seconds
+    this.maxAttempts = 60; // 5 minutes total
+  }
+
+  /**
+   * Poll deployment status until completion or timeout
+   * @param {string} platform - Platform name
+   * @param {string} deploymentId - Deployment ID to poll
+   * @param {Object} options - Polling options
+   * @returns {Object} Status result { status, message }
+   */
+  async pollStatus(platform, deploymentId, options = {}) {
+    const maxAttempts = options.maxAttempts || this.maxAttempts;
+    const interval = options.interval || this.pollInterval;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const status = await this.checkStatus(platform, deploymentId);
+
+      if (status === 'ready' || status === 'success' || status === 'completed') {
+        return { status: 'success', message: 'Deployment ready' };
+      }
+
+      if (status === 'error' || status === 'failed') {
+        return { status: 'failed', message: 'Deployment failed' };
+      }
+
+      // Wait before next poll
+      await this.sleep(interval);
+    }
+
+    return { status: 'timeout', message: 'Deployment polling timed out' };
+  }
+
+  /**
+   * Check current deployment status
+   * @param {string} platform - Platform name
+   * @param {string} deploymentId - Deployment ID
+   * @returns {string} Status: ready, pending, error
+   */
+  async checkStatus(platform, deploymentId) {
+    // Placeholder - would call platform API in real implementation
+    // For now, simulate pending -> ready progression
+    return 'pending';
+  }
+
+  /**
+   * Sleep for specified milliseconds
+   * @param {number} ms - Milliseconds to sleep
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+/**
+ * Poll deployment status
+ * @param {string} platform - Platform name
+ * @param {string} deploymentId - Deployment ID
+ * @param {Object} options - Polling options
+ * @returns {Object} Status result
+ */
+async function pollStatus(platform, deploymentId, options = {}) {
+  const status = new DeployStatus();
+  return status.pollStatus(platform, deploymentId, options);
+}
+
+module.exports = { DeployStatus, pollStatus };