@devramps/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -74,6 +74,80 @@ 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;
+  lastLineCount = 0;
+  eventLines = [];
+  maxVisibleEvents = 5;
+  constructor(label, total) {
+    this.label = label;
+    this.total = total;
+    this.render();
+  }
+  /**
+   * Update progress and re-render
+   */
+  update(current, eventMessage) {
+    this.current = current;
+    if (eventMessage) {
+      this.eventLines.push(eventMessage);
+      if (this.eventLines.length > this.maxVisibleEvents) {
+        this.eventLines.shift();
+      }
+    }
+    this.render();
+  }
+  /**
+   * Add an event message without changing progress
+   */
+  addEvent(message) {
+    this.eventLines.push(message);
+    if (this.eventLines.length > this.maxVisibleEvents) {
+      this.eventLines.shift();
+    }
+    this.render();
+  }
+  /**
+   * Clear the progress bar from the terminal
+   */
+  clear() {
+    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() {
+    this.clear();
+  }
+  /**
+   * Render the progress bar
+   */
+  render() {
+    this.clear();
+    const lines = [];
+    for (const event of this.eventLines) {
+      lines.push(event);
+    }
+    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;
+  }
+};
 function setVerbose(enabled) {
   verboseMode = enabled;
 }
@@ -234,13 +308,12 @@ import {
   CloudFormationClient,
   DescribeStacksCommand,
   DescribeStackResourcesCommand,
+  DescribeStackEventsCommand,
   CreateStackCommand,
   UpdateStackCommand,
   CreateChangeSetCommand,
   DescribeChangeSetCommand,
   DeleteChangeSetCommand,
-  waitUntilStackCreateComplete,
-  waitUntilStackUpdateComplete,
   waitUntilChangeSetCreateComplete,
   ChangeSetType
 } from "@aws-sdk/client-cloudformation";
@@ -361,21 +434,114 @@ 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 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) {
+  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;
+  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;
+        if (logicalId && logicalId !== stackName && isResourceComplete(event.ResourceStatus)) {
+          completedResources.add(logicalId);
+        }
+        if (progressBar) {
+          progressBar.update(completedResources.size, formatStackEvent(event));
+        }
+      }
+      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 +552,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 +565,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 +578,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 +635,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 +1273,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 +1495,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 +1953,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 +2155,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 +2200,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 +2212,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 +2433,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 +2447,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 +2457,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 +2508,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 +2529,7 @@ async function buildDeploymentPlan(pipelines, pipelineArtifacts, authData, curre
     cicdRegion,
     orgStack,
     pipelineStacks,
+    accountStacks,
     stageStacks
   };
 }
@@ -2373,34 +2553,40 @@ async function showDryRunPlan(plan) {
   info(`    Account: ${plan.orgStack.accountId}`);
   info(`    Target accounts with bucket access: ${plan.orgStack.targetAccountIds.length}`);
   newline();
-  info("Phase 2: Pipeline Stacks");
+  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}`);
   }
+  for (const stack of plan.accountStacks) {
+    info(`  ${stack.action}: ${stack.stackName}`);
+    info(`    Account: ${stack.accountId} (OIDC provider)`);
+  }
   newline();
-  info("Phase 3: Stage Stacks");
+  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}`);
   }
-  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}`);
 }
 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 }))
     ]
   });
@@ -2419,28 +2605,75 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
     throw error2;
   }
   newline();
-  header("Phase 2: Pipeline Stacks");
-  for (const stack of plan.pipelineStacks) {
-    const spinner = ora(`Deploying ${stack.stackName}...`).start();
+  header("Phase 2: Pipeline & Account Stacks (parallel)");
+  const totalPhase2Stacks = plan.pipelineStacks.length + plan.accountStacks.length;
+  info(`Deploying ${totalPhase2Stacks} stack(s) in parallel...`);
+  newline();
+  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)}`);
+      return {
+        stack: stack.stackName,
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
+    }
+  });
+  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 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");
-  for (const stack of plan.stageStacks) {
-    const spinner = ora(`Deploying ${stack.stackName} to ${stack.accountId}/${stack.region}...`).start();
+  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);
-      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 phase3Results = await Promise.all(stagePromises);
+  newline();
+  for (const result of phase3Results) {
+    if (result.success) {
+      success(`${result.stack} deployed`);
+      results.success++;
+    } else {
+      error(`${result.stack} failed: ${result.error}`);
       results.failed++;
     }
   }
@@ -2512,7 +2745,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 +2777,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 +2792,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.2",
   "description": "DevRamps CLI - Bootstrap AWS infrastructure for CI/CD pipelines",
   "main": "dist/index.js",
   "bin": {