@devramps/cli 0.1.3 → 0.1.4

package/dist/index.js

@@ -74,54 +74,75 @@ var CloudFormationError = class extends DevRampsError {
 // src/utils/logger.ts
 import chalk from "chalk";
 var verboseMode = false;
-var ProgressBar = class {
-  completed = 0;
-  total = 0;
-  label;
-  barWidth = 30;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var MultiStackProgress = class {
+  stacks = /* @__PURE__ */ new Map();
+  stackOrder = [];
   lastLineCount = 0;
-  inProgressResources = /* @__PURE__ */ new Map();
   isTTY;
-  constructor(label, total) {
-    this.label = label;
-    this.total = total;
+  spinnerFrame = 0;
+  spinnerInterval = null;
+  barWidth = 20;
+  constructor() {
     this.isTTY = process.stdout.isTTY ?? false;
+    if (this.isTTY) {
+      this.spinnerInterval = setInterval(() => {
+        this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, 80);
+    }
+  }
+  /**
+   * Register a stack to track
+   */
+  addStack(stackName, accountId, region, totalResources) {
+    this.stacks.set(stackName, {
+      stackName,
+      accountId,
+      region,
+      completed: 0,
+      total: totalResources,
+      status: "pending"
+    });
+    this.stackOrder.push(stackName);
     this.render();
   }
   /**
-   * Update progress with resource status
+   * Update a stack's progress
    */
-  update(completed, resourceStatus) {
-    this.completed = completed;
-    if (resourceStatus) {
-      if (resourceStatus.status === "in_progress") {
-        this.inProgressResources.set(resourceStatus.logicalId, resourceStatus);
-      } else {
-        this.inProgressResources.delete(resourceStatus.logicalId);
-      }
+  updateStack(stackName, completed, status, latestEvent, latestResourceId) {
+    const stack = this.stacks.get(stackName);
+    if (stack) {
+      stack.completed = completed;
+      stack.status = status;
+      if (latestEvent) stack.latestEvent = latestEvent;
+      if (latestResourceId) stack.latestResourceId = latestResourceId;
+      this.render();
     }
-    this.render();
   }
   /**
-   * Set a resource as in-progress
+   * Mark a stack as started
    */
-  setInProgress(logicalId, resourceType) {
-    this.inProgressResources.set(logicalId, {
-      logicalId,
-      resourceType,
-      status: "in_progress"
-    });
-    this.render();
+  startStack(stackName) {
+    const stack = this.stacks.get(stackName);
+    if (stack) {
+      stack.status = "in_progress";
+      this.render();
+    }
   }
   /**
-   * Mark a resource as complete (removes from in-progress)
+   * Mark a stack as complete
    */
-  setComplete(logicalId) {
-    this.inProgressResources.delete(logicalId);
-    this.render();
+  completeStack(stackName, success2) {
+    const stack = this.stacks.get(stackName);
+    if (stack) {
+      stack.status = success2 ? "complete" : "failed";
+      stack.completed = success2 ? stack.total : stack.completed;
+      this.render();
+    }
   }
   /**
-   * Clear the progress bar from the terminal (only for TTY)
+   * Clear the display
    */
   clear() {
     if (!this.isTTY) return;
@@ -131,56 +152,100 @@ var ProgressBar = class {
     this.lastLineCount = 0;
   }
   /**
-   * Finish the progress bar (don't clear - leave final state visible)
+   * Finish and stop updates
    */
   finish() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
     this.clear();
-    this.inProgressResources.clear();
-    const percentage = this.total > 0 ? this.completed / this.total : 0;
+    this.renderFinal();
+  }
+  /**
+   * Render final state (no clearing, just print)
+   */
+  renderFinal() {
+    for (const stackName of this.stackOrder) {
+      const stack = this.stacks.get(stackName);
+      if (!stack) continue;
+      console.log(this.formatStackLine(stack, false));
+    }
+  }
+  /**
+   * Format a single stack line
+   */
+  formatStackLine(stack, withSpinner) {
+    const { accountId, region, stackName, completed, total, status, latestEvent, latestResourceId } = stack;
+    let statusIndicator;
+    let colorFn;
+    switch (status) {
+      case "complete":
+        statusIndicator = "\u2714";
+        colorFn = chalk.green;
+        break;
+      case "failed":
+      case "rollback":
+        statusIndicator = "\u2716";
+        colorFn = chalk.red;
+        break;
+      case "in_progress":
+        statusIndicator = withSpinner ? SPINNER_FRAMES[this.spinnerFrame] : "\u22EF";
+        colorFn = chalk.blue;
+        break;
+      default:
+        statusIndicator = "\u25CB";
+        colorFn = chalk.gray;
+    }
+    const percentage = total > 0 ? completed / total : 0;
     const filled = Math.round(this.barWidth * percentage);
     const empty = this.barWidth - filled;
-    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
-    const count = chalk.cyan(`${this.completed}/${this.total}`);
-    const labelText = chalk.bold(this.label);
-    console.log(`${labelText} ${bar} ${count} resources`);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+    const accountLabel = `[${accountId} - ${region}]`;
+    const countLabel = `(${completed}/${total})`;
+    let eventLabel = "";
+    if (latestEvent && latestResourceId) {
+      const maxEventLen = 30;
+      const resourceIdTrunc = latestResourceId.length > 20 ? latestResourceId.slice(0, 17) + "..." : latestResourceId;
+      eventLabel = ` ${latestEvent} ${resourceIdTrunc}`;
+      if (eventLabel.length > maxEventLen) {
+        eventLabel = eventLabel.slice(0, maxEventLen - 3) + "...";
+      }
+    }
+    const line = `${statusIndicator} ${accountLabel} ${stackName} [${bar}] ${countLabel}${eventLabel}`;
+    return colorFn(line);
   }
   /**
-   * Render the progress bar with in-progress resources
+   * Render all stack progress bars
    */
   render() {
+    if (!this.isTTY) return;
     this.clear();
     const lines = [];
-    const percentage = this.total > 0 ? this.completed / this.total : 0;
-    const filled = Math.round(this.barWidth * percentage);
-    const empty = this.barWidth - filled;
-    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
-    const count = chalk.cyan(`${this.completed}/${this.total}`);
-    const labelText = chalk.bold(this.label);
-    lines.push(`${labelText} ${bar} ${count} resources`);
-    const inProgress = Array.from(this.inProgressResources.values()).slice(0, 8);
-    if (inProgress.length > 0) {
-      for (const resource of inProgress) {
-        const spinner = chalk.yellow("\u22EF");
-        const type = chalk.gray(resource.resourceType);
-        lines.push(`  ${spinner} ${resource.logicalId} ${type}`);
-      }
-      const remaining = this.inProgressResources.size - inProgress.length;
-      if (remaining > 0) {
-        lines.push(chalk.gray(`  ... and ${remaining} more in progress`));
-      }
+    for (const stackName of this.stackOrder) {
+      const stack = this.stacks.get(stackName);
+      if (!stack) continue;
+      lines.push(this.formatStackLine(stack, true));
     }
-    if (this.isTTY) {
-      for (const line of lines) {
-        process.stdout.write(line + "\n");
-      }
-      this.lastLineCount = lines.length;
-    } else {
-      if (this.completed === 0 || this.completed === this.total) {
-        console.log(lines[0]);
-      }
+    for (const line of lines) {
+      process.stdout.write(line + "\n");
     }
+    this.lastLineCount = lines.length;
   }
 };
+var globalProgress = null;
+function getMultiStackProgress() {
+  if (!globalProgress) {
+    globalProgress = new MultiStackProgress();
+  }
+  return globalProgress;
+}
+function clearMultiStackProgress() {
+  if (globalProgress) {
+    globalProgress.finish();
+    globalProgress = null;
+  }
+}
 function setVerbose(enabled) {
   verboseMode = enabled;
 }
@@ -241,18 +306,6 @@ function table(rows) {
 function newline() {
   console.log();
 }
-function resourceProgress(stackName, resourceId, resourceType, status, reason) {
-  const stackLabel = chalk.cyan(`[${stackName}]`);
-  const typeLabel = chalk.gray(resourceType);
-  if (status === "in_progress") {
-    console.log(`${stackLabel} ${chalk.yellow("\u22EF")} ${resourceId} ${typeLabel}`);
-  } else if (status === "complete") {
-    console.log(`${stackLabel} ${chalk.green("\u2714")} ${resourceId} ${typeLabel}`);
-  } else if (status === "failed") {
-    const reasonText = reason ? ` - ${reason}` : "";
-    console.log(`${stackLabel} ${chalk.red("\u2716")} ${resourceId} ${typeLabel}${reasonText}`);
-  }
-}
 
 // src/aws/credentials.ts
 var DEFAULT_REGION = "us-east-1";
@@ -499,13 +552,14 @@ function isResourceComplete(status) {
   if (!status) return false;
   return status.includes("_COMPLETE") && !status.includes("ROLLBACK");
 }
-async function waitForStackWithProgress(client, stackName, operationStartTime, totalResources, maxWaitTime = 600, showProgress = true) {
+async function waitForStackWithProgress(client, stackName, operationStartTime, totalResources, maxWaitTime = 600) {
   const seenEventIds = /* @__PURE__ */ new Set();
   const completedResources = /* @__PURE__ */ new Set();
-  const inProgressResources = /* @__PURE__ */ new Map();
   const startTime = Date.now();
   const pollInterval = 3e3;
-  const progressBar = showProgress ? new ProgressBar(stackName, totalResources) : null;
+  const progress = getMultiStackProgress();
+  let latestEvent = "";
+  let latestResourceId = "";
   try {
     while (true) {
       if (Date.now() - startTime > maxWaitTime * 1e3) {
@@ -531,56 +585,27 @@ async function waitForStackWithProgress(client, stackName, operationStartTime, t
           seenEventIds.add(event.EventId);
         }
         const logicalId = event.LogicalResourceId;
-        const resourceType = event.ResourceType || "Unknown";
         const status = event.ResourceStatus || "";
         if (logicalId && logicalId !== stackName) {
-          if (status.includes("IN_PROGRESS")) {
-            inProgressResources.set(logicalId, { resourceType });
-            if (progressBar) {
-              const resourceStatus = {
-                logicalId,
-                resourceType,
-                status: "in_progress"
-              };
-              progressBar.update(completedResources.size, resourceStatus);
-            } else {
-              resourceProgress(stackName, logicalId, resourceType, "in_progress");
-            }
-          } else if (isResourceComplete(status)) {
+          latestEvent = status;
+          latestResourceId = logicalId;
+          if (isResourceComplete(status)) {
             completedResources.add(logicalId);
-            inProgressResources.delete(logicalId);
-            if (progressBar) {
-              const resourceStatus = {
-                logicalId,
-                resourceType,
-                status: "complete"
-              };
-              progressBar.update(completedResources.size, resourceStatus);
-            } else {
-              resourceProgress(stackName, logicalId, resourceType, "complete");
-            }
-          } else if (status.includes("FAILED") || status.includes("ROLLBACK")) {
-            inProgressResources.delete(logicalId);
-            if (progressBar) {
-              const resourceStatus = {
-                logicalId,
-                resourceType,
-                status: "failed",
-                reason: event.ResourceStatusReason
-              };
-              progressBar.update(completedResources.size, resourceStatus);
-            } else {
-              resourceProgress(stackName, logicalId, resourceType, "failed", event.ResourceStatusReason);
-            }
           }
         }
       }
       const currentStatus = stack.StackStatus || "";
+      let displayStatus = "in_progress";
+      if (currentStatus.includes("ROLLBACK")) {
+        displayStatus = "rollback";
+      } else if (currentStatus.includes("FAILED")) {
+        displayStatus = "failed";
+      }
+      progress.updateStack(stackName, completedResources.size, displayStatus, latestEvent, latestResourceId);
       if (TERMINAL_STATES.has(currentStatus)) {
-        if (progressBar) {
-          progressBar.finish();
-        }
-        if (SUCCESS_STATES.has(currentStatus)) {
+        const success2 = SUCCESS_STATES.has(currentStatus);
+        progress.completeStack(stackName, success2);
+        if (success2) {
           return;
         }
         throw new Error(`Stack operation failed with status: ${currentStatus}`);
@@ -588,39 +613,41 @@ async function waitForStackWithProgress(client, stackName, operationStartTime, t
       await new Promise((resolve) => setTimeout(resolve, pollInterval));
     }
   } catch (error2) {
-    if (progressBar) {
-      progressBar.finish();
-    }
+    progress.completeStack(stackName, false);
     throw error2;
   }
 }
 async function deployStack(options) {
-  const { stackName, template, accountId, region, credentials, showProgress = true } = options;
+  const { stackName, template, accountId, region, credentials } = options;
   const client = new CloudFormationClient({
     credentials,
     region
   });
   const templateBody = JSON.stringify(template);
   const resourceCount = Object.keys(template.Resources || {}).length;
+  const progress = getMultiStackProgress();
+  progress.startStack(stackName);
   try {
     const stackStatus = await getStackStatus(stackName, credentials, region);
     if (stackStatus.exists) {
       verbose(`Stack ${stackName} exists, updating...`);
-      await updateStack(client, stackName, templateBody, accountId, resourceCount, showProgress);
+      await updateStack(client, stackName, templateBody, accountId, resourceCount);
     } else {
       verbose(`Stack ${stackName} does not exist, creating...`);
-      await createStack(client, stackName, templateBody, accountId, resourceCount, showProgress);
+      await createStack(client, stackName, templateBody, accountId, resourceCount);
     }
   } catch (error2) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
     if (errorMessage.includes("No updates are to be performed")) {
       verbose(`Stack ${stackName} is already up to date`);
+      progress.completeStack(stackName, true);
       return;
     }
+    progress.completeStack(stackName, false);
     throw new CloudFormationError(stackName, accountId, errorMessage);
   }
 }
-async function createStack(client, stackName, templateBody, accountId, resourceCount, showProgress = true) {
+async function createStack(client, stackName, templateBody, _accountId, resourceCount) {
   const operationStartTime = /* @__PURE__ */ new Date();
   await client.send(
     new CreateStackCommand({
@@ -633,11 +660,9 @@ async function createStack(client, stackName, templateBody, accountId, resourceC
       ]
     })
   );
-  info(`Creating stack ${stackName}...`);
-  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount, 600, showProgress);
-  success(`Stack ${stackName} created successfully in account ${accountId}`);
+  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount);
 }
-async function updateStack(client, stackName, templateBody, accountId, resourceCount, showProgress = true) {
+async function updateStack(client, stackName, templateBody, _accountId, resourceCount) {
   const operationStartTime = /* @__PURE__ */ new Date();
   await client.send(
     new UpdateStackCommand({
@@ -646,9 +671,7 @@ async function updateStack(client, stackName, templateBody, accountId, resourceC
       Capabilities: ["CAPABILITY_NAMED_IAM"]
     })
   );
-  info(`Updating stack ${stackName}...`);
-  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount, 600, showProgress);
-  success(`Stack ${stackName} updated successfully in account ${accountId}`);
+  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount);
 }
 async function readExistingStack(stackName, accountId, region, credentials) {
   const client = new CloudFormationClient({
@@ -2675,6 +2698,19 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
   header("Deploying All Stacks");
   info(`Deploying ${totalStacks} stack(s) in parallel...`);
   newline();
+  const progress = getMultiStackProgress();
+  progress.addStack(plan.orgStack.stackName, plan.orgStack.accountId, plan.orgStack.region, 5);
+  for (const stack of plan.pipelineStacks) {
+    const resourceCount = stack.dockerArtifacts.length + stack.bundleArtifacts.length;
+    progress.addStack(stack.stackName, stack.accountId, stack.region, Math.max(resourceCount, 1));
+  }
+  for (const stack of plan.accountStacks) {
+    progress.addStack(stack.stackName, stack.accountId, stack.region, 1);
+  }
+  for (const stack of plan.stageStacks) {
+    const resourceCount = stack.dockerArtifacts.length + stack.bundleArtifacts.length + 2;
+    progress.addStack(stack.stackName, stack.accountId, stack.region, resourceCount);
+  }
   const orgPromise = (async () => {
     try {
       await deployOrgStack(plan, pipelines, authData, currentAccountId, options);
@@ -2702,10 +2738,10 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
   const accountPromises = plan.accountStacks.map(async (stack) => {
     try {
       await deployAccountStack(stack, currentAccountId, options);
-      return { stack: `${stack.stackName} (${stack.accountId})`, success: true };
+      return { stack: stack.stackName, success: true };
     } catch (error2) {
       return {
-        stack: `${stack.stackName} (${stack.accountId})`,
+        stack: stack.stackName,
         success: false,
         error: error2 instanceof Error ? error2.message : String(error2)
       };
@@ -2729,6 +2765,7 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
     ...accountPromises,
     ...stagePromises
   ]);
+  clearMultiStackProgress();
   newline();
   for (const result of allResults) {
     if (result.success) {
@@ -2784,9 +2821,7 @@ async function deployOrgStack(plan, pipelines, authData, currentAccountId, optio
     template,
     accountId: cicdAccountId,
     region: cicdRegion,
-    credentials,
-    showProgress: false
-    // Disable progress bar for parallel deployment
+    credentials
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
@@ -2809,9 +2844,7 @@ async function deployPipelineStack(stack, authData, currentAccountId, options) {
     template,
     accountId: cicdAccountId,
     region: cicdRegion,
-    credentials,
-    showProgress: false
-    // Disable progress bar for parallel deployment
+    credentials
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
@@ -2828,9 +2861,7 @@ async function deployAccountStack(stack, currentAccountId, options) {
     template,
     accountId: stack.accountId,
     region: stack.region,
-    credentials,
-    showProgress: false
-    // Disable progress bar for parallel deployment
+    credentials
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
@@ -2856,9 +2887,7 @@ async function deployStageStack(stack, authData, currentAccountId, options) {
     template,
     accountId: stack.accountId,
     region: stack.region,
-    credentials,
-    showProgress: false
-    // Disable progress bar for parallel deployment
+    credentials
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devramps/cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "DevRamps CLI - Bootstrap AWS infrastructure for CI/CD pipelines",
   "main": "dist/index.js",
   "bin": {