@devramps/cli 0.1.6 → 0.1.7

package/dist/index.js

@@ -81,18 +81,34 @@ 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
   constructor() {
     this.isTTY = process.stdout.isTTY ?? false;
+  }
+  /**
+   * Start the progress display (call after all stacks are registered)
+   */
+  start() {
     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);
     }
   }
   /**
@@ -112,20 +128,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 +151,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 +194,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();
   }
   /**
@@ -186,7 +216,7 @@ var MultiStackProgress = class {
    * Format a single stack line
    */
   formatStackLine(stack, withSpinner) {
-    const { accountId, region, stackName, completed, total, status, latestEvent, latestResourceId } = stack;
+    const { accountId, region, stackName, completed, total, status, cfnStatus, latestResourceId, failureReason } = stack;
     let statusIndicator;
     let colorFn;
     switch (status) {
@@ -201,7 +231,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 +241,47 @@ 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 accountLabel = `${accountId} ${region}`;
+    const countLabel = `${completed}/${total}`;
+    const maxStackNameLen = 35;
+    const displayName = stackName.length > maxStackNameLen ? stackName.slice(0, maxStackNameLen - 3) + "..." : stackName.padEnd(maxStackNameLen);
+    let rightInfo = "";
+    if (status === "failed" && failureReason) {
+      const maxLen = 40;
+      rightInfo = failureReason.length > maxLen ? failureReason.slice(0, maxLen - 3) + "..." : failureReason;
+    } else if (status === "in_progress") {
+      const cfnStatusDisplay = cfnStatus || "DEPLOYING";
+      const resourceDisplay = latestResourceId ? latestResourceId.length > 20 ? latestResourceId.slice(0, 17) + "..." : latestResourceId : "";
+      rightInfo = resourceDisplay ? `${cfnStatusDisplay} \u2192 ${resourceDisplay}` : cfnStatusDisplay;
+    } else if (status === "complete") {
+      rightInfo = "COMPLETE";
+    }
+    const leftPart = `${statusIndicator} ${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,13 +604,12 @@ 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 = "";
   verbose(`[${stackName}] Starting to wait for stack operation...`);
   try {
@@ -610,7 +641,6 @@ 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)) {
@@ -624,10 +654,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 : currentStatus;
+        progress.completeStack(stackName, accountId, region, success2, failureReason);
         verbose(`[${stackName}] Reached terminal state: ${currentStatus} (success: ${success2})`);
         if (success2) {
           return;
@@ -2751,6 +2782,7 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
     const resourceCount = stack.dockerArtifacts.length + stack.bundleArtifacts.length + 2;
     progress.addStack(stack.stackName, 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.7",
   "description": "DevRamps CLI - Bootstrap AWS infrastructure for CI/CD pipelines",
   "main": "dist/index.js",
   "bin": {