@infuro/cms-core 1.0.6 → 1.0.7

package/dist/cli.cjs

@@ -0,0 +1,859 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var TEMPLATES = {
+  "src/lib/data-source.ts": `import 'reflect-metadata';
+import path from 'path';
+import { createRequire } from 'module';
+import { DataSource } from 'typeorm';
+import { CMS_ENTITY_MAP } from '@infuro/cms-core';
+
+const require = createRequire(import.meta.url);
+const coreDir = path.dirname(require.resolve('@infuro/cms-core'));
+
+let dataSource: DataSource | null = null;
+
+export function getDataSource(): DataSource {
+  if (!dataSource) {
+    dataSource = new DataSource({
+      type: 'postgres',
+      url: process.env.DATABASE_URL,
+      entities: Object.values(CMS_ENTITY_MAP),
+      synchronize: false,
+      ...(process.env.TYPEORM_CLI && {
+        migrations: [
+          path.join(coreDir, 'migrations', '*.ts'),
+          path.join(process.cwd(), 'src', 'migrations', '*.ts'),
+        ],
+      }),
+    });
+  }
+  return dataSource;
+}
+
+export async function getDataSourceInitialized(): Promise<DataSource> {
+  const ds = getDataSource();
+  if (!ds.isInitialized) await ds.initialize();
+  return ds;
+}
+
+export default getDataSource;
+`,
+  "src/lib/auth-helpers.ts": `import { getServerSession } from 'next-auth';
+import { NextResponse } from 'next/server';
+import { createAuthHelpers } from '@infuro/cms-core/auth';
+
+const helpers = createAuthHelpers(
+  async () => {
+    const s = await getServerSession();
+    return s ? { user: s.user } : null;
+  },
+  NextResponse
+);
+
+export const requireAuth = helpers.requireAuth;
+export const requirePermission = helpers.requirePermission;
+export const getAuthenticatedUser = helpers.getAuthenticatedUser;
+`,
+  "src/lib/cms.ts": `import {
+  createCmsApp,
+  localStoragePlugin,
+  type CmsApp,
+} from '@infuro/cms-core';
+import { getDataSourceInitialized } from './data-source';
+
+let cmsPromise: Promise<CmsApp> | null = null;
+
+export async function getCms(): Promise<CmsApp> {
+  if (cmsPromise) return cmsPromise;
+  const dataSource = await getDataSourceInitialized();
+  cmsPromise = createCmsApp({
+    dataSource,
+    config: process.env as unknown as Record<string, string>,
+    plugins: [
+      localStoragePlugin({ dir: 'public/uploads' }),
+    ],
+  });
+  return cmsPromise;
+}
+`,
+  "src/app/api/[[...path]]/route.ts": `import { NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { createCmsApiHandler } from '@infuro/cms-core/api';
+import { CMS_ENTITY_MAP } from '@infuro/cms-core';
+import { getDataSourceInitialized } from '@/lib/data-source';
+import { requireAuth } from '@/lib/auth-helpers';
+import { getCms } from '@/lib/cms';
+import bcrypt from 'bcryptjs';
+
+const baseUrl = process.env.NEXTAUTH_URL || 'http://localhost:3000';
+
+let handlerPromise: Promise<ReturnType<typeof createCmsApiHandler>> | null = null;
+
+async function getHandler() {
+  if (!handlerPromise) {
+    const dataSource = await getDataSourceInitialized();
+    handlerPromise = Promise.resolve(
+      createCmsApiHandler({
+        dataSource,
+        entityMap: CMS_ENTITY_MAP,
+        requireAuth,
+        json: NextResponse.json.bind(NextResponse),
+        getCms,
+        userAuth: {
+          dataSource,
+          entityMap: CMS_ENTITY_MAP,
+          json: NextResponse.json.bind(NextResponse),
+          baseUrl,
+          hashPassword: (p) => Promise.resolve(bcrypt.hashSync(p, 12)),
+          comparePassword: (p, h) => Promise.resolve(bcrypt.compareSync(p, h)),
+          resetExpiryHours: 1,
+          getSession: () =>
+            getServerSession().then((s) => (s ? { user: s.user } : null)),
+        },
+        dashboard: {
+          dataSource,
+          entityMap: CMS_ENTITY_MAP,
+          json: NextResponse.json.bind(NextResponse),
+          requireAuth,
+          requirePermission: requireAuth,
+        },
+        upload: {
+          json: NextResponse.json.bind(NextResponse),
+          requireAuth,
+          storage: () => getCms().then((cms) => cms.getPlugin('storage')),
+          localUploadDir: 'public/uploads',
+        },
+        blogBySlug: {
+          dataSource,
+          entityMap: CMS_ENTITY_MAP,
+          json: NextResponse.json.bind(NextResponse),
+          requireAuth: async () => null,
+        },
+        formBySlug: {
+          dataSource,
+          entityMap: CMS_ENTITY_MAP,
+          json: NextResponse.json.bind(NextResponse),
+          requireAuth: async () => null,
+        },
+        usersApi: {
+          dataSource,
+          entityMap: CMS_ENTITY_MAP,
+          json: NextResponse.json.bind(NextResponse),
+          requireAuth,
+          baseUrl,
+        },
+      })
+    );
+  }
+  return handlerPromise;
+}
+
+async function handle(method: string, req: Request, context: { params: Promise<{ path?: string[] }> }) {
+  try {
+    const handler = await getHandler();
+    const { path: pathSegments = [] } = await context.params;
+    return handler.handle(method, pathSegments, req);
+  } catch {
+    return NextResponse.json({ error: 'Server Error' }, { status: 500 });
+  }
+}
+
+export async function GET(req: Request, ctx: { params: Promise<{ path?: string[] }> }) { return handle('GET', req, ctx); }
+export async function POST(req: Request, ctx: { params: Promise<{ path?: string[] }> }) { return handle('POST', req, ctx); }
+export async function PUT(req: Request, ctx: { params: Promise<{ path?: string[] }> }) { return handle('PUT', req, ctx); }
+export async function PATCH(req: Request, ctx: { params: Promise<{ path?: string[] }> }) { return handle('PATCH', req, ctx); }
+export async function DELETE(req: Request, ctx: { params: Promise<{ path?: string[] }> }) { return handle('DELETE', req, ctx); }
+`,
+  "src/app/api/auth/[...nextauth]/route.ts": `import NextAuth from 'next-auth';
+import { getNextAuthOptions } from '@infuro/cms-core/auth';
+import { getDataSourceInitialized } from '@/lib/data-source';
+import { CMS_ENTITY_MAP } from '@infuro/cms-core';
+import bcrypt from 'bcryptjs';
+
+async function getOptions() {
+  const dataSource = await getDataSourceInitialized();
+  const userRepo = dataSource.getRepository(CMS_ENTITY_MAP.users);
+  return getNextAuthOptions({
+    getUserByEmail: async (email: string) => {
+      return userRepo.findOne({
+        where: { email },
+        relations: ['group', 'group.permissions'],
+        select: ['id', 'email', 'name', 'password', 'blocked', 'deleted', 'groupId'],
+      }) as any;
+    },
+    comparePassword: (plain, hash) => Promise.resolve(bcrypt.compareSync(plain, hash)),
+    signInPage: '/admin/signin',
+  });
+}
+
+let handler: ReturnType<typeof NextAuth> | null = null;
+
+async function getHandler() {
+  if (!handler) handler = NextAuth(await getOptions());
+  return handler;
+}
+
+type NextAuthContext = { params: Promise<{ nextauth?: string[] }> };
+
+export async function GET(req: Request, context: NextAuthContext) {
+  return (await getHandler())(req, context);
+}
+export async function POST(req: Request, context: NextAuthContext) {
+  return (await getHandler())(req, context);
+}
+`,
+  "src/app/admin/layout.tsx": `'use client';
+
+import '@infuro/cms-core/admin.css';
+import AdminLayout from '@infuro/cms-core/admin';
+
+export default function AdminLayoutWrapper({ children }: { children: React.ReactNode }) {
+  return (
+    <AdminLayout
+      customNavItems={[]}
+      customNavSections={[]}
+      customCrudConfigs={{}}
+    >
+      {children}
+    </AdminLayout>
+  );
+}
+`,
+  "src/app/admin/[[...slug]]/page.tsx": `import { AdminPageResolver } from '@infuro/cms-core/admin';
+
+export default async function AdminPage({ params }: { params: Promise<{ slug?: string[] }> }) {
+  const { slug } = await params;
+  return <AdminPageResolver slug={slug} />;
+}
+`,
+  "src/middleware.ts": `import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { createCmsMiddleware } from '@infuro/cms-core/auth';
+
+const cmsMiddleware = createCmsMiddleware({
+  publicApiMethods: {
+    '/api/contacts': ['POST'],
+    '/api/form-submissions': ['POST'],
+    '/api/blogs': ['GET'],
+    '/api/forms': ['GET'],
+    '/api/auth': ['GET', 'POST'],
+    '/api/users/forgot-password': ['POST'],
+    '/api/users/set-password': ['POST'],
+    '/api/users/invite': ['POST'],
+  },
+});
+
+export function middleware(request: NextRequest) {
+  const result = cmsMiddleware({
+    nextUrl: request.nextUrl,
+    url: request.url,
+    method: request.method,
+    cookies: request.cookies,
+  });
+
+  if (result.type === 'next') return NextResponse.next();
+  if (result.type === 'redirect') return NextResponse.redirect(result.url);
+  if (result.type === 'json') return NextResponse.json(result.body, { status: result.status });
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ['/admin/:path*', '/api/:path*'],
+};
+`,
+  "src/app/providers.tsx": `"use client";
+
+import { ThemeProvider } from "next-themes";
+import { SessionProvider } from "next-auth/react";
+import { Toaster } from "sonner";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <SessionProvider>
+      <ThemeProvider attribute="class" defaultTheme="system" enableSystem>
+        {children}
+        <Toaster position="top-right" />
+      </ThemeProvider>
+    </SessionProvider>
+  );
+}
+`,
+  ".env.example": `DATABASE_URL=postgres://user:password@localhost:5432/mydb
+NEXTAUTH_SECRET=your-random-secret
+NEXTAUTH_URL=http://localhost:3000
+
+# Admin user (for npm run seed)
+ADMIN_EMAIL=admin@example.com
+ADMIN_PASSWORD=changeme
+`,
+  "src/lib/seed.ts": `try { require('dotenv/config'); } catch {}
+import 'reflect-metadata';
+import { getDataSourceInitialized } from './data-source';
+import { CMS_ENTITY_MAP } from '@infuro/cms-core';
+import bcrypt from 'bcryptjs';
+
+async function main() {
+  const ds = await getDataSourceInitialized();
+  const userRepo = ds.getRepository(CMS_ENTITY_MAP.users);
+
+  const email = process.env.ADMIN_EMAIL || 'admin@example.com';
+  const password = process.env.ADMIN_PASSWORD || 'changeme';
+
+  const existing = await userRepo.findOne({ where: { email } });
+  if (!existing) {
+    const hashedPassword = await bcrypt.hash(password, 10);
+    await userRepo.save(userRepo.create({ name: 'Admin', email, password: hashedPassword }));
+    console.log('Default admin user created');
+  } else {
+    console.log('Default admin user already exists');
+  }
+
+  await ds.destroy();
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
+`,
+  "scripts/migration-datasource.cjs": `/**
+ * Data source for TypeORM CLI (migration:generate). Resolves @infuro/cms-core from project root (works with npm link).
+ */
+require('reflect-metadata');
+require('dotenv/config');
+const path = require('path');
+const { DataSource } = require('typeorm');
+const coreEntry = path.resolve(__dirname, '..', 'node_modules', '@infuro', 'cms-core', 'dist', 'index.cjs');
+const { CMS_ENTITY_MAP } = require(coreEntry);
+
+module.exports = new DataSource({
+  type: 'postgres',
+  url: process.env.DATABASE_URL,
+  entities: Object.values(CMS_ENTITY_MAP),
+  synchronize: false,
+  migrations: ['src/migrations/*.ts'],
+});
+`,
+  "scripts/run-migrations.ts": `/**
+ * Run TypeORM migrations. Loads .env so DATABASE_URL is set.
+ * Usage: npm run migration:run
+ */
+try { require('dotenv/config'); } catch {}
+import 'reflect-metadata';
+
+async function main() {
+  process.env.TYPEORM_CLI = '1';
+  const { getDataSourceInitialized } = await import('../src/lib/data-source');
+  const ds = await getDataSourceInitialized();
+  const run = await ds.runMigrations();
+  console.log(run.length ? \`Ran \${run.length} migration(s).\` : 'No pending migrations.');
+  await ds.destroy();
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});
+`,
+  "src/migrations/README.md": `# TypeORM migrations
+
+Generate a new migration (after changing entities):
+
+\`\`\`bash
+npm run migration:generate -- MyMigrationName
+\`\`\`
+
+Run pending migrations:
+
+\`\`\`bash
+npm run migration:run
+\`\`\`
+`,
+  "src/themes/default/index.ts": `import { createTheme } from '@infuro/cms-core/theme';
+
+import { Container, meta as containerMeta } from './components/Container';
+import { TextBlock, meta as textBlockMeta } from './components/TextBlock';
+
+import { Navbar } from './layout/Navbar';
+import { Footer, footerFields, footerDefaults } from './layout/Footer';
+
+export default createTheme({
+  name: 'default',
+  label: 'Default Theme',
+  components: [
+    { component: Container, meta: containerMeta },
+    { component: TextBlock, meta: textBlockMeta },
+  ],
+  layout: {
+    navbar: { component: Navbar },
+    footer: { component: Footer, fields: footerFields, defaults: footerDefaults },
+  },
+});
+`,
+  "src/themes/default/layout/Navbar.tsx": `import type { NavbarConfig, NavItem } from '@infuro/cms-core/theme';
+
+function NavLink({ item }: { item: NavItem }) {
+  return (
+    <li className="list-none">
+      <a
+        href={item.url}
+        target={item.openInNewTab ? '_blank' : undefined}
+        rel={item.openInNewTab ? 'noopener noreferrer' : undefined}
+        className="text-sm font-medium text-gray-700 hover:text-gray-900 px-3 py-2 inline-block"
+      >
+        {item.label}
+      </a>
+    </li>
+  );
+}
+
+export function Navbar({ logo, items, ctaLabel, ctaUrl }: NavbarConfig) {
+  return (
+    <nav className="bg-white sticky top-0 z-40 border-b">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div className="flex items-center justify-between h-16">
+          <a href="/" className="flex-shrink-0">
+            {logo ? (
+              <img src={logo} alt="Logo" className="h-8" />
+            ) : (
+              <span className="text-xl font-bold text-gray-900">Logo</span>
+            )}
+          </a>
+          <ul className="flex items-center gap-1 list-none m-0 p-0">
+            {items.map((item) => (
+              <NavLink key={item.id} item={item} />
+            ))}
+          </ul>
+          {ctaLabel && (
+            <a href={ctaUrl || '#'} className="text-sm font-medium text-gray-900 hover:underline">
+              {ctaLabel}
+            </a>
+          )}
+        </div>
+      </div>
+    </nav>
+  );
+}
+`,
+  "src/themes/default/layout/Footer.tsx": `import type { FooterConfig, PropDefinition } from '@infuro/cms-core/theme';
+
+export const footerFields: PropDefinition[] = [
+  { name: 'copyright', label: 'Copyright Text', type: 'text' },
+];
+
+export const footerDefaults: Record<string, any> = {
+  copyright: '\xA9 2025 Your Site. All rights reserved.',
+  columns: [],
+  socialLinks: [],
+};
+
+export function Footer({ copyright, columns = [], socialLinks = [] }: FooterConfig) {
+  return (
+    <footer className="bg-gray-900 text-gray-400 py-8 px-8">
+      <div className="max-w-7xl mx-auto">
+        {columns.length > 0 && (
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-8 mb-6">
+            {columns.map((col, i) => (
+              <div key={i}>
+                <h4 className="text-white font-semibold mb-3 text-sm">{col.title}</h4>
+                <ul className="space-y-2">
+                  {col.links.map((link, j) => (
+                    <li key={j}>
+                      <a href={link.url} className="text-sm hover:text-white transition-colors">
+                        {link.label}
+                      </a>
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            ))}
+          </div>
+        )}
+        <div className="border-t border-gray-800 pt-6">
+          <p className="text-sm">{copyright}</p>
+        </div>
+      </div>
+    </footer>
+  );
+}
+`,
+  "src/themes/default/components/Container.tsx": `import type { ComponentMeta } from '@infuro/cms-core/theme';
+
+export const meta: ComponentMeta = {
+  name: 'Container',
+  label: 'Container',
+  category: 'layout',
+  icon: 'LayoutDashboard',
+  description: 'A layout container that holds other components',
+  defaultProps: { background: '#ffffff' },
+  props: [{ name: 'background', label: 'Background', type: 'color' }],
+  canContainChildren: true,
+};
+
+export function Container({
+  background = '#ffffff',
+  children,
+}: {
+  background?: string;
+  children?: React.ReactNode;
+}) {
+  return (
+    <div style={{ backgroundColor: background, minHeight: '48px', padding: '1rem' }}>
+      {children}
+    </div>
+  );
+}
+`,
+  "src/themes/default/components/TextBlock.tsx": `import type { ComponentMeta } from '@infuro/cms-core/theme';
+
+export const meta: ComponentMeta = {
+  name: 'TextBlock',
+  label: 'Text Block',
+  category: 'content',
+  icon: 'Type',
+  description: 'Rich text content block',
+  defaultProps: { content: '<p>Enter your text here...</p>' },
+  props: [{ name: 'content', label: 'Content', type: 'richtext' }],
+};
+
+export function TextBlock({ content }: { content?: string }) {
+  return (
+    <div
+      className="prose prose-gray max-w-none py-4 px-2"
+      dangerouslySetInnerHTML={{ __html: content || '' }}
+    />
+  );
+}
+`,
+  "src/lib/theme-registry.ts": `import defaultTheme from '@/themes/default';
+import type { ThemeConfig } from '@infuro/cms-core/theme';
+
+export const defaultThemeConfig = defaultTheme;
+
+export interface ThemeRegistryItem {
+  id: string;
+  label: string;
+  config: ThemeConfig;
+  description?: string;
+}
+
+export const THEME_REGISTRY: ThemeRegistryItem[] = [
+  {
+    id: 'default',
+    label: 'Default',
+    config: defaultTheme,
+    description: 'Default theme with standard layout and components.',
+  },
+];
+
+export function getThemeById(id: string | undefined): ThemeConfig {
+  const theme = THEME_REGISTRY.find((t) => t.id === (id || '')) ?? THEME_REGISTRY[0];
+  return theme?.config ?? defaultTheme;
+}
+`,
+  "src/app/page.tsx": `export default function HomePage() {
+  return (
+    <main className="min-h-screen flex flex-col items-center justify-center p-8">
+      <h1 className="text-3xl font-bold text-gray-900 mb-4">Welcome</h1>
+      <p className="text-gray-600 mb-6">Your CMS is set up. Manage content at the admin panel.</p>
+      <a
+        href="/admin"
+        className="text-white bg-gray-900 hover:bg-gray-800 px-4 py-2 rounded-lg font-medium transition-colors"
+      >
+        Open Admin
+      </a>
+    </main>
+  );
+}
+`,
+  "src/app/contact/page.tsx": `export default function ContactPage() {
+  return (
+    <main className="min-h-screen p-8 max-w-2xl mx-auto">
+      <h1 className="text-3xl font-bold text-gray-900 mb-4">Contact</h1>
+      <p className="text-gray-600">
+        Add a contact form or wire this page to your CMS form. Use the admin panel to manage forms and submissions.
+      </p>
+    </main>
+  );
+}
+`
+};
+function findRoot(cwd) {
+  let dir = import_path.default.resolve(cwd);
+  for (let i = 0; i < 20; i++) {
+    const pkgPath = import_path.default.join(dir, "package.json");
+    if (import_fs.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs.default.readFileSync(pkgPath, "utf8"));
+        if (pkg.dependencies?.next || pkg.devDependencies?.next) return dir;
+      } catch {
+      }
+    }
+    const parent = import_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function writeFile(root, filePath, content, force2, dryRun2, log) {
+  const full = import_path.default.join(root, filePath);
+  if (import_fs.default.existsSync(full) && !force2) {
+    log(`  skip (exists): ${filePath}`);
+    return false;
+  }
+  if (dryRun2) {
+    log(`  would create: ${filePath}`);
+    return true;
+  }
+  const dir = import_path.default.dirname(full);
+  import_fs.default.mkdirSync(dir, { recursive: true });
+  import_fs.default.writeFileSync(full, content, "utf8");
+  log(`  created: ${filePath}`);
+  return true;
+}
+function patchNextConfig(root, dryRun2, log) {
+  const candidates = ["next.config.js", "next.config.mjs", "next.config.cjs"];
+  let configPath = null;
+  for (const name of candidates) {
+    const p = import_path.default.join(root, name);
+    if (import_fs.default.existsSync(p)) {
+      configPath = p;
+      break;
+    }
+  }
+  if (!configPath) {
+    log("  skip next.config: not found");
+    return false;
+  }
+  let content = import_fs.default.readFileSync(configPath, "utf8");
+  if (content.includes("'@infuro/cms-core'") || content.includes('"@infuro/cms-core"')) {
+    log(`  skip (already has core): ${import_path.default.basename(configPath)}`);
+    return false;
+  }
+  if (content.includes("serverExternalPackages")) {
+    content = content.replace(
+      /(serverExternalPackages:\s*\[)/,
+      "$1'@infuro/cms-core', 'typeorm', "
+    );
+  } else {
+    content = content.replace(
+      /(const nextConfig\s*=\s*\{|module\.exports\s*=\s*\{)/,
+      "$1\n  serverExternalPackages: ['@infuro/cms-core', 'typeorm'],"
+    );
+  }
+  if (dryRun2) {
+    log(`  would patch: ${import_path.default.basename(configPath)}`);
+    return true;
+  }
+  import_fs.default.writeFileSync(configPath, content, "utf8");
+  log(`  patched: ${import_path.default.basename(configPath)}`);
+  return true;
+}
+function patchTailwind(root, dryRun2, log) {
+  const candidates = ["tailwind.config.js", "tailwind.config.mjs", "tailwind.config.ts"];
+  let configPath = null;
+  for (const name of candidates) {
+    const p = import_path.default.join(root, name);
+    if (import_fs.default.existsSync(p)) {
+      configPath = p;
+      break;
+    }
+  }
+  if (!configPath) {
+    log("  skip tailwind: config not found");
+    return false;
+  }
+  let content = import_fs.default.readFileSync(configPath, "utf8");
+  const coreContent = "./node_modules/@infuro/cms-core/dist/**/*.{js,cjs}";
+  if (content.includes("@infuro/cms-core")) {
+    log(`  skip (already has core): ${import_path.default.basename(configPath)}`);
+    return false;
+  }
+  if (content.includes("content:")) {
+    content = content.replace(
+      /(content:\s*\[)/,
+      `$1
+    "${coreContent}",`
+    );
+  }
+  if (dryRun2) {
+    log(`  would patch: ${import_path.default.basename(configPath)}`);
+    return true;
+  }
+  import_fs.default.writeFileSync(configPath, content, "utf8");
+  log(`  patched: ${import_path.default.basename(configPath)}`);
+  return true;
+}
+function patchLayout(root, dryRun2, log) {
+  const layoutPath = import_path.default.join(root, "src/app/layout.tsx");
+  if (!import_fs.default.existsSync(layoutPath)) {
+    log("  skip layout: src/app/layout.tsx not found");
+    return false;
+  }
+  let content = import_fs.default.readFileSync(layoutPath, "utf8");
+  if (content.includes("<Providers>")) {
+    log("  skip layout: already uses Providers");
+    return false;
+  }
+  const bodyMatch = content.match(/<body([^>]*)>\s*(\{children\})\s*<\/body>/s);
+  if (!bodyMatch) {
+    log("  skip layout: unexpected structure (add <Providers> manually)");
+    return false;
+  }
+  if (dryRun2) {
+    log("  would patch: src/app/layout.tsx");
+    return true;
+  }
+  const [, bodyAttrs, children] = bodyMatch;
+  const newBody = `<body${bodyAttrs}>
+        <Providers>${children}</Providers>
+      </body>`;
+  content = content.replace(/<body[^>]*>\s*\{children\}\s*<\/body>/s, newBody);
+  if (!content.includes("from './providers'") && !content.includes('from "./providers"')) {
+    const firstImport = content.match(/^import .+ from .+;\n/m);
+    content = firstImport ? content.replace(firstImport[0], firstImport[0] + "import { Providers } from './providers';\n") : "import { Providers } from './providers';\n" + content;
+  }
+  if (content.includes("<html") && !content.includes("suppressHydrationWarning")) {
+    content = content.replace(/<html(\s)/, "<html suppressHydrationWarning$1");
+  }
+  import_fs.default.writeFileSync(layoutPath, content, "utf8");
+  log("  patched: src/app/layout.tsx");
+  return true;
+}
+function patchPackageJson(root, dryRun2, log) {
+  const pkgPath = import_path.default.join(root, "package.json");
+  if (!import_fs.default.existsSync(pkgPath)) return false;
+  const pkg = JSON.parse(import_fs.default.readFileSync(pkgPath, "utf8"));
+  const scripts = pkg.scripts || {};
+  let changed = false;
+  if (!scripts.seed) {
+    scripts.seed = "tsx src/lib/seed.ts";
+    changed = true;
+  }
+  if (!scripts["migration:run"]) {
+    scripts["migration:run"] = "tsx scripts/run-migrations.ts";
+    changed = true;
+  }
+  const dev = pkg.devDependencies || {};
+  const deps = pkg.dependencies || {};
+  if (!deps["@infuro/cms-core"]) {
+    deps["@infuro/cms-core"] = "^1.0.6";
+    changed = true;
+  }
+  if (!dev.tsx) {
+    dev.tsx = "^4.0.0";
+    changed = true;
+  }
+  if (!dev.dotenv) {
+    dev.dotenv = "^16.0.0";
+    changed = true;
+  }
+  if (!changed) {
+    log("  skip package.json: scripts/devDeps already present");
+    return false;
+  }
+  pkg.scripts = scripts;
+  pkg.dependencies = { ...pkg.dependencies, ...deps };
+  pkg.devDependencies = { ...pkg.devDependencies, ...dev };
+  if (dryRun2) {
+    log("  would patch: package.json (scripts + devDependencies)");
+    return true;
+  }
+  import_fs.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), "utf8");
+  log("  patched: package.json");
+  return true;
+}
+async function runNpmInstall(root, log) {
+  const { spawnSync } = await import("child_process");
+  log("  running: npm install (deps)...");
+  spawnSync("npm", ["install", "@infuro/cms-core", "typeorm", "reflect-metadata", "bcryptjs", "next-auth", "next-themes", "sonner"], {
+    cwd: root,
+    stdio: "inherit",
+    shell: true
+  });
+  log("  running: npm install -D tsx dotenv @types/node...");
+  spawnSync("npm", ["install", "-D", "tsx", "dotenv", "@types/node"], {
+    cwd: root,
+    stdio: "inherit",
+    shell: true
+  });
+}
+async function runInit(opts) {
+  const log = (msg) => console.log(msg);
+  const cwd = process.cwd();
+  const root = findRoot(cwd);
+  if (!root) {
+    console.error("Not a Next.js project (no package.json with next dependency found from " + cwd + ")");
+    process.exit(1);
+  }
+  const appDir = import_path.default.join(root, "src/app");
+  if (!import_fs.default.existsSync(appDir)) {
+    console.error("Expected src/app directory not found. Use a Next.js app with src directory (e.g. create-next-app --src-dir).");
+    process.exit(1);
+  }
+  log("Infuro CMS init @ " + root);
+  if (opts.dryRun) log("(dry run)");
+  for (const [filePath, content] of Object.entries(TEMPLATES)) {
+    writeFile(root, filePath, content, opts.force, opts.dryRun, log);
+  }
+  if (!opts.noPatchConfig) {
+    log("Config patches:");
+    patchNextConfig(root, opts.dryRun, log);
+    patchTailwind(root, opts.dryRun, log);
+    patchLayout(root, opts.dryRun, log);
+    patchPackageJson(root, opts.dryRun, log);
+  }
+  if (!opts.noDeps && !opts.dryRun) {
+    log("Dependencies:");
+    await runNpmInstall(root, log);
+  } else if (!opts.noDeps && opts.dryRun) {
+    log("  would run: npm install @infuro/cms-core typeorm reflect-metadata bcryptjs next-auth next-themes sonner");
+    log("  would run: npm install -D tsx dotenv @types/node");
+  }
+  log("");
+  log("Done. Next steps:");
+  log("  1. Copy .env.example to .env and set DATABASE_URL, NEXTAUTH_SECRET, NEXTAUTH_URL, ADMIN_EMAIL, ADMIN_PASSWORD");
+  log("  2. Run npm run migration:run then npm run seed (creates admin from ADMIN_EMAIL/ADMIN_PASSWORD)");
+  log("  3. npm run dev");
+}
+var args = process.argv.slice(2);
+var force = args.includes("--force");
+var dryRun = args.includes("--dry-run");
+var noDeps = args.includes("--no-deps");
+var noPatchConfig = args.includes("--no-patch-config");
+if (args[0] === "init" || args.includes("--init") || args.length === 0 && !args.some((a) => a.startsWith("--"))) {
+  runInit({ force, dryRun, noDeps, noPatchConfig }).catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+} else {
+  console.log("Usage: npx @infuro/cms-core init [--force] [--dry-run] [--no-deps] [--no-patch-config]");
+  process.exit(args[0] === "--help" || args[0] === "-h" ? 0 : 1);
+}
+//# sourceMappingURL=cli.cjs.map