astro-users 0.1.0

package/dist/index.js

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import pc3 from "picocolors";
+
+// src/commands/add.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/registry.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/alex-boop-chasey/astro-users/main/registry";
+function resolveRegistry(override) {
+  const raw = override ?? process.env.ASTRO_USERS_REGISTRY;
+  if (raw) {
+    if (/^https?:\/\//.test(raw)) return { kind: "remote", base: raw.replace(/\/$/, "") };
+    return { kind: "local", base: resolve(raw) };
+  }
+  const local = findLocalRegistry();
+  if (local) return { kind: "local", base: local };
+  return { kind: "remote", base: DEFAULT_REGISTRY_URL };
+}
+function findLocalRegistry() {
+  const starts = [dirname(fileURLToPath(import.meta.url)), process.cwd()];
+  for (const start of starts) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+      const candidate = join(dir, "registry");
+      if (existsSync(join(candidate, "schema.json"))) return candidate;
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function readSourceText(source, relPath) {
+  if (source.kind === "local") {
+    return readFile(join(source.base, relPath), "utf8");
+  }
+  const url = `${source.base}/${relPath.split("/").map(encodeURIComponent).join("/")}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Registry fetch failed (${res.status}) for ${url}`);
+  return res.text();
+}
+async function loadManifest(source, name) {
+  let text2;
+  try {
+    text2 = await readSourceText(source, `${name}/registry.json`);
+  } catch {
+    throw new Error(`Component "${name}" was not found in the registry (${source.base}).`);
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(text2);
+  } catch (err) {
+    throw new Error(`Component "${name}" has an invalid manifest: ${err.message}`);
+  }
+  if (!manifest.name || !Array.isArray(manifest.files)) {
+    throw new Error(`Component "${name}" has an incomplete manifest.`);
+  }
+  return manifest;
+}
+function readComponentFile(source, manifest, file) {
+  return readSourceText(source, `${manifest.name}/files/${file.path}`);
+}
+async function resolveInstallPlan(source, name) {
+  const seen = /* @__PURE__ */ new Map();
+  const order = [];
+  async function visit(slug, trail) {
+    if (seen.has(slug)) return;
+    if (trail.includes(slug)) {
+      throw new Error(`Circular dependency: ${[...trail, slug].join(" -> ")}`);
+    }
+    const manifest = await loadManifest(source, slug);
+    seen.set(slug, manifest);
+    for (const req of manifest.requires ?? []) {
+      await visit(req, [...trail, slug]);
+    }
+    order.push(manifest);
+  }
+  await visit(name, []);
+  return order;
+}
+
+// src/utils.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+async function detectProject(cwd) {
+  const root = resolve2(cwd);
+  const pkgPath = join2(root, "package.json");
+  if (!existsSync2(pkgPath)) {
+    throw new Error(
+      `No package.json found in ${root}. Run this inside an Astro project, or pass --cwd <path>.`
+    );
+  }
+  let hasAstro = false;
+  try {
+    const pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
+    hasAstro = Boolean(pkg.dependencies?.astro ?? pkg.devDependencies?.astro);
+  } catch {
+  }
+  return { root, hasAstro };
+}
+async function writeComponentFile(root, target, content, force) {
+  const abs = join2(root, target);
+  if (existsSync2(abs)) {
+    const existing = await readFile2(abs, "utf8");
+    if (existing === content) return { target, outcome: "unchanged" };
+    if (!force) {
+      const altAbs = `${abs}.astro-users-new`;
+      await mkdir(dirname2(altAbs), { recursive: true });
+      await writeFile(altAbs, content, "utf8");
+      return { target, outcome: "conflict", altPath: `${target}.astro-users-new` };
+    }
+    await writeFile(abs, content, "utf8");
+    return { target, outcome: "overwritten" };
+  }
+  await mkdir(dirname2(abs), { recursive: true });
+  await writeFile(abs, content, "utf8");
+  return { target, outcome: "created" };
+}
+async function mergeEnv(root, entries) {
+  const envPath = join2(root, ".env");
+  let current = "";
+  if (existsSync2(envPath)) current = await readFile2(envPath, "utf8");
+  const added = [];
+  const skipped = [];
+  const lines = [];
+  for (const entry of entries) {
+    const present = new RegExp(`^\\s*${escapeRegExp(entry.name)}\\s*=`, "m").test(current);
+    if (present) {
+      skipped.push(entry.name);
+      continue;
+    }
+    if (entry.comment) lines.push(`# ${entry.comment}`);
+    lines.push(`${entry.name}=${entry.value}`);
+    added.push(entry.name);
+  }
+  if (added.length > 0) {
+    const prefix = current.length > 0 && !current.endsWith("\n") ? "\n" : "";
+    const block = `${prefix}
+# --- Added by Astro Users ---
+${lines.join("\n")}
+`;
+    await writeFile(envPath, current + block, "utf8");
+  }
+  return { added, skipped };
+}
+async function checkAstroConfig(root) {
+  const candidates = ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.mts"];
+  for (const name of candidates) {
+    const p3 = join2(root, name);
+    if (!existsSync2(p3)) continue;
+    const src = await readFile2(p3, "utf8");
+    return {
+      found: true,
+      configPath: name,
+      isServer: /output\s*:\s*['"](server|hybrid)['"]/.test(src),
+      hasAdapter: /adapter\s*:/.test(src)
+    };
+  }
+  return { found: false, isServer: false, hasAdapter: false };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/add.ts
+async function runAdd(names, opts) {
+  p.intro(pc.bgMagenta(pc.black(" Astro Users ")));
+  if (names.length === 0) {
+    p.log.error("Specify at least one component, e.g. " + pc.cyan("astro-users add auth"));
+    p.outro(pc.red("Nothing to install."));
+    return 1;
+  }
+  const project = await detectProject(opts.cwd);
+  if (!project.hasAstro) {
+    p.log.warn(
+      `${pc.dim(project.root)}
+  No ${pc.cyan("astro")} dependency detected \u2014 installing anyway, but this may not be an Astro project.`
+    );
+  }
+  const source = resolveRegistry(opts.registry);
+  p.log.info(`Registry: ${pc.dim(`${source.kind} \xB7 ${source.base}`)}`);
+  const manifests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const spin = p.spinner();
+  spin.start("Resolving components");
+  try {
+    for (const name of names) {
+      const plan = await resolveInstallPlan(source, name);
+      for (const m of plan) {
+        if (!seen.has(m.name)) {
+          seen.add(m.name);
+          manifests.push(m);
+        }
+      }
+    }
+  } catch (err) {
+    spin.stop("Resolution failed", 1);
+    p.log.error(err.message);
+    p.outro(pc.red("Install aborted."));
+    return 1;
+  }
+  spin.stop(`Resolved ${manifests.length} component${manifests.length === 1 ? "" : "s"}`);
+  const pro = manifests.filter((m) => m.tier === "pro");
+  if (pro.length > 0) {
+    p.log.error(
+      `${pro.map((m) => pc.cyan(m.name)).join(", ")} ${pro.length === 1 ? "is a Pro component" : "are Pro components"} and require a license key.
+  Pro delivery is not enabled yet.`
+    );
+    p.outro(pc.red("Install aborted."));
+    return 1;
+  }
+  const npmDeps = {};
+  for (const m of manifests) Object.assign(npmDeps, m.npmDependencies ?? {});
+  const planLines = [];
+  for (const m of manifests) {
+    planLines.push(pc.bold(`${m.title} ${pc.dim(`v${m.version} \xB7 ${m.tier}`)}`));
+    for (const f of m.files) planLines.push(`  ${pc.green("+")} ${f.target}`);
+  }
+  const depNames = Object.keys(npmDeps);
+  if (depNames.length > 0) {
+    planLines.push(pc.bold("npm dependencies"));
+    for (const [n, v] of Object.entries(npmDeps)) planLines.push(`  ${pc.yellow("\u2022")} ${n}@${v}`);
+  }
+  p.note(planLines.join("\n"), "Install plan");
+  if (!opts.yes) {
+    const go = await p.confirm({ message: `Install into ${pc.cyan(project.root)}?` });
+    if (p.isCancel(go) || !go) {
+      p.cancel("Cancelled.");
+      return 1;
+    }
+  }
+  const results = [];
+  const write = p.spinner();
+  write.start("Writing files");
+  for (const m of manifests) {
+    for (const f of m.files) {
+      const content = await readComponentFile(source, m, f);
+      results.push(await writeComponentFile(project.root, f.target, content, opts.force));
+    }
+  }
+  write.stop("Files written");
+  renderFileResults(results);
+  await handleEnv(project.root, manifests, opts, source);
+  const needsServer = manifests.some((m) => m.astro?.output === "server" || m.astro?.output === "hybrid");
+  const needsAdapter = manifests.some((m) => m.astro?.adapterRequired);
+  if (needsServer || needsAdapter) {
+    const cfg = await checkAstroConfig(project.root);
+    const warns = [];
+    if (!cfg.found) warns.push("No astro.config.* found \u2014 add one with an SSR adapter.");
+    else {
+      if (needsServer && !cfg.isServer)
+        warns.push(`Set ${pc.cyan("output: 'server'")} in ${cfg.configPath}.`);
+      if (needsAdapter && !cfg.hasAdapter)
+        warns.push(`Add an SSR ${pc.cyan("adapter")} (e.g. @astrojs/cloudflare) in ${cfg.configPath}.`);
+    }
+    if (warns.length > 0) p.log.warn("Astro config:\n  " + warns.join("\n  "));
+  }
+  if (depNames.length > 0) {
+    const pm = detectPackageManager(project.root);
+    p.log.info(
+      `Install dependencies:
+  ${pc.cyan(`${pm} ${pm === "npm" ? "install" : "add"} ${depNames.join(" ")}`)}`
+    );
+  }
+  const notes = manifests.flatMap((m) => (m.postInstall ?? []).map((line) => `\u2022 ${line}`));
+  if (notes.length > 0) p.note(notes.join("\n"), "Next steps");
+  p.outro(pc.green(`Installed ${manifests.map((m) => m.name).join(", ")}. Happy building.`));
+  return 0;
+}
+function renderFileResults(results) {
+  const symbol = {
+    created: pc.green("created"),
+    overwritten: pc.yellow("overwritten"),
+    unchanged: pc.dim("unchanged"),
+    conflict: pc.red("conflict")
+  };
+  const lines = results.map((r) => {
+    const base = `${symbol[r.outcome]}  ${r.target}`;
+    if (r.outcome === "conflict") {
+      return `${base}
+  ${pc.dim(`\u2192 kept your file; wrote ${r.altPath} for you to compare`)}`;
+    }
+    return base;
+  });
+  p.log.message(lines.join("\n"));
+  if (results.some((r) => r.outcome === "conflict")) {
+    p.log.warn(
+      "Some files already existed and were left untouched. Review the .astro-users-new files and merge manually, or re-run with --force to overwrite."
+    );
+  }
+}
+async function handleEnv(root, manifests, opts, _source) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const m of manifests) for (const e of m.env ?? []) if (!entries.has(e.name)) entries.set(e.name, e);
+  if (entries.size === 0) return;
+  const envPath = join3(root, ".env");
+  const currentEnv = existsSync3(envPath) ? await readFile3(envPath, "utf8") : "";
+  const missing = [...entries.values()].filter(
+    (e) => !new RegExp(`^\\s*${e.name}\\s*=`, "m").test(currentEnv)
+  );
+  if (missing.length === 0) {
+    p.log.info(pc.dim("All required environment variables already present in .env."));
+    return;
+  }
+  const values = [];
+  if (opts.yes) {
+    for (const e of missing) values.push({ name: e.name, value: "", comment: e.prompt });
+  } else {
+    for (const e of missing) {
+      const answer = await p.text({
+        message: `${pc.cyan(e.name)}${e.required ? "" : pc.dim(" (optional)")}${e.prompt ? pc.dim(` \u2014 ${e.prompt}`) : ""}`,
+        placeholder: e.example ?? (e.secret ? "\u2022\u2022\u2022\u2022 (kept in .env, git-ignored)" : ""),
+        defaultValue: ""
+      });
+      if (p.isCancel(answer)) {
+        p.cancel("Cancelled.");
+        process.exit(1);
+      }
+      values.push({ name: e.name, value: answer ?? "", comment: e.prompt });
+    }
+  }
+  const merged = await mergeEnv(root, values);
+  if (merged.added.length > 0)
+    p.log.success(`Wrote ${merged.added.length} variable(s) to .env: ${merged.added.join(", ")}`);
+  if (merged.skipped.length > 0) p.log.info(pc.dim(`Left existing: ${merged.skipped.join(", ")}`));
+}
+function detectPackageManager(root) {
+  if (existsSync3(join3(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(root, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+
+// src/commands/list.ts
+import { readdir } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+async function runList(registry) {
+  p2.intro(pc2.bgMagenta(pc2.black(" Astro Users ")));
+  const source = resolveRegistry(registry);
+  p2.log.info(`Registry: ${pc2.dim(`${source.kind} \xB7 ${source.base}`)}`);
+  let slugs = [];
+  try {
+    if (source.kind === "local") {
+      const entries = await readdir(source.base, { withFileTypes: true });
+      slugs = entries.filter((e) => e.isDirectory() && existsSync4(join4(source.base, e.name, "registry.json"))).map((e) => e.name);
+    } else {
+      const res = await fetch(`${source.base}/index.json`);
+      if (!res.ok) throw new Error(`Registry index unavailable (${res.status}).`);
+      const index = await res.json();
+      slugs = index.components ?? [];
+    }
+  } catch (err) {
+    p2.log.error(err.message);
+    p2.outro(pc2.red("Could not list components."));
+    return 1;
+  }
+  const manifests = [];
+  for (const slug of slugs.sort()) {
+    try {
+      manifests.push(await loadManifest(source, slug));
+    } catch {
+    }
+  }
+  if (manifests.length === 0) {
+    p2.outro(pc2.yellow("No components found."));
+    return 0;
+  }
+  const lines = manifests.map((m) => {
+    const tag = m.tier === "pro" ? pc2.yellow("[pro] ") : pc2.green("[free]");
+    return `${tag} ${pc2.bold(m.name.padEnd(12))} ${pc2.dim(m.description.split(".")[0] + ".")}`;
+  });
+  p2.note(lines.join("\n"), `${manifests.length} component(s)`);
+  p2.outro(`Install with ${pc2.cyan("astro-users add <name>")}`);
+  return 0;
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  const out = {
+    positionals: [],
+    cwd: process.cwd(),
+    force: false,
+    yes: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--cwd":
+        out.cwd = argv[++i] ?? process.cwd();
+        break;
+      case "--registry":
+        out.registry = argv[++i];
+        break;
+      case "--force":
+      case "-f":
+        out.force = true;
+        break;
+      case "--yes":
+      case "-y":
+        out.yes = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      case "--version":
+      case "-v":
+        out.version = true;
+        break;
+      default:
+        if (arg.startsWith("-")) break;
+        if (!out.command) out.command = arg;
+        else out.positionals.push(arg);
+    }
+  }
+  return out;
+}
+var HELP = `
+${pc3.bold("astro-users")} \u2014 install Astro Users components into your Astro project.
+
+${pc3.bold("Usage")}
+  astro-users <command> [options]
+
+${pc3.bold("Commands")}
+  add <name...>     Copy component(s) into your src/ (with .env + config guidance)
+  list              List available components in the registry
+  help              Show this help
+
+${pc3.bold("Options")}
+  --cwd <path>      Target project directory (default: current directory)
+  --registry <ref>  Registry URL or local path (default: local dev / hosted)
+  -y, --yes         Non-interactive; skip prompts and confirmations
+  -f, --force       Overwrite existing files instead of writing *.astro-users-new
+  -h, --help        Show help
+  -v, --version     Show version
+
+${pc3.bold("Examples")}
+  ${pc3.dim("$")} astro-users list
+  ${pc3.dim("$")} astro-users add auth
+  ${pc3.dim("$")} astro-users add auth --cwd ./my-site
+`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.version) {
+    console.log("astro-users 0.1.0");
+    return 0;
+  }
+  if (args.help || !args.command || args.command === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  switch (args.command) {
+    case "add":
+      return runAdd(args.positionals, {
+        cwd: args.cwd,
+        registry: args.registry,
+        force: args.force,
+        yes: args.yes
+      });
+    case "list":
+    case "ls":
+      return runList(args.registry);
+    default:
+      console.error(pc3.red(`Unknown command: ${args.command}`));
+      console.log(HELP);
+      return 1;
+  }
+}
+main().then((code) => process.exit(code ?? 0)).catch((err) => {
+  console.error(pc3.red(`
+Unexpected error: ${err.message}`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "astro-users",
+  "version": "0.1.0",
+  "description": "Install Astro Users components into your Astro project — copied into your src/, fully yours to edit.",
+  "type": "module",
+  "bin": {
+    "astro-users": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alex-boop-chasey/astro-users.git"
+  },
+  "homepage": "https://github.com/alex-boop-chasey/astro-users#readme",
+  "bugs": {
+    "url": "https://github.com/alex-boop-chasey/astro-users/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "astro",
+    "astro-users",
+    "auth",
+    "cli",
+    "scaffold"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "picocolors": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  }
+}