create-egregore 0.18.6 → 0.18.8

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.5.20
+// egregore-launcher-version: 0.5.23
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -30,7 +30,7 @@ const https = require("node:https");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.5.20";
+const VERSION = "0.5.23";
 const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
 const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
 const PUBLIC_NPX_PACKAGE = "create-egregore";
@@ -99,6 +99,7 @@ const ANSI = {
   clear:          "\x1b[2J",
   home:           "\x1b[H",
   clearLine:      "\x1b[K",
+  clearDown:      "\x1b[J",
   // Disable every terminal mouse-reporting mode. Some terminals (tmux,
   // iTerm2) or a TUI run earlier in the session leave mouse reporting ON,
   // which turns the scroll wheel into escape sequences that corrupt our
@@ -126,6 +127,23 @@ function makeMouseFilter() {
   let x11 = 0;     // raw bytes left to swallow after ESC [ M
   return function isMouseEvent(chunk, key) {
     const seq = (key && key.sequence) || (typeof chunk === "string" ? chunk : "") || "";
+    // A real, unshifted navigation/action key is never part of a mouse report
+    // — those decompose into "[<"/"[M" plus digit keypresses, never named
+    // arrows/enter/etc. If a quirky terminal (e.g. Warp) emitted a malformed or
+    // partial mouse sequence, the stuck sgr/x11 state below would otherwise
+    // swallow these keys and freeze navigation ("arrows don't work"). Reset and
+    // let them through. Digits are deliberately NOT included — they stay
+    // filtered mid-sequence so scroll-wheel protection still holds.
+    if (key && !key.shift && !key.ctrl && !key.meta) {
+      const nm = key.name;
+      if (nm === "up" || nm === "down" || nm === "left" || nm === "right" ||
+          nm === "return" || nm === "escape" || nm === "home" || nm === "end" ||
+          nm === "pageup" || nm === "pagedown") {
+        sgr = false;
+        x11 = 0;
+        return false;
+      }
+    }
     if (sgr) {
       if (/[Mm]/.test(seq)) sgr = false; // SGR terminates on M (press) / m (release)
       return true;
@@ -691,8 +709,15 @@ async function launch(inst, runtimeOverride) {
 }
 
 function setupNewEgregore(runtimeOverride) {
-  const args = ["--yes", `${PUBLIC_NPX_PACKAGE}@latest`, "--open"];
+  // The launcher (alt-screen) already served as the entry screen. Pass
+  // --no-welcome so the spawned installer skips its own full-screen welcome
+  // bookend: a second alt-screen enter right after the launcher's teardown
+  // demands a redundant Enter and churns the alt buffer (duplicated footer on
+  // some terminals). The ending summary bookend is unaffected.
+  const args = ["--yes", `${PUBLIC_NPX_PACKAGE}@latest`, "--open", "--no-welcome"];
   if (runtimeOverride) args.push("--runtime", runtimeOverride);
+  // Bridge the npx-resolve gap so the first Enter never looks like a no-op.
+  process.stdout.write(`\n  ${CYAN}❯${RESET} ${BOLD}Setting up a new Egregore…${RESET}\n  ${DIM}fetching the latest installer — this can take a few seconds${RESET}\n\n`);
   const child = spawn("npx", args, {
     stdio: "inherit",
     cwd: safeCwd(),
@@ -1500,7 +1525,13 @@ async function browser(args = {}) {
     const h = process.stdout.rows || 24;
 
     const out = [];
-    out.push(ANSI.home);
+    // Home AND clear-to-end-of-screen each frame. The per-line ANSI.clearLine
+    // calls below are belt-and-suspenders; some terminals (notably Warp) don't
+    // apply incremental \x1b[K reliably across an alt-screen redraw, leaving
+    // stale lines — most visibly a duplicated footer. A single clear-down after
+    // home wipes the slate before redraw. It's part of the same atomic write,
+    // so there's no extra flicker.
+    out.push(ANSI.home + ANSI.clearDown);
 
     if (state.runtimeInst) {
       const runtimeLines = renderRuntimePanel({
@@ -1681,7 +1712,13 @@ async function browser(args = {}) {
     process.stdin.setRawMode(false);
     process.stdin.pause();
     process.stdin.removeAllListeners("keypress");
-    process.stdout.write(ANSI.mouseOff + ANSI.cursorShow + ANSI.altScreenLeave);
+    // Clear the alt buffer BEFORE leaving it. A well-behaved terminal discards
+    // the alt buffer and restores the primary screen on \x1b[?1049l, so this is
+    // a harmless no-op there. Warp, however, dumps the alt buffer's contents
+    // into the primary scrollback on exit — clearing first means it dumps a
+    // blank screen instead of the whole launcher frame, so the next flow (the
+    // guided "+ new" setup) starts on a clean screen.
+    process.stdout.write(ANSI.mouseOff + ANSI.cursorShow + ANSI.clear + ANSI.home + ANSI.altScreenLeave);
   };
   process.on("exit", cleanup);
   process.on("SIGINT", () => { cleanup(); process.exit(130); });

package/bin/cli.js

@@ -205,6 +205,12 @@ function parseArgs(argv) {
       args.noAutolaunch = true;
     } else if (argv[i] === "--no-screens") {
       args.noScreens = true;
+    } else if (argv[i] === "--no-welcome") {
+      // Skip only the full-screen entry welcome bookend (keep the ending
+      // summary). Used when re-entered from the launcher's "+ new", which
+      // already served as the entry screen — a second alt-screen welcome
+      // would otherwise demand a redundant Enter and churn the alt buffer.
+      args.noWelcome = true;
     } else if (argv[i] === "--codex") {
       args.runtime = "codex";
     } else if (argv[i] === "--claude" || argv[i] === "--claude-code") {
@@ -459,7 +465,7 @@ async function main() {
   // or the other — don't double up. `--no-screens` and non-TTY fall back
   // to the inline banner.
   const useScreens = !args.noScreens && ui.canShowScreens();
-  if (useScreens) {
+  if (useScreens && !args.noWelcome) {
     const mode = args.subcommand === "join" ? "join"
       : args.token ? "token"
       : args.open ? "founder"

package/lib/local.js

@@ -990,42 +990,14 @@ async function localFounderFlow(ui, ctx = {}) {
     statePath: path.join(egregoreDir, ".egregore-state.json"),
   });
 
-  // 18. Optional invite — picker for org members, text fallback otherwise.
+  // 18. Optional invite — looped so the founder can bring in several
+  //      teammates and then explicitly finish, instead of being dropped into
+  //      the assistant the instant the first invite lands.
   ui.section("Bring someone in", "Egregore shines when it's shared");
 
-  let invUsername = "";
-  if (isOrg) {
-    const memberSpin = ui.spinner("Loading org members...");
-    const members = await listOrgMembers(githubToken, githubOrg);
-    memberSpin.stop(members.length > 0 ? `Loaded ${members.length} members` : "No visible members");
-
-    // Filter out the current user — they can't invite themselves.
-    const pickable = members
-      .filter((m) => m.login !== user.login)
-      .slice(0, 20);
-
-    if (pickable.length > 0) {
-      const choices = [
-        { label: "Skip — work solo for now", description: "I can always /invite later" },
-        ...pickable.map((m) => ({ label: m.login, description: `@${githubOrg} member` })),
-        { label: "Type a username", description: "invite someone not in the list" },
-      ];
-      const picked = await ui.choose("who should we invite?", choices);
-      if (picked.label === "Skip — work solo for now") {
-        invUsername = "";
-      } else if (picked.label === "Type a username") {
-        invUsername = await ui.prompt("GitHub username");
-      } else {
-        invUsername = picked.label;
-      }
-    } else {
-      invUsername = await ui.prompt("teammate's GitHub username (or Enter to skip)");
-    }
-  } else {
-    invUsername = await ui.prompt("teammate's GitHub username (or Enter to skip)");
-  }
-
-  if (invUsername) {
+  // Perform a single invite. Returns true on success so the caller can track
+  // who's been added (and keep them out of the picker on the next round).
+  const inviteOne = async (invUsername) => {
     const invSpin = ui.spinner(`Inviting ${invUsername}...`);
     try {
       // Add as collaborator to all repos
@@ -1071,9 +1043,64 @@ async function localFounderFlow(ui, ctx = {}) {
         shareLines.push(`Telegram: ${egreConfig.telegram_group_link}`);
       }
       ui.card("share", shareLines);
+      return true;
     } catch (err) {
       invSpin.fail(`Could not invite ${invUsername}: ${err.message}`);
+      return false;
+    }
+  };
+
+  // Load org members once (the picker source); text fallback otherwise.
+  let orgMembers = [];
+  if (isOrg) {
+    const memberSpin = ui.spinner("Loading org members...");
+    orgMembers = await listOrgMembers(githubToken, githubOrg);
+    memberSpin.stop(orgMembers.length > 0 ? `Loaded ${orgMembers.length} members` : "No visible members");
+  }
+
+  const invitedUsers = [];
+  // Loop until the founder skips/finishes or runs out of people to invite.
+  for (;;) {
+    const first = invitedUsers.length === 0;
+    let invUsername = "";
+
+    // Members not yet invited and not the founder themselves. No cap — the
+    // picker scrolls and filters, so large orgs stay navigable.
+    const pickable = orgMembers
+      .filter((m) => m.login !== user.login && !invitedUsers.includes(m.login));
+
+    if (isOrg && pickable.length > 0) {
+      const stopChoice = first
+        ? { label: "Skip — work solo for now", description: "I can always /invite later" }
+        : { label: "Done — continue setup", description: `${invitedUsers.length} invited so far` };
+      const choices = [
+        stopChoice,
+        ...pickable.map((m) => ({ label: m.login, description: `@${githubOrg} member` })),
+        { label: "Type a username", description: "invite someone not in the list" },
+      ];
+      const picked = await ui.choose(first ? "who should we invite?" : "invite someone else?", choices);
+      if (picked.label === stopChoice.label) break;
+      if (picked.label === "Type a username") {
+        invUsername = await ui.prompt("GitHub username");
+      } else {
+        invUsername = picked.label;
+      }
+    } else {
+      const prompt = first
+        ? "teammate's GitHub username (or Enter to skip)"
+        : "another teammate's GitHub username (or Enter to finish)";
+      invUsername = await ui.prompt(prompt);
     }
+
+    invUsername = (invUsername || "").trim();
+    if (!invUsername) break;
+    if (invitedUsers.includes(invUsername)) {
+      ui.info(`Already invited ${invUsername}.`);
+      continue;
+    }
+
+    const ok = await inviteOne(invUsername);
+    if (ok) invitedUsers.push(invUsername);
   }
 
   // 18b. Record invite outcome in state so the /onboarding skill knows to
@@ -1083,7 +1110,7 @@ async function localFounderFlow(ui, ctx = {}) {
     try {
       const cur = JSON.parse(fs.readFileSync(statePath, "utf-8"));
       cur.onboarding = cur.onboarding || {};
-      cur.onboarding.invite_skipped = !invUsername;
+      cur.onboarding.invite_skipped = invitedUsers.length === 0;
       cur.onboarding.invite_handled_by = "installer";
       cur.onboarding.phase = "complete";
       cur.onboarding.completed_at = cur.onboarding.completed_at || new Date().toISOString();
@@ -1111,7 +1138,9 @@ async function localFounderFlow(ui, ctx = {}) {
   const assistantName = preferredRuntime === "codex" ? "Codex" : "Claude Code";
   const setupSummary = {
     workspace: "created",
-    invite: invUsername ? `sent to ${invUsername}` : "skipped",
+    invite: invitedUsers.length
+      ? `sent to ${invitedUsers.join(", ")}`
+      : "skipped",
     telegram: telegramResult.groupLink
       ? "connected"
       : telegramResult.setup

package/lib/ui.js

@@ -330,20 +330,38 @@ async function interactiveChoose(question, options, hint) {
       Math.max(...options.map((o) => o.label.length)),
     );
 
+    // Scrolling viewport: only ever draw a bounded window of options so a big
+    // list (hundreds of org members/repos) doesn't flood the terminal. The
+    // window follows the cursor; "↑/↓ N more" mark the hidden remainder, and
+    // type-to-filter narrows the full set. Sized to the terminal, clamped.
+    const VIEWPORT = Math.max(6, Math.min(14, (process.stdout.rows || 24) - 8));
+
+    const renderRow = (entry, i) => {
+      const { opt } = entry;
+      const desc = opt.description ? `  ${DIM}${opt.description}${RESET}` : "";
+      if (opt.disabled) {
+        return `    ${DIM}·  ${pad(opt.label, labelWidth)}${RESET}${desc}`;
+      }
+      const selected = i === cursor;
+      const marker = selected ? `${CYAN}❯${RESET}` : " ";
+      const labelPart = selected ? `${BOLD}${CYAN}${pad(opt.label, labelWidth)}${RESET}` : pad(opt.label, labelWidth);
+      return `    ${marker}  ${labelPart}${desc}`;
+    };
+
     const render = (first = false) => {
-      const lines = visible.map((entry, i) => {
-        const { opt } = entry;
-        const desc = opt.description ? `  ${DIM}${opt.description}${RESET}` : "";
-        if (opt.disabled) {
-          return `    ${DIM}·  ${pad(opt.label, labelWidth)}${RESET}${desc}`;
-        }
-        const selected = i === cursor;
-        const marker = selected ? `${CYAN}❯${RESET}` : " ";
-        const labelPart = selected ? `${BOLD}${CYAN}${pad(opt.label, labelWidth)}${RESET}` : pad(opt.label, labelWidth);
-        return `    ${marker}  ${labelPart}${desc}`;
-      });
-      if (visible.length === 0) {
+      const lines = [];
+      const total = visible.length;
+      if (total === 0) {
         lines.push(`    ${DIM}(no matches)${RESET}`);
+      } else if (total <= VIEWPORT) {
+        for (let i = 0; i < total; i++) lines.push(renderRow(visible[i], i));
+      } else {
+        const half = Math.floor(VIEWPORT / 2);
+        const start = Math.max(0, Math.min(total - VIEWPORT, cursor - half));
+        const end = Math.min(total, start + VIEWPORT);
+        if (start > 0) lines.push(`    ${DIM}↑ ${start} more${RESET}`);
+        for (let i = start; i < end; i++) lines.push(renderRow(visible[i], i));
+        if (end < total) lines.push(`    ${DIM}↓ ${total - end} more · type to filter${RESET}`);
       }
       if (!first) clearLines(lastLineCount);
       lastLineCount = renderPicker({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.18.6",
+  "version": "0.18.8",
   "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": {