@devramps/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -74,80 +74,178 @@ var CloudFormationError = class extends DevRampsError {
 // src/utils/logger.ts
 import chalk from "chalk";
 var verboseMode = false;
-var ProgressBar = class {
-  current = 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;
-  eventLines = [];
-  maxVisibleEvents = 5;
-  constructor(label, total) {
-    this.label = label;
-    this.total = total;
+  isTTY;
+  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 and re-render
+   * Update a stack's progress
    */
-  update(current, eventMessage) {
-    this.current = current;
-    if (eventMessage) {
-      this.eventLines.push(eventMessage);
-      if (this.eventLines.length > this.maxVisibleEvents) {
-        this.eventLines.shift();
-      }
+  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();
   }
   /**
-   * Add an event message without changing progress
+   * Mark a stack as started
    */
-  addEvent(message) {
-    this.eventLines.push(message);
-    if (this.eventLines.length > this.maxVisibleEvents) {
-      this.eventLines.shift();
+  startStack(stackName) {
+    const stack = this.stacks.get(stackName);
+    if (stack) {
+      stack.status = "in_progress";
+      this.render();
     }
-    this.render();
   }
   /**
-   * Clear the progress bar from the terminal
+   * Mark a stack as complete
+   */
+  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 display
    */
   clear() {
+    if (!this.isTTY) return;
     for (let i = 0; i < this.lastLineCount; i++) {
       process.stdout.write("\x1B[A\x1B[2K");
     }
     this.lastLineCount = 0;
   }
   /**
-   * Finish and clear the progress bar
+   * Finish and stop updates
    */
   finish() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
     this.clear();
+    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 = "\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
+   * Render all stack progress bars
    */
   render() {
+    if (!this.isTTY) return;
     this.clear();
     const lines = [];
-    for (const event of this.eventLines) {
-      lines.push(event);
+    for (const stackName of this.stackOrder) {
+      const stack = this.stacks.get(stackName);
+      if (!stack) continue;
+      lines.push(this.formatStackLine(stack, true));
     }
-    const percentage = this.total > 0 ? this.current / 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.current}/${this.total}`);
-    const labelText = chalk.bold(this.label);
-    lines.push(`${labelText} ${bar} ${count} resources`);
-    lines.push("");
     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;
 }
@@ -353,7 +451,7 @@ async function previewStackChanges(options) {
   const stackStatus = await getStackStatus(stackName, credentials, region);
   const changeSetName = `devramps-preview-${Date.now()}`;
   if (!stackStatus.exists) {
-    info(`  Stack ${stackName} will be created (new stack)`);
+    info(`  Stack ${stackName} will be created (new stack) in account ${options.accountId} (${region || "default region"})`);
     return;
   }
   try {
@@ -376,7 +474,7 @@ async function previewStackChanges(options) {
         ChangeSetName: changeSetName
       })
     );
-    logStackChanges(stackName, changeSetResponse.Changes || [], stackStatus.exists);
+    logStackChanges(stackName, changeSetResponse.Changes || [], stackStatus.exists, options.accountId, region);
     await client.send(
       new DeleteChangeSetCommand({
         StackName: stackName,
@@ -401,13 +499,13 @@ async function previewStackChanges(options) {
     verbose(`  Could not preview changes for ${stackName}: ${errorMessage}`);
   }
 }
-function logStackChanges(stackName, changes, isUpdate) {
+function logStackChanges(stackName, changes, isUpdate, accountId, region) {
   if (changes.length === 0) {
     verbose(`  Stack ${stackName}: No changes`);
     return;
   }
   const action = isUpdate ? "update" : "create";
-  info(`  Stack ${stackName} will ${action} ${changes.length} resource(s):`);
+  info(`  Stack ${stackName} will ${action} ${changes.length} resource(s) in account ${accountId} (${region || "default region"}):`);
   for (const change of changes) {
     const resourceChange = change.ResourceChange;
     if (!resourceChange) continue;
@@ -450,31 +548,18 @@ var SUCCESS_STATES = /* @__PURE__ */ new Set([
   "CREATE_COMPLETE",
   "UPDATE_COMPLETE"
 ]);
-function getStatusSymbol(status) {
-  if (!status) return "?";
-  if (status.includes("COMPLETE") && !status.includes("ROLLBACK")) return "\u2714";
-  if (status.includes("FAILED") || status.includes("ROLLBACK")) return "\u2716";
-  if (status.includes("IN_PROGRESS")) return "\u22EF";
-  return "?";
-}
-function formatStackEvent(event) {
-  const symbol = getStatusSymbol(event.ResourceStatus);
-  const resourceType = event.ResourceType || "Unknown";
-  const logicalId = event.LogicalResourceId || "Unknown";
-  const status = event.ResourceStatus || "Unknown";
-  const reason = event.ResourceStatusReason ? ` - ${event.ResourceStatusReason}` : "";
-  return `  ${symbol} ${resourceType} (${logicalId}): ${status}${reason}`;
-}
 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 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) {
@@ -500,19 +585,27 @@ async function waitForStackWithProgress(client, stackName, operationStartTime, t
           seenEventIds.add(event.EventId);
         }
         const logicalId = event.LogicalResourceId;
-        if (logicalId && logicalId !== stackName && isResourceComplete(event.ResourceStatus)) {
-          completedResources.add(logicalId);
-        }
-        if (progressBar) {
-          progressBar.update(completedResources.size, formatStackEvent(event));
+        const status = event.ResourceStatus || "";
+        if (logicalId && logicalId !== stackName) {
+          latestEvent = status;
+          latestResourceId = logicalId;
+          if (isResourceComplete(status)) {
+            completedResources.add(logicalId);
+          }
         }
       }
       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}`);
@@ -520,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({
@@ -565,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({
@@ -578,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({
@@ -2548,30 +2639,39 @@ async function showDryRunPlan(plan) {
   info(`CI/CD Account: ${plan.cicdAccountId}`);
   info(`CI/CD Region: ${plan.cicdRegion}`);
   newline();
-  info("Phase 1: Org Stack");
+  info("Org Stack:");
   info(`  ${plan.orgStack.action}: ${plan.orgStack.stackName}`);
-  info(`    Account: ${plan.orgStack.accountId}`);
+  info(`    Account: ${plan.orgStack.accountId}, Region: ${plan.orgStack.region}`);
   info(`    Target accounts with bucket access: ${plan.orgStack.targetAccountIds.length}`);
-  newline();
-  info("Phase 2: Pipeline & Account Stacks (parallel)");
-  for (const stack of plan.pipelineStacks) {
-    info(`  ${stack.action}: ${stack.stackName}`);
-    info(`    ECR repos: ${stack.dockerArtifacts.length}, S3 buckets: ${stack.bundleArtifacts.length}`);
+  if (plan.pipelineStacks.length > 0) {
+    newline();
+    info("Pipeline Stacks:");
+    for (const stack of plan.pipelineStacks) {
+      info(`  ${stack.action}: ${stack.stackName}`);
+      info(`    Account: ${stack.accountId}, Region: ${stack.region}`);
+      info(`    ECR repos: ${stack.dockerArtifacts.length}, S3 buckets: ${stack.bundleArtifacts.length}`);
+    }
   }
-  for (const stack of plan.accountStacks) {
-    info(`  ${stack.action}: ${stack.stackName}`);
-    info(`    Account: ${stack.accountId} (OIDC provider)`);
+  if (plan.accountStacks.length > 0) {
+    newline();
+    info("Account Stacks:");
+    for (const stack of plan.accountStacks) {
+      info(`  ${stack.action}: ${stack.stackName}`);
+      info(`    Account: ${stack.accountId}, Region: ${stack.region} (OIDC provider)`);
+    }
   }
-  newline();
-  info("Phase 3: Stage Stacks (parallel)");
-  for (const stack of plan.stageStacks) {
-    info(`  ${stack.action}: ${stack.stackName}`);
-    info(`    Account: ${stack.accountId}, Region: ${stack.region}`);
-    info(`    ECR repos: ${stack.dockerArtifacts.length}, S3 buckets: ${stack.bundleArtifacts.length}`);
+  if (plan.stageStacks.length > 0) {
+    newline();
+    info("Stage Stacks:");
+    for (const stack of plan.stageStacks) {
+      info(`  ${stack.action}: ${stack.stackName}`);
+      info(`    Account: ${stack.accountId}, Region: ${stack.region}`);
+      info(`    ECR repos: ${stack.dockerArtifacts.length}, S3 buckets: ${stack.bundleArtifacts.length}`);
+    }
   }
   const totalStacks = 1 + plan.pipelineStacks.length + plan.accountStacks.length + plan.stageStacks.length;
   newline();
-  info(`Total stacks to deploy: ${totalStacks}`);
+  info(`Total stacks to deploy (in parallel): ${totalStacks}`);
 }
 async function confirmDeploymentPlan(plan) {
   const totalStacks = 1 + plan.pipelineStacks.length + plan.accountStacks.length + plan.stageStacks.length;
@@ -2593,22 +2693,36 @@ async function confirmDeploymentPlan(plan) {
 }
 async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, currentAccountId, options) {
   const results = { success: 0, failed: 0 };
+  const totalStacks = 1 + plan.pipelineStacks.length + plan.accountStacks.length + plan.stageStacks.length;
   newline();
-  header("Phase 1: Org Stack");
-  try {
-    await deployOrgStack(plan, pipelines, authData, currentAccountId, options);
-    results.success++;
-    success("Org stack deployed successfully");
-  } catch (error2) {
-    results.failed++;
-    error(`Org stack failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    throw error2;
-  }
-  newline();
-  header("Phase 2: Pipeline & Account Stacks (parallel)");
-  const totalPhase2Stacks = plan.pipelineStacks.length + plan.accountStacks.length;
-  info(`Deploying ${totalPhase2Stacks} stack(s) in parallel...`);
+  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);
+      return { stack: plan.orgStack.stackName, success: true };
+    } catch (error2) {
+      return {
+        stack: plan.orgStack.stackName,
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
+    }
+  })();
   const pipelinePromises = plan.pipelineStacks.map(async (stack) => {
     try {
       await deployPipelineStack(stack, authData, currentAccountId, options);
@@ -2624,36 +2738,15 @@ 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)
       };
     }
   });
-  const pipelineResults = await Promise.all(pipelinePromises);
-  const accountResults = await Promise.all(accountPromises);
-  newline();
-  let accountStacksFailed = false;
-  for (const result of [...pipelineResults, ...accountResults]) {
-    if (result.success) {
-      success(`${result.stack} deployed`);
-      results.success++;
-    } else {
-      error(`${result.stack} failed: ${result.error}`);
-      results.failed++;
-    }
-  }
-  accountStacksFailed = accountResults.some((r) => !r.success);
-  if (accountStacksFailed) {
-    warn("Some Account stacks failed. Stage stacks may fail if their account OIDC provider did not deploy.");
-  }
-  newline();
-  header("Phase 3: Stage Stacks (parallel)");
-  info(`Deploying ${plan.stageStacks.length} stack(s) in parallel...`);
-  newline();
   const stagePromises = plan.stageStacks.map(async (stack) => {
     try {
       await deployStageStack(stack, authData, currentAccountId, options);
@@ -2666,9 +2759,15 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
       };
     }
   });
-  const phase3Results = await Promise.all(stagePromises);
+  const allResults = await Promise.all([
+    orgPromise,
+    ...pipelinePromises,
+    ...accountPromises,
+    ...stagePromises
+  ]);
+  clearMultiStackProgress();
   newline();
-  for (const result of phase3Results) {
+  for (const result of allResults) {
     if (result.success) {
       success(`${result.stack} deployed`);
       results.success++;
@@ -2745,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);
@@ -2764,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);
@@ -2792,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.2",
+  "version": "0.1.4",
   "description": "DevRamps CLI - Bootstrap AWS infrastructure for CI/CD pipelines",
   "main": "dist/index.js",
   "bin": {