@biffo/cli 0.34.0 → 0.34.1

package/core.version

@@ -1 +1 @@
-0.34.0
+0.34.1

package/dist/index.js

@@ -697,12 +697,22 @@ var GitHubAdapter = class {
     log.info(`Created branch ${branch} from ${from}`);
   }
   /**
-   * Read a file's decoded UTF-8 content at `ref`, or `undefined` if it is absent
-   * (404) or is not a regular file (a directory or submodule).
+   * Read a file's decoded UTF-8 content at `ref` (the repo's default branch when
+   * omitted), or `undefined` if it is absent (404) or is not a regular file (a
+   * directory or submodule).
+   *
+   * Public because `biffo teardown` reads the sibling registry and the sibling
+   * marker file straight from GitHub (issue #306) — teardown must work from a
+   * machine that never cloned the project.
    */
   async getFileContent(org, repo, path, ref) {
     try {
-      const { data } = await this.octokit.repos.getContent({ owner: org, repo, path, ref });
+      const { data } = await this.octokit.repos.getContent({
+        owner: org,
+        repo,
+        path,
+        ...ref ? { ref } : {}
+      });
       if (Array.isArray(data) || data.type !== "file" || typeof data.content !== "string") {
         return void 0;
       }
@@ -906,6 +916,37 @@ var GitHubAdapter = class {
       }
     }
   }
+  /**
+   * Does this repository exist (and is it visible to our token)?
+   *
+   * Used by `biffo teardown` to tell "sibling registered, repo since deleted"
+   * apart from "sibling repo still live", which decide different teardown paths.
+   */
+  async repoExists(org, repo) {
+    try {
+      await this.octokit.repos.get({ owner: org, repo });
+      return true;
+    } catch (err) {
+      if (err.status === 404) return false;
+      throw err;
+    }
+  }
+  /**
+   * Head branch names of the repo's open pull requests.
+   *
+   * Teardown uses this to spot siblings whose registration PR has not merged
+   * yet (branch `biffo/register-sibling-<name>`) — they exist as real repos and
+   * real AWS resources, but nothing has landed in the merged registry.
+   */
+  async listOpenPullRequests(org, repo) {
+    const prs = await this.octokit.paginate(this.octokit.pulls.list, {
+      owner: org,
+      repo,
+      state: "open",
+      per_page: 100
+    });
+    return prs.map((pr) => ({ number: pr.number, headRef: pr.head.ref }));
+  }
   /**
    * Read a repository Actions variable's value, or `undefined` if it isn't set.
    * A 404 means the variable doesn't exist on the repo (not an error) — used to
@@ -5814,6 +5855,129 @@ import { GetCallerIdentityCommand as GetCallerIdentityCommand3, STSClient as STS
 import chalk20 from "chalk";
 import { Command as Command22 } from "commander";
 import inquirer8 from "inquirer";
+
+// src/lib/sibling-teardown.ts
+var SiblingResolutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SiblingResolutionError";
+  }
+};
+var REGISTRY_ENVIRONMENTS = ["dev", "staging", "prod"];
+function registryPath(environment) {
+  return `infra/environments/${environment}/siblings.auto.tfvars.json`;
+}
+var REGISTRATION_BRANCH_PREFIX = "biffo/register-sibling-";
+function parseSiblingBucketDomain(domain) {
+  const host = /^(?<bucket>[a-z0-9][a-z0-9.-]*)\.s3(?:\.[a-z0-9-]+)?\.amazonaws\.com$/.exec(domain);
+  const bucket = host?.groups?.["bucket"];
+  if (!bucket) return null;
+  const parts = /^(?<project>.+)-(?<env>dev|staging|prod)-site-(?<account>\d{12})$/.exec(bucket);
+  const project = parts?.groups?.["project"];
+  const env = parts?.groups?.["env"];
+  const account = parts?.groups?.["account"];
+  if (!project || !env || !account) return null;
+  return { projectName: project, environment: env, accountId: account };
+}
+function parseRegistry(contents) {
+  if (contents === void 0 || contents.trim() === "") return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch {
+    throw new SiblingResolutionError(
+      "A siblings.auto.tfvars.json in the core repo is not valid JSON. Refusing to tear down while the sibling registry cannot be read \u2014 fix or remove the file and re-run."
+    );
+  }
+  const origins = parsed.sibling_origins;
+  if (origins === void 0) return [];
+  if (!Array.isArray(origins)) {
+    throw new SiblingResolutionError(
+      "sibling_origins in the core repo is not a list. Refusing to tear down while the sibling registry cannot be read."
+    );
+  }
+  return origins;
+}
+function collectSiblings(sources) {
+  const byPrefix = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    for (const entry of source.entries) {
+      if (!entry?.name || !entry.bucket_regional_domain) {
+        throw new SiblingResolutionError(
+          `A sibling entry in ${registryPath(source.environment)} is missing name or bucket_regional_domain. Refusing to tear down while a registered sibling cannot be identified \u2014 it would be left behind, still billing.`
+        );
+      }
+      const parsed = parseSiblingBucketDomain(entry.bucket_regional_domain);
+      if (!parsed) {
+        throw new SiblingResolutionError(
+          `Could not work out which project owns the sibling "${entry.name}" from its bucket "${entry.bucket_regional_domain}" (in ${registryPath(source.environment)}).
+  Refusing to guess \u2014 tear that sibling down by hand, remove its entry, then re-run.`
+        );
+      }
+      const existing = byPrefix.get(entry.name);
+      if (existing) {
+        if (existing.projectName !== parsed.projectName) {
+          throw new SiblingResolutionError(
+            `The sibling "${entry.name}" maps to two different projects across environments ("${existing.projectName}" and "${parsed.projectName}"). Refusing to guess which repo to delete \u2014 resolve the registry by hand and re-run.`
+          );
+        }
+        if (!existing.environments.includes(parsed.environment)) {
+          existing.environments.push(parsed.environment);
+        }
+        if (source.pendingRegistrationPr === void 0) {
+          existing.registered = true;
+          delete existing.pendingRegistrationPr;
+        }
+        continue;
+      }
+      byPrefix.set(entry.name, {
+        pathPrefix: entry.name,
+        projectName: parsed.projectName,
+        environments: [parsed.environment],
+        accountId: parsed.accountId,
+        registered: source.pendingRegistrationPr === void 0,
+        ...source.pendingRegistrationPr !== void 0 ? { pendingRegistrationPr: source.pendingRegistrationPr } : {}
+      });
+    }
+  }
+  return [...byPrefix.values()].sort((a, b) => a.pathPrefix.localeCompare(b.pathPrefix));
+}
+var SIBLING_MARKER_FILE = "biffo.sibling.json";
+function markerMatches(marker, coreProjectName, sibling) {
+  if (!marker) return false;
+  if (marker.core_project !== coreProjectName) return false;
+  return marker.path_prefix === sibling.pathPrefix || marker.name === sibling.projectName;
+}
+async function resolveSiblingRepos(github, coreOrg, coreProjectName, siblings) {
+  const resolved = [];
+  for (const sibling of siblings) {
+    const repo = sibling.projectName;
+    if (!await github.repoExists(coreOrg, repo)) {
+      resolved.push({ ...sibling, org: coreOrg, repo, repoState: "gone" });
+      continue;
+    }
+    const raw = await github.getFileContent(coreOrg, repo, SIBLING_MARKER_FILE);
+    let marker = null;
+    if (raw !== void 0) {
+      try {
+        marker = JSON.parse(raw);
+      } catch {
+        marker = null;
+      }
+    }
+    if (!markerMatches(marker, coreProjectName, sibling)) {
+      throw new SiblingResolutionError(
+        `Refusing to tear down: ${coreOrg}/${repo} is registered as the sibling "${sibling.pathPrefix}" of "${coreProjectName}", but that repo does not carry a matching ${SIBLING_MARKER_FILE}.
+  It may be an unrelated repo that happens to share the name. Deleting a repo cannot be undone, so nothing has been deleted.
+  Delete ${coreOrg}/${repo} by hand if it really is the sibling, remove its entry from the core repo's siblings.auto.tfvars.json, then re-run biffo teardown.`
+      );
+    }
+    resolved.push({ ...sibling, org: coreOrg, repo, repoState: "present" });
+  }
+  return resolved;
+}
+
+// src/commands/teardown.ts
 var teardownCommand = new Command22("teardown").description(
   "Destroy all infrastructure then remove the repo, IAM role, and state bucket \u2014 single command"
 ).option("--project <name>", "Project name to tear down (reads session if omitted)").option("--skip-destroy", "Skip terraform destroy (only use if infrastructure is already gone)").option(
@@ -5912,6 +6076,21 @@ var teardownCommand = new Command22("teardown").description(
     const allDeployed = options.skipDestroy ? [] : await aws.listDeployedEnvironments(stateBucket).catch(() => []);
     const deployedEnvs = allDeployed.filter((e) => e !== "global");
     const hasGlobal = allDeployed.includes("global");
+    let siblings = [];
+    if (org && repo) {
+      try {
+        siblings = await discoverSiblings(github, org, repo, projectName);
+        if (!options.skipDestroy) {
+          await assertSiblingsAreDestroyable(github, siblings);
+        }
+      } catch (err) {
+        if (err instanceof SiblingResolutionError) {
+          log.error(err.message);
+          process.exit(1);
+        }
+        throw err;
+      }
+    }
     console.log(chalk20.red.bold("  This will permanently delete:\n"));
     if (deployedEnvs.length > 0 || hasGlobal) {
       console.log(chalk20.red("  Infrastructure (via GitHub Actions terraform destroy):"));
@@ -5925,6 +6104,9 @@ var teardownCommand = new Command22("teardown").description(
       }
       console.log();
     }
+    for (const line of formatSiblingPlan(siblings, options.skipDestroy === true)) {
+      console.log(line);
+    }
     console.log(chalk20.red("  Biffo resources:"));
     console.log(`    ${chalk20.red("\u2717")} GitHub repository  ${chalk20.bold(`${org}/${repo}`)}`);
     console.log(
@@ -5934,11 +6116,22 @@ var teardownCommand = new Command22("teardown").description(
       `    ${chalk20.red("\u2717")} S3 bucket          ${chalk20.bold(stateBucket)} (all versions)`
     );
     console.log(`    ${chalk20.red("\u2717")} Local session file`);
+    if (options.skipDestroy) {
+      console.log();
+      console.log(
+        chalk20.yellow(
+          "  --skip-destroy: NO terraform destroy runs, for this project or any sibling.\n  Everything above is deleted, but any infrastructure still standing is left\n  standing \u2014 and, with the state buckets gone, orphaned."
+        )
+      );
+    }
     console.log();
     if (!await confirmTeardown(projectName, options)) {
       log.warn("Teardown cancelled \u2014 project name did not match");
       return;
     }
+    if (!options.skipDestroy && siblings.length > 0) {
+      await destroySiblingInfrastructure(github, siblings);
+    }
     if (deployedEnvs.length > 0) {
       const actionsUrl = `https://github.com/${org}/${repo}/actions`;
       for (const env of deployedEnvs) {
@@ -6006,6 +6199,32 @@ Destroying ${env} infrastructure (20\u201330 min for first run)...`);
         log.warn("destroy-global.yml not found \u2014 skipping global infrastructure teardown");
       }
     }
+    for (const sibling of siblings) {
+      if (sibling.repoState === "gone") {
+        log.warn(
+          `Sibling "${sibling.pathPrefix}" (${sibling.org}/${sibling.repo}) no longer has a repo \u2014 leaving its IAM role and Terraform state bucket in place so its infrastructure can still be reclaimed:
+    IAM role   biffo-github-actions-${sibling.projectName}
+    S3 bucket  ${sibling.projectName}-terraform-state-${sibling.accountId}`
+        );
+        continue;
+      }
+      await github.deleteRepo(sibling.org, sibling.repo).catch((err) => {
+        log.warn(
+          `Could not delete sibling repo ${sibling.org}/${sibling.repo} (skipping): ${err.message}`
+        );
+      });
+      await aws.teardownOidcRole(sibling.projectName).catch((err) => {
+        log.warn(
+          `Could not delete sibling IAM role for ${sibling.projectName} (skipping): ${err.message}`
+        );
+      });
+      await aws.teardownTerraformBackend(sibling.projectName).catch((err) => {
+        log.warn(
+          `Could not delete sibling state bucket for ${sibling.projectName} (skipping): ${err.message}`
+        );
+      });
+      log.success(`Sibling ${sibling.org}/${sibling.repo} removed`);
+    }
     await github.deleteRepo(org, repo).catch((err) => {
       log.warn(`Could not delete repo (skipping): ${err.message}`);
     });
@@ -6021,6 +6240,124 @@ Destroying ${env} infrastructure (20\u201330 min for first run)...`);
     console.log("  All biffo resources have been removed.\n");
   }
 );
+async function destroySiblingInfrastructure(github, siblings) {
+  for (const sibling of siblings) {
+    if (sibling.repoState !== "present") continue;
+    const actionsUrl = `https://github.com/${sibling.org}/${sibling.repo}/actions`;
+    for (const env of sibling.environments) {
+      const envBranch = { dev: "dev", staging: "staging", prod: "main" };
+      const branch = envBranch[env] ?? "dev";
+      log.info(`
+Destroying sibling ${sibling.org}/${sibling.repo} (${env})...`);
+      log.info(`  Watch live: ${actionsUrl}`);
+      const baselineId = await github.getLatestWorkflowRunId(
+        sibling.org,
+        sibling.repo,
+        SIBLING_DESTROY_WORKFLOW
+      );
+      await github.triggerWorkflow(
+        sibling.org,
+        sibling.repo,
+        SIBLING_DESTROY_WORKFLOW,
+        { environment: env },
+        branch
+      );
+      const result = await github.waitForWorkflowRun(
+        sibling.org,
+        sibling.repo,
+        SIBLING_DESTROY_WORKFLOW,
+        baselineId,
+        36e5,
+        3e4,
+        branch
+      );
+      if (result.conclusion !== "success") {
+        log.error(
+          `Sibling destroy ${result.conclusion ?? "failed"} for ${sibling.org}/${sibling.repo} (${env}).`
+        );
+        log.error(`  Run details: ${actionsUrl}/runs/${result.id}`);
+        log.error(
+          "  Nothing else has been destroyed or deleted \u2014 this project and every other sibling are still intact.\n  Fix the sibling and re-run biffo teardown, or use --skip-destroy."
+        );
+        process.exit(1);
+      }
+      log.success(`Sibling ${sibling.org}/${sibling.repo} (${env}) infrastructure destroyed`);
+    }
+  }
+}
+var SIBLING_DESTROY_WORKFLOW = "destroy-infra.yml";
+var SIBLING_DESTROY_WORKFLOW_PATH = `.github/workflows/${SIBLING_DESTROY_WORKFLOW}`;
+async function discoverSiblings(github, coreOrg, coreRepo, coreProjectName) {
+  const sources = [];
+  for (const env of REGISTRY_ENVIRONMENTS) {
+    const contents = await github.getFileContent(coreOrg, coreRepo, registryPath(env));
+    sources.push({ environment: env, entries: parseRegistry(contents) });
+  }
+  const openPrs = await github.listOpenPullRequests(coreOrg, coreRepo);
+  for (const pr of openPrs) {
+    if (!pr.headRef.startsWith(REGISTRATION_BRANCH_PREFIX)) continue;
+    for (const env of REGISTRY_ENVIRONMENTS) {
+      const contents = await github.getFileContent(coreOrg, coreRepo, registryPath(env), pr.headRef);
+      sources.push({
+        environment: env,
+        entries: parseRegistry(contents),
+        pendingRegistrationPr: pr.number
+      });
+    }
+  }
+  const discovered = collectSiblings(sources);
+  return resolveSiblingRepos(github, coreOrg, coreProjectName, discovered);
+}
+async function assertSiblingsAreDestroyable(github, siblings) {
+  const missing = [];
+  for (const sibling of siblings) {
+    if (sibling.repoState !== "present") continue;
+    const workflow = await github.getFileContent(
+      sibling.org,
+      sibling.repo,
+      SIBLING_DESTROY_WORKFLOW_PATH
+    );
+    if (workflow === void 0) missing.push(`${sibling.org}/${sibling.repo}`);
+  }
+  if (missing.length > 0) {
+    throw new SiblingResolutionError(
+      `These sibling repos have no ${SIBLING_DESTROY_WORKFLOW_PATH}, so their AWS resources cannot be destroyed:
+` + missing.map((r) => `    ${r}`).join("\n") + "\n  Nothing has been deleted. Either add that workflow to each repo (copy it from biffo's sibling skeleton), destroy those siblings by hand, or re-run with --skip-destroy to delete the repos and leave their infrastructure standing."
+    );
+  }
+}
+function formatSiblingPlan(siblings, skipDestroy) {
+  if (siblings.length === 0) return [];
+  const lines = [chalk20.red(`  Sibling apps (${siblings.length}) \u2014 ADR-0007:`)];
+  for (const s of siblings) {
+    const envs = s.environments.join(", ");
+    if (s.repoState === "gone") {
+      lines.push(
+        `    ${chalk20.yellow("!")} ${chalk20.bold(`${s.org}/${s.repo}`)} \u2014 repo already deleted; its ${envs} infrastructure CANNOT be destroyed and will be left standing`
+      );
+      continue;
+    }
+    lines.push(
+      `    ${chalk20.red("\u2717")} GitHub repository  ${chalk20.bold(`${s.org}/${s.repo}`)} (routed at /${s.pathPrefix})`
+    );
+    lines.push(
+      `      ${chalk20.red("\u2717")} ${skipDestroy ? "infrastructure NOT destroyed (--skip-destroy)" : `${envs} infrastructure \u2014 S3 site bucket, Lambda, API Gateway`}`
+    );
+    lines.push(
+      `      ${chalk20.red("\u2717")} IAM role           ${chalk20.bold(`biffo-github-actions-${s.projectName}`)}`
+    );
+    lines.push(
+      `      ${chalk20.red("\u2717")} S3 bucket          ${chalk20.bold(`${s.projectName}-terraform-state-${s.accountId}`)}`
+    );
+    if (s.pendingRegistrationPr !== void 0) {
+      lines.push(
+        chalk20.dim(`      registration PR #${s.pendingRegistrationPr} is still open \u2014 never routed`)
+      );
+    }
+  }
+  lines.push("");
+  return lines;
+}
 function pickSoleProjectConfig() {
   const configs = listProjectConfigs();
   if (configs.length > 1 && isNonInteractive()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/cli",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "description": "Biffo project scaffolding CLI",
   "license": "MIT",
   "type": "module",