@actuate-media/cli 0.1.0

package/src/commands/seed.ts

@@ -0,0 +1,388 @@
+import { Command } from "commander";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import ora from "ora";
+import { logger } from "../utils/logger.js";
+
+async function confirm(question: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(`${question} (y/N) `);
+  rl.close();
+  return answer.trim().toLowerCase() === "y";
+}
+
+const DEMO_PAGES = [
+  {
+    title: "Home",
+    slug: "home",
+    content: "<h1>Welcome</h1><p>Your homepage content goes here.</p>",
+  },
+  {
+    title: "About",
+    slug: "about",
+    content:
+      "<h1>About Us</h1><p>Learn more about our team and mission.</p>",
+  },
+  {
+    title: "Contact",
+    slug: "contact",
+    content:
+      "<h1>Contact</h1><p>Get in touch with us via the form below.</p>",
+  },
+  {
+    title: "Privacy Policy",
+    slug: "privacy-policy",
+    content:
+      "<h1>Privacy Policy</h1><p>Your privacy matters to us. Read our full policy.</p>",
+  },
+  {
+    title: "Terms of Service",
+    slug: "terms",
+    content:
+      "<h1>Terms of Service</h1><p>Please read the following terms carefully.</p>",
+  },
+];
+
+const DEMO_POSTS = [
+  {
+    title: "Getting Started with Actuate CMS",
+    slug: "getting-started",
+    excerpt: "Learn how to set up and configure your new CMS.",
+    content:
+      "<h1>Getting Started</h1><p>Welcome to Actuate CMS. This guide walks you through initial setup.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Content Modeling Best Practices",
+    slug: "content-modeling",
+    excerpt: "Design your collections and fields for maximum flexibility.",
+    content:
+      "<h1>Content Modeling</h1><p>Effective content modeling is the foundation of a great CMS.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Working with Media",
+    slug: "working-with-media",
+    excerpt: "Upload, organize, and optimize your media assets.",
+    content:
+      "<h1>Working with Media</h1><p>Actuate CMS provides powerful media management.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "SEO Optimization Tips",
+    slug: "seo-optimization",
+    excerpt: "Boost your search rankings with built-in SEO tools.",
+    content:
+      "<h1>SEO Optimization</h1><p>Follow these tips to improve your site visibility.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Building Custom Plugins",
+    slug: "building-plugins",
+    excerpt: "Extend Actuate CMS with your own plugins.",
+    content:
+      "<h1>Building Plugins</h1><p>The plugin system lets you add custom functionality.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "API Reference Overview",
+    slug: "api-reference",
+    excerpt: "A comprehensive guide to the Actuate CMS REST API.",
+    content:
+      "<h1>API Reference</h1><p>Use the API to integrate your content anywhere.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Deployment Guide",
+    slug: "deployment-guide",
+    excerpt: "Deploy Actuate CMS to Vercel, AWS, or self-hosted.",
+    content:
+      "<h1>Deployment Guide</h1><p>Multiple deployment options for every use case.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Multi-language Content",
+    slug: "multi-language",
+    excerpt: "Set up localization and manage translated content.",
+    content:
+      "<h1>Multi-language Content</h1><p>Reach a global audience with localized content.</p>",
+    status: "PUBLISHED",
+  },
+  {
+    title: "Webhooks and Integrations",
+    slug: "webhooks-integrations",
+    excerpt: "Connect Actuate CMS to external services with webhooks.",
+    content:
+      "<h1>Webhooks</h1><p>Automate workflows by connecting to third-party services.</p>",
+    status: "DRAFT",
+  },
+  {
+    title: "Advanced Access Control",
+    slug: "access-control",
+    excerpt: "Fine-tune permissions with role-based access control.",
+    content:
+      "<h1>Access Control</h1><p>Protect your content with granular permissions.</p>",
+    status: "DRAFT",
+  },
+];
+
+const DEMO_FORMS = [
+  {
+    title: "Contact Form",
+    slug: "contact-form",
+    fields: [
+      { name: "name", type: "text", required: true },
+      { name: "email", type: "email", required: true },
+      { name: "message", type: "textarea", required: true },
+    ],
+    submitLabel: "Send Message",
+    successMessage: "Thanks for reaching out! We'll get back to you soon.",
+  },
+  {
+    title: "Newsletter Signup",
+    slug: "newsletter",
+    fields: [
+      { name: "email", type: "email", required: true },
+      { name: "firstName", type: "text", required: false },
+    ],
+    submitLabel: "Subscribe",
+    successMessage: "You're subscribed! Check your inbox for confirmation.",
+  },
+  {
+    title: "Feedback Form",
+    slug: "feedback",
+    fields: [
+      { name: "name", type: "text", required: false },
+      { name: "rating", type: "select", options: ["1", "2", "3", "4", "5"], required: true },
+      { name: "comments", type: "textarea", required: false },
+    ],
+    submitLabel: "Submit Feedback",
+    successMessage: "Thank you for your feedback!",
+  },
+];
+
+const DEMO_USERS = [
+  { email: "editor@example.com", name: "Demo Editor", role: "EDITOR" as const },
+  { email: "author@example.com", name: "Demo Author", role: "AUTHOR" as const },
+];
+
+interface SeedOptions {
+  demo?: boolean;
+  file?: string;
+  reset?: boolean;
+}
+
+async function runSeed(options: SeedOptions): Promise<void> {
+  if (!options.demo && !options.file) {
+    logger.error("Specify --demo to seed demo content or --file <path> to seed from a JSON file.");
+    process.exit(1);
+  }
+
+  try {
+    const { getDB } = await import("@actuate-media/cms-core");
+    const db = getDB<any>();
+
+    if (options.reset) {
+      const yes = await confirm(
+        "This will delete ALL existing documents and versions. Continue?",
+      );
+      if (!yes) {
+        logger.warn("Seed cancelled.");
+        return;
+      }
+
+      const resetSpinner = ora("Clearing existing data…").start();
+      await db.version.deleteMany({});
+      await db.mediaUsage.deleteMany({});
+      await db.document.deleteMany({});
+      resetSpinner.succeed("Existing data cleared.");
+    }
+
+    if (options.demo) {
+      await seedDemoData(db);
+    }
+
+    if (options.file) {
+      await seedFromFile(db, options.file);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(`Seed failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+async function seedDemoData(db: any): Promise<void> {
+  const spinner = ora("Seeding demo data…").start();
+
+  let adminUser = await db.user.findFirst({ where: { role: "ADMIN" } });
+  if (!adminUser) {
+    adminUser = await db.user.create({
+      data: {
+        email: "admin@actuatecms.dev",
+        name: "Admin",
+        role: "ADMIN",
+        isActive: true,
+        isApproved: true,
+        emailVerified: true,
+      },
+    });
+  }
+  const userId = adminUser.id;
+
+  let pagesCreated = 0;
+  for (const page of DEMO_PAGES) {
+    await db.document.create({
+      data: {
+        collection: "pages",
+        data: page,
+        status: "PUBLISHED",
+        publishedAt: new Date(),
+        createdById: userId,
+        updatedById: userId,
+        plainText: `${page.title} ${page.slug}`,
+      },
+    });
+    pagesCreated++;
+  }
+
+  let postsCreated = 0;
+  for (const post of DEMO_POSTS) {
+    await db.document.create({
+      data: {
+        collection: "posts",
+        data: post,
+        status: post.status,
+        publishedAt: post.status === "PUBLISHED" ? new Date() : null,
+        createdById: userId,
+        updatedById: userId,
+        plainText: `${post.title} ${post.excerpt}`,
+      },
+    });
+    postsCreated++;
+  }
+
+  let formsCreated = 0;
+  for (const form of DEMO_FORMS) {
+    await db.document.create({
+      data: {
+        collection: "forms",
+        data: form,
+        status: "PUBLISHED",
+        publishedAt: new Date(),
+        createdById: userId,
+        updatedById: userId,
+        plainText: `${form.title} ${form.slug}`,
+      },
+    });
+    formsCreated++;
+  }
+
+  let usersCreated = 0;
+  for (const user of DEMO_USERS) {
+    const exists = await db.user.findFirst({ where: { email: user.email } });
+    if (!exists) {
+      await db.user.create({
+        data: {
+          email: user.email,
+          name: user.name,
+          role: user.role,
+          isActive: true,
+          isApproved: true,
+          emailVerified: true,
+        },
+      });
+      usersCreated++;
+    }
+  }
+
+  spinner.succeed("Demo data seeded successfully.");
+  logger.info(`  Pages:  ${pagesCreated}`);
+  logger.info(`  Posts:  ${postsCreated}`);
+  logger.info(`  Forms:  ${formsCreated}`);
+  logger.info(`  Users:  ${usersCreated} (+ existing admin)`);
+}
+
+async function seedFromFile(db: any, filePath: string): Promise<void> {
+  if (!existsSync(filePath)) {
+    logger.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const spinner = ora(`Seeding from ${filePath}…`).start();
+
+  const raw = await readFile(filePath, "utf-8");
+  let seedData: any;
+  try {
+    seedData = JSON.parse(raw);
+  } catch {
+    spinner.fail("Invalid JSON file.");
+    process.exit(1);
+  }
+
+  if (!Array.isArray(seedData) && typeof seedData !== "object") {
+    spinner.fail("Seed file must contain a JSON array or an object with collection keys.");
+    process.exit(1);
+  }
+
+  let adminUser = await db.user.findFirst({ where: { role: "ADMIN" } });
+  if (!adminUser) {
+    adminUser = await db.user.create({
+      data: {
+        email: "admin@actuatecms.dev",
+        name: "Admin",
+        role: "ADMIN",
+        isActive: true,
+        isApproved: true,
+        emailVerified: true,
+      },
+    });
+  }
+  const userId = adminUser.id;
+
+  let count = 0;
+
+  if (Array.isArray(seedData)) {
+    for (const doc of seedData) {
+      await db.document.create({
+        data: {
+          collection: doc.collection ?? "imported",
+          data: doc.data ?? doc,
+          status: doc.status ?? "DRAFT",
+          createdById: userId,
+          updatedById: userId,
+        },
+      });
+      count++;
+    }
+  } else {
+    for (const [collection, docs] of Object.entries(seedData)) {
+      if (!Array.isArray(docs)) continue;
+      for (const doc of docs as any[]) {
+        await db.document.create({
+          data: {
+            collection,
+            data: doc.data ?? doc,
+            status: doc.status ?? "DRAFT",
+            createdById: userId,
+            updatedById: userId,
+          },
+        });
+        count++;
+      }
+    }
+  }
+
+  spinner.succeed(`Seeded ${count} documents from ${filePath}.`);
+}
+
+export function registerSeedCommand(program: Command): void {
+  program
+    .command("seed")
+    .description("Seed the database with demo or custom data")
+    .option("--demo", "Seed demo content (pages, posts, forms, users)")
+    .option("--file <path>", "Seed from a JSON file")
+    .option("--reset", "Clear existing data before seeding")
+    .action(runSeed);
+}

package/src/commands/update-check.ts

@@ -0,0 +1,147 @@
+import { Command } from "commander";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import ora from "ora";
+import { logger } from "../utils/logger.js";
+
+const UPDATE_SERVER_URL = "https://updates.actuatecms.com/api/versions";
+
+function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^[^0-9]*/, "").split(".").map(Number);
+  const pb = b.replace(/^[^0-9]*/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+interface PackageVersions {
+  [pkg: string]: string;
+}
+
+async function getLocalVersions(): Promise<PackageVersions> {
+  const pkgPath = resolve(process.cwd(), "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error("No package.json found in the current directory.");
+  }
+
+  const raw = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  const versions: PackageVersions = {};
+
+  for (const section of ["dependencies", "devDependencies"] as const) {
+    const deps = pkg[section];
+    if (!deps) continue;
+    for (const [name, version] of Object.entries(deps)) {
+      if (name.startsWith("@actuate-media/") && typeof version === "string") {
+        versions[name] = version.replace(/^[\^~]/, "").replace("workspace:", "");
+      }
+    }
+  }
+
+  return versions;
+}
+
+async function fetchLatestVersions(
+  packages: string[],
+): Promise<PackageVersions> {
+  const versions: PackageVersions = {};
+
+  try {
+    const res = await fetch(UPDATE_SERVER_URL);
+    if (res.ok) {
+      const data = await res.json();
+      for (const pkg of packages) {
+        if (data[pkg]) {
+          versions[pkg] = data[pkg];
+        }
+      }
+      if (Object.keys(versions).length === packages.length) {
+        return versions;
+      }
+    }
+  } catch {
+    // Fall through to npm registry
+  }
+
+  for (const pkg of packages) {
+    if (versions[pkg]) continue;
+    try {
+      const npmUrl = `https://registry.npmjs.org/${pkg}/latest`;
+      const res = await fetch(npmUrl);
+      if (res.ok) {
+        const data = await res.json();
+        versions[pkg] = data.version;
+      }
+    } catch {
+      // Skip packages we can't look up
+    }
+  }
+
+  return versions;
+}
+
+async function runUpdateCheck(): Promise<void> {
+  const spinner = ora("Checking for updates…").start();
+
+  try {
+    const local = await getLocalVersions();
+    const packages = Object.keys(local);
+
+    if (packages.length === 0) {
+      spinner.warn("No @actuate-media/* packages found in package.json.");
+      return;
+    }
+
+    const latest = await fetchLatestVersions(packages);
+    spinner.stop();
+
+    let hasUpdates = false;
+
+    console.log("\n  " + "Package".padEnd(30) + "Current".padEnd(14) + "Latest".padEnd(14) + "Status");
+    console.log("  " + "-".repeat(68));
+
+    for (const pkg of packages) {
+      const current = local[pkg];
+      const remote = latest[pkg] ?? "unknown";
+      let status: string;
+
+      if (remote === "unknown") {
+        status = "?";
+      } else if (compareVersions(current!, remote) < 0) {
+        status = "Update available";
+        hasUpdates = true;
+      } else {
+        status = "Up to date";
+      }
+
+      console.log(
+        `  ${pkg.padEnd(30)}${(current ?? '').padEnd(14)}${remote.padEnd(14)}${status}`,
+      );
+    }
+
+    console.log();
+
+    if (hasUpdates) {
+      logger.warn('Updates available! Run "actuate upgrade" to update.');
+    } else {
+      logger.success("All packages are up to date!");
+    }
+  } catch (err) {
+    spinner.fail("Update check failed.");
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(message);
+    process.exit(1);
+  }
+}
+
+export function registerUpdateCheckCommand(program: Command): void {
+  program
+    .command("update-check")
+    .description(
+      "Check for available Actuate CMS package updates",
+    )
+    .action(runUpdateCheck);
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,173 @@
+import { Command } from "commander";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import ora from "ora";
+import { logger } from "../utils/logger.js";
+
+const UPDATE_SERVER_URL = "https://updates.actuatecms.com/api/versions";
+
+function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^[^0-9]*/, "").split(".").map(Number);
+  const pb = b.replace(/^[^0-9]*/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+async function confirm(question: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} (y/N) `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+
+async function fetchLatestVersions(
+  packages: string[],
+): Promise<Record<string, string>> {
+  const versions: Record<string, string> = {};
+
+  try {
+    const res = await fetch(UPDATE_SERVER_URL);
+    if (res.ok) {
+      const data = await res.json();
+      for (const pkg of packages) {
+        if (data[pkg]) versions[pkg] = data[pkg];
+      }
+      if (Object.keys(versions).length === packages.length) return versions;
+    }
+  } catch {
+    // Fall through to npm registry
+  }
+
+  for (const pkg of packages) {
+    if (versions[pkg]) continue;
+    try {
+      const res = await fetch(`https://registry.npmjs.org/${pkg}/latest`);
+      if (res.ok) {
+        const data = await res.json();
+        versions[pkg] = data.version;
+      }
+    } catch {
+      // Skip
+    }
+  }
+
+  return versions;
+}
+
+interface UpgradeOptions {
+  latest?: boolean;
+  version?: string;
+  dryRun?: boolean;
+}
+
+async function runUpgrade(options: UpgradeOptions): Promise<void> {
+  const pkgPath = resolve(process.cwd(), "package.json");
+  if (!existsSync(pkgPath)) {
+    logger.error("No package.json found in the current directory.");
+    process.exit(1);
+  }
+
+  const raw = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+
+  const actuatePackages: { name: string; current: string; section: string }[] = [];
+
+  for (const section of ["dependencies", "devDependencies"] as const) {
+    const deps = pkg[section];
+    if (!deps) continue;
+    for (const [name, version] of Object.entries(deps)) {
+      if (name.startsWith("@actuate-media/") && typeof version === "string") {
+        if (version.startsWith("workspace:")) continue;
+        actuatePackages.push({
+          name,
+          current: version.replace(/^[\^~]/, ""),
+          section,
+        });
+      }
+    }
+  }
+
+  if (actuatePackages.length === 0) {
+    logger.warn("No @actuate-media/* packages found in package.json (excluding workspace: references).");
+    return;
+  }
+
+  const spinner = ora("Resolving target versions…").start();
+
+  let targetVersions: Record<string, string>;
+
+  if (options.version) {
+    targetVersions = {};
+    for (const p of actuatePackages) {
+      targetVersions[p.name] = options.version;
+    }
+    spinner.succeed(`Target version: ${options.version}`);
+  } else {
+    targetVersions = await fetchLatestVersions(
+      actuatePackages.map((p) => p.name),
+    );
+    spinner.succeed("Resolved latest versions.");
+  }
+
+  const upgrades: { name: string; from: string; to: string; section: string }[] = [];
+
+  for (const p of actuatePackages) {
+    const target = targetVersions[p.name];
+    if (!target) continue;
+    if (compareVersions(p.current, target) < 0) {
+      upgrades.push({ name: p.name, from: p.current, to: target, section: p.section });
+    }
+  }
+
+  if (upgrades.length === 0) {
+    logger.success("All @actuate-media/* packages are already up to date.");
+    return;
+  }
+
+  console.log("\n  Proposed upgrades:\n");
+  console.log("  " + "Package".padEnd(30) + "From".padEnd(14) + "To");
+  console.log("  " + "-".repeat(54));
+  for (const u of upgrades) {
+    console.log(`  ${u.name.padEnd(30)}${u.from.padEnd(14)}${u.to}`);
+  }
+  console.log();
+
+  if (options.dryRun) {
+    logger.info("Dry run — no changes were made.");
+    return;
+  }
+
+  const proceed = await confirm("Apply these upgrades to package.json?");
+  if (!proceed) {
+    logger.warn("Upgrade cancelled.");
+    return;
+  }
+
+  for (const u of upgrades) {
+    const prefix = pkg[u.section][u.name]?.match(/^[\^~]/)?.[0] ?? "^";
+    pkg[u.section][u.name] = `${prefix}${u.to}`;
+  }
+
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+
+  logger.success(`Updated ${upgrades.length} package(s) in package.json.`);
+  logger.info('Run "pnpm install" to apply the upgrade.');
+}
+
+export function registerUpgradeCommand(program: Command): void {
+  program
+    .command("upgrade")
+    .description("Upgrade @actuate-media/* packages to the latest or a specific version")
+    .option("--latest", "Upgrade to the latest version (default)", true)
+    .option("--version <ver>", "Upgrade to a specific version")
+    .option("--dry-run", "Show proposed changes without modifying files")
+    .action(runUpgrade);
+}