create-egregore 0.1.0

package/bin/cli.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+/**
+ * create-egregore — Set up Egregore in one command.
+ *
+ * Two modes:
+ *   npx create-egregore --token st_xxxx   (from website — primary path)
+ *   npx create-egregore                    (terminal-only fallback)
+ */
+
+const ui = require("../lib/ui");
+const { EgregoreAPI } = require("../lib/api");
+const { deviceFlow } = require("../lib/auth");
+const { install } = require("../lib/setup");
+
+const API_URL = process.env.EGREGORE_API_URL || "https://egregore-production-55f2.up.railway.app";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--token" && argv[i + 1]) {
+      args.token = argv[++i];
+    } else if (argv[i].startsWith("--token=")) {
+      args.token = argv[i].split("=")[1];
+    } else if (argv[i] === "--api" && argv[i + 1]) {
+      args.api = argv[++i];
+    } else if (argv[i] === "--help" || argv[i] === "-h") {
+      args.help = true;
+    }
+  }
+  return args;
+}
+
+function showHelp() {
+  ui.banner();
+  ui.info("Usage:");
+  ui.info("  npx create-egregore --token <setup-token>   Install from website");
+  ui.info("  npx create-egregore                          Interactive setup");
+  ui.info("");
+  ui.info("Options:");
+  ui.info("  --token <token>   Setup token from egregore.dev");
+  ui.info("  --api <url>       API URL override");
+  ui.info("  -h, --help        Show this help");
+  ui.info("");
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const api = new EgregoreAPI(args.api || API_URL);
+
+  ui.banner();
+
+  if (args.token) {
+    // ===== Website flow: token provided =====
+    await tokenFlow(api, args.token);
+  } else {
+    // ===== Terminal fallback: interactive =====
+    await interactiveFlow(api);
+  }
+}
+
+async function tokenFlow(api, token) {
+  const s = ui.spinner("Claiming setup token...");
+  try {
+    const data = await api.claimToken(token);
+    s.stop(`Claimed — setting up ${ui.bold(data.org_name)}`);
+    await install(data, ui);
+  } catch (err) {
+    s.fail("Token claim failed");
+    ui.error(err.message);
+    ui.info("");
+    ui.info("The token may have expired or already been used.");
+    ui.info("Visit egregore.dev to get a new one, or run without --token:");
+    ui.info("  npx create-egregore");
+    process.exit(1);
+  }
+}
+
+async function interactiveFlow(api) {
+  // 1. GitHub auth
+  ui.info("Let's set up Egregore. First, sign in with GitHub.\n");
+  let githubToken;
+  try {
+    githubToken = await deviceFlow(ui);
+    ui.success("Authenticated with GitHub");
+  } catch (err) {
+    ui.error(`GitHub auth failed: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 2. Detect orgs
+  console.log("");
+  const s = ui.spinner("Checking your organizations...");
+  let orgsData;
+  try {
+    orgsData = await api.getOrgs(githubToken);
+    s.stop("Found your organizations");
+  } catch (err) {
+    s.fail("Failed to check organizations");
+    ui.error(err.message);
+    process.exit(1);
+  }
+
+  // 3. Build choices
+  const choices = [];
+
+  // Orgs with egregore → join
+  for (const org of orgsData.orgs) {
+    if (org.has_egregore) {
+      choices.push({
+        label: org.name || org.login,
+        description: "Join existing",
+        action: "join",
+        login: org.login,
+      });
+    }
+  }
+
+  // Orgs without egregore → set up
+  for (const org of orgsData.orgs) {
+    if (!org.has_egregore) {
+      choices.push({
+        label: org.name || org.login,
+        description: "Set up new",
+        action: "setup",
+        login: org.login,
+      });
+    }
+  }
+
+  // Personal account
+  if (orgsData.personal.has_egregore) {
+    choices.push({
+      label: `${orgsData.user.login} (personal)`,
+      description: "Join existing",
+      action: "join",
+      login: orgsData.user.login,
+    });
+  } else {
+    choices.push({
+      label: `${orgsData.user.login} (personal)`,
+      description: "Set up personal",
+      action: "setup",
+      login: orgsData.user.login,
+      is_personal: true,
+    });
+  }
+
+  if (choices.length === 0) {
+    ui.error("No organizations found. Check your GitHub permissions.");
+    process.exit(1);
+  }
+
+  // 4. User picks
+  const choice = await ui.choose("Where do you want Egregore?", choices);
+
+  // 5. Execute
+  console.log("");
+  if (choice.action === "join") {
+    await joinFlow(api, githubToken, choice);
+  } else {
+    await setupFlow(api, githubToken, choice);
+  }
+}
+
+async function setupFlow(api, githubToken, choice) {
+  const orgName = await ui.prompt(`Organization display name [${choice.login}]:`);
+  const name = orgName || choice.login;
+
+  const s = ui.spinner(`Setting up Egregore for ${ui.bold(name)}...`);
+  try {
+    const result = await api.setupOrg(githubToken, {
+      github_org: choice.login,
+      org_name: name,
+      is_personal: choice.is_personal || false,
+    });
+    s.stop("Setup complete on GitHub");
+
+    // Claim the token immediately
+    const data = await api.claimToken(result.setup_token);
+    await install(data, ui);
+
+    if (result.telegram_invite_link) {
+      console.log("");
+      ui.info(`Connect Telegram (optional): ${result.telegram_invite_link}`);
+    }
+  } catch (err) {
+    s.fail("Setup failed");
+    ui.error(err.message);
+    process.exit(1);
+  }
+}
+
+async function joinFlow(api, githubToken, choice) {
+  const s = ui.spinner(`Joining ${ui.bold(choice.login)}...`);
+  try {
+    const result = await api.joinOrg(githubToken, {
+      github_org: choice.login,
+    });
+    s.stop("Joined");
+
+    const data = await api.claimToken(result.setup_token);
+    await install(data, ui);
+  } catch (err) {
+    s.fail("Join failed");
+    ui.error(err.message);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  ui.error(err.message);
+  process.exit(1);
+});

package/lib/api.js

@@ -0,0 +1,101 @@
+/**
+ * Egregore API client.
+ * Zero dependencies — uses node:https built-in.
+ */
+
+const https = require("node:https");
+const { URL } = require("node:url");
+
+const DEFAULT_API = "https://egregore-production-55f2.up.railway.app";
+
+function request(method, url, { body, headers = {}, timeout = 30000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const opts = {
+      hostname: parsed.hostname,
+      port: parsed.port || 443,
+      path: parsed.pathname + parsed.search,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...headers,
+      },
+      timeout,
+    };
+
+    const req = https.request(opts, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            reject(new Error(json.detail || `HTTP ${res.statusCode}`));
+          } else {
+            resolve(json);
+          }
+        } catch {
+          if (res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          } else {
+            resolve(data);
+          }
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+}
+
+class EgregoreAPI {
+  constructor(baseUrl) {
+    this.base = (baseUrl || DEFAULT_API).replace(/\/$/, "");
+  }
+
+  async claimToken(token) {
+    return request("GET", `${this.base}/api/org/claim/${token}`);
+  }
+
+  async getOrgs(githubToken) {
+    return request("GET", `${this.base}/api/org/setup/orgs`, {
+      headers: { Authorization: `Bearer ${githubToken}` },
+    });
+  }
+
+  async setupOrg(githubToken, { github_org, org_name, is_personal = false }) {
+    return request("POST", `${this.base}/api/org/setup`, {
+      headers: { Authorization: `Bearer ${githubToken}` },
+      body: { github_org, org_name, is_personal },
+    });
+  }
+
+  async joinOrg(githubToken, { github_org }) {
+    return request("POST", `${this.base}/api/org/join`, {
+      headers: { Authorization: `Bearer ${githubToken}` },
+      body: { github_org },
+    });
+  }
+
+  async exchangeCode(code) {
+    return request("POST", `${this.base}/api/auth/github/callback`, {
+      body: { code },
+    });
+  }
+
+  async getClientId() {
+    return request("GET", `${this.base}/api/auth/github/client-id`);
+  }
+}
+
+module.exports = { EgregoreAPI, request };

package/lib/auth.js

@@ -0,0 +1,135 @@
+/**
+ * GitHub Device Flow authentication.
+ * Zero dependencies — uses node:https built-in.
+ */
+
+const https = require("node:https");
+
+const CLIENT_ID = "Ov23lizB4nYEeIRsHTdb";
+const SCOPE = "repo,read:org";
+
+function post(url, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const data = new URLSearchParams(body).toString();
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json",
+          "Content-Length": Buffer.byteLength(data),
+        },
+      },
+      (res) => {
+        let buf = "";
+        res.on("data", (c) => (buf += c));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(buf));
+          } catch {
+            reject(new Error(buf));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function openBrowser(url) {
+  const { exec } = require("node:child_process");
+  const cmd =
+    process.platform === "darwin"
+      ? `open "${url}"`
+      : process.platform === "win32"
+        ? `start "${url}"`
+        : `xdg-open "${url}"`;
+  exec(cmd, () => {});
+}
+
+function copyToClipboard(text) {
+  const { exec } = require("node:child_process");
+  if (process.platform === "darwin") {
+    exec(`printf '%s' '${text}' | pbcopy`, () => {});
+    return true;
+  }
+  try {
+    exec(`printf '%s' '${text}' | xclip -selection clipboard`, () => {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Run GitHub Device Flow.
+ * Returns the access token string, or throws on failure.
+ */
+async function deviceFlow(ui) {
+  // 1. Request device code
+  const codeResp = await post("https://github.com/login/device/code", {
+    client_id: CLIENT_ID,
+    scope: SCOPE,
+  });
+
+  if (!codeResp.device_code) {
+    throw new Error("Failed to start GitHub device flow");
+  }
+
+  const { device_code, user_code, verification_uri, interval: pollInterval } = codeResp;
+  const verifyUrl = codeResp.verification_uri_complete || verification_uri;
+
+  // 2. Show code + open browser
+  const copied = copyToClipboard(user_code);
+  ui.info("");
+  if (copied) {
+    ui.info(`Code copied to clipboard: ${ui.bold(user_code)}`);
+  } else {
+    ui.info(`Your code: ${ui.bold(user_code)}`);
+  }
+  ui.info("Opening browser — paste the code and authorize.");
+  ui.info("");
+  openBrowser(verifyUrl);
+
+  // 3. Poll for token
+  let interval = (pollInterval || 5) * 1000;
+  const timeout = 300000; // 5 minutes
+  const start = Date.now();
+
+  while (Date.now() - start < timeout) {
+    await sleep(interval);
+
+    const tokenResp = await post("https://github.com/login/oauth/access_token", {
+      client_id: CLIENT_ID,
+      device_code,
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    });
+
+    if (tokenResp.access_token) {
+      return tokenResp.access_token;
+    }
+
+    if (tokenResp.error === "authorization_pending") {
+      continue;
+    }
+    if (tokenResp.error === "slow_down") {
+      interval += 5000;
+      continue;
+    }
+
+    throw new Error(tokenResp.error_description || tokenResp.error || "Auth failed");
+  }
+
+  throw new Error("Timed out waiting for authorization (5 minutes)");
+}
+
+module.exports = { deviceFlow };

package/lib/setup.js

@@ -0,0 +1,133 @@
+/**
+ * Local setup — clone, symlink, alias, .env.
+ * Zero dependencies — uses node:child_process, node:fs, node:path, node:os.
+ */
+
+const { execSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { stdio: "pipe", encoding: "utf-8", timeout: 60000, ...opts }).trim();
+}
+
+/**
+ * Full local setup from claimed token data.
+ *
+ * @param {object} data - from /api/org/claim/{token}
+ * @param {object} ui - UI module for output
+ * @param {string} targetDir - where to install (default: cwd)
+ */
+async function install(data, ui, targetDir) {
+  const { fork_url, memory_url, github_token, org_name, github_org, slug } = data;
+  const base = targetDir || process.cwd();
+
+  const egregoreDir = path.join(base, "egregore");
+  const memoryDirName = memory_url
+    .split("/")
+    .pop()
+    .replace(/\.git$/, "");
+  const memoryDir = path.join(base, memoryDirName);
+
+  const totalSteps = 5;
+
+  // Configure git credential helper for HTTPS cloning
+  configureGitCredentials(github_token);
+
+  // 1. Clone fork
+  ui.step(1, totalSteps, "Cloning egregore...");
+  if (fs.existsSync(egregoreDir)) {
+    ui.warn("egregore/ already exists — pulling latest");
+    run("git pull", { cwd: egregoreDir });
+  } else {
+    run(`git clone "${fork_url}" "${egregoreDir}"`);
+  }
+  ui.success("Cloned egregore");
+
+  // 2. Clone memory
+  ui.step(2, totalSteps, "Cloning shared memory...");
+  if (fs.existsSync(memoryDir)) {
+    ui.warn(`${memoryDirName}/ already exists — pulling latest`);
+    run("git pull", { cwd: memoryDir });
+  } else {
+    run(`git clone "${memory_url}" "${memoryDir}"`);
+  }
+  ui.success("Cloned memory");
+
+  // 3. Symlink
+  ui.step(3, totalSteps, "Linking memory...");
+  const symlinkTarget = path.join(egregoreDir, "memory");
+  if (fs.existsSync(symlinkTarget)) {
+    ui.warn("memory/ symlink already exists");
+  } else {
+    const relPath = path.relative(egregoreDir, memoryDir);
+    fs.symlinkSync(relPath, symlinkTarget);
+  }
+  ui.success("Linked");
+
+  // 4. Write .env
+  ui.step(4, totalSteps, "Writing credentials...");
+  const envPath = path.join(egregoreDir, ".env");
+  const envContent = `GITHUB_TOKEN=${github_token}\n`;
+  fs.writeFileSync(envPath, envContent, { mode: 0o600 });
+  ui.success("Credentials saved");
+
+  // 5. Shell alias
+  ui.step(5, totalSteps, "Setting up launch command...");
+  setupAlias(egregoreDir, ui);
+
+  // Done
+  console.log("");
+  ui.success(`Egregore is ready for ${ui.bold(org_name)}`);
+  console.log("");
+  ui.info(`Your workspace:`);
+  ui.info(`  ${ui.cyan("./egregore/")}         — Your Egregore instance`);
+  ui.info(`  ${ui.cyan(`./${memoryDirName}/`)}  — Shared knowledge`);
+  console.log("");
+  ui.info(`Next: type ${ui.bold("egregore")} in any terminal to start.`);
+  console.log("");
+}
+
+function configureGitCredentials(token) {
+  try {
+    run("git config --global credential.helper store");
+    const credentialInput = `protocol=https\nhost=github.com\nusername=x-access-token\npassword=${token}\n`;
+    execSync("git credential-store store", {
+      input: credentialInput,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+  } catch {
+    // Non-fatal — user may have their own credential setup
+  }
+}
+
+function setupAlias(egregoreDir, ui) {
+  const profiles = [
+    path.join(os.homedir(), ".zshrc"),
+    path.join(os.homedir(), ".bashrc"),
+    path.join(os.homedir(), ".bash_profile"),
+  ];
+
+  const profile = profiles.find((p) => fs.existsSync(p));
+  if (!profile) {
+    ui.warn("No shell profile found — add this to your shell config:");
+    ui.info(`  alias egregore='cd "${egregoreDir}" && claude start'`);
+    return;
+  }
+
+  const existing = fs.readFileSync(profile, "utf-8");
+  // Remove old alias
+  const cleaned = existing
+    .split("\n")
+    .filter((line) => !line.includes("alias egregore=") && !line.match(/^# Egregore$/))
+    .join("\n");
+
+  const aliasBlock = `\n# Egregore\nalias egregore='cd "${egregoreDir}" && claude start'\n`;
+  fs.writeFileSync(profile, cleaned + aliasBlock);
+
+  ui.success(`Added ${ui.dim("egregore")} alias to ${path.basename(profile)}`);
+}
+
+module.exports = { install };

package/lib/ui.js

@@ -0,0 +1,117 @@
+/**
+ * Terminal UI — colors, spinner, prompts, banner.
+ * Zero dependencies. Node 18+ built-ins only.
+ */
+
+const readline = require("node:readline");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const WHITE = "\x1b[37m";
+
+const BANNER = `
+${BOLD}${CYAN}  ███████╗ ██████╗ ██████╗ ███████╗ ██████╗  ██████╗ ██████╗ ███████╗
+  ██╔════╝██╔════╝ ██╔══██╗██╔════╝██╔════╝ ██╔═══██╗██╔══██╗██╔════╝
+  █████╗  ██║  ███╗██████╔╝█████╗  ██║  ███╗██║   ██║██████╔╝█████╗
+  ██╔══╝  ██║   ██║██╔══██╗██╔══╝  ██║   ██║██║   ██║██╔══██╗██╔══╝
+  ███████╗╚██████╔╝██║  ██║███████╗╚██████╔╝╚██████╔╝██║  ██║███████╗
+  ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝${RESET}
+`;
+
+function banner() {
+  console.log(BANNER);
+}
+
+function info(msg) {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${GREEN}✓${RESET} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${YELLOW}!${RESET} ${msg}`);
+}
+
+function error(msg) {
+  console.error(`  ${RED}✗${RESET} ${msg}`);
+}
+
+function step(n, total, msg) {
+  console.log(`\n  ${DIM}[${n}/${total}]${RESET} ${msg}`);
+}
+
+function dim(msg) {
+  return `${DIM}${msg}${RESET}`;
+}
+
+function bold(msg) {
+  return `${BOLD}${msg}${RESET}`;
+}
+
+function cyan(msg) {
+  return `${CYAN}${msg}${RESET}`;
+}
+
+// Simple spinner
+function spinner(msg) {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r  ${CYAN}${frames[i++ % frames.length]}${RESET} ${msg}`);
+  }, 80);
+  return {
+    stop(result) {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${GREEN}✓${RESET} ${result || msg}\n`);
+    },
+    fail(result) {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${RED}✗${RESET} ${result || msg}\n`);
+    },
+  };
+}
+
+// Prompt for input
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(`  ${question} `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Prompt with numbered choices
+async function choose(question, options) {
+  console.log(`\n  ${question}\n`);
+  for (let i = 0; i < options.length; i++) {
+    const { label, description } = options[i];
+    console.log(`  ${BOLD}${i + 1}.${RESET} ${label}${description ? ` ${DIM}— ${description}${RESET}` : ""}`);
+  }
+  console.log();
+
+  while (true) {
+    const answer = await prompt(`Pick [1-${options.length}]:`);
+    const n = parseInt(answer, 10);
+    if (n >= 1 && n <= options.length) {
+      return options[n - 1];
+    }
+    warn(`Enter a number between 1 and ${options.length}`);
+  }
+}
+
+module.exports = {
+  banner, info, success, warn, error, step, dim, bold, cyan,
+  spinner, prompt, choose,
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "create-egregore",
+  "version": "0.1.0",
+  "description": "Set up Egregore for your team in one command",
+  "license": "MIT",
+  "bin": {
+    "create-egregore": "./bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "keywords": [
+    "egregore",
+    "claude",
+    "ai",
+    "collaboration"
+  ]
+}