@vexblocks/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1215 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import pc6 from "picocolors";
+
+// src/commands/init.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+import pc2 from "picocolors";
+import ora from "ora";
+import { confirm, input, select } from "@inquirer/prompts";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (message) => {
+    console.log(pc.blue("\u2139"), message);
+  },
+  success: (message) => {
+    console.log(pc.green("\u2714"), message);
+  },
+  warn: (message) => {
+    console.log(pc.yellow("\u26A0"), message);
+  },
+  error: (message) => {
+    console.log(pc.red("\u2716"), message);
+  },
+  log: (message) => {
+    console.log(message);
+  },
+  break: () => {
+    console.log();
+  },
+  title: (message) => {
+    console.log();
+    console.log(pc.bold(pc.cyan(message)));
+    console.log();
+  },
+  step: (step, total, message) => {
+    console.log(pc.dim(`[${step}/${total}]`), message);
+  },
+  list: (items) => {
+    for (const item of items) {
+      console.log(pc.dim("  \u2022"), item);
+    }
+  },
+  box: (title, content) => {
+    const maxLength = Math.max(title.length, ...content.map((c) => c.length));
+    const border = "\u2500".repeat(maxLength + 4);
+    console.log();
+    console.log(pc.dim(`\u250C${border}\u2510`));
+    console.log(pc.dim("\u2502"), pc.bold(title.padEnd(maxLength + 2)), pc.dim("\u2502"));
+    console.log(pc.dim(`\u251C${border}\u2524`));
+    for (const line of content) {
+      console.log(pc.dim("\u2502"), line.padEnd(maxLength + 2), pc.dim("\u2502"));
+    }
+    console.log(pc.dim(`\u2514${border}\u2518`));
+    console.log();
+  },
+  code: (code, language) => {
+    console.log();
+    console.log(pc.dim(`\`\`\`${language || ""}`));
+    console.log(code);
+    console.log(pc.dim("```"));
+    console.log();
+  }
+};
+
+// src/utils/fs.ts
+import fs from "fs-extra";
+import path from "path";
+import crypto from "crypto";
+async function isTurborepoProject(cwd) {
+  const turboJsonPath = path.join(cwd, "turbo.json");
+  return fs.pathExists(turboJsonPath);
+}
+async function getPackageManager(cwd) {
+  if (await fs.pathExists(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fs.pathExists(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fs.pathExists(path.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  return "npm";
+}
+async function createBackup(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  if (await fs.pathExists(filePath)) {
+    await fs.copy(filePath, backupPath);
+  }
+  return backupPath;
+}
+
+// src/utils/manifest.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// src/utils/constants.ts
+var GITHUB_REPO = "vexblocks/vexblocks";
+var GITHUB_BRANCH = "main";
+var GITHUB_RAW_URL = `https://raw.githubusercontent.com/${GITHUB_REPO}/${GITHUB_BRANCH}`;
+var MANIFEST_FILE = "vexblocks.json";
+var PACKAGE_PATHS = {
+  cms: "apps/cms",
+  backend: "packages/backend",
+  shared: "packages/cms-shared",
+  types: "packages/type-generator"
+};
+var PACKAGE_NAMES = {
+  cms: "CMS Dashboard",
+  backend: "Convex Backend",
+  shared: "Shared Utilities",
+  types: "Type Generator"
+};
+var MANAGED_PACKAGES = ["cms", "shared", "types"];
+var PACKAGE_DEPENDENCIES = {
+  cms: ["backend", "shared"],
+  backend: [],
+  shared: [],
+  types: ["backend"]
+};
+var REQUIRED_ENV_VARS = {
+  cms: ["CONVEX_DEPLOYMENT", "NEXT_PUBLIC_CONVEX_URL", "SITE_URL"],
+  backend: ["CONVEX_DEPLOYMENT", "NEXT_PUBLIC_CONVEX_URL", "SITE_URL"],
+  shared: [],
+  types: ["CONVEX_URL"]
+};
+var OPTIONAL_ENV_VARS = {
+  backend: [
+    {
+      name: "CLOUDFLARE_ACCOUNT_ID",
+      description: "Required for media library (Cloudflare Images)"
+    },
+    {
+      name: "CLOUDFLARE_SECRET_TOKEN",
+      description: "Required for media library (Cloudflare Images)"
+    },
+    {
+      name: "REVALIDATE_SECRET",
+      description: "Required for ISR revalidation webhooks"
+    },
+    {
+      name: "FRONTEND_URL",
+      description: "Your frontend URL for revalidation"
+    }
+  ]
+};
+
+// src/utils/manifest.ts
+async function readManifest(cwd) {
+  const manifestPath = path2.join(cwd, MANIFEST_FILE);
+  try {
+    if (await fs2.pathExists(manifestPath)) {
+      return await fs2.readJson(manifestPath);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeManifest(cwd, manifest) {
+  const manifestPath = path2.join(cwd, MANIFEST_FILE);
+  await fs2.writeJson(manifestPath, manifest, { spaces: 2 });
+}
+function createManifest(version) {
+  return {
+    $schema: "https://vexblocks.dev/schema/vexblocks.json",
+    version,
+    packages: {}
+  };
+}
+
+// src/utils/github.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+async function fetchRemoteManifest() {
+  const url = `${GITHUB_RAW_URL}/templates/manifest.json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function fetchFile(filePath) {
+  const url = `${GITHUB_RAW_URL}/${filePath}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch file ${filePath}: ${response.statusText}`);
+  }
+  return response.text();
+}
+async function downloadFile(remotePath, localPath) {
+  const url = `${GITHUB_RAW_URL}/${remotePath}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${remotePath}: ${response.statusText}`);
+  }
+  await fs3.ensureDir(path3.dirname(localPath));
+  const content = await response.text();
+  await fs3.writeFile(localPath, content, "utf-8");
+}
+async function downloadAndExtractPackage(packagePath, targetDir, onProgress) {
+  const treeUrl = `https://api.github.com/repos/${GITHUB_REPO}/git/trees/${GITHUB_BRANCH}?recursive=1`;
+  const response = await fetch(treeUrl, {
+    headers: {
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "vexblocks-cli"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch repository tree: ${response.statusText}`);
+  }
+  const data = await response.json();
+  const files = data.tree.filter(
+    (item) => item.type === "blob" && item.path.startsWith(`${packagePath}/`)
+  );
+  for (const file of files) {
+    const relativePath = file.path.slice(packagePath.length + 1);
+    const localPath = path3.join(targetDir, relativePath);
+    onProgress?.(relativePath);
+    await downloadFile(file.path, localPath);
+  }
+}
+async function getPackageFiles(packagePath) {
+  const treeUrl = `https://api.github.com/repos/${GITHUB_REPO}/git/trees/${GITHUB_BRANCH}?recursive=1`;
+  const response = await fetch(treeUrl, {
+    headers: {
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "vexblocks-cli"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch repository tree: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.tree.filter(
+    (item) => item.type === "blob" && item.path.startsWith(`${packagePath}/`)
+  ).map((item) => item.path.slice(packagePath.length + 1));
+}
+async function getLatestVersion() {
+  const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "vexblocks-cli"
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data.tag_name.replace(/^v/, "");
+    }
+  } catch {
+  }
+  try {
+    const manifest = await fetchRemoteManifest();
+    return manifest.version;
+  } catch {
+    return "1.0.0";
+  }
+}
+async function getChangelog(fromVersion, toVersion) {
+  const manifest = await fetchRemoteManifest();
+  const changelog = {};
+  const versions = Object.keys(manifest.changelog).sort((a, b) => {
+    const [aMajor, aMinor, aPatch] = a.split(".").map(Number);
+    const [bMajor, bMinor, bPatch] = b.split(".").map(Number);
+    if (aMajor !== bMajor) return aMajor - bMajor;
+    if (aMinor !== bMinor) return aMinor - bMinor;
+    return aPatch - bPatch;
+  });
+  const fromIndex = versions.indexOf(fromVersion);
+  const toIndex = versions.indexOf(toVersion);
+  if (fromIndex === -1 || toIndex === -1) {
+    return changelog;
+  }
+  for (let i = fromIndex + 1; i <= toIndex; i++) {
+    const version = versions[i];
+    if (manifest.changelog[version]) {
+      changelog[version] = manifest.changelog[version];
+    }
+  }
+  return changelog;
+}
+function compareVersions(a, b) {
+  const [aMajor, aMinor, aPatch] = a.split(".").map(Number);
+  const [bMajor, bMinor, bPatch] = b.split(".").map(Number);
+  if (aMajor !== bMajor) return aMajor < bMajor ? -1 : 1;
+  if (aMinor !== bMinor) return aMinor < bMinor ? -1 : 1;
+  if (aPatch !== bPatch) return aPatch < bPatch ? -1 : 1;
+  return 0;
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const cwd = options.cwd ? path4.resolve(options.cwd) : process.cwd();
+  logger.title("\u{1F680} VexBlocks CMS Setup");
+  const manifestPath = path4.join(cwd, MANIFEST_FILE);
+  if (await fs4.pathExists(manifestPath)) {
+    logger.warn("VexBlocks is already initialized in this directory.");
+    const continueAnyway = options.yes || await confirm({
+      message: "Do you want to reinitialize?",
+      default: false
+    });
+    if (!continueAnyway) {
+      logger.info("Run `vexblocks add <package>` to add packages.");
+      return;
+    }
+  }
+  const isTurbo = await isTurborepoProject(cwd);
+  let projectType;
+  if (isTurbo) {
+    logger.success("Detected existing Turborepo project");
+    projectType = "existing";
+  } else {
+    projectType = await select({
+      message: "What would you like to do?",
+      choices: [
+        {
+          name: "Create a new Turborepo project with VexBlocks",
+          value: "new"
+        },
+        {
+          name: "Add VexBlocks to this directory (I'll set up Turborepo manually)",
+          value: "existing"
+        }
+      ]
+    });
+  }
+  if (projectType === "new") {
+    await createNewProject(cwd, options);
+  } else {
+    await initializeExisting(cwd, options);
+  }
+}
+async function createNewProject(cwd, options) {
+  const projectName = await input({
+    message: "Project name:",
+    default: path4.basename(cwd),
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (!/^[a-z0-9-_]+$/.test(value)) {
+        return "Project name can only contain lowercase letters, numbers, hyphens, and underscores";
+      }
+      return true;
+    }
+  });
+  const projectDir = path4.join(cwd, projectName);
+  if (await fs4.pathExists(projectDir)) {
+    const overwrite = await confirm({
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      default: false
+    });
+    if (!overwrite) {
+      logger.info("Aborted.");
+      return;
+    }
+    await fs4.remove(projectDir);
+  }
+  const spinner = ora("Creating project structure...").start();
+  try {
+    await fs4.ensureDir(projectDir);
+    await fs4.ensureDir(path4.join(projectDir, "apps"));
+    await fs4.ensureDir(path4.join(projectDir, "packages"));
+    const packageJson = {
+      name: projectName,
+      version: "0.1.0",
+      private: true,
+      packageManager: "pnpm@9.15.0",
+      workspaces: ["apps/*", "packages/*"],
+      scripts: {
+        dev: "turbo run dev",
+        build: "turbo run build",
+        lint: "turbo run lint",
+        "generate-types": "pnpm --filter @repo/type-generator generate"
+      },
+      devDependencies: {
+        turbo: "^2.6.1"
+      }
+    };
+    await fs4.writeJson(path4.join(projectDir, "package.json"), packageJson, {
+      spaces: 2
+    });
+    const turboJson = {
+      $schema: "https://turbo.build/schema.json",
+      globalDependencies: ["**/.env.*local"],
+      globalEnv: [
+        "CONVEX_DEPLOYMENT",
+        "NEXT_PUBLIC_CONVEX_URL",
+        "NEXT_PUBLIC_CONVEX_SITE_URL",
+        "SITE_URL",
+        "CLOUDFLARE_ACCOUNT_ID",
+        "CLOUDFLARE_SECRET_TOKEN"
+      ],
+      ui: "tui",
+      tasks: {
+        dev: {
+          cache: false,
+          persistent: true
+        },
+        build: {
+          dependsOn: ["^build"],
+          inputs: ["$TURBO_DEFAULT$", ".env*"],
+          outputs: [".next/**", "dist/**"]
+        },
+        lint: {
+          outputs: []
+        }
+      }
+    };
+    await fs4.writeJson(path4.join(projectDir, "turbo.json"), turboJson, {
+      spaces: 2
+    });
+    const pnpmWorkspace = `packages:
+  - "apps/*"
+  - "packages/*"
+`;
+    await fs4.writeFile(
+      path4.join(projectDir, "pnpm-workspace.yaml"),
+      pnpmWorkspace
+    );
+    const gitignore = `# Dependencies
+node_modules
+.pnpm-store
+
+# Build outputs
+dist
+.next
+.turbo
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# Convex
+.convex
+`;
+    await fs4.writeFile(path4.join(projectDir, ".gitignore"), gitignore);
+    const envExample = `# Convex
+CONVEX_DEPLOYMENT=
+NEXT_PUBLIC_CONVEX_URL=
+
+# Better Auth
+SITE_URL=http://localhost:3001
+
+# Cloudflare Images (optional, for media library)
+CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_SECRET_TOKEN=
+
+# Revalidation (optional, for ISR)
+REVALIDATE_SECRET=
+FRONTEND_URL=http://localhost:3000
+`;
+    await fs4.writeFile(path4.join(projectDir, ".env.example"), envExample);
+    const version = await getLatestVersion();
+    const manifest = createManifest(version);
+    await writeManifest(projectDir, manifest);
+    spinner.succeed("Project structure created");
+    logger.break();
+    logger.box("\u2705 Project created successfully!", [
+      `Directory: ${pc2.cyan(projectDir)}`,
+      "",
+      pc2.bold("Next steps:"),
+      `1. ${pc2.cyan(`cd ${projectName}`)}`,
+      `2. ${pc2.cyan("pnpm install")}`,
+      `3. ${pc2.cyan("npx vexblocks add all")}`,
+      "4. Set up your Convex project",
+      `5. ${pc2.cyan("pnpm dev")}`
+    ]);
+    const addPackages = options.yes || await confirm({
+      message: "Would you like to add VexBlocks packages now?",
+      default: true
+    });
+    if (addPackages) {
+      logger.break();
+      logger.info(`Run: ${pc2.cyan("npx vexblocks add all")}`);
+      logger.info("After navigating to your project directory.");
+    }
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    throw error;
+  }
+}
+async function initializeExisting(cwd, _options) {
+  const spinner = ora("Initializing VexBlocks...").start();
+  try {
+    const hasTurbo = await isTurborepoProject(cwd);
+    if (!hasTurbo) {
+      spinner.warn("No turbo.json found");
+      logger.warn(
+        "VexBlocks requires Turborepo. Please set up Turborepo first."
+      );
+      logger.info(`Run: ${pc2.cyan("npx create-turbo@latest")}`);
+      return;
+    }
+    const version = await getLatestVersion();
+    const manifest = createManifest(version);
+    await writeManifest(cwd, manifest);
+    spinner.succeed("VexBlocks initialized");
+    const packageManager = await getPackageManager(cwd);
+    logger.break();
+    logger.box("\u2705 VexBlocks initialized!", [
+      `Manifest: ${pc2.cyan(MANIFEST_FILE)}`,
+      `Version: ${pc2.cyan(version)}`,
+      "",
+      pc2.bold("Next steps:"),
+      `1. ${pc2.cyan("npx vexblocks add all")} - Add all CMS packages`,
+      "2. Configure your environment variables",
+      `3. ${pc2.cyan(`${packageManager} install`)}`,
+      `4. ${pc2.cyan(`${packageManager === "npm" ? "npm run" : packageManager} dev`)}`
+    ]);
+  } catch (error) {
+    spinner.fail("Failed to initialize");
+    throw error;
+  }
+}
+
+// src/commands/add.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import pc3 from "picocolors";
+import ora2 from "ora";
+import { confirm as confirm2, checkbox } from "@inquirer/prompts";
+var ALL_PACKAGES = ["backend", "shared", "types", "cms"];
+async function addCommand(packages, options) {
+  const cwd = options.cwd ? path5.resolve(options.cwd) : process.cwd();
+  logger.title("\u{1F4E6} Add VexBlocks Packages");
+  const isTurbo = await isTurborepoProject(cwd);
+  if (!isTurbo) {
+    logger.error("This is not a Turborepo project.");
+    logger.info(
+      `Run ${pc3.cyan("npx vexblocks init")} first to set up your project.`
+    );
+    process.exit(1);
+  }
+  let manifest = await readManifest(cwd);
+  if (!manifest) {
+    const version2 = await getLatestVersion();
+    manifest = createManifest(version2);
+    await writeManifest(cwd, manifest);
+    logger.info(`Created ${MANIFEST_FILE}`);
+  }
+  let packagesToAdd = [];
+  if (packages.length === 0 || packages.includes("all")) {
+    if (packages.includes("all")) {
+      packagesToAdd = ALL_PACKAGES;
+    } else {
+      const selectedPackages = await checkbox({
+        message: "Which packages would you like to add?",
+        choices: ALL_PACKAGES.map((pkg) => ({
+          name: `${PACKAGE_NAMES[pkg]} (${PACKAGE_PATHS[pkg]})`,
+          value: pkg,
+          checked: true
+        }))
+      });
+      packagesToAdd = selectedPackages;
+    }
+  } else {
+    for (const pkg of packages) {
+      if (pkg !== "all" && !ALL_PACKAGES.includes(pkg)) {
+        logger.error(`Unknown package: ${pkg}`);
+        logger.info(`Available packages: ${ALL_PACKAGES.join(", ")}, all`);
+        process.exit(1);
+      }
+    }
+    packagesToAdd = packages.filter((p) => p !== "all");
+  }
+  if (packagesToAdd.length === 0) {
+    logger.info("No packages selected.");
+    return;
+  }
+  const resolvedPackages = resolveDependencies(packagesToAdd);
+  if (resolvedPackages.length !== packagesToAdd.length) {
+    const added = resolvedPackages.filter((p) => !packagesToAdd.includes(p));
+    logger.info(
+      `Adding dependencies: ${added.map((p) => PACKAGE_NAMES[p]).join(", ")}`
+    );
+  }
+  const existingPackages = [];
+  for (const pkg of resolvedPackages) {
+    const targetPath = getPackageTargetPath(cwd, pkg);
+    if (await fs5.pathExists(targetPath)) {
+      existingPackages.push(pkg);
+    }
+  }
+  if (existingPackages.length > 0 && !options.overwrite) {
+    logger.warn(`These packages already exist: ${existingPackages.join(", ")}`);
+    const overwrite = options.yes || await confirm2({
+      message: "Overwrite existing packages?",
+      default: false
+    });
+    if (!overwrite) {
+      const newPackages = resolvedPackages.filter(
+        (p) => !existingPackages.includes(p)
+      );
+      if (newPackages.length === 0) {
+        logger.info("No new packages to add.");
+        return;
+      }
+      resolvedPackages.length = 0;
+      resolvedPackages.push(...newPackages);
+    }
+  }
+  logger.break();
+  logger.log(pc3.bold("Packages to install:"));
+  for (const pkg of resolvedPackages) {
+    const targetPath = getPackageTargetPath(cwd, pkg);
+    const relativePath = path5.relative(cwd, targetPath);
+    logger.log(
+      `  ${pc3.green("+")} ${PACKAGE_NAMES[pkg]} \u2192 ${pc3.dim(relativePath)}`
+    );
+  }
+  logger.break();
+  const proceed = options.yes || await confirm2({
+    message: "Proceed with installation?",
+    default: true
+  });
+  if (!proceed) {
+    logger.info("Aborted.");
+    return;
+  }
+  const version = await getLatestVersion();
+  for (const pkg of resolvedPackages) {
+    await installPackage(cwd, pkg, version, manifest);
+  }
+  await writeManifest(cwd, manifest);
+  showNextSteps(resolvedPackages);
+}
+function resolveDependencies(packages) {
+  const resolved = /* @__PURE__ */ new Set();
+  const toProcess = [...packages];
+  while (toProcess.length > 0) {
+    const pkg = toProcess.pop();
+    if (resolved.has(pkg)) continue;
+    const deps = PACKAGE_DEPENDENCIES[pkg] || [];
+    for (const dep of deps) {
+      if (!resolved.has(dep)) {
+        toProcess.push(dep);
+      }
+    }
+    resolved.add(pkg);
+  }
+  const orderedPackages = [];
+  const order = ["backend", "shared", "types", "cms"];
+  for (const pkg of order) {
+    if (resolved.has(pkg)) {
+      orderedPackages.push(pkg);
+    }
+  }
+  return orderedPackages;
+}
+function getPackageTargetPath(cwd, pkg) {
+  switch (pkg) {
+    case "cms":
+      return path5.join(cwd, "apps", "cms");
+    case "backend":
+      return path5.join(cwd, "packages", "backend");
+    case "shared":
+      return path5.join(cwd, "packages", "cms-shared");
+    case "types":
+      return path5.join(cwd, "packages", "type-generator");
+    default:
+      return path5.join(cwd, PACKAGE_PATHS[pkg]);
+  }
+}
+async function installPackage(cwd, pkg, version, manifest) {
+  const spinner = ora2(`Installing ${PACKAGE_NAMES[pkg]}...`).start();
+  try {
+    const targetPath = getPackageTargetPath(cwd, pkg);
+    const sourcePath = PACKAGE_PATHS[pkg];
+    if (pkg === "backend") {
+      await installBackendPackage(targetPath, sourcePath, spinner);
+    } else {
+      await fs5.ensureDir(targetPath);
+      await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
+        spinner.text = `Installing ${PACKAGE_NAMES[pkg]}... ${pc3.dim(file)}`;
+      });
+    }
+    const config = {
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      path: path5.relative(cwd, targetPath)
+    };
+    manifest.packages[pkg] = config;
+    spinner.succeed(`Installed ${PACKAGE_NAMES[pkg]}`);
+  } catch (error) {
+    spinner.fail(`Failed to install ${PACKAGE_NAMES[pkg]}`);
+    throw error;
+  }
+}
+async function installBackendPackage(targetPath, sourcePath, spinner) {
+  const convexPath = path5.join(targetPath, "convex");
+  const existingSchemaPath = path5.join(convexPath, "schema.ts");
+  const hasSchema = await fs5.pathExists(existingSchemaPath);
+  if (hasSchema) {
+    spinner.text = "Detected existing Convex schema, merging CMS tables...";
+    const backupPath = `${existingSchemaPath}.backup-${Date.now()}`;
+    await fs5.copy(existingSchemaPath, backupPath);
+    logger.info(`Backed up existing schema to ${path5.basename(backupPath)}`);
+    const cmsFiles = [
+      "convex/cms",
+      "convex/schema.cms.ts",
+      "convex/auth.ts",
+      "convex/auth.config.ts",
+      "convex/http.ts",
+      "convex/settings.ts",
+      "better-auth",
+      "emails"
+    ];
+    for (const file of cmsFiles) {
+      const fullSourcePath = `${sourcePath}/${file}`;
+      const fullTargetPath = path5.join(targetPath, file);
+      spinner.text = `Downloading ${file}...`;
+      try {
+        await downloadAndExtractPackage(fullSourcePath, fullTargetPath);
+      } catch {
+        try {
+          const content = await fetchFile(fullSourcePath);
+          await fs5.ensureDir(path5.dirname(fullTargetPath));
+          await fs5.writeFile(fullTargetPath, content);
+        } catch {
+        }
+      }
+    }
+    const schemaInstructions = `
+// === VEXBLOCKS CMS ===
+// Add the following imports and tables to your schema:
+//
+// import { cmsSchemaExports } from "./schema.cms"
+//
+// Then add to your defineSchema:
+// export default defineSchema({
+//   ...yourExistingTables,
+//   ...cmsSchemaExports,
+// })
+// === END VEXBLOCKS CMS ===
+`;
+    const existingContent = await fs5.readFile(existingSchemaPath, "utf-8");
+    if (!existingContent.includes("VEXBLOCKS CMS")) {
+      await fs5.appendFile(existingSchemaPath, schemaInstructions);
+    }
+  } else {
+    await fs5.ensureDir(targetPath);
+    await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
+      spinner.text = `Installing backend... ${pc3.dim(file)}`;
+    });
+  }
+}
+function showNextSteps(packages) {
+  const packageManager = "pnpm";
+  logger.break();
+  logger.box("\u2705 Packages installed successfully!", [
+    "",
+    pc3.bold("Next steps:"),
+    "",
+    `1. Install dependencies: ${pc3.cyan(`${packageManager} install`)}`,
+    "",
+    "2. Set up environment variables:",
+    ...getRequiredEnvVars(packages).map((v) => `   ${pc3.dim(v)}`),
+    "",
+    "3. Set up Convex (if not already):",
+    `   ${pc3.cyan("npx convex dev")} in packages/backend`,
+    "",
+    "4. Start development:",
+    `   ${pc3.cyan(`${packageManager} dev`)}`,
+    "",
+    pc3.dim("CMS will be available at http://localhost:3001")
+  ]);
+  const optionalVars = getOptionalEnvVars(packages);
+  if (optionalVars.length > 0) {
+    logger.break();
+    logger.log(pc3.bold("Optional environment variables:"));
+    for (const { name, description } of optionalVars) {
+      logger.log(`  ${pc3.yellow(name)}`);
+      logger.log(`    ${pc3.dim(description)}`);
+    }
+  }
+}
+function getRequiredEnvVars(packages) {
+  const vars = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    const required = REQUIRED_ENV_VARS[pkg] || [];
+    for (const v of required) {
+      vars.add(v);
+    }
+  }
+  return Array.from(vars);
+}
+function getOptionalEnvVars(packages) {
+  const vars = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    const optional = OPTIONAL_ENV_VARS[pkg] || [];
+    for (const v of optional) {
+      if (!seen.has(v.name)) {
+        seen.add(v.name);
+        vars.push(v);
+      }
+    }
+  }
+  return vars;
+}
+
+// src/commands/upgrade.ts
+import path6 from "path";
+import fs6 from "fs-extra";
+import pc4 from "picocolors";
+import ora3 from "ora";
+import { confirm as confirm3 } from "@inquirer/prompts";
+async function upgradeCommand(packages, options) {
+  const cwd = options.cwd ? path6.resolve(options.cwd) : process.cwd();
+  logger.title("\u2B06\uFE0F  Upgrade VexBlocks Packages");
+  const manifest = await readManifest(cwd);
+  if (!manifest) {
+    logger.error("No vexblocks.json found. Run `vexblocks init` first.");
+    process.exit(1);
+  }
+  const spinner = ora3("Checking for updates...").start();
+  const latestVersion = await getLatestVersion();
+  spinner.stop();
+  const installedPackages = Object.keys(manifest.packages);
+  if (installedPackages.length === 0) {
+    logger.info("No packages installed. Run `vexblocks add <package>` first.");
+    return;
+  }
+  let packagesToUpgrade;
+  if (packages.length === 0) {
+    packagesToUpgrade = installedPackages;
+  } else {
+    packagesToUpgrade = packages.filter(
+      (p) => installedPackages.includes(p)
+    );
+    if (packagesToUpgrade.length === 0) {
+      logger.error("None of the specified packages are installed.");
+      return;
+    }
+  }
+  const updates = [];
+  for (const pkg of packagesToUpgrade) {
+    const config = manifest.packages[pkg];
+    if (!config) continue;
+    const comparison = compareVersions(config.version, latestVersion);
+    if (comparison < 0) {
+      updates.push({
+        pkg,
+        from: config.version,
+        to: latestVersion
+      });
+    }
+  }
+  if (updates.length === 0) {
+    logger.success("All packages are up to date!");
+    logger.info(`Current version: ${pc4.cyan(latestVersion)}`);
+    return;
+  }
+  logger.log(pc4.bold("\nAvailable updates:"));
+  logger.break();
+  for (const update of updates) {
+    const isManaged = MANAGED_PACKAGES.includes(update.pkg);
+    logger.log(
+      `  ${PACKAGE_NAMES[update.pkg]}`,
+      pc4.dim(`${update.from} \u2192 `),
+      pc4.green(update.to),
+      isManaged ? pc4.yellow(" (managed)") : ""
+    );
+  }
+  const changelog = await getChangelog(updates[0].from, latestVersion);
+  if (Object.keys(changelog).length > 0) {
+    logger.break();
+    logger.log(pc4.bold("Changelog:"));
+    for (const [version, changes] of Object.entries(changelog)) {
+      logger.log(`
+  ${pc4.cyan(version)}`);
+      for (const change of changes) {
+        logger.log(`    ${pc4.dim("\u2022")} ${change}`);
+      }
+    }
+  }
+  if (options.check) {
+    logger.break();
+    logger.info(
+      `Run ${pc4.cyan("npx vexblocks upgrade")} to apply these updates.`
+    );
+    return;
+  }
+  logger.break();
+  const proceed = options.yes || await confirm3({
+    message: `Upgrade ${updates.length} package(s)?`,
+    default: true
+  });
+  if (!proceed) {
+    logger.info("Aborted.");
+    return;
+  }
+  for (const update of updates) {
+    await upgradePackage(cwd, update.pkg, update.to, manifest, options);
+  }
+  manifest.version = latestVersion;
+  await writeManifest(cwd, manifest);
+  logger.break();
+  logger.success(`Upgraded to version ${pc4.cyan(latestVersion)}`);
+  logger.info(
+    "Run your package manager's install command to update dependencies."
+  );
+}
+async function upgradePackage(cwd, pkg, version, manifest, options) {
+  const spinner = ora3(`Upgrading ${PACKAGE_NAMES[pkg]}...`).start();
+  try {
+    const config = manifest.packages[pkg];
+    if (!config) {
+      spinner.skip(`${PACKAGE_NAMES[pkg]} not installed`);
+      return;
+    }
+    const targetPath = path6.join(cwd, config.path);
+    if (!await fs6.pathExists(targetPath)) {
+      spinner.warn(
+        `${PACKAGE_NAMES[pkg]} directory not found at ${config.path}`
+      );
+      return;
+    }
+    const isManaged = MANAGED_PACKAGES.includes(pkg);
+    if (isManaged || options.force) {
+      const backupPath = await createBackup(targetPath);
+      spinner.text = `Created backup at ${path6.basename(backupPath)}`;
+      await fs6.remove(targetPath);
+      const sourcePath = getSourcePath(pkg);
+      await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
+        spinner.text = `Upgrading ${PACKAGE_NAMES[pkg]}... ${pc4.dim(file)}`;
+      });
+    } else {
+      spinner.text = `Upgrading CMS files in ${PACKAGE_NAMES[pkg]}...`;
+      const cmsFiles = ["convex/cms", "convex/schema.cms.ts"];
+      for (const file of cmsFiles) {
+        const targetFilePath = path6.join(targetPath, file);
+        const sourceFilePath = `packages/backend/${file}`;
+        if (await fs6.pathExists(targetFilePath)) {
+          await createBackup(targetFilePath);
+        }
+        try {
+          await fs6.remove(targetFilePath);
+          await downloadAndExtractPackage(sourceFilePath, targetFilePath);
+        } catch {
+        }
+      }
+    }
+    const newConfig = {
+      ...config,
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    manifest.packages[pkg] = newConfig;
+    spinner.succeed(`Upgraded ${PACKAGE_NAMES[pkg]} to ${version}`);
+  } catch (error) {
+    spinner.fail(`Failed to upgrade ${PACKAGE_NAMES[pkg]}`);
+    throw error;
+  }
+}
+function getSourcePath(pkg) {
+  switch (pkg) {
+    case "cms":
+      return "apps/cms";
+    case "backend":
+      return "packages/backend";
+    case "shared":
+      return "packages/cms-shared";
+    case "types":
+      return "packages/type-generator";
+    default:
+      throw new Error(`Unknown package: ${pkg}`);
+  }
+}
+
+// src/commands/diff.ts
+import path7 from "path";
+import fs7 from "fs-extra";
+import pc5 from "picocolors";
+import ora4 from "ora";
+import { createTwoFilesPatch } from "diff";
+async function diffCommand(packageArg, options) {
+  const cwd = options.cwd ? path7.resolve(options.cwd) : process.cwd();
+  logger.title("\u{1F50D} VexBlocks Diff");
+  const manifest = await readManifest(cwd);
+  if (!manifest) {
+    logger.error("No vexblocks.json found. Run `vexblocks init` first.");
+    process.exit(1);
+  }
+  const installedPackages = Object.keys(manifest.packages);
+  if (installedPackages.length === 0) {
+    logger.info("No packages installed.");
+    return;
+  }
+  let packageToDiff;
+  if (packageArg) {
+    if (!installedPackages.includes(packageArg)) {
+      logger.error(`Package "${packageArg}" is not installed.`);
+      logger.info(`Installed packages: ${installedPackages.join(", ")}`);
+      return;
+    }
+    packageToDiff = packageArg;
+  } else if (installedPackages.length === 1) {
+    packageToDiff = installedPackages[0];
+  } else {
+    logger.error("Please specify a package to diff.");
+    logger.info(`Usage: ${pc5.cyan("vexblocks diff <package>")}`);
+    logger.info(`Installed packages: ${installedPackages.join(", ")}`);
+    return;
+  }
+  const spinner = ora4(`Comparing ${PACKAGE_NAMES[packageToDiff]}...`).start();
+  try {
+    const config = manifest.packages[packageToDiff];
+    if (!config) {
+      spinner.fail("Package configuration not found");
+      return;
+    }
+    const localPath = path7.join(cwd, config.path);
+    const remotePath = getSourcePath2(packageToDiff);
+    const remoteFiles = await getPackageFiles(remotePath);
+    let totalDiffs = 0;
+    let newFiles = 0;
+    let modifiedFiles = 0;
+    let deletedFiles = 0;
+    spinner.stop();
+    for (const file of remoteFiles) {
+      const localFilePath = path7.join(localPath, file);
+      const remoteFilePath = `${remotePath}/${file}`;
+      let localContent = "";
+      let remoteContent = "";
+      if (await fs7.pathExists(localFilePath)) {
+        localContent = await fs7.readFile(localFilePath, "utf-8");
+      }
+      try {
+        remoteContent = await fetchFile(remoteFilePath);
+      } catch {
+        continue;
+      }
+      if (!localContent && remoteContent) {
+        newFiles++;
+        totalDiffs++;
+        logger.log(`${pc5.green("+")} ${file} ${pc5.dim("(new file)")}`);
+      } else if (localContent !== remoteContent) {
+        modifiedFiles++;
+        totalDiffs++;
+        logger.log(`${pc5.yellow("~")} ${file} ${pc5.dim("(modified)")}`);
+        const patch = createTwoFilesPatch(
+          `local/${file}`,
+          `remote/${file}`,
+          localContent,
+          remoteContent,
+          "",
+          ""
+        );
+        const lines = patch.split("\n").slice(4);
+        const maxLines = 10;
+        let lineCount = 0;
+        for (const line of lines) {
+          if (lineCount >= maxLines) {
+            logger.log(pc5.dim(`  ... (${lines.length - maxLines} more lines)`));
+            break;
+          }
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            logger.log(pc5.green(`  ${line}`));
+            lineCount++;
+          } else if (line.startsWith("-") && !line.startsWith("---")) {
+            logger.log(pc5.red(`  ${line}`));
+            lineCount++;
+          }
+        }
+        logger.break();
+      }
+    }
+    const localFiles = await getLocalFiles(localPath);
+    for (const file of localFiles) {
+      if (!remoteFiles.includes(file)) {
+        if (file.includes("node_modules") || file.includes("dist") || file.includes(".next") || file.startsWith(".")) {
+          continue;
+        }
+        deletedFiles++;
+        totalDiffs++;
+        logger.log(`${pc5.red("-")} ${file} ${pc5.dim("(deleted in remote)")}`);
+      }
+    }
+    logger.break();
+    if (totalDiffs === 0) {
+      logger.success(
+        "No differences found. Local files match the latest version."
+      );
+    } else {
+      logger.log(pc5.bold("Summary:"));
+      if (newFiles > 0) logger.log(`  ${pc5.green(`+${newFiles}`)} new files`);
+      if (modifiedFiles > 0)
+        logger.log(`  ${pc5.yellow(`~${modifiedFiles}`)} modified files`);
+      if (deletedFiles > 0)
+        logger.log(`  ${pc5.red(`-${deletedFiles}`)} files removed in remote`);
+      logger.break();
+      logger.info(
+        `Run ${pc5.cyan("npx vexblocks upgrade")} to update to the latest version.`
+      );
+    }
+  } catch (error) {
+    spinner.fail("Failed to compare files");
+    throw error;
+  }
+}
+function getSourcePath2(pkg) {
+  switch (pkg) {
+    case "cms":
+      return "apps/cms";
+    case "backend":
+      return "packages/backend";
+    case "shared":
+      return "packages/cms-shared";
+    case "types":
+      return "packages/type-generator";
+    default:
+      throw new Error(`Unknown package: ${pkg}`);
+  }
+}
+async function getLocalFiles(dir, base = "") {
+  const files = [];
+  if (!await fs7.pathExists(dir)) {
+    return files;
+  }
+  const entries = await fs7.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relativePath = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      if (["node_modules", "dist", ".next", ".turbo", ".git"].includes(entry.name)) {
+        continue;
+      }
+      const subFiles = await getLocalFiles(
+        path7.join(dir, entry.name),
+        relativePath
+      );
+      files.push(...subFiles);
+    } else {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
+
+// src/utils/package-info.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path8.dirname(__filename);
+async function getPackageInfo() {
+  const packageJsonPath = path8.resolve(__dirname, "../../package.json");
+  try {
+    const packageJson = await fs8.readJson(packageJsonPath);
+    return {
+      name: packageJson.name || "vexblocks",
+      version: packageJson.version || "0.0.0"
+    };
+  } catch {
+    return {
+      name: "vexblocks",
+      version: "0.0.0"
+    };
+  }
+}
+
+// src/index.ts
+async function main() {
+  const packageInfo = await getPackageInfo();
+  const program = new Command().name("vexblocks").description("Add VexBlocks Headless CMS to your Turborepo project").version(packageInfo.version, "-v, --version", "Display the version number");
+  program.command("init").description(
+    "Initialize a new VexBlocks project or add to existing Turborepo"
+  ).option("-y, --yes", "Skip confirmation prompts").option("--cwd <path>", "Working directory (defaults to current directory)").action(initCommand);
+  program.command("add [packages...]").description("Add VexBlocks packages to your project").option("-y, --yes", "Skip confirmation prompts").option("--cwd <path>", "Working directory (defaults to current directory)").option("--overwrite", "Overwrite existing files without prompting").addHelpText(
+    "after",
+    `
+${pc6.bold("Available packages:")}
+  cms        The CMS dashboard (Next.js app)
+  backend    Convex backend with CMS functions
+  shared     Shared utilities and components
+  types      TypeScript type generator
+  all        All packages
+
+${pc6.bold("Examples:")}
+  $ vexblocks add cms
+  $ vexblocks add backend shared
+  $ vexblocks add all
+		`
+  ).action(addCommand);
+  program.command("upgrade [packages...]").description("Upgrade VexBlocks packages to the latest version").option("-y, --yes", "Skip confirmation prompts").option("--cwd <path>", "Working directory (defaults to current directory)").option("--check", "Check for updates without upgrading").option("--force", "Force upgrade even if local changes detected").action(upgradeCommand);
+  program.command("diff [package]").description("Show differences between local files and latest version").option("--cwd <path>", "Working directory (defaults to current directory)").action(diffCommand);
+  program.parse();
+}
+main().catch((error) => {
+  console.error(pc6.red("Error:"), error.message);
+  process.exit(1);
+});