create-egregore 0.14.2 → 0.15.1

package/lib/auth.js

@@ -5,7 +5,8 @@
 
 const https = require("node:https");
 
-const CLIENT_ID = "Iv23li2obNsAjakoK2RE";  // GitHub App — clean consent, permissions via installation
+const GITHUB_APP_CLIENT_ID = "Iv23li2obNsAjakoK2RE";   // GitHub App — founder flow (clean install screen)
+const OAUTH_APP_CLIENT_ID = "Ov23liYZjJbbbNgnJ9vH";    // OAuth App — join flow (repo:invite only)
 
 function post(url, body) {
   return new Promise((resolve, reject) => {
@@ -72,12 +73,18 @@ function copyToClipboard(text) {
 /**
  * Run GitHub Device Flow.
  * Returns the access token string, or throws on failure.
+ * @param {object} [opts] - Options
+ * @param {string} [opts.mode] - "join" uses OAuth App with repo:invite scope
  */
-async function deviceFlow(ui) {
+async function deviceFlow(ui, opts = {}) {
+  const isJoin = opts.mode === "join";
+  const clientId = isJoin ? OAUTH_APP_CLIENT_ID : GITHUB_APP_CLIENT_ID;
+  const scope = isJoin ? "repo:invite" : "";
+
   // 1. Request device code
   const codeResp = await post("https://github.com/login/device/code", {
-    client_id: CLIENT_ID,
-    scope: "",
+    client_id: clientId,
+    scope,
   });
 
   if (!codeResp.device_code) {
@@ -111,7 +118,7 @@ async function deviceFlow(ui) {
     await sleep(interval);
 
     const tokenResp = await post("https://github.com/login/oauth/access_token", {
-      client_id: CLIENT_ID,
+      client_id: clientId,
       device_code,
       grant_type: "urn:ietf:params:oauth:grant-type:device_code",
     });

package/lib/local.js

@@ -168,6 +168,43 @@ function cloneRepo(url, dir, token, ui, label) {
   ui.success(`Cloned ${label}`);
 }
 
+/**
+ * Convert HTTPS GitHub URL to SSH format.
+ * https://github.com/org/repo.git → git@github.com:org/repo.git
+ */
+function toSSH(url) {
+  const m = url.match(/https:\/\/github\.com\/(.+?)(?:\.git)?$/);
+  return m ? `git@github.com:${m[1]}.git` : null;
+}
+
+/**
+ * Clone a repo, trying SSH first then HTTPS.
+ * GIT_TERMINAL_PROMPT=0 prevents the hanging username/password prompt.
+ */
+function cloneWithFallback(httpsUrl, dir, timeout = 60000) {
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+  const sshUrl = toSSH(httpsUrl);
+
+  // Try SSH first (most devs have SSH keys; GitHub no longer supports HTTPS password auth)
+  if (sshUrl) {
+    try {
+      execFileSync("git", ["clone", sshUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+      return true;
+    } catch {
+      // Clean up partial clone so HTTPS fallback can use the same dir
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  }
+
+  // Fall back to HTTPS (works if user has gh CLI or a credential helper configured)
+  try {
+    execFileSync("git", ["clone", httpsUrl, dir], { stdio: "pipe", encoding: "utf-8", timeout, env });
+    return true;
+  } catch {}
+
+  return false;
+}
+
 function setGitIdentity(dir, user) {
   try {
     run(`git config user.name "${user.name}"`, { cwd: dir });
@@ -568,18 +605,11 @@ async function localJoinFlow(orgArg, ui) {
     explicitRepo = null;
   }
 
-  // 1. Install GitHub App — needed for the token to access repository resources
+  // 1. GitHub auth — OAuth with repo:invite scope (narrow: just invitation acceptance)
   ui.info(`Joining ${ui.bold(orgLogin)}. First, sign in with GitHub.\n`);
-  ui.info("Install the Egregore app on your GitHub account.");
-  ui.info("This lets Egregore access the repos you've been invited to.\n");
-  openBrowser(APP_INSTALL_URL);
-  await ui.prompt("Press Enter when done...");
-
-  // 2. GitHub auth (auto-approved after App install)
-  ui.info("");
   let githubToken;
   try {
-    githubToken = await deviceFlow(ui);
+    githubToken = await deviceFlow(ui, { mode: "join" });
     ui.success("Authenticated with GitHub");
   } catch (err) {
     ui.error(`GitHub auth failed: ${err.message}`);
@@ -589,54 +619,50 @@ async function localJoinFlow(orgArg, ui) {
   // 2. Get user info
   const user = await getUser(githubToken);
 
-  // 3. Accept pending invitations (may silently fail with GitHub App tokens)
+  // 3. Accept pending invitations
   console.log("");
-  const s1 = ui.spinner("Checking for invitations...");
+  const s1 = ui.spinner("Accepting invitations...");
   await acceptPendingInvitations(githubToken, orgLogin, ui);
-  s1.stop("Checked invitations");
+  s1.stop("Invitations accepted");
+
+  // 4. Determine repo name
+  const repoName = explicitRepo || "egregore";
+  if (!repoName) {
+    ui.error("Usage: npx create-egregore join <org>/<repo>");
+    process.exit(1);
+  }
 
-  // 4. Find egregore repo
-  let repoName = await findEgregoreRepo(githubToken, orgLogin, explicitRepo);
+  // 5. Clone repos using git credentials (SSH keys / gh CLI / credential helper)
+  //    The OAuth token only has repo:invite scope — cloning uses the joiner's own git setup.
+  const base = process.cwd();
+  const egregoreDir = path.join(base, repoName);
 
-  // 4b. If repo not found, the user likely has a pending invitation that couldn't
-  //     be accepted automatically. Open the repo page so they can accept with one click.
-  if (!repoName && explicitRepo) {
-    console.log("");
-    ui.info("Accept the repo invitation in your browser.");
-    openBrowser(`https://github.com/${orgLogin}/${explicitRepo}`);
-    await ui.prompt("Press Enter after accepting...");
-
-    const s2 = ui.spinner("Retrying...");
-    repoName = await findEgregoreRepo(githubToken, orgLogin, explicitRepo);
-    if (!repoName) {
-      s2.fail(`Still can't access ${orgLogin}/${explicitRepo}`);
-      ui.error("Make sure the org admin has set up Egregore and invited you.");
-      process.exit(1);
-    }
-    s2.stop("Access confirmed");
-  } else if (!repoName) {
-    ui.error(`No egregore repo found in ${orgLogin}`);
-    ui.error("Make sure the org admin has set up Egregore and invited you.");
-    ui.info("If the repo has a custom name, use: npx create-egregore join <org>/<repo>");
+  console.log("");
+  const s2 = ui.spinner(`Cloning ${orgLogin}/${repoName}...`);
+  if (cloneWithFallback(`https://github.com/${orgLogin}/${repoName}.git`, egregoreDir)) {
+    s2.stop(`Cloned ${repoName}`);
+  } else {
+    s2.fail(`Could not clone ${orgLogin}/${repoName}`);
+    ui.error("Make sure you have git credentials set up (SSH keys or gh auth login).");
+    ui.error("Also verify the org admin has set up Egregore and invited you.");
     process.exit(1);
   }
+  setGitIdentity(egregoreDir, user);
 
-  // 5. Read egregore.json from remote
-  const s3 = ui.spinner(`Reading config from ${orgLogin}/${repoName}...`);
-  const configRaw = await getFileContent(githubToken, orgLogin, repoName, "egregore.json");
-  if (!configRaw) {
-    s3.fail("Could not read egregore.json");
-    ui.error("The egregore repo exists but has no egregore.json. Ask the admin to set up first.");
+  // 6. Read egregore.json from local clone
+  const configPath = path.join(egregoreDir, "egregore.json");
+  if (!fs.existsSync(configPath)) {
+    ui.error("The repo has no egregore.json. Ask the admin to set up first.");
     process.exit(1);
   }
   let config;
   try {
-    config = JSON.parse(configRaw);
+    config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
   } catch {
-    s3.fail("Invalid egregore.json");
+    ui.error("Invalid egregore.json");
     process.exit(1);
   }
-  s3.stop(`Found ${ui.bold(config.org_name || orgLogin)}`);
+  ui.success(`Found ${ui.bold(config.org_name || orgLogin)}`);
 
   const orgName = config.org_name || orgLogin;
   const memoryRepoName = config.memory_repo
@@ -644,61 +670,33 @@ async function localJoinFlow(orgArg, ui) {
     : `${orgLogin}-memory`;
   const managedRepos = config.repos || [];
 
-  // 5b. Check access to ALL repos — open browser for any that need invitation acceptance
-  const allRepos = [repoName, memoryRepoName, ...managedRepos];
-  const inaccessible = [];
-  for (const repo of allRepos) {
-    if (!(await repoExists(githubToken, orgLogin, repo))) {
-      inaccessible.push(repo);
-    }
-  }
-  if (inaccessible.length > 0) {
-    console.log("");
-    ui.info(`Accept ${inaccessible.length === 1 ? "the invitation" : `${inaccessible.length} invitations`} in your browser.`);
-    for (const repo of inaccessible) {
-      openBrowser(`https://github.com/${orgLogin}/${repo}`);
-    }
-    await ui.prompt("Press Enter after accepting...");
-
-    // Retry — only block on main + memory, managed repos are best-effort
-    for (const repo of [repoName, memoryRepoName]) {
-      if (inaccessible.includes(repo) && !(await repoExists(githubToken, orgLogin, repo))) {
-        ui.error(`Still can't access ${orgLogin}/${repo}`);
-        ui.error("Make sure the org admin has set up Egregore and invited you.");
-        process.exit(1);
-      }
-    }
-    ui.success("Access confirmed");
-  }
-
-  // 6. Clone locally
-  const base = process.cwd();
-  const forkUrl = `https://github.com/${orgLogin}/${repoName}.git`;
+  // 7. Clone memory + managed repos
   const memoryUrl = config.memory_repo || `https://github.com/${orgLogin}/${memoryRepoName}.git`;
-  const egregoreDir = path.join(base, repoName);
   const memoryDir = path.join(base, memoryRepoName);
 
-  const totalSteps = 5 + managedRepos.length;
-  configureGitCredentials(githubToken);
+  const totalSteps = 4 + managedRepos.length;
+  // Store the invite token for later use (invitation acceptance, not cloning)
+  const inviteToken = githubToken;
 
-  ui.step(1, totalSteps, "Cloning egregore...");
-  cloneRepo(forkUrl, egregoreDir, githubToken, ui, "egregore");
-  setGitIdentity(egregoreDir, user);
-
-  ui.step(2, totalSteps, "Cloning shared memory...");
-  cloneRepo(memoryUrl, memoryDir, githubToken, ui, "memory");
+  // Clone memory using SSH-first fallback (same as main repo)
+  ui.step(1, totalSteps, "Cloning shared memory...");
+  if (cloneWithFallback(memoryUrl, memoryDir)) {
+    ui.success("Cloned memory");
+  } else {
+    ui.warn("Could not clone memory repo — you may not have access yet.");
+  }
   setGitIdentity(memoryDir, user);
 
-  // 7. Symlink
-  ui.step(3, totalSteps, "Linking memory...");
+  // Symlink
+  ui.step(2, totalSteps, "Linking memory...");
   createSymlink(egregoreDir, memoryDir, ui);
 
-  // 8. Write .env
-  ui.step(4, totalSteps, "Writing credentials...");
-  fs.writeFileSync(path.join(egregoreDir, ".env"), `GITHUB_TOKEN=${githubToken}\n`, { mode: 0o600 });
+  // Write .env — store invite token for session-start invitation checks
+  ui.step(3, totalSteps, "Writing credentials...");
+  fs.writeFileSync(path.join(egregoreDir, ".env"), `GITHUB_TOKEN=${inviteToken}\n`, { mode: 0o600 });
   ui.success("Credentials saved");
 
-  // 9. "What should we call you?" + write state
+  // "What should we call you?" + write state
   console.log("");
   const displayName = await ui.prompt(`What should we call you? [${user.login}]:`);
 
@@ -715,30 +713,21 @@ async function localJoinFlow(orgArg, ui) {
   };
   fs.writeFileSync(path.join(egregoreDir, ".egregore-state.json"), JSON.stringify(state, null, 2) + "\n");
 
-  // 10. Register + alias
-  ui.step(5, totalSteps, "Registering instance...");
+  // Register + alias
+  ui.step(4, totalSteps, "Registering instance...");
   registerInstance(repoName, orgName, egregoreDir);
   const alias = await installShellAlias(egregoreDir, ui);
 
-  // 11. Clone managed repos (retry once — git servers may lag behind invitation acceptance)
+  // Clone managed repos using SSH-first fallback
   for (let i = 0; i < managedRepos.length; i++) {
     const mr = managedRepos[i];
-    ui.step(6 + i, totalSteps, `Cloning ${mr}...`);
+    ui.step(5 + i, totalSteps, `Cloning ${mr}...`);
     const repoDir = path.join(base, mr);
-    try {
-      const repoUrl = `https://github.com/${orgLogin}/${mr}.git`;
-      cloneRepo(repoUrl, repoDir, githubToken, ui, mr);
+    if (cloneWithFallback(`https://github.com/${orgLogin}/${mr}.git`, repoDir)) {
       setGitIdentity(repoDir, user);
-    } catch {
-      // Retry after a short delay — invitation acceptance may not have propagated
-      await new Promise((r) => setTimeout(r, 3000));
-      try {
-        const repoUrl = `https://github.com/${orgLogin}/${mr}.git`;
-        cloneRepo(repoUrl, repoDir, githubToken, ui, mr);
-        setGitIdentity(repoDir, user);
-      } catch {
-        ui.warn(`Could not clone ${mr} — you may not have access yet.`);
-      }
+      ui.success(`Cloned ${mr}`);
+    } else {
+      ui.warn(`Could not clone ${mr} — you may not have access yet.`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.14.2",
+  "version": "0.15.1",
   "description": "Set up Egregore for your team in one command",
   "license": "MIT",
   "bin": {