create-egregore 0.18.9 → 0.18.10

package/lib/local.js

@@ -125,6 +125,62 @@ async function getFileContent(token, owner, repo, filePath) {
   return Buffer.from(data.content, "base64").toString("utf-8");
 }
 
+// True if `owner` resolves to a real GitHub account (user OR org — both live
+// under /users/{login}). Lets join distinguish "wrong owner" from "owner has
+// no Egregore", which is the difference between a typo and a missing repo.
+async function ownerExists(token, owner) {
+  const { status } = await ghApi("GET", `/users/${owner}`, token);
+  return status === 200;
+}
+
+// Repo names under `owner` that the authenticated user can actually reach —
+// org membership or a (already-accepted) personal-repo collaborator invite.
+// /user/repos is the only endpoint that honors private + collaborator repos
+// across arbitrary owners, so we list it and filter by owner.
+async function listAccessibleRepos(token, owner) {
+  const ownerLc = owner.toLowerCase();
+  const names = [];
+  let page = 1;
+  while (page <= 4) { // cap at 400 accessible repos
+    const url = `/user/repos?per_page=100&sort=updated&affiliation=owner,collaborator,organization_member&page=${page}`;
+    const { status, data } = await ghApi("GET", url, token);
+    if (status !== 200 || !Array.isArray(data) || data.length === 0) break;
+    for (const r of data) {
+      if (r.owner?.login?.toLowerCase() === ownerLc) names.push(r.name);
+    }
+    if (data.length < 100) break;
+    page += 1;
+  }
+  return names;
+}
+
+// Discover every repo under `owner` that carries an egregore.json on its
+// default branch. Probes the conventional name first, then Egregore-looking
+// names, then the rest — capped so a large account doesn't fan out forever.
+// Returns [{ repo, config }] so the caller never re-fetches the config.
+async function discoverEgregoreRepos(token, owner) {
+  const seen = new Set();
+  const candidates = [];
+  const add = (name) => {
+    const key = name.toLowerCase();
+    if (!seen.has(key)) { seen.add(key); candidates.push(name); }
+  };
+  add("egregore"); // conventional default — also covers public repos not in the list
+  const accessible = await listAccessibleRepos(token, owner);
+  for (const n of accessible.filter((n) => /egregore/i.test(n))) add(n);
+  for (const n of accessible.filter((n) => !/egregore/i.test(n))) add(n);
+
+  const MAX_PROBES = 20;
+  const found = [];
+  for (const repo of candidates.slice(0, MAX_PROBES)) {
+    let raw = null;
+    try { raw = await getFileContent(token, owner, repo, "egregore.json"); } catch { raw = null; }
+    if (!raw) continue;
+    try { found.push({ repo, config: JSON.parse(raw) }); } catch { /* malformed config — skip */ }
+  }
+  return found;
+}
+
 async function putFileContent(token, owner, repo, filePath, content, message) {
   // Get SHA if file already exists
   const { status: existStatus, data: existData } = await ghApi(
@@ -1253,22 +1309,63 @@ async function localJoinFlow(orgArg, ui, ctx = {}) {
   await acceptPendingInvitations(githubToken, orgLogin, ui);
   s1.stop("Invitations accepted");
 
-  // 4. Resolve egregore.json before cloning. The shared install() helper owns
-  //    all local filesystem setup after this point.
-  const repoName = explicitRepo || "egregore";
-  const s2 = ui.spinner(`Reading ${orgLogin}/${repoName}/egregore.json...`);
-  let config;
+  // 4. Resolve which repo under `orgLogin` holds egregore.json. An explicit
+  //    repo is read directly; a bare owner is discovered (the founder flow
+  //    names the repo after the org slug, NOT "egregore", so we can't assume).
+  //    The shared install() helper owns all local setup after this point.
+  const s2 = ui.spinner(
+    explicitRepo
+      ? `Reading ${orgLogin}/${explicitRepo}/egregore.json...`
+      : `Finding the Egregore in ${orgLogin}...`,
+  );
+  let candidates = [];
   try {
-    const raw = await getFileContent(githubToken, orgLogin, repoName, "egregore.json");
-    if (!raw) throw new Error("missing");
-    config = JSON.parse(raw);
-    s2.stop("Resolved Egregore config");
-  } catch (err) {
-    s2.fail("Could not read egregore.json");
-    ui.error(`Make sure ${orgLogin}/${repoName} exists and you accepted the GitHub invitation.`);
-    ui.info(`Ask the admin to resend: ${joinCommand(orgLogin, repoName)}`);
+    if (explicitRepo) {
+      const raw = await getFileContent(githubToken, orgLogin, explicitRepo, "egregore.json");
+      if (raw) candidates = [{ repo: explicitRepo, config: JSON.parse(raw) }];
+    } else {
+      candidates = await discoverEgregoreRepos(githubToken, orgLogin);
+    }
+  } catch {
+    candidates = [];
+  }
+
+  if (candidates.length === 0) {
+    s2.fail("Could not find an Egregore to join");
+    const exists = await ownerExists(githubToken, orgLogin);
+    if (!exists) {
+      // The owner itself isn't a GitHub account — almost always a repo name
+      // passed where owner/repo was meant (e.g. `join xenocracy` for
+      // `fcdagdelen/xenocracy`).
+      ui.error(`No GitHub user or organization named ${ui.bold(orgLogin)}.`);
+      ui.info(`Join targets are ${ui.bold("owner/repo")} — e.g. ${ui.bold(joinCommand("acme", "acme"))}.`);
+    } else if (explicitRepo) {
+      ui.error(`${ui.bold(`${orgLogin}/${explicitRepo}`)} has no egregore.json on its default branch.`);
+      ui.info("Confirm the repo name, that egregore.json is committed to the default branch, and that you accepted the GitHub invitation.");
+    } else {
+      ui.error(`No Egregore repo found under ${ui.bold(orgLogin)} that you can access.`);
+      ui.info(`If you know it, pass the repo: ${ui.bold(joinCommand(orgLogin, "<repo>"))}. Otherwise ask the admin for the exact ${ui.bold("owner/repo")}.`);
+    }
     process.exit(1);
   }
+
+  let repoName;
+  let config;
+  if (candidates.length === 1) {
+    ({ repo: repoName, config } = candidates[0]);
+    s2.stop(`Found ${orgLogin}/${repoName}`);
+  } else {
+    s2.stop(`Found ${candidates.length} Egregores in ${orgLogin}`);
+    const picked = await ui.choose(
+      `Which Egregore in ${orgLogin}?`,
+      candidates.map((c) => ({
+        label: `${orgLogin}/${c.repo}`,
+        description: c.config.org_name || "",
+        _candidate: c,
+      })),
+    );
+    ({ repo: repoName, config } = picked._candidate);
+  }
   ui.success(`Found ${ui.bold(config.org_name || orgLogin)}`);
 
   const orgName = config.org_name || orgLogin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.18.9",
+  "version": "0.18.10",
   "description": "Set up Egregore for your team in one command — installs the egregore launcher and your choice of Claude Code or Codex.",
   "license": "MIT",
   "bin": {