@biffo/cli 0.166.0 → 0.166.1

package/dist/index.js

@@ -1629,6 +1629,34 @@ var GitHubAdapter = class {
       throw err;
     }
   }
+  /**
+   * How many self-hosted runners this repo can actually see (#803, biffo-runners#2).
+   *
+   * Setting `RUNNER_LABEL` points a repo's jobs at a self-hosted fleet. It does
+   * not grant the fleet's GitHub App access to that repo — and until someone
+   * does, the repo sees **zero** runners and every job queues for ever with no
+   * error at all. Measured on a freshly created plugin repo: 0 runners, while an
+   * established one in the same fleet saw 3.
+   *
+   * Queuing for ever and failing at the billing wall look completely different
+   * in the UI and are the same outcome under branch protection: nothing can
+   * merge. Callers use this to say so at create time rather than leaving it to
+   * be discovered on the first PR.
+   *
+   * Returns `null` when the count cannot be read (permissions, API error) —
+   * distinct from `0`, which is a real and actionable answer.
+   */
+  async repoRunnerCount(org, repo) {
+    try {
+      const { data } = await this.octokit.actions.listSelfHostedRunnersForRepo({
+        owner: org,
+        repo
+      });
+      return data.total_count;
+    } catch {
+      return null;
+    }
+  }
   async setRepoVariable(org, repo, name, value) {
     log.info(`Setting variable: ${name}`);
     try {
@@ -6839,6 +6867,9 @@ var pluginCreateCommand = new Command13("create").description("Scaffold a new pl
 ).option(
   "--org <org>",
   "With --standalone, also create the GitHub repo under this org (or user), push, and protect dev"
+).option(
+  "--runner-label <label>",
+  "With --org, the RUNNER_LABEL the new repo\u2019s CI should run on (defaults to mirroring this checkout\u2019s)"
 ).option(
   "--skeleton <path>",
   "Path to the plugin skeleton (defaults to _skeletons/plugin-template)"
@@ -6852,6 +6883,7 @@ var pluginCreateCommand = new Command13("create").description("Scaffold a new pl
           firstParty: options.firstParty ?? false,
           standalone: options.standalone ?? false,
           ...options.org ? { org: options.org } : {},
+          ...options.runnerLabel ? { runnerLabel: options.runnerLabel } : {},
           ...options.skeleton ? { skeletonRoot: resolve11(options.skeleton) } : {},
           dryRun: options.dryRun ?? false,
           commit: options.commit !== false,
@@ -6980,18 +7012,19 @@ async function runStandaloneCreate(names, options, deps) {
         "--org needs a commit to push. Drop --no-commit, or create the repo yourself using the steps printed by a --no-commit run."
       );
     }
-    await createAndPushStandaloneRepo(options.org, names, destDir, deps);
+    await createAndPushStandaloneRepo(options.org, names, destDir, options, deps);
     return;
   }
   printStandaloneNextSteps(names, minorOf(manifest.version));
 }
-async function createAndPushStandaloneRepo(org, names, destDir, deps) {
+async function createAndPushStandaloneRepo(org, names, destDir, options, deps) {
   if (deps.makeGitHub === void 0 || deps.resolveToken === void 0) {
     throw new Error("No GitHub adapter available \u2014 cannot create a repository.");
   }
   const token = await deps.resolveToken();
   const github = deps.makeGitHub(token);
   const cloneUrl = await github.createEmptyRepo(org, names.dist, `${names.slug} \u2014 a Biffo plugin`);
+  await propagateRunnerLabel(org, names.dist, options, deps, github);
   await deps.git.addRemote(destDir, "origin", cloneUrl);
   await deps.git.push(destDir, "dev", { token });
   log.success(`Pushed dev to ${org}/${names.dist}`);
@@ -7007,6 +7040,45 @@ async function createAndPushStandaloneRepo(org, names, destDir, deps) {
   }
   printStandaloneRemoteNextSteps(names, org);
 }
+async function propagateRunnerLabel(org, repo, options, deps, github) {
+  try {
+    let label = options.runnerLabel?.trim();
+    if (!label) {
+      const source = await currentRepoSlug(options.cwd, deps);
+      if (source) {
+        label = (await github.getRepoVariable(source.org, source.repo, "RUNNER_LABEL"))?.trim();
+      }
+    }
+    if (!label) {
+      log.warn(
+        `No RUNNER_LABEL set on ${org}/${repo} \u2014 its CI will use GitHub-hosted runners. If this account routes CI to a self-hosted fleet, every job will fail before it starts, and the branch protection just configured will block every PR on checks that never report. Fix with: gh variable set RUNNER_LABEL --repo ${org}/${repo}`
+      );
+      return;
+    }
+    await github.setRepoVariable(org, repo, "RUNNER_LABEL", label);
+    log.success(`RUNNER_LABEL=${label} set on ${org}/${repo}`);
+    const runners = await github.repoRunnerCount(org, repo);
+    if (runners === 0) {
+      log.warn(
+        `${org}/${repo} points at the '${label}' runner fleet but can see 0 runners. Jobs will queue indefinitely with no error until the fleet's GitHub App is granted access to this repo (biffo-runners#2) \u2014 and the branch protection just applied will block every PR until then.`
+      );
+    }
+  } catch (err) {
+    log.warn(
+      `Could not set RUNNER_LABEL on ${org}/${repo}: ${err.message}. Set it manually if this account uses self-hosted runners.`
+    );
+  }
+}
+async function currentRepoSlug(cwd, deps) {
+  try {
+    const url = await deps.git.getRemoteUrl(cwd, "origin");
+    const match = /[:/]([^/:]+)\/([^/]+?)(?:\.git)?$/.exec(url.trim());
+    if (match?.[1] === void 0 || match[2] === void 0) return null;
+    return { org: match[1], repo: match[2] };
+  } catch {
+    return null;
+  }
+}
 function printStandaloneRemoteNextSteps(names, org) {
   console.log(chalk13.bold("\n  Standalone plugin repo created!\n"));
   console.log(`  https://github.com/${org}/${names.dist}  (dev, protected)

package/package.json

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