@devramps/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -74,6 +74,113 @@ 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;
+  lastLineCount = 0;
+  inProgressResources = /* @__PURE__ */ new Map();
+  isTTY;
+  constructor(label, total) {
+    this.label = label;
+    this.total = total;
+    this.isTTY = process.stdout.isTTY ?? false;
+    this.render();
+  }
+  /**
+   * Update progress with resource status
+   */
+  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);
+      }
+    }
+    this.render();
+  }
+  /**
+   * Set a resource as in-progress
+   */
+  setInProgress(logicalId, resourceType) {
+    this.inProgressResources.set(logicalId, {
+      logicalId,
+      resourceType,
+      status: "in_progress"
+    });
+    this.render();
+  }
+  /**
+   * Mark a resource as complete (removes from in-progress)
+   */
+  setComplete(logicalId) {
+    this.inProgressResources.delete(logicalId);
+    this.render();
+  }
+  /**
+   * Clear the progress bar from the terminal (only for TTY)
+   */
+  clear() {
+    if (!this.isTTY) return;
+    for (let i = 0; i < this.lastLineCount; i++) {
+      process.stdout.write("\x1B[A\x1B[2K");
+    }
+    this.lastLineCount = 0;
+  }
+  /**
+   * Finish the progress bar (don't clear - leave final state visible)
+   */
+  finish() {
+    this.clear();
+    this.inProgressResources.clear();
+    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);
+    console.log(`${labelText} ${bar} ${count} resources`);
+  }
+  /**
+   * Render the progress bar with in-progress resources
+   */
+  render() {
+    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`));
+      }
+    }
+    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]);
+      }
+    }
+  }
+};
 function setVerbose(enabled) {
   verboseMode = enabled;
 }
@@ -134,6 +241,18 @@ 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";
@@ -234,13 +353,12 @@ import {
   CloudFormationClient,
   DescribeStacksCommand,
   DescribeStackResourcesCommand,
+  DescribeStackEventsCommand,
   CreateStackCommand,
   UpdateStackCommand,
   CreateChangeSetCommand,
   DescribeChangeSetCommand,
   DeleteChangeSetCommand,
-  waitUntilStackCreateComplete,
-  waitUntilStackUpdateComplete,
   waitUntilChangeSetCreateComplete,
   ChangeSetType
 } from "@aws-sdk/client-cloudformation";
@@ -280,7 +398,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 {
@@ -303,7 +421,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,
@@ -328,13 +446,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;
@@ -361,21 +479,137 @@ function getActionSymbol(action) {
       return " ";
   }
 }
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "CREATE_COMPLETE",
+  "CREATE_FAILED",
+  "DELETE_COMPLETE",
+  "DELETE_FAILED",
+  "ROLLBACK_COMPLETE",
+  "ROLLBACK_FAILED",
+  "UPDATE_COMPLETE",
+  "UPDATE_FAILED",
+  "UPDATE_ROLLBACK_COMPLETE",
+  "UPDATE_ROLLBACK_FAILED"
+]);
+var SUCCESS_STATES = /* @__PURE__ */ new Set([
+  "CREATE_COMPLETE",
+  "UPDATE_COMPLETE"
+]);
+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) {
+  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;
+  try {
+    while (true) {
+      if (Date.now() - startTime > maxWaitTime * 1e3) {
+        throw new Error(`Stack operation timed out after ${maxWaitTime} seconds`);
+      }
+      const stackResponse = await client.send(
+        new DescribeStacksCommand({ StackName: stackName })
+      );
+      const stack = stackResponse.Stacks?.[0];
+      if (!stack) {
+        throw new Error(`Stack ${stackName} not found`);
+      }
+      const eventsResponse = await client.send(
+        new DescribeStackEventsCommand({ StackName: stackName })
+      );
+      const newEvents = (eventsResponse.StackEvents || []).filter((event) => {
+        if (!event.Timestamp || event.Timestamp < operationStartTime) return false;
+        if (!event.EventId || seenEventIds.has(event.EventId)) return false;
+        return true;
+      }).reverse();
+      for (const event of newEvents) {
+        if (event.EventId) {
+          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)) {
+            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 || "";
+      if (TERMINAL_STATES.has(currentStatus)) {
+        if (progressBar) {
+          progressBar.finish();
+        }
+        if (SUCCESS_STATES.has(currentStatus)) {
+          return;
+        }
+        throw new Error(`Stack operation failed with status: ${currentStatus}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  } catch (error2) {
+    if (progressBar) {
+      progressBar.finish();
+    }
+    throw error2;
+  }
+}
 async function deployStack(options) {
-  const { stackName, template, accountId, region, credentials } = options;
+  const { stackName, template, accountId, region, credentials, showProgress = true } = options;
   const client = new CloudFormationClient({
     credentials,
     region
   });
   const templateBody = JSON.stringify(template);
+  const resourceCount = Object.keys(template.Resources || {}).length;
   try {
     const stackStatus = await getStackStatus(stackName, credentials, region);
     if (stackStatus.exists) {
       verbose(`Stack ${stackName} exists, updating...`);
-      await updateStack(client, stackName, templateBody, accountId);
+      await updateStack(client, stackName, templateBody, accountId, resourceCount, showProgress);
     } else {
       verbose(`Stack ${stackName} does not exist, creating...`);
-      await createStack(client, stackName, templateBody, accountId);
+      await createStack(client, stackName, templateBody, accountId, resourceCount, showProgress);
     }
   } catch (error2) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
@@ -386,7 +620,8 @@ async function deployStack(options) {
     throw new CloudFormationError(stackName, accountId, errorMessage);
   }
 }
-async function createStack(client, stackName, templateBody, accountId) {
+async function createStack(client, stackName, templateBody, accountId, resourceCount, showProgress = true) {
+  const operationStartTime = /* @__PURE__ */ new Date();
   await client.send(
     new CreateStackCommand({
       StackName: stackName,
@@ -398,14 +633,12 @@ async function createStack(client, stackName, templateBody, accountId) {
       ]
     })
   );
-  verbose(`Waiting for stack ${stackName} to be created...`);
-  await waitUntilStackCreateComplete(
-    { client, maxWaitTime: 600 },
-    { StackName: stackName }
-  );
+  info(`Creating stack ${stackName}...`);
+  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount, 600, showProgress);
   success(`Stack ${stackName} created successfully in account ${accountId}`);
 }
-async function updateStack(client, stackName, templateBody, accountId) {
+async function updateStack(client, stackName, templateBody, accountId, resourceCount, showProgress = true) {
+  const operationStartTime = /* @__PURE__ */ new Date();
   await client.send(
     new UpdateStackCommand({
       StackName: stackName,
@@ -413,11 +646,8 @@ async function updateStack(client, stackName, templateBody, accountId) {
       Capabilities: ["CAPABILITY_NAMED_IAM"]
     })
   );
-  verbose(`Waiting for stack ${stackName} to be updated...`);
-  await waitUntilStackUpdateComplete(
-    { client, maxWaitTime: 600 },
-    { StackName: stackName }
-  );
+  info(`Updating stack ${stackName}...`);
+  await waitForStackWithProgress(client, stackName, operationStartTime, resourceCount, 600, showProgress);
   success(`Stack ${stackName} updated successfully in account ${accountId}`);
 }
 async function readExistingStack(stackName, accountId, region, credentials) {
@@ -473,49 +703,6 @@ async function readExistingStack(stackName, accountId, region, credentials) {
   }
 }
 
-// src/aws/oidc-provider.ts
-import {
-  IAMClient,
-  GetOpenIDConnectProviderCommand,
-  ListOpenIDConnectProvidersCommand
-} from "@aws-sdk/client-iam";
-async function checkOidcProviderExists(credentials, region) {
-  const client = new IAMClient({
-    credentials,
-    region
-  });
-  try {
-    const response = await client.send(new ListOpenIDConnectProvidersCommand({}));
-    const providers = response.OpenIDConnectProviderList || [];
-    for (const provider of providers) {
-      if (!provider.Arn) continue;
-      try {
-        const providerDetails = await client.send(
-          new GetOpenIDConnectProviderCommand({
-            OpenIDConnectProviderArn: provider.Arn
-          })
-        );
-        if (providerDetails.Url?.includes(OIDC_PROVIDER_URL)) {
-          verbose(`Found existing OIDC provider: ${provider.Arn}`);
-          return {
-            exists: true,
-            arn: provider.Arn
-          };
-        }
-      } catch {
-      }
-    }
-    verbose(`No existing OIDC provider found for ${OIDC_PROVIDER_URL}`);
-    return { exists: false };
-  } catch (error2) {
-    verbose(`Error checking OIDC providers: ${error2 instanceof Error ? error2.message : String(error2)}`);
-    return { exists: false };
-  }
-}
-function getOidcThumbprint() {
-  return "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-}
-
 // src/auth/browser-auth.ts
 import express from "express";
 import open from "open";
@@ -1154,6 +1341,16 @@ function getArtifactId(artifact) {
   return artifact.name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 
+// src/aws/oidc-provider.ts
+import {
+  IAMClient,
+  GetOpenIDConnectProviderCommand,
+  ListOpenIDConnectProvidersCommand
+} from "@aws-sdk/client-iam";
+function getOidcThumbprint() {
+  return "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+}
+
 // src/templates/common.ts
 var STANDARD_TAGS = [
   { Key: "CreatedBy", Value: "DevRamps" },
@@ -1366,6 +1563,9 @@ function getPipelineStackName(pipelineSlug) {
 function getStageStackName(pipelineSlug, stageName) {
   return truncateName(`DevRamps-${pipelineSlug}-${stageName}-Stage`, CF_STACK_MAX_LENGTH);
 }
+function getAccountStackName() {
+  return "DevRamps-Account-Bootstrap";
+}
 function getKmsKeyAlias(orgSlug) {
   return `alias/devramps-${normalizeName(orgSlug)}`;
 }
@@ -1821,6 +2021,21 @@ function generatePipelineStackTemplate(options) {
   return template;
 }
 
+// src/templates/account-stack.ts
+function generateAccountStackTemplate() {
+  const template = createBaseTemplate(
+    "DevRamps Account Bootstrap Stack - Creates OIDC provider for the account"
+  );
+  addOidcProviderResource(template, false);
+  template.Outputs = {
+    OIDCProviderArn: {
+      Description: "ARN of the OIDC provider",
+      Value: { "Fn::GetAtt": ["DevRampsOIDCProvider", "Arn"] }
+    }
+  };
+  return template;
+}
+
 // src/permissions/eks-deploy.ts
 var EKS_DEPLOY_PERMISSIONS = {
   actions: [
@@ -2008,7 +2223,6 @@ function generateStageStackTemplate(options) {
   const template = createBaseTemplate(
     `DevRamps Stage Stack for ${pipelineSlug}/${stageName}`
   );
-  addOidcProviderResource(template, true);
   const roleName = generateStageRoleName(pipelineSlug, stageName);
   const trustPolicy = buildStageTrustPolicy(accountId, orgSlug, pipelineSlug, stageName);
   const policies = buildStagePolicies(steps, additionalPolicies);
@@ -2054,6 +2268,7 @@ function generateStageStackTemplate(options) {
     );
     s3Outputs[artifact.name] = { resourceId };
   }
+  const oidcProviderArn = `arn:aws:iam::${accountId}:oidc-provider/${OIDC_PROVIDER_URL}`;
   template.Outputs = {
     StageRoleArn: {
       Description: "ARN of the stage deployment role",
@@ -2065,8 +2280,8 @@ function generateStageStackTemplate(options) {
       Value: { Ref: "StageDeploymentRole" }
     },
     OIDCProviderArn: {
-      Description: "ARN of the OIDC provider",
-      Value: getOidcProviderArn(accountId, true)
+      Description: "ARN of the OIDC provider (created by Account Bootstrap stack)",
+      Value: oidcProviderArn
     },
     PipelineSlug: {
       Description: "Pipeline slug",
@@ -2286,7 +2501,7 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
   }
   const orgStackName = getOrgStackName(orgSlug);
   const orgStack = {
-    stackType: "Org",
+    stackType: "Org" /* ORG */,
     stackName: orgStackName,
     accountId: cicdAccountId,
     region: cicdRegion,
@@ -2300,7 +2515,7 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
     const filteredArtifacts = filterArtifactsForPipelineStack(artifacts);
     const stackName = getPipelineStackName(pipeline.slug);
     pipelineStacks.push({
-      stackType: "Pipeline",
+      stackType: "Pipeline" /* PIPELINE */,
       stackName,
       accountId: cicdAccountId,
       region: cicdRegion,
@@ -2310,6 +2525,38 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
       bundleArtifacts: filteredArtifacts.bundle
     });
   }
+  const accountStacks = [];
+  const accountStackName = getAccountStackName();
+  const accountsWithStacks = /* @__PURE__ */ new Set();
+  for (const pipeline of pipelines) {
+    for (const stage of pipeline.stages) {
+      if (accountsWithStacks.has(stage.account_id)) {
+        continue;
+      }
+      accountsWithStacks.add(stage.account_id);
+      let accountCredentials;
+      try {
+        if (stage.account_id !== currentAccountId) {
+          const assumed = await assumeRoleForAccount({
+            targetAccountId: stage.account_id,
+            currentAccountId,
+            targetRoleName
+          });
+          accountCredentials = assumed?.credentials;
+        }
+      } catch {
+        verbose(`Could not assume role in ${stage.account_id} for status check`);
+      }
+      accountStacks.push({
+        stackType: "Account" /* ACCOUNT */,
+        stackName: accountStackName,
+        accountId: stage.account_id,
+        region: cicdRegion,
+        // Deploy in CI/CD region for consistency
+        action: await determineStackAction(accountStackName, accountCredentials, cicdRegion)
+      });
+    }
+  }
   const stageStacks = [];
   for (const pipeline of pipelines) {
     const artifacts = pipelineArtifacts.get(pipeline.slug);
@@ -2329,7 +2576,7 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
         verbose(`Could not assume role in ${stage.account_id} for status check`);
       }
       stageStacks.push({
-        stackType: "Stage",
+        stackType: "Stage" /* STAGE */,
         stackName,
         accountId: stage.account_id,
         region: stage.region,
@@ -2350,6 +2597,7 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
     cicdRegion,
     orgStack,
     pipelineStacks,
+    accountStacks,
     stageStacks
   };
 }
@@ -2368,79 +2616,126 @@ 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 Stacks");
-  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}`);
+    }
   }
-  newline();
-  info("Phase 3: 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}`);
+  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)`);
+    }
+  }
+  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.stageStacks.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.stageStacks.length;
+  const totalStacks = 1 + plan.pipelineStacks.length + plan.accountStacks.length + plan.stageStacks.length;
   newline();
   info(`About to deploy ${totalStacks} stack(s):`);
   info(`  - 1 Org stack (${plan.orgStack.action})`);
   info(`  - ${plan.pipelineStacks.length} Pipeline stack(s)`);
+  info(`  - ${plan.accountStacks.length} Account stack(s) (OIDC provider)`);
   info(`  - ${plan.stageStacks.length} Stage stack(s)`);
   return confirmDeployment({
     orgSlug: plan.orgSlug,
     stacks: [
       { ...plan.orgStack, pipelineSlug: "org", steps: [], additionalPoliciesCount: 0 },
       ...plan.pipelineStacks.map((s) => ({ ...s, steps: [], additionalPoliciesCount: 0 })),
+      ...plan.accountStacks.map((s) => ({ ...s, pipelineSlug: "account", steps: [], additionalPoliciesCount: 0 })),
       ...plan.stageStacks.map((s) => ({ ...s, steps: s.steps.map((st) => st.name), additionalPoliciesCount: s.additionalPolicies.length }))
     ]
   });
 }
 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;
-  }
+  header("Deploying All Stacks");
+  info(`Deploying ${totalStacks} stack(s) in parallel...`);
   newline();
-  header("Phase 2: Pipeline Stacks");
-  for (const stack of plan.pipelineStacks) {
-    const spinner = ora(`Deploying ${stack.stackName}...`).start();
+  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);
-      spinner.succeed(`${stack.stackName} deployed`);
-      results.success++;
+      return { stack: stack.stackName, success: true };
     } catch (error2) {
-      spinner.fail(`${stack.stackName} failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      results.failed++;
+      return {
+        stack: stack.stackName,
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
     }
-  }
-  newline();
-  header("Phase 3: Stage Stacks");
-  for (const stack of plan.stageStacks) {
-    const spinner = ora(`Deploying ${stack.stackName} to ${stack.accountId}/${stack.region}...`).start();
+  });
+  const accountPromises = plan.accountStacks.map(async (stack) => {
+    try {
+      await deployAccountStack(stack, currentAccountId, options);
+      return { stack: `${stack.stackName} (${stack.accountId})`, success: true };
+    } catch (error2) {
+      return {
+        stack: `${stack.stackName} (${stack.accountId})`,
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
+    }
+  });
+  const stagePromises = plan.stageStacks.map(async (stack) => {
     try {
       await deployStageStack(stack, authData, currentAccountId, options);
-      spinner.succeed(`${stack.stackName} deployed to ${stack.accountId}`);
-      results.success++;
+      return { stack: stack.stackName, success: true };
     } catch (error2) {
-      spinner.fail(`${stack.stackName} failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      return {
+        stack: stack.stackName,
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
+    }
+  });
+  const allResults = await Promise.all([
+    orgPromise,
+    ...pipelinePromises,
+    ...accountPromises,
+    ...stagePromises
+  ]);
+  newline();
+  for (const result of allResults) {
+    if (result.success) {
+      success(`${result.stack} deployed`);
+      results.success++;
+    } else {
+      error(`${result.stack} failed: ${result.error}`);
       results.failed++;
     }
   }
@@ -2489,7 +2784,9 @@ async function deployOrgStack(plan, pipelines, authData, currentAccountId, optio
     template,
     accountId: cicdAccountId,
     region: cicdRegion,
-    credentials
+    credentials,
+    showProgress: false
+    // Disable progress bar for parallel deployment
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
@@ -2512,7 +2809,28 @@ async function deployPipelineStack(stack, authData, currentAccountId, options) {
     template,
     accountId: cicdAccountId,
     region: cicdRegion,
-    credentials
+    credentials,
+    showProgress: false
+    // Disable progress bar for parallel deployment
+  };
+  await previewStackChanges(deployOptions);
+  await deployStack(deployOptions);
+}
+async function deployAccountStack(stack, currentAccountId, options) {
+  const credentials = stack.accountId !== currentAccountId ? (await assumeRoleForAccount({
+    targetAccountId: stack.accountId,
+    currentAccountId,
+    targetRoleName: options.targetAccountRoleName
+  }))?.credentials : void 0;
+  const template = generateAccountStackTemplate();
+  const deployOptions = {
+    stackName: stack.stackName,
+    template,
+    accountId: stack.accountId,
+    region: stack.region,
+    credentials,
+    showProgress: false
+    // Disable progress bar for parallel deployment
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
@@ -2523,8 +2841,6 @@ async function deployStageStack(stack, authData, currentAccountId, options) {
     currentAccountId,
     targetRoleName: options.targetAccountRoleName
   }))?.credentials : void 0;
-  const oidcInfo = await checkOidcProviderExists(credentials, stack.region);
-  verbose(`OIDC provider in ${stack.accountId}: ${oidcInfo.exists ? "exists" : "will be created"}`);
   const template = generateStageStackTemplate({
     pipelineSlug: stack.pipelineSlug,
     stageName: stack.stageName,
@@ -2540,7 +2856,9 @@ async function deployStageStack(stack, authData, currentAccountId, options) {
     template,
     accountId: stack.accountId,
     region: stack.region,
-    credentials
+    credentials,
+    showProgress: false
+    // Disable progress bar for parallel deployment
   };
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);

package/package.json

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