@devramps/cli 0.1.30 → 0.1.32

package/dist/index.js

@@ -4,6 +4,7 @@
 import { program } from "commander";
 
 // src/commands/bootstrap.ts
+import { createHash as createHash2 } from "crypto";
 import ora from "ora";
 
 // src/aws/credentials.ts
@@ -1008,8 +1009,11 @@ async function authenticateViaBrowser(options = {}) {
     verbose(`CI/CD Account: ${cicdAccountId}, Region: ${awsConfig.defaultRegion}`);
     return {
       orgSlug: orgResponse.slug,
+      organizationId: tokenResponse.organization_id,
       cicdAccountId,
-      cicdRegion: awsConfig.defaultRegion
+      cicdRegion: awsConfig.defaultRegion,
+      accessToken: tokenResponse.access_token,
+      apiBaseUrl: baseUrl
     };
   } finally {
     process.removeListener("SIGINT", sigintHandler);
@@ -1378,15 +1382,30 @@ async function parsePipeline(basePath, slug) {
       throw new PipelineParseError(slug, `Stage "${stage.name}" is missing region`);
     }
   }
+  if (definition.pipeline.ephemeral_environments) {
+    for (const [name, env] of Object.entries(definition.pipeline.ephemeral_environments)) {
+      if (!env.account_id) {
+        throw new PipelineParseError(slug, `Ephemeral environment "${name}" is missing account_id`);
+      }
+      if (!env.region) {
+        throw new PipelineParseError(slug, `Ephemeral environment "${name}" is missing region`);
+      }
+    }
+  }
   const targetAccountIds = extractTargetAccountIds(definition);
   const steps = extractSteps(definition);
   const additionalPolicies = await parseAdditionalPoliciesForPipeline(basePath, slug);
-  verbose(`Pipeline ${slug}: ${targetAccountIds.length} accounts, ${steps.length} steps`);
+  const ephemeralStages = ephemeralEnvironmentsAsStages(definition);
+  const allStages = [...definition.pipeline.stages, ...ephemeralStages];
+  if (ephemeralStages.length > 0) {
+    verbose(`Pipeline ${slug}: ${ephemeralStages.length} ephemeral environment(s) will be bootstrapped as stages`);
+  }
+  verbose(`Pipeline ${slug}: ${targetAccountIds.length} accounts, ${allStages.length} stages, ${steps.length} steps`);
   return {
     slug,
     definition,
     targetAccountIds,
-    stages: definition.pipeline.stages,
+    stages: allStages,
     steps,
     additionalPolicies
   };
@@ -1398,8 +1417,26 @@ function extractTargetAccountIds(definition) {
       accountIds.add(stage.account_id);
     }
   }
+  if (definition.pipeline.ephemeral_environments) {
+    for (const env of Object.values(definition.pipeline.ephemeral_environments)) {
+      if (env.account_id) {
+        accountIds.add(env.account_id);
+      }
+    }
+  }
   return Array.from(accountIds);
 }
+function ephemeralEnvironmentsAsStages(definition) {
+  const envs = definition.pipeline.ephemeral_environments;
+  if (!envs) return [];
+  return Object.entries(envs).map(([name, env]) => ({
+    name: `ephemeral-${name}`,
+    account_id: env.account_id,
+    region: env.region,
+    skip: env.skip,
+    vars: env.vars
+  }));
+}
 function extractSteps(definition) {
   return definition.pipeline.steps || [];
 }
@@ -3365,6 +3402,7 @@ async function executeDeployment(plan, pipelines, pipelineArtifacts, authData, c
   header("Deployment Summary");
   if (results.failed === 0) {
     success(`All ${results.success} stack(s) deployed successfully!`);
+    await markPipelinesBootstrapped(pipelines, authData);
     process.exit(0);
   } else {
     warn(`${results.success} stack(s) succeeded, ${results.failed} stack(s) failed.`);
@@ -3510,6 +3548,69 @@ async function deployImportStack(stack, currentAccountId, options, oidcProviderU
   await previewStackChanges(deployOptions);
   await deployStack(deployOptions);
 }
+async function markPipelinesBootstrapped(pipelines, authData) {
+  newline();
+  const spinner = ora("Registering bootstrap status...").start();
+  let pipelineMap;
+  try {
+    const listUrl = `${authData.apiBaseUrl}/api/v1/organizations/${authData.organizationId}/pipelines?limit=100`;
+    const listRes = await fetch(listUrl, {
+      headers: {
+        Authorization: `Bearer ${authData.accessToken}`,
+        Accept: "application/json"
+      }
+    });
+    if (!listRes.ok) {
+      spinner.warn(`Could not register bootstrap status: failed to list pipelines (${listRes.status})`);
+      return;
+    }
+    const listData = await listRes.json();
+    pipelineMap = new Map(listData.pipelines.map((p) => [p.slug, p.id]));
+  } catch (error2) {
+    spinner.warn(`Could not register bootstrap status: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    return;
+  }
+  let succeeded = 0;
+  let failed = 0;
+  for (const pipeline of pipelines) {
+    const pipelineId = pipelineMap.get(pipeline.slug);
+    if (!pipelineId) {
+      verbose(`Pipeline ${pipeline.slug} not found in backend \u2014 skipping mark-bootstrapped`);
+      failed++;
+      continue;
+    }
+    const definitionHash = createHash2("sha256").update(JSON.stringify(pipeline.definition)).digest("hex");
+    try {
+      const url = `${authData.apiBaseUrl}/api/v1/organizations/${authData.organizationId}/pipelines/${pipelineId}/mark-bootstrapped`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${authData.accessToken}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({ definitionHash })
+      });
+      if (res.ok) {
+        verbose(`Marked ${pipeline.slug} as bootstrapped (hash: ${definitionHash.slice(0, 12)}...)`);
+        succeeded++;
+      } else {
+        verbose(`Failed to mark ${pipeline.slug} as bootstrapped: ${res.status}`);
+        failed++;
+      }
+    } catch (error2) {
+      verbose(`Error marking ${pipeline.slug} as bootstrapped: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      failed++;
+    }
+  }
+  if (failed === 0) {
+    spinner.succeed(`Bootstrap status registered for ${succeeded} pipeline(s)`);
+  } else if (succeeded > 0) {
+    spinner.warn(`Bootstrap status registered for ${succeeded} pipeline(s), ${failed} failed (non-fatal)`);
+  } else {
+    spinner.warn("Could not register bootstrap status (non-fatal)");
+  }
+}
 
 // src/index.ts
 program.name("devramps").description("DevRamps CLI - Bootstrap AWS infrastructure for CI/CD pipelines").version("0.1.0");

package/package.json

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