@devramps/cli 0.1.6 → 0.1.8

package/dist/index.js

@@ -81,30 +81,54 @@ function getStackKey(stackName, accountId, region) {
 var MultiStackProgress = class {
   stacks = /* @__PURE__ */ new Map();
   stackOrder = [];
-  lastLineCount = 0;
   isTTY;
   spinnerFrame = 0;
   spinnerInterval = null;
   barWidth = 20;
+  renderScheduled = false;
+  lastRenderTime = 0;
+  hasRenderedOnce = false;
+  useAltScreen = true;
+  // Use alternate screen buffer for clean display
+  maxStackNameLen = 40;
+  // Will be calculated dynamically
   constructor() {
     this.isTTY = process.stdout.isTTY ?? false;
+  }
+  /**
+   * Start the progress display (call after all stacks are registered)
+   */
+  start() {
+    this.maxStackNameLen = Math.max(
+      ...Array.from(this.stacks.values()).map((s) => s.stackName.length),
+      20
+      // minimum width
+    );
     if (this.isTTY) {
+      if (this.useAltScreen) {
+        process.stdout.write("\x1B[?1049h");
+      }
+      process.stdout.write("\x1B[?25l");
+      process.stdout.write("\x1B[H");
+      process.stdout.write("\x1B[2J");
+      this.doRender();
       this.spinnerInterval = setInterval(() => {
         this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
-        this.render();
-      }, 80);
+        this.scheduleRender();
+      }, 100);
     }
   }
   /**
    * Register a stack to track
    */
-  addStack(stackName, accountId, region, totalResources) {
+  addStack(stackName, stackType, accountId, region, totalResources) {
     const key = getStackKey(stackName, accountId, region);
     if (this.stacks.has(key)) {
       return;
     }
     this.stacks.set(key, {
       stackName,
+      stackType,
       accountId,
       region,
       completed: 0,
@@ -112,20 +136,19 @@ var MultiStackProgress = class {
       status: "pending"
     });
     this.stackOrder.push(key);
-    this.render();
   }
   /**
    * Update a stack's progress
    */
-  updateStack(stackName, accountId, region, completed, status, latestEvent, latestResourceId) {
+  updateStack(stackName, accountId, region, completed, status, cfnStatus, latestResourceId) {
     const key = getStackKey(stackName, accountId, region);
     const stack = this.stacks.get(key);
     if (stack) {
       stack.completed = completed;
       stack.status = status;
-      if (latestEvent) stack.latestEvent = latestEvent;
+      if (cfnStatus) stack.cfnStatus = cfnStatus;
       if (latestResourceId) stack.latestResourceId = latestResourceId;
-      this.render();
+      this.scheduleRender();
     }
   }
   /**
@@ -136,30 +159,40 @@ var MultiStackProgress = class {
     const stack = this.stacks.get(key);
     if (stack) {
       stack.status = "in_progress";
-      this.render();
+      stack.cfnStatus = "STARTING";
+      this.scheduleRender();
     }
   }
   /**
    * Mark a stack as complete
    */
-  completeStack(stackName, accountId, region, success2) {
+  completeStack(stackName, accountId, region, success2, failureReason) {
     const key = getStackKey(stackName, accountId, region);
     const stack = this.stacks.get(key);
     if (stack) {
       stack.status = success2 ? "complete" : "failed";
       stack.completed = success2 ? stack.total : stack.completed;
-      this.render();
+      if (failureReason) stack.failureReason = failureReason;
+      this.scheduleRender();
     }
   }
   /**
-   * Clear the display
+   * Schedule a render (debounced to prevent too many updates)
    */
-  clear() {
-    if (!this.isTTY) return;
-    for (let i = 0; i < this.lastLineCount; i++) {
-      process.stdout.write("\x1B[A\x1B[2K");
+  scheduleRender() {
+    if (this.renderScheduled) return;
+    const now = Date.now();
+    const timeSinceLastRender = now - this.lastRenderTime;
+    const minInterval = 50;
+    if (timeSinceLastRender >= minInterval) {
+      this.doRender();
+    } else {
+      this.renderScheduled = true;
+      setTimeout(() => {
+        this.renderScheduled = false;
+        this.doRender();
+      }, minInterval - timeSinceLastRender);
     }
-    this.lastLineCount = 0;
   }
   /**
    * Finish and stop updates
@@ -169,7 +202,12 @@ var MultiStackProgress = class {
       clearInterval(this.spinnerInterval);
       this.spinnerInterval = null;
     }
-    this.clear();
+    if (this.isTTY) {
+      process.stdout.write("\x1B[?25h");
+      if (this.useAltScreen) {
+        process.stdout.write("\x1B[?1049l");
+      }
+    }
     this.renderFinal();
   }
   /**
@@ -182,11 +220,26 @@ var MultiStackProgress = class {
       console.log(this.formatStackLine(stack, false));
     }
   }
+  /**
+   * Get a short label for stack type
+   */
+  getTypeLabel(stackType) {
+    switch (stackType) {
+      case "org":
+        return "ORG";
+      case "pipeline":
+        return "PIPE";
+      case "account":
+        return "ACCT";
+      case "stage":
+        return "STAGE";
+    }
+  }
   /**
    * Format a single stack line
    */
   formatStackLine(stack, withSpinner) {
-    const { accountId, region, stackName, completed, total, status, latestEvent, latestResourceId } = stack;
+    const { accountId, region, stackName, stackType, completed, total, status, cfnStatus, latestResourceId, failureReason } = stack;
     let statusIndicator;
     let colorFn;
     switch (status) {
@@ -201,7 +254,7 @@ var MultiStackProgress = class {
         break;
       case "in_progress":
         statusIndicator = withSpinner ? SPINNER_FRAMES[this.spinnerFrame] : "\u22EF";
-        colorFn = chalk.blue;
+        colorFn = chalk.cyanBright;
         break;
       default:
         statusIndicator = "\u25CB";
@@ -211,45 +264,53 @@ var MultiStackProgress = class {
     const filled = Math.round(this.barWidth * percentage);
     const empty = this.barWidth - filled;
     const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
-    const shortAccount = accountId.slice(-4);
-    const accountLabel = `[...${shortAccount}/${region}]`;
-    const countLabel = `(${completed}/${total})`;
-    let eventLabel = "";
-    if (status === "in_progress" && latestEvent && latestResourceId) {
-      const shortStatus = latestEvent.replace("CREATE_", "").replace("UPDATE_", "").replace("DELETE_", "");
-      const resourceIdTrunc = latestResourceId.length > 15 ? latestResourceId.slice(0, 12) + "..." : latestResourceId;
-      eventLabel = ` ${shortStatus} ${resourceIdTrunc}`;
-    }
-    const maxStackNameLen = 40;
-    const displayName = stackName.length > maxStackNameLen ? "..." + stackName.slice(-(maxStackNameLen - 3)) : stackName;
-    const line = `${statusIndicator} ${accountLabel} ${displayName} [${bar}] ${countLabel}${eventLabel}`;
+    const typeLabel = this.getTypeLabel(stackType).padEnd(5);
+    const accountLabel = `${accountId} ${region.padEnd(12)}`;
+    const countLabel = `${completed}/${total}`;
+    const displayName = stackName.padEnd(this.maxStackNameLen);
+    let rightInfo = "";
+    if (status === "failed" || status === "rollback") {
+      const statusText = cfnStatus || "FAILED";
+      if (failureReason && failureReason !== cfnStatus) {
+        const maxLen = 50;
+        const fullReason = `${statusText}: ${failureReason}`;
+        rightInfo = fullReason.length > maxLen ? fullReason.slice(0, maxLen - 3) + "..." : fullReason;
+      } else {
+        rightInfo = statusText;
+      }
+    } else if (status === "in_progress") {
+      const cfnStatusDisplay = cfnStatus || "DEPLOYING";
+      const resourceDisplay = latestResourceId ? latestResourceId.length > 25 ? latestResourceId.slice(0, 22) + "..." : latestResourceId : "";
+      rightInfo = resourceDisplay ? `${cfnStatusDisplay} \u2192 ${resourceDisplay}` : cfnStatusDisplay;
+    } else if (status === "complete") {
+      rightInfo = cfnStatus || "COMPLETE";
+    }
+    const leftPart = `${statusIndicator} [${typeLabel}] ${accountLabel} ${displayName}`;
+    const middlePart = `[${bar}] ${countLabel}`;
+    const line = `${leftPart} ${middlePart} ${rightInfo}`;
     return colorFn(line);
   }
   /**
-   * Render all stack progress bars
+   * Perform the actual render
    */
-  render() {
-    if (this.isRendering) return;
-    this.isRendering = true;
-    try {
-      if (this.isTTY) {
-        this.clear();
-        const lines = [];
-        for (const key of this.stackOrder) {
-          const stack = this.stacks.get(key);
-          if (!stack) continue;
-          lines.push(this.formatStackLine(stack, true));
-        }
-        for (const line of lines) {
-          process.stdout.write(line + "\n");
-        }
-        this.lastLineCount = lines.length;
-      }
-    } finally {
-      this.isRendering = false;
+  doRender() {
+    this.lastRenderTime = Date.now();
+    if (!this.isTTY) return;
+    process.stdout.write("\x1B[H");
+    process.stdout.write(chalk.bold.underline("Deploying Stacks") + "\x1B[K\n\n");
+    for (const key of this.stackOrder) {
+      const stack = this.stacks.get(key);
+      if (!stack) continue;
+      process.stdout.write(this.formatStackLine(stack, true) + "\x1B[K\n");
     }
+    const completed = Array.from(this.stacks.values()).filter((s) => s.status === "complete").length;
+    const failed = Array.from(this.stacks.values()).filter((s) => s.status === "failed" || s.status === "rollback").length;
+    const inProgress = Array.from(this.stacks.values()).filter((s) => s.status === "in_progress").length;
+    const pending = Array.from(this.stacks.values()).filter((s) => s.status === "pending").length;
+    process.stdout.write("\n");
+    process.stdout.write(chalk.gray(`Progress: ${completed} complete, ${inProgress} in progress, ${pending} pending, ${failed} failed`) + "\x1B[K\n");
+    this.hasRenderedOnce = true;
   }
-  isRendering = false;
 };
 var globalProgress = null;
 function getMultiStackProgress() {
@@ -572,14 +633,14 @@ function isResourceComplete(status) {
   if (!status) return false;
   return status.includes("_COMPLETE") && !status.includes("ROLLBACK");
 }
-async function waitForStackWithProgress(client, stackName, accountId, region, operationStartTime, totalResources, maxWaitTime = 600) {
+async function waitForStackWithProgress(client, stackName, accountId, region, operationStartTime, _totalResources, maxWaitTime = 600) {
   const seenEventIds = /* @__PURE__ */ new Set();
   const completedResources = /* @__PURE__ */ new Set();
   const startTime = Date.now();
   const pollInterval = 2e3;
   const progress = getMultiStackProgress();
-  let latestEvent = "";
   let latestResourceId = "";
+  let latestFailureReason = "";
   verbose(`[${stackName}] Starting to wait for stack operation...`);
   try {
     while (true) {
@@ -610,12 +671,15 @@ async function waitForStackWithProgress(client, stackName, accountId, region, op
         const logicalId = event.LogicalResourceId;
         const status = event.ResourceStatus || "";
         if (logicalId && logicalId !== stackName) {
-          latestEvent = status;
           latestResourceId = logicalId;
           verbose(`[${stackName}] Resource ${logicalId}: ${status}`);
           if (isResourceComplete(status)) {
             completedResources.add(logicalId);
           }
+          if (status.includes("FAILED") && event.ResourceStatusReason) {
+            latestFailureReason = `${logicalId}: ${event.ResourceStatusReason}`;
+            verbose(`[${stackName}] Failure reason: ${latestFailureReason}`);
+          }
         }
       }
       let displayStatus = "in_progress";
@@ -624,10 +688,11 @@ async function waitForStackWithProgress(client, stackName, accountId, region, op
       } else if (currentStatus.includes("FAILED")) {
         displayStatus = "failed";
       }
-      progress.updateStack(stackName, accountId, region, completedResources.size, displayStatus, latestEvent, latestResourceId);
+      progress.updateStack(stackName, accountId, region, completedResources.size, displayStatus, currentStatus, latestResourceId);
       if (TERMINAL_STATES.has(currentStatus)) {
         const success2 = SUCCESS_STATES.has(currentStatus);
-        progress.completeStack(stackName, accountId, region, success2);
+        const failureReason = success2 ? void 0 : latestFailureReason || currentStatus;
+        progress.completeStack(stackName, accountId, region, success2, failureReason);
         verbose(`[${stackName}] Reached terminal state: ${currentStatus} (success: ${success2})`);
         if (success2) {
           return;
@@ -2739,18 +2804,19 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
   info(`Deploying ${totalStacks} stack(s) in parallel...`);
   newline();
   const progress = getMultiStackProgress();
-  progress.addStack(plan.orgStack.stackName, plan.orgStack.accountId, plan.orgStack.region, 5);
+  progress.addStack(plan.orgStack.stackName, "org", 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));
+    progress.addStack(stack.stackName, "pipeline", stack.accountId, stack.region, Math.max(resourceCount, 1));
   }
   for (const stack of plan.accountStacks) {
-    progress.addStack(stack.stackName, stack.accountId, stack.region, 1);
+    progress.addStack(stack.stackName, "account", 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);
+    progress.addStack(stack.stackName, "stage", stack.accountId, stack.region, resourceCount);
   }
+  progress.start();
   const orgPromise = (async () => {
     try {
       await deployOrgStack(plan, pipelines, authData, currentAccountId, options);

package/package.json

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