codeguilds 0.2.0

package/README.md

@@ -0,0 +1,70 @@
+# codeguilds CLI
+
+The official CLI for [CodeGuilds](https://codeguilds.dev) — install Claude Code skills, agents, MCP servers, hooks, prompts, and CLAUDE.md templates in one command.
+
+## Install
+
+```bash
+npm install -g codeguilds
+```
+
+Or run without installing:
+```bash
+npx codeguilds install <slug>
+```
+
+## Commands
+
+### `codeguilds install <slug>`
+Install a package from the registry.
+
+```bash
+codeguilds install context7          # MCP server → ~/.claude/settings.json
+codeguilds install my-skill          # Skill → ~/.claude/commands/
+codeguilds install my-agent          # Agent → ~/.claude/agents/
+codeguilds install my-template       # CLAUDE.md template → ./CLAUDE.md (append)
+codeguilds install my-template --strategy prepend   # prepend instead
+codeguilds install my-hook           # Hook → ~/.claude/settings.json
+codeguilds install my-mcp --project  # Project-local install
+```
+
+### `codeguilds search <query>`
+Search the registry.
+
+```bash
+codeguilds search github
+codeguilds search "code review"
+```
+
+### `codeguilds info <slug>`
+Show details about a package.
+
+### `codeguilds list`
+List locally installed packages.
+
+### `codeguilds uninstall <slug>`
+Remove a package and undo configuration changes.
+
+### `codeguilds login`
+Log in with your CodeGuilds account (opens browser).
+
+## How it works
+
+Each package in the registry stores an `install_config` that tells the CLI exactly where to place the package:
+
+| Type | Installed to |
+|------|-------------|
+| `mcp_server` | `~/.claude/settings.json` → `mcpServers` |
+| `hook` | `~/.claude/settings.json` → `hooks` |
+| `skill` / `prompt` | `~/.claude/commands/` |
+| `agent` | `~/.claude/agents/` |
+| `claude_md_template` | `./CLAUDE.md` (merged) or `~/.claude/CLAUDE.md` |
+
+## Requirements
+
+- Node.js 18+
+- Claude Code installed
+
+## License
+
+MIT

package/dist/auth-B7TRPIVY.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  clearAuth,
+  getAuthHeader,
+  readAuth,
+  saveAuth
+} from "./chunk-3T3YVJPG.js";
+export {
+  clearAuth,
+  getAuthHeader,
+  readAuth,
+  saveAuth
+};

package/dist/chunk-3T3YVJPG.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/lib/auth.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".codeguilds");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+function readAuth() {
+  try {
+    if (!existsSync(AUTH_FILE)) return null;
+    const raw = readFileSync(AUTH_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.access_token) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveAuth(tokens) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  const data = { ...tokens, saved_at: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuth() {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      unlinkSync(AUTH_FILE);
+    }
+  } catch {
+  }
+}
+function getAuthHeader() {
+  const auth = readAuth();
+  return auth ? `Bearer ${auth.access_token}` : null;
+}
+
+export {
+  __require,
+  readAuth,
+  saveAuth,
+  clearAuth,
+  getAuthHeader
+};

package/dist/index.js

@@ -0,0 +1,557 @@
+#!/usr/bin/env node
+import {
+  __require,
+  readAuth,
+  saveAuth
+} from "./chunk-3T3YVJPG.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/install.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/lib/api.ts
+var REGISTRY_URL = "https://wfolayipdobqxxhmejwq.supabase.co";
+var PUBLIC_ANON_KEY = process.env.CODEGUILDS_ANON_KEY ?? "sb_publishable_n5NyXLvcPMLSAWpQodcuWQ_kOz_LUTs";
+var ANON_KEY = PUBLIC_ANON_KEY;
+async function restGet(path) {
+  const res = await fetch(`${REGISTRY_URL}/rest/v1/${path}`, {
+    headers: {
+      apikey: ANON_KEY,
+      Authorization: `Bearer ${ANON_KEY}`
+    }
+  });
+  if (!res.ok) throw new Error(`Registry error ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+async function fetchPackage(slug) {
+  const rows = await restGet(
+    `packages?slug=eq.${encodeURIComponent(slug)}&status=eq.published&select=id,slug,name,description,package_type,current_version,download_count,star_count,install_config,source_url,readme_content,license,published_at,publisher:profiles!packages_publisher_id_fkey(username,display_name)&limit=1`
+  );
+  return rows[0] ?? null;
+}
+async function searchPackages(query) {
+  const safeQuery = query.replace(/[*?]/g, "");
+  return restGet(
+    `packages?status=eq.published&or=(name.ilike.*${encodeURIComponent(safeQuery)}*,description.ilike.*${encodeURIComponent(safeQuery)}*)&select=id,slug,name,description,package_type,current_version,download_count,star_count,published_at,publisher:profiles!packages_publisher_id_fkey(username,display_name)&limit=20&order=download_count.desc`
+  );
+}
+async function recordDownload(packageId) {
+  try {
+    await fetch(`${REGISTRY_URL}/rpc/record_download`, {
+      method: "POST",
+      headers: {
+        apikey: ANON_KEY,
+        Authorization: `Bearer ${ANON_KEY}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ p_package_id: packageId, p_source: "cli" })
+    });
+  } catch {
+  }
+}
+
+// src/lib/installers.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/lib/claude-settings.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { homedir } from "os";
+function getSettingsPath(scope) {
+  if (scope === "global") {
+    return resolve(homedir(), ".claude", "settings.json");
+  }
+  return resolve(process.cwd(), ".claude", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+}
+function addMcpServer(serverName, command, args, env, scope) {
+  const path = getSettingsPath(scope);
+  const settings = readSettings(path);
+  settings.mcpServers = settings.mcpServers ?? {};
+  settings.mcpServers[serverName] = {
+    command,
+    ...args.length ? { args } : {},
+    ...Object.keys(env).length ? { env } : {}
+  };
+  writeSettings(path, settings);
+}
+function removeMcpServer(serverName, scope) {
+  const path = getSettingsPath(scope);
+  const settings = readSettings(path);
+  if (!settings.mcpServers?.[serverName]) return false;
+  delete settings.mcpServers[serverName];
+  writeSettings(path, settings);
+  return true;
+}
+function addHook(event, matcher, command, scope) {
+  const path = getSettingsPath(scope);
+  const settings = readSettings(path);
+  settings.hooks = settings.hooks ?? {};
+  settings.hooks[event] = settings.hooks[event] ?? [];
+  const existing = settings.hooks[event].find((h) => h.matcher === matcher);
+  if (existing) {
+    existing.hooks = existing.hooks.filter((h) => h.command !== command);
+    existing.hooks.push({ type: "command", command });
+  } else {
+    settings.hooks[event].push({
+      ...matcher ? { matcher } : {},
+      hooks: [{ type: "command", command }]
+    });
+  }
+  writeSettings(path, settings);
+}
+function removeHook(event, command, scope) {
+  const path = getSettingsPath(scope);
+  const settings = readSettings(path);
+  if (!settings.hooks?.[event]) return false;
+  let removed = false;
+  settings.hooks[event] = settings.hooks[event].map((h) => {
+    const filtered = h.hooks.filter((hk) => hk.command !== command);
+    if (filtered.length !== h.hooks.length) removed = true;
+    return { ...h, hooks: filtered };
+  }).filter((h) => h.hooks.length > 0);
+  if (removed) writeSettings(path, settings);
+  return removed;
+}
+
+// src/lib/installers.ts
+async function installPackage(pkg, scope, strategyOverride) {
+  switch (pkg.package_type) {
+    case "mcp_server": {
+      if (!pkg.install_config) throw new Error(`Package '${pkg.slug}' has no install_config.`);
+      return installMcp(pkg, pkg.install_config, scope);
+    }
+    case "hook": {
+      if (!pkg.install_config) throw new Error(`Package '${pkg.slug}' has no install_config.`);
+      return installHook(pkg, pkg.install_config, scope);
+    }
+    case "skill":
+    case "prompt": {
+      const fileConfig = pkg.install_config;
+      const filename = fileConfig?.filename ?? `${pkg.slug}.md`;
+      return installFile(pkg, { filename }, "commands");
+    }
+    case "agent": {
+      const fileConfig = pkg.install_config;
+      const filename = fileConfig?.filename ?? `${pkg.slug}.md`;
+      return installFile(pkg, { filename }, "agents");
+    }
+    case "claude_md_template": {
+      const tmplConfig = pkg.install_config;
+      const strategy = strategyOverride ?? tmplConfig?.merge_strategy ?? "append";
+      return installTemplate(pkg, { filename: tmplConfig?.filename ?? "CLAUDE.md", merge_strategy: strategy }, scope);
+    }
+    default:
+      throw new Error(`Unknown package type: ${pkg.package_type}`);
+  }
+}
+function installMcp(pkg, config, scope) {
+  addMcpServer(config.server_name, config.command, config.args ?? [], config.env ?? {}, scope);
+  const path = scope === "global" ? "~/.claude/settings.json" : ".claude/settings.json";
+  return {
+    destination: path,
+    note: `Added MCP server '${config.server_name}' \u2014 restart Claude Code to activate`
+  };
+}
+function installHook(pkg, config, scope) {
+  addHook(config.event, config.matcher, config.command, scope);
+  const path = scope === "global" ? "~/.claude/settings.json" : ".claude/settings.json";
+  return {
+    destination: path,
+    note: `Added hook for '${config.event}' event`
+  };
+}
+function isSafeFilename(filename) {
+  if (!filename || filename.includes("..") || filename.includes("/") || filename.startsWith("~")) return false;
+  return /^[\w\-. ]+$/.test(filename);
+}
+async function installFile(pkg, config, subdir) {
+  if (!pkg.readme_content) {
+    throw new Error(`No content to install for '${pkg.slug}'`);
+  }
+  if (!isSafeFilename(config.filename)) {
+    throw new Error(`Unsafe filename rejected: '${config.filename}'`);
+  }
+  const dir = resolve2(homedir2(), ".claude", subdir);
+  mkdirSync2(dir, { recursive: true });
+  const dest = resolve2(dir, config.filename);
+  writeFileSync2(dest, pkg.readme_content);
+  return { destination: `~/.claude/${subdir}/${config.filename}` };
+}
+async function installTemplate(pkg, config, scope) {
+  if (!pkg.readme_content) {
+    throw new Error(`No content to install for '${pkg.slug}'`);
+  }
+  const dest = scope === "project" ? resolve2(process.cwd(), "CLAUDE.md") : resolve2(homedir2(), ".claude", "CLAUDE.md");
+  const content = pkg.readme_content;
+  if (!existsSync2(dest) || config.merge_strategy === "replace") {
+    writeFileSync2(dest, content);
+  } else {
+    const existing = readFileSync2(dest, "utf-8");
+    const merged = config.merge_strategy === "prepend" ? `${content}
+
+${existing}` : `${existing}
+
+${content}`;
+    writeFileSync2(dest, merged);
+  }
+  const displayDest = scope === "project" ? "./CLAUDE.md" : "~/.claude/CLAUDE.md";
+  return { destination: displayDest, note: `Merged via '${config.merge_strategy}' strategy` };
+}
+function uninstallPackage(pkg, scope) {
+  if (!pkg.install_config) return { success: true, message: "Nothing to undo" };
+  switch (pkg.package_type) {
+    case "mcp_server": {
+      const config = pkg.install_config;
+      const removed = removeMcpServer(config.server_name, scope);
+      return {
+        success: true,
+        message: removed ? `Removed MCP server '${config.server_name}' from settings` : `MCP server '${config.server_name}' was not in settings`
+      };
+    }
+    case "hook": {
+      const config = pkg.install_config;
+      const removed = removeHook(config.event, config.command, scope);
+      return {
+        success: true,
+        message: removed ? `Removed hook from '${config.event}'` : `Hook was not found in settings`
+      };
+    }
+    default:
+      return {
+        success: true,
+        message: "File-based package \u2014 remove it manually from ~/.claude/commands/ or ~/.claude/agents/"
+      };
+  }
+}
+
+// src/lib/lock.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+function getLockPath(projectDir) {
+  return resolve3(projectDir ?? process.cwd(), ".codeguilds-lock.json");
+}
+function readLock(projectDir) {
+  const path = getLockPath(projectDir);
+  if (!existsSync3(path)) return { version: 1, packages: {} };
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return { version: 1, packages: {} };
+  }
+}
+function writeLock(lock, projectDir) {
+  writeFileSync3(getLockPath(projectDir), JSON.stringify(lock, null, 2) + "\n");
+}
+function addToLock(entry, projectDir) {
+  const lock = readLock(projectDir);
+  lock.packages[entry.slug] = entry;
+  writeLock(lock, projectDir);
+}
+function removeFromLock(slug, projectDir) {
+  const lock = readLock(projectDir);
+  if (!lock.packages[slug]) return false;
+  delete lock.packages[slug];
+  writeLock(lock, projectDir);
+  return true;
+}
+
+// src/commands/install.ts
+var VALID_STRATEGIES = ["append", "prepend", "replace"];
+async function install(slug, options) {
+  const scope = options.project ? "project" : "global";
+  if (options.strategy && !VALID_STRATEGIES.includes(options.strategy)) {
+    console.error(`Invalid strategy '${options.strategy}'. Must be: append, prepend, replace`);
+    process.exit(1);
+  }
+  const strategy = options.strategy ?? "append";
+  const spinner = ora(`Looking up ${chalk.cyan(slug)}...`).start();
+  try {
+    const pkg = await fetchPackage(slug);
+    if (!pkg) {
+      spinner.fail(`Package ${chalk.cyan(slug)} not found in registry`);
+      process.exit(1);
+    }
+    const lock = readLock();
+    if (lock.packages[slug]) {
+      spinner.info(
+        `${chalk.cyan(pkg.name)} ${chalk.dim(`v${lock.packages[slug].current_version}`)} is already installed`
+      );
+      return;
+    }
+    spinner.text = `Installing ${chalk.cyan(pkg.name)} v${pkg.current_version}...`;
+    const result = await installPackage(pkg, scope, strategy);
+    await recordDownload(pkg.id);
+    addToLock({
+      slug: pkg.slug,
+      name: pkg.name,
+      current_version: pkg.current_version,
+      package_type: pkg.package_type,
+      installed_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    spinner.succeed(
+      `Installed ${chalk.green(pkg.name)} ${chalk.dim(`v${pkg.current_version}`)} \u2192 ${chalk.dim(result.destination)}`
+    );
+    if (result.note) console.log(`  ${chalk.dim("\u2139")} ${result.note}`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/uninstall.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+async function uninstall(slug, options) {
+  const scope = options.project ? "project" : "global";
+  const lock = readLock();
+  if (!lock.packages[slug]) {
+    console.log(chalk2.yellow(`${chalk2.cyan(slug)} is not in the lock file \u2014 may not be installed`));
+  }
+  const spinner = ora2(`Uninstalling ${chalk2.cyan(slug)}...`).start();
+  try {
+    const pkg = await fetchPackage(slug);
+    if (!pkg) {
+      removeFromLock(slug);
+      spinner.succeed(`Removed ${chalk2.cyan(slug)} from lock file (package not found in registry)`);
+      return;
+    }
+    const result = uninstallPackage(pkg, scope);
+    removeFromLock(slug);
+    spinner.succeed(`Uninstalled ${chalk2.green(pkg.name)}`);
+    console.log(`  ${chalk2.dim("\u2139")} ${result.message}`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/search.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+
+// src/lib/format.ts
+function formatNumber(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+
+// src/commands/search.ts
+var TYPE_LABELS = {
+  mcp_server: "MCP",
+  skill: "skill",
+  agent: "agent",
+  hook: "hook",
+  prompt: "prompt",
+  claude_md_template: "template"
+};
+async function search(query) {
+  const spinner = ora3(`Searching for "${query}"...`).start();
+  try {
+    const results = await searchPackages(query);
+    spinner.stop();
+    if (results.length === 0) {
+      console.log(chalk3.yellow(`No packages found for "${query}"`));
+      return;
+    }
+    console.log(`
+${chalk3.bold(`Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}"`)}
+`);
+    for (const pkg of results) {
+      const typeLabel = TYPE_LABELS[pkg.package_type] ?? pkg.package_type;
+      const publisher = pkg.publisher?.username ?? "unknown";
+      console.log(
+        `  ${chalk3.cyan(pkg.slug.padEnd(36))} ${chalk3.dim(typeLabel.padEnd(10))} ${chalk3.dim(`\u2193 ${formatNumber(pkg.download_count).padEnd(8)}`)} ${chalk3.dim(`by @${publisher}`)}`
+      );
+      if (pkg.description) {
+        console.log(`  ${chalk3.dim("  " + pkg.description.slice(0, 72))}`);
+      }
+    }
+    console.log(`
+${chalk3.dim(`Install with: codeguilds install <slug>`)}`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+var TYPE_LABELS2 = {
+  mcp_server: "MCP",
+  skill: "skill",
+  agent: "agent",
+  hook: "hook",
+  prompt: "prompt",
+  claude_md_template: "template"
+};
+function list() {
+  const lock = readLock();
+  const entries = Object.values(lock.packages);
+  if (entries.length === 0) {
+    console.log(chalk4.dim("No packages installed. Run `codeguilds install <slug>` to get started."));
+    return;
+  }
+  console.log(`
+${chalk4.bold(`${entries.length} package${entries.length === 1 ? "" : "s"} installed`)}
+`);
+  for (const entry of entries.sort((a, b) => a.slug.localeCompare(b.slug))) {
+    const typeLabel = TYPE_LABELS2[entry.package_type] ?? entry.package_type;
+    const date = new Date(entry.installed_at).toLocaleDateString();
+    console.log(
+      `  ${chalk4.cyan(entry.slug.padEnd(36))} ${chalk4.dim(typeLabel.padEnd(10))} ${chalk4.dim(`v${entry.current_version.padEnd(10)}`)} ${chalk4.dim(date)}`
+    );
+  }
+}
+
+// src/commands/info.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+async function info(slug) {
+  const spinner = ora4(`Fetching ${chalk5.cyan(slug)}...`).start();
+  try {
+    const pkg = await fetchPackage(slug);
+    spinner.stop();
+    if (!pkg) {
+      console.log(chalk5.yellow(`Package ${chalk5.cyan(slug)} not found`));
+      process.exit(1);
+    }
+    console.log(`
+${chalk5.bold(pkg.name)} ${chalk5.dim(`v${pkg.current_version}`)}
+${pkg.description ?? ""}
+
+  ${chalk5.dim("Type:")}       ${pkg.package_type}
+  ${chalk5.dim("Publisher:")}  @${pkg.publisher?.username ?? "unknown"}
+  ${chalk5.dim("Downloads:")}  ${formatNumber(pkg.download_count)}
+  ${chalk5.dim("Stars:")}      ${pkg.star_count}
+  ${chalk5.dim("License:")}    ${pkg.license ?? "unknown"}
+  ${chalk5.dim("Published:")}  ${pkg.published_at ? new Date(pkg.published_at).toLocaleDateString() : "\u2014"}
+  ${pkg.source_url ? `${chalk5.dim("Source:")}     ${pkg.source_url}` : ""}
+
+${chalk5.dim("Install:")}
+  ${chalk5.cyan(`codeguilds install ${pkg.slug}`)}
+`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+import { createServer } from "http";
+import { createHash, randomBytes } from "crypto";
+import chalk6 from "chalk";
+import ora5 from "ora";
+var WEB_BASE = process.env.CODEGUILDS_WEB_URL ?? "https://codeguilds.dev";
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+function randomPort() {
+  return 1e4 + Math.floor(Math.random() * 5e4);
+}
+function openBrowser(url) {
+  const { spawn } = __require("child_process");
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  spawn(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+}
+async function login() {
+  const existing = readAuth();
+  if (existing) {
+    const saved = new Date(existing.saved_at).toLocaleDateString();
+    console.log(chalk6.yellow(`Already logged in (session saved ${saved}).`));
+    console.log(`Run ${chalk6.cyan("codeguilds logout")} to clear the session.
+`);
+    return;
+  }
+  const port = randomPort();
+  const state = randomBytes(16).toString("hex");
+  const authUrl = `${WEB_BASE}/cli-auth?port=${port}&state=${encodeURIComponent(state)}`;
+  const spinner = ora5("Waiting for browser authentication...").start();
+  const result = await new Promise((resolve4) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      resolve4(null);
+    }, LOGIN_TIMEOUT_MS);
+    const server = createServer((req, res) => {
+      if (!req.url?.startsWith("/callback")) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const url = new URL(req.url, `http://localhost:${port}`);
+      const receivedState = url.searchParams.get("state");
+      const accessToken = url.searchParams.get("access_token");
+      const refreshToken = url.searchParams.get("refresh_token");
+      const expectedBuf = Buffer.from(state);
+      const receivedBuf = Buffer.from(receivedState ?? "");
+      const stateValid = expectedBuf.length === receivedBuf.length && createHash("sha256").update(expectedBuf).digest().equals(
+        createHash("sha256").update(receivedBuf).digest()
+      );
+      if (!stateValid || !accessToken || !refreshToken) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Authentication failed. Please try again.</h2></body></html>");
+        clearTimeout(timeout);
+        server.close();
+        resolve4(null);
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body style='font-family:sans-serif;text-align:center;padding:4rem'><h2>\u2705 Logged in successfully!</h2><p>You can close this tab and return to your terminal.</p></body></html>"
+      );
+      clearTimeout(timeout);
+      server.close();
+      resolve4({ access_token: accessToken, refresh_token: refreshToken });
+    });
+    server.listen(port, "127.0.0.1", () => {
+      spinner.text = `Opening browser... ${chalk6.dim(authUrl)}`;
+      openBrowser(authUrl);
+      console.log(`
+${chalk6.dim("If the browser did not open, visit:")}`);
+      console.log(`${chalk6.cyan(authUrl)}
+`);
+    });
+    server.on("error", () => {
+      clearTimeout(timeout);
+      resolve4(null);
+    });
+  });
+  if (!result) {
+    spinner.fail("Login timed out or was cancelled.");
+    process.exit(1);
+  }
+  saveAuth(result);
+  spinner.succeed(chalk6.green("Logged in successfully! Credentials saved to ~/.codeguilds/auth.json"));
+}
+async function logout() {
+  const { clearAuth } = await import("./auth-B7TRPIVY.js");
+  clearAuth();
+  console.log(chalk6.green("Logged out. Session cleared."));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("codeguilds").description("CLI for the CodeGuilds registry \u2014 install packages for Claude Code").version("0.1.0");
+program.command("install <slug>").description("Install a package from the registry").option("--project", "Install into project-local .claude/ instead of global").option("--strategy <strategy>", "Merge strategy for CLAUDE.md templates: append | prepend | replace", "append").action(install);
+program.command("uninstall <slug>").alias("remove").description("Uninstall a package and undo config changes").option("--project", "Target project-local .claude/ scope").action(uninstall);
+program.command("search <query>").description("Search the registry").action(search);
+program.command("list").alias("ls").description("List installed packages").action(list);
+program.command("info <slug>").description("Show details about a package").action(info);
+program.command("login").description("Authenticate via browser OAuth").action(login);
+program.command("logout").description("Clear saved credentials").action(logout);
+program.parse();