next-blogpanel 1.0.0

package/dist/cli/index.cjs

@@ -0,0 +1,2036 @@
+#!/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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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/lib/limits.ts
+var DEFAULT_MAX_IMAGE_SIZE, DEFAULT_MAX_UPLOAD_SIZE;
+var init_limits = __esm({
+  "src/lib/limits.ts"() {
+    "use strict";
+    DEFAULT_MAX_IMAGE_SIZE = 2 * 1024 * 1024;
+    DEFAULT_MAX_UPLOAD_SIZE = 10 * 1024 * 1024;
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  ConfigNotInstalledError: () => ConfigNotInstalledError,
+  defineConfig: () => defineConfig,
+  getBlogConfig: () => getBlogConfig,
+  getConfig: () => getConfig,
+  getEnvConfig: () => getEnvConfig,
+  isConfigInstalled: () => isConfigInstalled,
+  isR2Configured: () => isR2Configured,
+  requireApiPath: () => requireApiPath,
+  resetConfig: () => resetConfig,
+  resetEnvCache: () => resetEnvCache,
+  setConfig: () => setConfig
+});
+function getEnvConfig() {
+  if (cachedEnv) return cachedEnv;
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    const missing = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`);
+    throw new Error(`Next BlogPanel configuration error:
+${missing.join("\n")}`);
+  }
+  cachedEnv = result.data;
+  return cachedEnv;
+}
+function resetEnvCache() {
+  cachedEnv = null;
+}
+function isR2Configured() {
+  const env = getEnvConfig();
+  return !!(env.BLOGPANEL_R2_ACCOUNT_ID && env.BLOGPANEL_R2_ACCESS_KEY && env.BLOGPANEL_R2_SECRET_KEY && env.BLOGPANEL_R2_BUCKET && env.BLOGPANEL_R2_PUBLIC_URL);
+}
+function mergeConfig(base, userConfig) {
+  return {
+    ...base,
+    ...userConfig,
+    editor: { ...base.editor, ...userConfig?.editor },
+    seo: { ...base.seo, ...userConfig?.seo },
+    auth: { ...base.auth, ...userConfig?.auth },
+    features: { ...base.features, ...userConfig?.features },
+    theme: {
+      ...base.theme,
+      ...userConfig?.theme,
+      variables: { ...base.theme.variables, ...userConfig?.theme?.variables }
+    },
+    hooks: { ...base.hooks, ...userConfig?.hooks }
+  };
+}
+function slot() {
+  const store = globalThis;
+  let current = store[CONFIG_SLOT];
+  if (!current) {
+    current = { installed: false, config: mergeConfig(defaultConfig) };
+    store[CONFIG_SLOT] = current;
+  }
+  return current;
+}
+function warnApiPathConflict(previous, next) {
+  const store = globalThis;
+  const seen = store[CONFIG_WARNED] || (store[CONFIG_WARNED] = /* @__PURE__ */ new Set());
+  const key = `${previous}=>${next}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn(
+    `[blogpanel] setConfig() was called again with a different apiPath ('${next}', previously '${previous}'). apiPath is baked into every GridFS media URL already written to the database and into post bodies that embed those images, so this does not retroactively fix or break anything already stored \u2014 but every upload from this point on will use the new value. If that is not what you intended, look for more than one setConfig() call with a hardcoded apiPath (for example, your own call alongside the generated next-blogpanel.setup.ts).`
+  );
+}
+function defineConfig(config) {
+  return config;
+}
+function setConfig(userConfig) {
+  const current = slot();
+  const base = current.installed ? current.config : defaultConfig;
+  if (current.installed && userConfig.apiPath !== void 0 && userConfig.apiPath !== current.config.apiPath) {
+    warnApiPathConflict(current.config.apiPath, userConfig.apiPath);
+  }
+  const merged = mergeConfig(base, userConfig);
+  current.config = merged;
+  current.installed = true;
+  return merged;
+}
+function isConfigInstalled() {
+  return slot().installed;
+}
+function getConfig(userConfig) {
+  if (userConfig) return mergeConfig(defaultConfig, userConfig);
+  return slot().config;
+}
+function requireApiPath(context) {
+  const current = slot();
+  if (!current.installed) {
+    throw new ConfigNotInstalledError(context);
+  }
+  return current.config.apiPath;
+}
+function resetConfig() {
+  const store = globalThis;
+  delete store[CONFIG_SLOT];
+  delete store[CONFIG_WARNED];
+}
+function getBlogConfig() {
+  const env = getEnvConfig();
+  const config = getConfig();
+  return {
+    ...config,
+    siteUrl: env.BLOGPANEL_SITE_URL,
+    siteName: env.BLOGPANEL_SITE_NAME,
+    metadata: {
+      title: `Blog | ${env.BLOGPANEL_SITE_NAME}`,
+      description: `Latest posts from ${env.BLOGPANEL_SITE_NAME}`,
+      openGraph: {
+        title: `Blog | ${env.BLOGPANEL_SITE_NAME}`,
+        description: `Latest posts from ${env.BLOGPANEL_SITE_NAME}`,
+        url: `${env.BLOGPANEL_SITE_URL}${config.basePath}`,
+        siteName: env.BLOGPANEL_SITE_NAME,
+        type: "website"
+      }
+    }
+  };
+}
+var import_zod, envSchema, cachedEnv, defaultConfig, CONFIG_SLOT, CONFIG_WARNED, ConfigNotInstalledError;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    init_limits();
+    envSchema = import_zod.z.object({
+      // Required
+      BLOGPANEL_MONGODB_URI: import_zod.z.string().min(1, "MongoDB URI is required"),
+      BLOGPANEL_API_KEY: import_zod.z.string().min(32, "API key must be at least 32 characters"),
+      // Optional — Database name (defaults to the database in your connection URI)
+      BLOGPANEL_MONGODB_DB: import_zod.z.string().optional(),
+      // Optional — Cloudflare R2 (image storage)
+      BLOGPANEL_R2_ACCOUNT_ID: import_zod.z.string().optional(),
+      BLOGPANEL_R2_ACCESS_KEY: import_zod.z.string().optional(),
+      BLOGPANEL_R2_SECRET_KEY: import_zod.z.string().optional(),
+      BLOGPANEL_R2_BUCKET: import_zod.z.string().optional(),
+      BLOGPANEL_R2_PUBLIC_URL: import_zod.z.string().optional(),
+      // Optional — force a storage backend regardless of what is configured.
+      //
+      // Not a z.enum(['gridfs','r2']) any more: a custom provider registered via
+      // registerStorageProvider() is selectable here by its own name, and an enum
+      // could not know those names — they are supplied by application code at
+      // runtime, long after this schema is evaluated.
+      //
+      // The enum did buy loud detection of a typo, and that is not given up, only
+      // moved: getStorageProviderByName() throws StorageProviderNotRegisteredError
+      // and names every resolvable provider. That is a strictly better failure
+      // than the enum's, which rejected the whole environment — taking down
+      // routes that never touch storage — and could only say "expected 'gridfs' |
+      // 'r2'". Left as a plain optional string rather than .min(1) so that an
+      // empty `BLOGPANEL_STORAGE=` line, which reads as "unset" in every .env
+      // file, does not fail config parsing process-wide; getStorageProvider()
+      // treats blank as absent.
+      BLOGPANEL_STORAGE: import_zod.z.string().optional(),
+      // Optional — Site info (defaults provided)
+      BLOGPANEL_SITE_URL: import_zod.z.string().optional().default(""),
+      BLOGPANEL_SITE_NAME: import_zod.z.string().optional().default("Blog")
+    });
+    cachedEnv = null;
+    defaultConfig = {
+      basePath: "/blog",
+      adminPath: "/admin/blog",
+      apiPath: "/api/blog",
+      postsPerPage: 10,
+      excerptLength: 160,
+      codeHighlighter: "shiki",
+      editor: {
+        blocks: [
+          "paragraph",
+          "heading",
+          "image",
+          "codeBlock",
+          "blockquote",
+          "bulletList",
+          "orderedList",
+          "taskList",
+          "table",
+          "embed",
+          "horizontalRule",
+          "callout",
+          "tableOfContents",
+          "faq",
+          "html"
+        ],
+        maxImageSize: DEFAULT_MAX_IMAGE_SIZE,
+        // stored result ceiling — compression target
+        maxUploadSize: DEFAULT_MAX_UPLOAD_SIZE,
+        // raw ingest ceiling — rejection threshold
+        imageFormats: ["jpg", "jpeg", "png", "gif", "webp", "svg"],
+        autosaveInterval: 3e4
+      },
+      seo: {
+        titleTemplate: "%s | %siteName%",
+        generateRSS: true,
+        generateSitemap: true,
+        structuredData: true,
+        minContentLength: 300
+      },
+      auth: {
+        strategy: "api-key"
+      },
+      features: {
+        search: true,
+        relatedPosts: true,
+        readingProgress: true,
+        tableOfContents: true,
+        shareButtons: true,
+        darkMode: true,
+        scheduling: true,
+        revisionHistory: true,
+        imageOptimization: true
+      },
+      theme: {
+        darkMode: true,
+        variables: {
+          "--nbp-primary": "#2563eb",
+          "--nbp-primary-hover": "#1d4ed8",
+          "--nbp-text": "#1f2937",
+          "--nbp-text-muted": "#6b7280",
+          "--nbp-bg": "#ffffff",
+          "--nbp-bg-secondary": "#f9fafb",
+          "--nbp-card-bg": "#ffffff",
+          "--nbp-border": "#e5e7eb",
+          "--nbp-radius": "0.5rem",
+          "--nbp-font-heading": '"Inter", system-ui, sans-serif',
+          "--nbp-font-body": '"Inter", system-ui, sans-serif',
+          "--nbp-font-code": '"JetBrains Mono", "Fira Code", monospace'
+        }
+      },
+      hooks: {}
+    };
+    CONFIG_SLOT = /* @__PURE__ */ Symbol.for("next-blogpanel.config.v1");
+    CONFIG_WARNED = /* @__PURE__ */ Symbol.for("next-blogpanel.config.warned");
+    ConfigNotInstalledError = class extends Error {
+      constructor(context) {
+        super(
+          `Next BlogPanel: no configuration has been installed in this server runtime, so ${context} cannot be resolved.
+  This value is built from \`apiPath\` and then stored permanently, so falling back to the default ('${defaultConfig.apiPath}') would write a URL that may never resolve.
+  Fix: import the setup module \`next-blogpanel init\` generated next to your app directory (app/next-blogpanel.setup.ts) from the route handler that reaches this code, or call setConfig(config) yourself before serving requests.
+  See docs/configuration.md \u2014 "Getting the config to the server".`
+        );
+        this.name = "ConfigNotInstalledError";
+      }
+    };
+  }
+});
+
+// src/lib/slug.ts
+function generateSlug(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function ensureUniqueSlug(slug, collection, excludeId) {
+  let candidate = slug;
+  let counter = 1;
+  while (true) {
+    const query = { slug: candidate };
+    if (excludeId) {
+      query._id = { $ne: excludeId };
+    }
+    const existing = await collection.findOne(query);
+    if (!existing) return candidate;
+    candidate = `${slug}-${counter}`;
+    counter++;
+  }
+}
+var init_slug = __esm({
+  "src/lib/slug.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/reading-time.ts
+function calculateReadingTime(text) {
+  const words = countWords(text);
+  return Math.max(1, Math.ceil(words / WORDS_PER_MINUTE));
+}
+function countWords(text) {
+  if (!text || !text.trim()) return 0;
+  return text.trim().split(/\s+/).length;
+}
+function extractTextFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (typeof n.text === "string") {
+      parts.push(n.text);
+    }
+    if (Array.isArray(n.content)) {
+      for (const child of n.content) {
+        walk(child);
+      }
+    }
+  }
+  for (const block of blocks) {
+    walk(block);
+  }
+  return parts.join(" ");
+}
+var WORDS_PER_MINUTE;
+var init_reading_time = __esm({
+  "src/lib/reading-time.ts"() {
+    "use strict";
+    WORDS_PER_MINUTE = 200;
+  }
+});
+
+// src/lib/db.ts
+var db_exports = {};
+__export(db_exports, {
+  createApiToken: () => createApiToken,
+  createCategory: () => createCategory,
+  createMedia: () => createMedia,
+  createPost: () => createPost,
+  deleteApiToken: () => deleteApiToken,
+  deleteCategory: () => deleteCategory,
+  deleteMedia: () => deleteMedia,
+  deletePost: () => deletePost,
+  ensureIndexes: () => ensureIndexes,
+  getCategoryBySlug: () => getCategoryBySlug,
+  getCollection: () => getCollection,
+  getDb: () => getDb,
+  getMediaById: () => getMediaById,
+  getPostById: () => getPostById,
+  getPostBySlug: () => getPostBySlug,
+  getSettings: () => getSettings,
+  hardDeletePost: () => hardDeletePost,
+  listApiTokens: () => listApiTokens,
+  listCategories: () => listCategories,
+  listMedia: () => listMedia,
+  listPosts: () => listPosts,
+  updateCategory: () => updateCategory,
+  updateCategoryPostCount: () => updateCategoryPostCount,
+  updatePost: () => updatePost,
+  updateSettings: () => updateSettings,
+  verifyApiToken: () => verifyApiToken
+});
+async function getDb() {
+  if (db) return db;
+  const env = getEnvConfig();
+  client = new import_mongodb.MongoClient(env.BLOGPANEL_MONGODB_URI);
+  await client.connect();
+  db = client.db(env.BLOGPANEL_MONGODB_DB || void 0);
+  return db;
+}
+async function getCollection(name) {
+  const database = await getDb();
+  return database.collection(name);
+}
+async function ensureIndexes() {
+  const database = await getDb();
+  const posts = database.collection("nbk_posts");
+  await posts.createIndex({ slug: 1 }, { unique: true });
+  await posts.createIndex({ status: 1, publishedAt: -1 });
+  await posts.createIndex({ categories: 1, status: 1 });
+  await posts.createIndex({ tags: 1, status: 1 });
+  await posts.createIndex({ "seo.focusKeyword": 1 });
+  await posts.createIndex({ contentText: "text", title: "text", excerpt: "text" });
+  const categories = database.collection("nbk_categories");
+  await categories.createIndex({ slug: 1 }, { unique: true });
+  await categories.createIndex({ order: 1 });
+  const media = database.collection("nbk_media");
+  await media.createIndex({ createdAt: -1 });
+  await media.createIndex({ storageKey: 1 }, { unique: true });
+  const tokens = database.collection("nbk_api_tokens");
+  await tokens.createIndex({ tokenHash: 1 }, { unique: true });
+  await tokens.createIndex({ createdAt: -1 });
+}
+async function createPost(input, defaultAuthor) {
+  const col = await getCollection("nbk_posts");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.title),
+    col
+  );
+  const contentText = input.contentText || extractTextFromBlocks(input.content || []);
+  const wordCount = countWords(contentText);
+  const readingTime = calculateReadingTime(contentText);
+  const excerpt = input.excerpt || contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    title: input.title,
+    slug,
+    excerpt,
+    content: input.content || [],
+    contentHTML: input.contentHTML || "",
+    contentText,
+    coverImage: input.coverImage,
+    categories: input.categories || [],
+    tags: input.tags || [],
+    author: input.author || defaultAuthor || { name: "Admin" },
+    seo: {
+      ogType: "article",
+      noIndex: false,
+      ...input.seo
+    },
+    status: input.status || "draft",
+    publishedAt: input.status === "published" ? now : input.publishedAt,
+    scheduledAt: input.scheduledAt,
+    readingTime,
+    wordCount,
+    version: 1,
+    revisions: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updatePost(id, input) {
+  const col = await getCollection("nbk_posts");
+  const objectId = new import_mongodb.ObjectId(id);
+  const existing = await col.findOne({ _id: objectId });
+  if (!existing) return null;
+  const updates = { ...input, updatedAt: /* @__PURE__ */ new Date() };
+  if (input.slug && input.slug !== existing.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.content) {
+    const contentText = input.contentText || extractTextFromBlocks(input.content);
+    updates.contentText = contentText;
+    updates.wordCount = countWords(contentText);
+    updates.readingTime = calculateReadingTime(contentText);
+    if (!input.excerpt) {
+      updates.excerpt = contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+    }
+    const revision = {
+      version: existing.version || 1,
+      title: existing.title,
+      content: existing.content,
+      contentHTML: existing.contentHTML,
+      savedAt: /* @__PURE__ */ new Date()
+    };
+    const revisions = [...existing.revisions || [], revision].slice(-10);
+    updates.revisions = revisions;
+    updates.version = (existing.version || 1) + 1;
+  }
+  if (input.status === "published" && existing.status !== "published") {
+    updates.publishedAt = /* @__PURE__ */ new Date();
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.updateOne(
+    { _id: new import_mongodb.ObjectId(id) },
+    { $set: { status: "archived", updatedAt: /* @__PURE__ */ new Date() } }
+  );
+  return result.modifiedCount > 0;
+}
+async function hardDeletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function getPostBySlug(slug) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ slug });
+}
+async function getPostById(id) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ _id: new import_mongodb.ObjectId(id) });
+}
+async function listPosts(query = {}) {
+  const col = await getCollection("nbk_posts");
+  const {
+    page = 1,
+    limit = 10,
+    category,
+    tag,
+    status,
+    search,
+    sortBy = "publishedAt",
+    sortOrder = "desc"
+  } = query;
+  const filter = {};
+  if (status) {
+    filter.status = status;
+  } else {
+    filter.status = { $ne: "archived" };
+  }
+  if (category) filter.categories = category;
+  if (tag) filter.tags = tag;
+  if (search) {
+    filter.$text = { $search: search };
+  }
+  const sort = {
+    [sortBy]: sortOrder === "asc" ? 1 : -1
+  };
+  const skip = (page - 1) * limit;
+  const [posts, total] = await Promise.all([
+    col.find(filter).sort(sort).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return {
+    posts,
+    total
+  };
+}
+async function createCategory(input) {
+  const col = await getCollection("nbk_categories");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.name),
+    col
+  );
+  const doc = {
+    name: input.name,
+    slug,
+    description: input.description,
+    seo: input.seo,
+    order: input.order ?? 0,
+    parentId: input.parentId ? new import_mongodb.ObjectId(input.parentId) : void 0,
+    postCount: 0
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updateCategory(id, input) {
+  const col = await getCollection("nbk_categories");
+  const objectId = new import_mongodb.ObjectId(id);
+  const updates = { ...input };
+  if (input.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.parentId) {
+    updates.parentId = new import_mongodb.ObjectId(input.parentId);
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deleteCategory(id) {
+  const col = await getCollection("nbk_categories");
+  const result = await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function listCategories() {
+  const col = await getCollection("nbk_categories");
+  return await col.find({}).sort({ order: 1 }).toArray();
+}
+async function getCategoryBySlug(slug) {
+  const col = await getCollection("nbk_categories");
+  return await col.findOne({ slug });
+}
+async function updateCategoryPostCount(categorySlug) {
+  const posts = await getCollection("nbk_posts");
+  const categories = await getCollection("nbk_categories");
+  const count = await posts.countDocuments({
+    categories: categorySlug,
+    status: "published"
+  });
+  await categories.updateOne({ slug: categorySlug }, { $set: { postCount: count } });
+}
+async function createMedia(data) {
+  const col = await getCollection("nbk_media");
+  const result = await col.insertOne(data);
+  return { _id: result.insertedId, ...data };
+}
+async function getMediaById(id) {
+  const col = await getCollection("nbk_media");
+  const media = await col.findOne({ _id: new import_mongodb.ObjectId(id) });
+  return media || null;
+}
+async function deleteMedia(id) {
+  const col = await getCollection("nbk_media");
+  const media = await col.findOne({ _id: new import_mongodb.ObjectId(id) });
+  if (!media) return null;
+  await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return media;
+}
+async function listMedia(query = {}) {
+  const col = await getCollection("nbk_media");
+  const { page = 1, limit = 20, mimeType } = query;
+  const filter = {};
+  if (mimeType) filter.mimeType = { $regex: mimeType };
+  const skip = (page - 1) * limit;
+  const [media, total] = await Promise.all([
+    col.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return { media, total };
+}
+async function getSettings() {
+  const col = await getCollection("nbk_settings");
+  const settings = await col.findOne({ _id: "global" });
+  if (!settings) {
+    const defaults = {
+      _id: "global",
+      postsPerPage: 10,
+      commentSystem: "none"
+    };
+    await col.insertOne(defaults);
+    return defaults;
+  }
+  return settings;
+}
+async function updateSettings(data) {
+  const col = await getCollection("nbk_settings");
+  const { _id, ...updates } = data;
+  await col.updateOne(
+    { _id: "global" },
+    { $set: updates },
+    { upsert: true }
+  );
+  return getSettings();
+}
+function hashToken(plain) {
+  return (0, import_crypto.createHash)("sha256").update(plain).digest("hex");
+}
+async function createApiToken(name) {
+  const col = await getCollection("nbk_api_tokens");
+  const plainToken = "nbk_" + (0, import_crypto.randomBytes)(24).toString("hex");
+  const tokenHash = hashToken(plainToken);
+  const prefix = plainToken.slice(0, 8);
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    name,
+    tokenHash,
+    prefix,
+    createdAt: now
+  };
+  const result = await col.insertOne(doc);
+  const token = { _id: result.insertedId, ...doc };
+  return { token, plainToken };
+}
+async function listApiTokens() {
+  const col = await getCollection("nbk_api_tokens");
+  return await col.find({}, { projection: { tokenHash: 0 } }).sort({ createdAt: -1 }).toArray();
+}
+async function deleteApiToken(id) {
+  const col = await getCollection("nbk_api_tokens");
+  const result = await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function verifyApiToken(plainToken) {
+  const col = await getCollection("nbk_api_tokens");
+  const tokenHash = hashToken(plainToken);
+  const token = await col.findOneAndUpdate(
+    { tokenHash },
+    { $set: { lastUsedAt: /* @__PURE__ */ new Date() } },
+    { returnDocument: "after" }
+  );
+  return token;
+}
+var import_mongodb, import_crypto, client, db;
+var init_db = __esm({
+  "src/lib/db.ts"() {
+    "use strict";
+    import_mongodb = require("mongodb");
+    import_crypto = require("crypto");
+    init_config();
+    init_slug();
+    init_reading_time();
+    client = null;
+    db = null;
+  }
+});
+
+// src/lib/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  BUILT_IN_PROVIDER_NAMES: () => BUILT_IN_PROVIDER_NAMES,
+  GRIDFS_BUCKET: () => GRIDFS_BUCKET,
+  GridFSStorageProvider: () => GridFSStorageProvider,
+  R2StorageProvider: () => R2StorageProvider,
+  StorageProviderNotRegisteredError: () => StorageProviderNotRegisteredError,
+  generateKey: () => generateKey,
+  getStorageProvider: () => getStorageProvider,
+  getStorageProviderByName: () => getStorageProviderByName,
+  isStorageProviderRegistered: () => isStorageProviderRegistered,
+  listStorageProviderNames: () => listStorageProviderNames,
+  registerStorageProvider: () => registerStorageProvider,
+  resetStorageProviders: () => resetStorageProviders,
+  rollbackUploads: () => rollbackUploads,
+  unregisterStorageProvider: () => unregisterStorageProvider
+});
+function getS3Client() {
+  if (clientInstance) return clientInstance;
+  if (!isR2Configured()) {
+    throw new Error(
+      "Cloudflare R2 is not configured. Set BLOGPANEL_R2_ACCOUNT_ID, BLOGPANEL_R2_ACCESS_KEY, BLOGPANEL_R2_SECRET_KEY, BLOGPANEL_R2_BUCKET, and BLOGPANEL_R2_PUBLIC_URL environment variables to enable image uploads."
+    );
+  }
+  const env = getEnvConfig();
+  clientInstance = new import_client_s3.S3Client({
+    region: "auto",
+    endpoint: `https://${env.BLOGPANEL_R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
+    credentials: {
+      accessKeyId: env.BLOGPANEL_R2_ACCESS_KEY,
+      secretAccessKey: env.BLOGPANEL_R2_SECRET_KEY
+    }
+  });
+  return clientInstance;
+}
+function generateKey(filename) {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const uuid = (0, import_crypto2.randomUUID)().split("-")[0];
+  const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase();
+  return `media/${year}/${month}/${uuid}-${safeName}`;
+}
+function registry() {
+  const store = globalThis;
+  let current = store[REGISTRY_SLOT];
+  if (!current) {
+    current = /* @__PURE__ */ new Map();
+    store[REGISTRY_SLOT] = current;
+  }
+  return current;
+}
+function registerStorageProvider(provider) {
+  if (!provider || typeof provider !== "object") {
+    throw new Error(
+      "Next BlogPanel: registerStorageProvider() expects a StorageProvider instance."
+    );
+  }
+  const name = provider.name;
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error(
+      "Next BlogPanel: a storage provider must expose a non-empty `name`. That value is written to Media.provider on every upload and read back to route the delete, so a provider without one cannot have its objects deleted."
+    );
+  }
+  if (BUILT_IN_PROVIDER_NAMES.includes(name)) {
+    throw new Error(
+      `Next BlogPanel: '${name}' is reserved by a built-in storage provider and cannot be registered over. Media documents already record '${name}', so replacing it would redirect their deletes to a backend that does not hold them \u2014 which strands the objects silently. Give your provider a distinct name.`
+    );
+  }
+  for (const method of ["upload", "delete", "list"]) {
+    if (typeof provider[method] !== "function") {
+      throw new Error(
+        `Next BlogPanel: storage provider '${name}' is missing a \`${method}()\` method. upload(), delete() and list() are all required \u2014 see docs/storage.md.`
+      );
+    }
+  }
+  registry().set(name, provider);
+  return provider;
+}
+function unregisterStorageProvider(name) {
+  return registry().delete(name);
+}
+function listStorageProviderNames() {
+  return [...BUILT_IN_PROVIDER_NAMES, ...registry().keys()];
+}
+function isStorageProviderRegistered(name) {
+  return BUILT_IN_PROVIDER_NAMES.includes(name) || registry().has(name);
+}
+function resetStorageProviders() {
+  const store = globalThis;
+  delete store[REGISTRY_SLOT];
+}
+function getStorageProvider() {
+  const env = getEnvConfig();
+  const forced = env.BLOGPANEL_STORAGE?.trim();
+  if (forced) return getStorageProviderByName(forced);
+  return isR2Configured() ? new R2StorageProvider() : new GridFSStorageProvider();
+}
+function getStorageProviderByName(name) {
+  if (name === "gridfs") return new GridFSStorageProvider();
+  if (name === "r2") return new R2StorageProvider();
+  const registered = registry().get(name);
+  if (registered) return registered;
+  throw new StorageProviderNotRegisteredError(name, listStorageProviderNames());
+}
+async function rollbackUploads(storage, keys, context) {
+  await Promise.allSettled(
+    keys.map(
+      (key) => storage.delete(key).catch((cleanupError) => {
+        console.error(
+          `[blogpanel] Failed to clean up orphaned upload after ${context} (provider=${storage.name}, key=${key}):`,
+          cleanupError
+        );
+      })
+    )
+  );
+}
+var import_client_s3, import_mongodb2, import_crypto2, BUILT_IN_PROVIDER_NAMES, clientInstance, R2StorageProvider, GRIDFS_BUCKET, GridFSStorageProvider, REGISTRY_SLOT, StorageProviderNotRegisteredError;
+var init_storage = __esm({
+  "src/lib/storage.ts"() {
+    "use strict";
+    import_client_s3 = require("@aws-sdk/client-s3");
+    import_mongodb2 = require("mongodb");
+    init_config();
+    init_db();
+    import_crypto2 = require("crypto");
+    BUILT_IN_PROVIDER_NAMES = ["gridfs", "r2"];
+    clientInstance = null;
+    R2StorageProvider = class {
+      constructor() {
+        this.name = "r2";
+      }
+      async upload(file, filename, contentType) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        const key = generateKey(filename);
+        await client2.send(
+          new import_client_s3.PutObjectCommand({
+            Bucket: env.BLOGPANEL_R2_BUCKET,
+            Key: key,
+            Body: file,
+            ContentType: contentType
+          })
+        );
+        return {
+          key,
+          url: `${env.BLOGPANEL_R2_PUBLIC_URL}/${key}`,
+          size: file.length,
+          contentType
+        };
+      }
+      async delete(key) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        await client2.send(
+          new import_client_s3.DeleteObjectCommand({
+            Bucket: env.BLOGPANEL_R2_BUCKET,
+            Key: key
+          })
+        );
+      }
+      async list(prefix) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        const response = await client2.send(
+          new import_client_s3.ListObjectsV2Command({
+            Bucket: env.BLOGPANEL_R2_BUCKET,
+            Prefix: prefix || "media/"
+          })
+        );
+        return (response.Contents || []).map((obj) => ({
+          key: obj.Key || "",
+          size: obj.Size || 0,
+          lastModified: obj.LastModified || /* @__PURE__ */ new Date()
+        }));
+      }
+    };
+    GRIDFS_BUCKET = "media";
+    GridFSStorageProvider = class {
+      constructor() {
+        this.name = "gridfs";
+      }
+      async bucket() {
+        const db2 = await getDb();
+        return new import_mongodb2.GridFSBucket(db2, { bucketName: GRIDFS_BUCKET });
+      }
+      async upload(file, filename, contentType) {
+        const apiPath = requireApiPath("the URL for this GridFS upload");
+        const bucket = await this.bucket();
+        const key = generateKey(filename);
+        await new Promise((resolve2, reject) => {
+          const stream = bucket.openUploadStream(key, { contentType });
+          stream.on("error", reject);
+          stream.on("finish", () => resolve2());
+          stream.end(file);
+        });
+        return {
+          key,
+          url: `${apiPath}/media/file/${key}`,
+          size: file.length,
+          contentType
+        };
+      }
+      async delete(key) {
+        const bucket = await this.bucket();
+        const files = await bucket.find({ filename: key }).toArray();
+        for (const file of files) {
+          await bucket.delete(file._id);
+        }
+      }
+      async list(prefix) {
+        const bucket = await this.bucket();
+        const pattern = new RegExp("^" + (prefix || "media/").replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        const files = await bucket.find({ filename: { $regex: pattern } }).toArray();
+        return files.map((f) => ({
+          key: f.filename,
+          size: f.length,
+          lastModified: f.uploadDate
+        }));
+      }
+    };
+    REGISTRY_SLOT = /* @__PURE__ */ Symbol.for("next-blogpanel.storage.registry.v1");
+    StorageProviderNotRegisteredError = class extends Error {
+      constructor(providerName, available) {
+        super(
+          `Next BlogPanel: no storage provider named '${providerName}' is registered in this server runtime.
+  Resolvable here: ${available.map((n) => `'${n}'`).join(", ")}.
+  This is refused rather than quietly falling back to the configured default, because every backend generates identically-shaped keys: a default asked to delete a key it does not hold finds nothing and returns cleanly, silently stranding the real object.
+  Fix: call registerStorageProvider(new MyProvider()) before any request is served \u2014 the generated setup module (app/next-blogpanel.setup.ts) is the place, since every scaffolded route imports it. If '${providerName}' is a typo in BLOGPANEL_STORAGE or in a stored Media.provider value, correct that instead.
+  See docs/storage.md \u2014 "Custom storage providers".`
+        );
+        this.name = "StorageProviderNotRegisteredError";
+        this.providerName = providerName;
+        this.available = available;
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_commander = require("commander");
+
+// src/cli/init.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+
+// src/cli/templates.ts
+var SETUP_MODULE = "next-blogpanel.setup";
+function setupSpecifier(templatePath) {
+  const depth = templatePath.split("/").length - 1;
+  return depth === 0 ? `./${SETUP_MODULE}` : `${"../".repeat(depth)}${SETUP_MODULE}`;
+}
+function toDir(urlPath) {
+  return urlPath.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function toUrl(urlPath) {
+  return "/" + toDir(urlPath);
+}
+function getEnvExample() {
+  return `# Next BlogPanel Configuration
+# Copy this to .env.local and fill in your values
+
+# MongoDB Connection (required)
+BLOGPANEL_MONGODB_URI=mongodb+srv://user:pass@cluster.mongodb.net/mydb
+
+# Authentication (required \u2014 must be at least 32 characters)
+BLOGPANEL_API_KEY=your-secure-api-key-must-be-at-least-32-characters-long
+
+# Image storage
+# GridFS (stored inside your MongoDB database) is the DEFAULT and needs no
+# setup \u2014 leave the block below commented out to use it. Uncomment ALL FIVE
+# lines to switch the storage backend to Cloudflare R2 instead. They are
+# only read as a set: isR2Configured() requires every one of them to be
+# present, so partially filling them in has no effect and GridFS keeps
+# being used.
+# BLOGPANEL_R2_ACCOUNT_ID=your-account-id
+# BLOGPANEL_R2_ACCESS_KEY=your-access-key
+# BLOGPANEL_R2_SECRET_KEY=your-secret-key
+# BLOGPANEL_R2_BUCKET=blog-media
+# BLOGPANEL_R2_PUBLIC_URL=https://media.yourdomain.com
+
+# Force a specific storage backend, overriding the automatic choice above.
+# Accepts 'gridfs', 'r2', or the name of a provider you registered yourself
+# with registerStorageProvider() \u2014 see docs/storage.md, "Custom storage
+# providers". A name that cannot be resolved fails loudly and names the ones
+# that can, rather than quietly falling back. Leave commented out to let the
+# automatic choice apply.
+# BLOGPANEL_STORAGE=gridfs
+
+# Site info \u2014 REQUIRED before you deploy, even though the schema marks
+# them optional. The sitemap, RSS feed, and JSON-LD structured data all
+# build absolute URLs from BLOGPANEL_SITE_URL. Leaving the placeholder
+# below means your sitemap.xml and RSS feed will advertise pages on
+# "yourdomain.com" \u2014 a domain you don't own \u2014 to search engines and
+# feed readers. If you comment this out instead, it's worse: it defaults
+# to an empty string, so every one of those absolute URLs becomes a bare
+# relative path, which is invalid per the sitemap protocol and schema.org.
+# Set this to your real domain (no trailing slash) before going live.
+BLOGPANEL_SITE_URL=https://yourdomain.com
+BLOGPANEL_SITE_NAME="Your Site Name"
+`;
+}
+function getTemplates(options) {
+  const blogDir = toDir(options.blogPath);
+  const adminDir = toDir(options.adminPath);
+  const apiDir = toDir(options.apiPath);
+  const blogUrl = toUrl(options.blogPath);
+  const adminUrl = toUrl(options.adminPath);
+  const apiUrl = toUrl(options.apiPath);
+  const configImport = options.configImport || "../next-blogpanel.config";
+  const setup = {
+    path: `${SETUP_MODULE}.ts`,
+    content: `// Generated by \`next-blogpanel init\`. Do not delete.
+//
+// This module hands your next-blogpanel.config.ts to the server at runtime.
+// Nothing else reads that file: without this import chain the package would
+// silently run on its built-in defaults, and \`apiPath\` in particular would be
+// wrong in URLs that get written permanently into the database.
+//
+// Every scaffolded route handler, layout and page imports this module. That
+// looks redundant, and on a single server it is \u2014 but Next.js instantiates
+// server modules per route entry, so a value installed while handling one
+// route is not guaranteed to be visible to the module instance serving
+// another. setConfig() stores the config on globalThis, which every bundle in
+// the process shares, and importing this module everywhere guarantees some
+// entry point has installed it before any request is served, whichever route
+// gets hit first.
+//
+// If you add your own route handler or server component that calls
+// next-blogpanel APIs, import this module at the top of it too:
+//
+//   import '<relative path>/${SETUP_MODULE}';
+import { setConfig } from 'next-blogpanel';
+import config from '${configImport}';
+
+setConfig(config);
+
+// ---- Custom storage backend (optional) ----
+//
+// GridFS is the default and needs nothing here. Cloudflare R2 is selected by
+// its five environment variables and needs nothing here either.
+//
+// To store uploads somewhere else \u2014 Vercel Blob, Supabase Storage, Backblaze
+// B2, ImageKit, UploadThing, S3, anything \u2014 implement the StorageProvider
+// interface and register the instance below, then set BLOGPANEL_STORAGE to
+// the same name your provider reports.
+//
+// This module is the right home for it: registration has to happen before any
+// request is served, and every scaffolded route imports this file, so
+// whichever route a request lands on first has already run it.
+//
+// The name matters more than it looks. It is written to \`provider\` on every
+// media document and read back to decide which backend to ask when that item
+// is deleted. Keep it stable, and never reuse it for a different backend \u2014
+// see docs/storage.md, "Custom storage providers".
+//
+// import { registerStorageProvider } from 'next-blogpanel';
+// import { MyStorageProvider } from '../lib/my-storage-provider';
+//
+// registerStorageProvider(new MyStorageProvider());
+`
+  };
+  const files = [
+    // ---- Blog Pages ----
+    {
+      path: `${blogDir}/layout.tsx`,
+      content: `import 'next-blogpanel/styles/blog.css';
+
+export default function BlogLayout({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}
+`
+    },
+    {
+      path: `${blogDir}/page.tsx`,
+      content: `import { BlogCard, BlogSearch, Pagination, CategoryList } from 'next-blogpanel/components';
+import { listPosts, listCategories } from 'next-blogpanel/lib';
+
+interface Props {
+  searchParams: Promise<{ page?: string; category?: string; q?: string }>;
+}
+
+export default async function Blog({ searchParams }: Props) {
+  const params = await searchParams;
+  const page = parseInt(params.page || '1', 10);
+
+  const [{ posts, total }, categories] = await Promise.all([
+    listPosts({
+      page,
+      limit: 10,
+      status: 'published',
+      category: params.category || undefined,
+      search: params.q || undefined,
+      sortBy: 'publishedAt',
+      sortOrder: 'desc',
+    }),
+    listCategories(),
+  ]);
+
+  const totalPages = Math.ceil(total / 10);
+
+  return (
+    <div className="nbp-blog-list">
+      <div className="nbp-blog-header">
+        <BlogSearch apiPath="${apiUrl}" />
+      </div>
+
+      <div className="nbp-blog-layout">
+        <div className="nbp-blog-main">
+          {posts.length === 0 ? (
+            <div className="nbp-empty-state">
+              <p>No posts found.</p>
+            </div>
+          ) : (
+            <div className="nbp-posts-grid">
+              {posts.map((post) => (
+                <BlogCard
+                  key={String(post._id || post.slug)}
+                  post={JSON.parse(JSON.stringify(post))}
+                  basePath="${blogUrl}"
+                />
+              ))}
+            </div>
+          )}
+
+          {totalPages > 1 && (
+            <Pagination
+              currentPage={page}
+              totalPages={totalPages}
+              basePath="${blogUrl}"
+              category={params.category}
+            />
+          )}
+        </div>
+
+        {categories.length > 0 && (
+          <aside className="nbp-blog-sidebar">
+            <CategoryList
+              categories={JSON.parse(JSON.stringify(categories))}
+              activeCategory={params.category}
+              basePath="${blogUrl}"
+            />
+          </aside>
+        )}
+      </div>
+    </div>
+  );
+}
+`
+    },
+    {
+      path: `${blogDir}/[slug]/page.tsx`,
+      content: `import { AuthorCard, BreadcrumbNav, ShareButtons, ReadingProgressBar, BlogCard } from 'next-blogpanel/components';
+import { getPostBySlug, listPosts, generateMetaTags } from 'next-blogpanel/lib';
+import type { Metadata } from 'next';
+
+interface Props {
+  params: Promise<{ slug: string }>;
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { slug } = await params;
+  const post = await getPostBySlug(slug);
+  if (!post) return { title: 'Post Not Found' };
+  const meta = generateMetaTags(post);
+  return {
+    title: meta.title,
+    description: meta.description,
+    openGraph: meta.openGraph,
+    twitter: meta.twitter,
+    alternates: { canonical: meta.canonical },
+  };
+}
+
+export default async function BlogPost({ params }: Props) {
+  const { slug } = await params;
+  const post = await getPostBySlug(slug);
+
+  if (!post) {
+    return <div className="nbp-not-found">Post not found</div>;
+  }
+
+  let relatedPosts: any[] = [];
+  if (post.categories?.length) {
+    const { posts } = await listPosts({
+      status: 'published',
+      category: post.categories[0],
+      limit: 4,
+    });
+    relatedPosts = posts
+      .filter((p) => String(p._id) !== String(post._id))
+      .slice(0, 3);
+  }
+
+  const date = post.publishedAt
+    ? new Date(post.publishedAt).toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+      })
+    : '';
+
+  return (
+    <article className="nbp-post">
+      <ReadingProgressBar />
+
+      <BreadcrumbNav
+        items={[
+          { label: 'Home', href: '/' },
+          { label: 'Blog', href: '${blogUrl}' },
+          ...(post.categories?.[0]
+            ? [{ label: post.categories[0], href: \`${blogUrl}/category/\${post.categories[0]}\` }]
+            : []),
+          { label: post.title },
+        ]}
+      />
+
+      <header className="nbp-post-header">
+        {post.categories?.length > 0 && (
+          <div className="nbp-post-categories">
+            {post.categories.map((cat: string) => (
+              <a key={cat} href={\`${blogUrl}/category/\${cat}\`} className="nbp-post-category">
+                {cat}
+              </a>
+            ))}
+          </div>
+        )}
+        <h1 className="nbp-post-title">{post.title}</h1>
+        <div className="nbp-post-meta">
+          <span className="nbp-post-author">{post.author?.name}</span>
+          {date && (
+            <>
+              <span className="nbp-post-sep">&middot;</span>
+              <time className="nbp-post-date">{date}</time>
+            </>
+          )}
+          <span className="nbp-post-sep">&middot;</span>
+          <span className="nbp-post-reading-time">{post.readingTime} min read</span>
+        </div>
+      </header>
+
+      {post.coverImage?.url && (
+        <div className="nbp-post-cover">
+          <img src={post.coverImage.url} alt={post.coverImage.alt || post.title} />
+        </div>
+      )}
+
+      <div
+        className="nbp-post-content"
+        dangerouslySetInnerHTML={{ __html: post.contentHTML || '' }}
+      />
+
+      <ShareButtons url={\`${blogUrl}/\${slug}\`} title={post.title} />
+
+      {post.author && <AuthorCard author={post.author} />}
+
+      {relatedPosts.length > 0 && (
+        <section className="nbp-related">
+          <h2 className="nbp-related-title">Related Posts</h2>
+          <div className="nbp-related-grid">
+            {relatedPosts.map((p) => (
+              <BlogCard key={String(p._id)} post={JSON.parse(JSON.stringify(p))} basePath="${blogUrl}" />
+            ))}
+          </div>
+        </section>
+      )}
+    </article>
+  );
+}
+`
+    },
+    {
+      path: `${blogDir}/category/[slug]/page.tsx`,
+      content: `import { BlogCard, BlogSearch, Pagination, CategoryList } from 'next-blogpanel/components';
+import { listPosts, listCategories } from 'next-blogpanel/lib';
+
+interface Props {
+  params: Promise<{ slug: string }>;
+  searchParams: Promise<{ page?: string }>;
+}
+
+export default async function CategoryPage({ params, searchParams }: Props) {
+  const { slug } = await params;
+  const sp = await searchParams;
+  const page = parseInt(sp.page || '1', 10);
+
+  const [{ posts, total }, categories] = await Promise.all([
+    listPosts({
+      page,
+      limit: 10,
+      status: 'published',
+      category: slug,
+      sortBy: 'publishedAt',
+      sortOrder: 'desc',
+    }),
+    listCategories(),
+  ]);
+
+  const totalPages = Math.ceil(total / 10);
+
+  return (
+    <div className="nbp-blog-list">
+      <div className="nbp-blog-header">
+        <BlogSearch apiPath="${apiUrl}" />
+      </div>
+
+      <div className="nbp-blog-layout">
+        <div className="nbp-blog-main">
+          {posts.length === 0 ? (
+            <div className="nbp-empty-state">
+              <p>No posts found in this category.</p>
+            </div>
+          ) : (
+            <div className="nbp-posts-grid">
+              {posts.map((post) => (
+                <BlogCard
+                  key={String(post._id || post.slug)}
+                  post={JSON.parse(JSON.stringify(post))}
+                  basePath="${blogUrl}"
+                />
+              ))}
+            </div>
+          )}
+
+          {totalPages > 1 && (
+            <Pagination
+              currentPage={page}
+              totalPages={totalPages}
+              basePath="${blogUrl}"
+              category={slug}
+            />
+          )}
+        </div>
+
+        {categories.length > 0 && (
+          <aside className="nbp-blog-sidebar">
+            <CategoryList
+              categories={JSON.parse(JSON.stringify(categories))}
+              activeCategory={slug}
+              basePath="${blogUrl}"
+            />
+          </aside>
+        )}
+      </div>
+    </div>
+  );
+}
+`
+    },
+    // ---- Admin Pages ----
+    {
+      path: `${adminDir}/layout.tsx`,
+      content: `import { AdminLayout } from 'next-blogpanel/admin';
+import 'next-blogpanel/styles/admin.css';
+
+export default function AdminBlogLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <AdminLayout adminPath="${adminUrl}" apiPath="${apiUrl}" basePath="${blogUrl}">
+      {children}
+    </AdminLayout>
+  );
+}
+`
+    },
+    {
+      path: `${adminDir}/page.tsx`,
+      content: `import { Dashboard } from 'next-blogpanel/admin';
+
+export default function AdminDashboard() {
+  return <Dashboard />;
+}
+`
+    },
+    {
+      path: `${adminDir}/posts/page.tsx`,
+      content: `import { PostList } from 'next-blogpanel/admin';
+
+export default function AdminPosts() {
+  return <PostList />;
+}
+`
+    },
+    {
+      path: `${adminDir}/new/page.tsx`,
+      content: `import { PostEditor } from 'next-blogpanel/admin';
+
+export default function NewPost() {
+  return <PostEditor />;
+}
+`
+    },
+    {
+      path: `${adminDir}/[id]/edit/page.tsx`,
+      content: `import { PostEditor } from 'next-blogpanel/admin';
+
+interface Props {
+  params: Promise<{ id: string }>;
+}
+
+export default async function EditPost({ params }: Props) {
+  const { id } = await params;
+  return <PostEditor postId={id} />;
+}
+`
+    },
+    {
+      path: `${adminDir}/media/page.tsx`,
+      content: `import { MediaLibrary } from 'next-blogpanel/admin';
+
+export default function AdminMedia() {
+  return <MediaLibrary />;
+}
+`
+    },
+    {
+      path: `${adminDir}/categories/page.tsx`,
+      content: `import { CategoryManager } from 'next-blogpanel/admin';
+
+export default function AdminCategories() {
+  return <CategoryManager />;
+}
+`
+    },
+    {
+      path: `${adminDir}/settings/page.tsx`,
+      content: `import { SettingsPage } from 'next-blogpanel/admin';
+
+export default function AdminSettings() {
+  return <SettingsPage />;
+}
+`
+    },
+    // ---- API Routes ----
+    {
+      path: `${apiDir}/posts/route.ts`,
+      content: `export { GET, POST, PUT, DELETE } from 'next-blogpanel/api/posts';
+`
+    },
+    {
+      path: `${apiDir}/media/route.ts`,
+      content: `export { GET, POST, DELETE } from 'next-blogpanel/api/media';
+`
+    },
+    {
+      path: `${apiDir}/media/file/[...key]/route.ts`,
+      content: `export { GET } from 'next-blogpanel/api/media-file';
+`
+    },
+    {
+      path: `${apiDir}/categories/route.ts`,
+      content: `export { GET, POST, PUT, DELETE } from 'next-blogpanel/api/categories';
+`
+    },
+    {
+      path: `${apiDir}/settings/route.ts`,
+      content: `export { GET, PUT } from 'next-blogpanel/api/settings';
+`
+    },
+    {
+      path: `${apiDir}/tokens/route.ts`,
+      content: `export { GET, POST, DELETE } from 'next-blogpanel/api/tokens';
+`
+    },
+    {
+      path: `${apiDir}/sitemap.xml/route.ts`,
+      content: `export { GET } from 'next-blogpanel/api/sitemap';
+`
+    },
+    {
+      path: `${apiDir}/rss.xml/route.ts`,
+      content: `export { GET } from 'next-blogpanel/api/rss';
+`
+    }
+  ];
+  return [
+    setup,
+    ...files.map((file) => ({
+      ...file,
+      content: `import '${setupSpecifier(file.path)}';
+${file.content}`
+    }))
+  ];
+}
+
+// src/cli/init.ts
+var SETUP_TEMPLATE_PATH = `${SETUP_MODULE}.ts`;
+async function init(options) {
+  const cwd2 = options.cwd || process.cwd();
+  const packageJsonPath = import_path.default.join(cwd2, "package.json");
+  if (!import_fs.default.existsSync(packageJsonPath)) {
+    console.error("Error: No package.json found. Run this in a Next.js project root.");
+    process.exit(1);
+  }
+  const pkg = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+  const hasNext = pkg.dependencies?.next || pkg.devDependencies?.next;
+  if (!hasNext) {
+    console.error("Error: next is not a dependency. This must be a Next.js project.");
+    process.exit(1);
+  }
+  const usesSrcDir = import_fs.default.existsSync(import_path.default.join(cwd2, "src", "app"));
+  const appDir = usesSrcDir ? import_path.default.join(cwd2, "src", "app") : import_path.default.join(cwd2, "app");
+  if (!import_fs.default.existsSync(appDir)) {
+    console.error("Error: No app/ directory found. Next BlogPanel requires the Next.js App Router.");
+    process.exit(1);
+  }
+  const blogDir = toDir(options.blogPath);
+  const adminDir = toDir(options.adminPath);
+  const apiDir = toDir(options.apiPath);
+  const blogUrl = toUrl(options.blogPath);
+  const adminUrl = toUrl(options.adminPath);
+  const apiUrl = toUrl(options.apiPath);
+  const named = [
+    ["--blog-path", blogDir],
+    ["--admin-path", adminDir],
+    ["--api-path", apiDir]
+  ];
+  const rootPaths = named.filter(([, dir]) => dir === "");
+  if (rootPaths.length > 0) {
+    const flags = rootPaths.map(([flag]) => flag).join(" and ");
+    console.error(
+      `Error: ${flags} resolve${rootPaths.length === 1 ? "s" : ""} to the site root ('/'). Choose a non-root path, e.g. '/blog'.`
+    );
+    process.exit(1);
+  }
+  for (let i = 0; i < named.length; i++) {
+    for (let j = i + 1; j < named.length; j++) {
+      if (named[i][1] === named[j][1]) {
+        console.error(
+          `Error: ${named[i][0]} and ${named[j][0]} both resolve to 'app/${named[i][1]}/'. Choose distinct paths.`
+        );
+        process.exit(1);
+      }
+    }
+  }
+  const knownDefaults = ["blog", "admin/blog", "api/blog"];
+  const chosen = [blogDir, adminDir, apiDir];
+  for (const [i, def] of knownDefaults.entries()) {
+    if (chosen[i] !== def && import_fs.default.existsSync(import_path.default.join(appDir, def))) {
+      console.log(`  \u26A0 Found an existing app/${def}/ from a previous init.`);
+      console.log(`    You are scaffolding to app/${chosen[i]}/ \u2014 remove the old folder when ready.`);
+    }
+  }
+  console.log("");
+  console.log("  Next BlogPanel \u2014 Initializing...");
+  console.log("");
+  const templates = getTemplates({
+    ...options,
+    configImport: usesSrcDir ? "../../next-blogpanel.config" : "../next-blogpanel.config"
+  });
+  let setupModuleWritten = false;
+  const skippedFiles = [];
+  for (const template of templates) {
+    const filePath = import_path.default.join(appDir, template.path);
+    const dir = import_path.default.dirname(filePath);
+    if (!import_fs.default.existsSync(dir)) {
+      import_fs.default.mkdirSync(dir, { recursive: true });
+    }
+    if (import_fs.default.existsSync(filePath)) {
+      console.log(`  \u26A0 Skipping ${template.path} (already exists)`);
+      if (template.path !== SETUP_TEMPLATE_PATH) {
+        skippedFiles.push(template.path);
+      }
+      continue;
+    }
+    import_fs.default.writeFileSync(filePath, template.content);
+    console.log(`  \u2713 ${template.path}`);
+    if (template.path === SETUP_TEMPLATE_PATH) {
+      setupModuleWritten = true;
+    }
+  }
+  const configPath = import_path.default.join(cwd2, "next-blogpanel.config.ts");
+  if (!import_fs.default.existsSync(configPath)) {
+    import_fs.default.writeFileSync(
+      configPath,
+      `import { defineConfig } from 'next-blogpanel';
+
+export default defineConfig({
+  basePath: '${blogUrl}',
+  adminPath: '${adminUrl}',
+  apiPath: '${apiUrl}',
+  auth: {
+    strategy: 'api-key',
+  },
+});
+`
+    );
+    console.log("  \u2713 next-blogpanel.config.ts");
+  }
+  const envExamplePath = import_path.default.join(cwd2, ".env.local.example");
+  if (!import_fs.default.existsSync(envExamplePath)) {
+    import_fs.default.writeFileSync(envExamplePath, getEnvExample());
+    console.log("  \u2713 .env.local.example");
+  }
+  console.log("");
+  console.log("  Done! Next steps:");
+  console.log("");
+  console.log("  1. Copy .env.local.example to .env.local and fill in your values");
+  console.log("  2. Run: npm run dev");
+  console.log(`  3. Visit: http://localhost:3000${adminUrl}`);
+  console.log("");
+  if (setupModuleWritten && skippedFiles.length > 0) {
+    console.log(`  \u26A0 IMPORTANT: ${SETUP_TEMPLATE_PATH} was created, but ${skippedFiles.length} existing file${skippedFiles.length === 1 ? "" : "s"} that would import it ${skippedFiles.length === 1 ? "was" : "were"} left untouched:`);
+    console.log("");
+    for (const file of skippedFiles) {
+      console.log(`      - ${file}`);
+    }
+    console.log("");
+    console.log(`    None of them installs your next-blogpanel.config.ts at runtime, so every`);
+    console.log(`    GridFS media upload will fail with CONFIG_NOT_INSTALLED instead of writing`);
+    console.log(`    a URL \u2014 add this import to the top of each file above:`);
+    console.log("");
+    console.log(`      import '<relative path to app dir>/${SETUP_MODULE}';`);
+    console.log("");
+    console.log("    See docs/migrating-from-nextblogkit.md for the exact import line per file.");
+    console.log("");
+  }
+}
+
+// src/cli/seed.ts
+async function seed() {
+  console.log("");
+  console.log("  Next BlogPanel \u2014 Seeding example content...");
+  console.log("");
+  try {
+    const { ensureIndexes: ensureIndexes2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const { createPost: createPost2, createCategory: createCategory2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    await ensureIndexes2();
+    console.log("  \u2713 Database indexes created");
+    const categories = [
+      { name: "Technology", slug: "technology", description: "Tech tutorials and updates", order: 0 },
+      { name: "Design", slug: "design", description: "UI/UX and design tips", order: 1 },
+      { name: "Tutorials", slug: "tutorials", description: "Step-by-step guides", order: 2 }
+    ];
+    for (const cat of categories) {
+      try {
+        await createCategory2(cat);
+        console.log(`  \u2713 Category: ${cat.name}`);
+      } catch (err) {
+        if (err.code === 11e3) {
+          console.log(`  \u26A0 Category "${cat.name}" already exists`);
+        } else {
+          throw err;
+        }
+      }
+    }
+    try {
+      await createPost2({
+        title: "Welcome to Next BlogPanel",
+        slug: "welcome-to-next-blogpanel",
+        excerpt: "Your new blog is ready! This is an example post to get you started with Next BlogPanel.",
+        content: [
+          {
+            type: "heading",
+            attrs: { level: 2 },
+            content: [{ type: "text", text: "Getting Started" }]
+          },
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Congratulations! Your Next BlogPanel blog is up and running. This example post shows you what\u2019s possible." }
+            ]
+          },
+          {
+            type: "heading",
+            attrs: { level: 2 },
+            content: [{ type: "text", text: "Features" }]
+          },
+          {
+            type: "bulletList",
+            content: [
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Block editor with slash commands" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Full SEO optimization out of the box" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Media library with built-in image storage" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Dynamic sitemap and RSS feed" }] }] }
+            ]
+          },
+          {
+            type: "callout",
+            attrs: { type: "tip" },
+            content: [
+              { type: "paragraph", content: [{ type: "text", text: "Head to the admin panel to start creating your own posts!" }] }
+            ]
+          }
+        ],
+        contentHTML: "<h2>Getting Started</h2><p>Congratulations! Your Next BlogPanel blog is up and running.</p><h2>Features</h2><ul><li>Block editor with slash commands</li><li>Full SEO optimization out of the box</li><li>Media library with built-in image storage</li><li>Dynamic sitemap and RSS feed</li></ul>",
+        status: "published",
+        categories: ["technology"],
+        tags: ["nextjs", "blog", "getting-started"]
+      });
+      console.log('  \u2713 Example post: "Welcome to Next BlogPanel"');
+    } catch (err) {
+      if (err.code === 11e3) {
+        console.log("  \u26A0 Example post already exists");
+      } else {
+        throw err;
+      }
+    }
+    console.log("");
+    console.log("  Seeding complete!");
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("  \u2717 Seeding failed:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/health.ts
+function editDistance(a, b) {
+  if (a === b) return 0;
+  if (!a.length) return b.length;
+  if (!b.length) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, substitution);
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+function looksLikeTypoOf(name, candidate) {
+  if (name === candidate) return false;
+  const lowerName = name.toLowerCase();
+  const lowerCandidate = candidate.toLowerCase();
+  if (lowerName === lowerCandidate) return true;
+  const threshold = Math.max(name.length, candidate.length) <= 4 ? 1 : 2;
+  return editDistance(lowerName, lowerCandidate) <= threshold;
+}
+async function classifyUnresolvedProvider(name) {
+  const { BUILT_IN_PROVIDER_NAMES: BUILT_IN_PROVIDER_NAMES2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+  const known = [...BUILT_IN_PROVIDER_NAMES2];
+  try {
+    const { getCollection: getCollection2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const col = await getCollection2("nbk_media");
+    const stored = (await col.distinct("provider")).filter(
+      (value) => typeof value === "string" && value.length > 0
+    );
+    if (stored.includes(name)) {
+      return { kind: "custom", storedCount: await col.countDocuments({ provider: name }) };
+    }
+    known.push(...stored);
+  } catch {
+    return { kind: "custom", storedCount: 0 };
+  }
+  for (const candidate of known) {
+    if (looksLikeTypoOf(name, candidate)) return { kind: "typo", suggestion: candidate };
+  }
+  return { kind: "custom", storedCount: 0 };
+}
+async function health() {
+  console.log("");
+  console.log("  Next BlogPanel \u2014 Health Check");
+  console.log("");
+  let allPassed = true;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const db2 = await getDb2();
+    await db2.command({ ping: 1 });
+    console.log("  \u2713 MongoDB: Connected");
+  } catch (err) {
+    console.log(`  \u2717 MongoDB: ${err.message}`);
+    allPassed = false;
+  }
+  try {
+    const { getStorageProvider: getStorageProvider2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+    const storage = getStorageProvider2();
+    await storage.list("media/");
+    const labels = { r2: "Cloudflare R2", gridfs: "GridFS" };
+    console.log(`  \u2713 Storage (${labels[storage.name] || storage.name}): Connected`);
+  } catch (err) {
+    if (err?.name === "StorageProviderNotRegisteredError") {
+      const verdict = await classifyUnresolvedProvider(err.providerName);
+      if (verdict.kind === "typo") {
+        console.log(
+          `  \u2717 Storage: BLOGPANEL_STORAGE is set to '${err.providerName}', which resolves to nothing.`
+        );
+        console.log(`    Did you mean '${verdict.suggestion}'?`);
+        console.log(
+          `    Storage backend names are case-sensitive and must match exactly. Uploads will fail`
+        );
+        console.log(`    with STORAGE_PROVIDER_NOT_REGISTERED until this is corrected.`);
+        allPassed = false;
+      } else {
+        console.log(
+          `  \u26A0 Storage ('${err.providerName}'): not verified \u2014 custom providers cannot be resolved from the CLI.`
+        );
+        if (verdict.storedCount > 0) {
+          console.log(
+            `    ${verdict.storedCount} media document(s) are already stored under this name, so your`
+          );
+          console.log(`    app has registered it successfully.`);
+        }
+        console.log(
+          `    This CLI does not load your app's next-blogpanel.setup module, where`
+        );
+        console.log(
+          `    registerStorageProvider() is called, so this is expected. Check the running server.`
+        );
+        console.log(`    The exit code is not affected by this warning.`);
+      }
+    } else {
+      console.log(`  \u2717 Storage: ${err.message}`);
+      allPassed = false;
+    }
+  }
+  try {
+    const { getEnvConfig: getEnvConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    getEnvConfig2();
+    console.log("  \u2713 Environment: Required variables set");
+  } catch (err) {
+    console.log(`  \u2717 Environment: ${err.message}`);
+    allPassed = false;
+  }
+  console.log("");
+  if (allPassed) {
+    console.log("  All checks passed!");
+  } else {
+    console.log("  Some checks failed. Please review your configuration.");
+  }
+  console.log("");
+  process.exit(allPassed ? 0 : 1);
+}
+
+// src/cli/migrate.ts
+init_db();
+async function migrate() {
+  console.log("");
+  console.log("  Next BlogPanel \u2014 Database Migration");
+  console.log("");
+  const db2 = await getDb();
+  const media = db2.collection("nbk_media");
+  const legacy = await media.countDocuments({ r2Key: { $exists: true } });
+  if (legacy > 0) {
+    await media.updateMany({ r2Key: { $exists: true } }, [
+      { $set: { storageKey: "$r2Key", provider: "r2" } },
+      { $unset: "r2Key" }
+    ]);
+    console.log(`  \u2713 Migrated ${legacy} media record(s): r2Key \u2192 storageKey`);
+  }
+  await media.dropIndex("r2Key_1").catch(() => {
+  });
+  await ensureIndexes();
+  console.log("  \u2713 Indexes created");
+  console.log("");
+}
+async function migrateCommand() {
+  try {
+    await migrate();
+    console.log("  Migration complete!");
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("  \u2717 Migration failed:", error);
+    process.exit(1);
+  }
+}
+
+// package.json
+var package_default = {
+  name: "next-blogpanel",
+  version: "1.0.0",
+  description: "A drop-in blog engine for Next.js \u2014 admin panel, block editor, SEO, and media, all backed by your own MongoDB.",
+  license: "MIT",
+  author: "Santosh Patidar",
+  repository: {
+    type: "git",
+    url: "https://github.com/butterblogs/next-blogpanel"
+  },
+  keywords: [
+    "nextjs",
+    "blog",
+    "blog-engine",
+    "cms",
+    "seo",
+    "editor",
+    "tiptap",
+    "mongodb",
+    "gridfs"
+  ],
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    "next-blogpanel": "./dist/cli/index.cjs"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./components": {
+      types: "./dist/components/index.d.ts",
+      import: "./dist/components/index.js",
+      require: "./dist/components/index.cjs"
+    },
+    "./admin": {
+      types: "./dist/admin/index.d.ts",
+      import: "./dist/admin/index.js",
+      require: "./dist/admin/index.cjs"
+    },
+    "./api/*": {
+      types: "./dist/api/*.d.ts",
+      import: "./dist/api/*.js",
+      require: "./dist/api/*.cjs"
+    },
+    "./lib": {
+      types: "./dist/lib/index.d.ts",
+      import: "./dist/lib/index.js",
+      require: "./dist/lib/index.cjs"
+    },
+    "./editor": {
+      types: "./dist/editor/index.d.ts",
+      import: "./dist/editor/index.js",
+      require: "./dist/editor/index.cjs"
+    },
+    "./styles/*.css": "./dist/styles/*.css"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    lint: "eslint src/ --ext .ts,.tsx",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    "@aws-sdk/client-s3": "^3.500.0",
+    "@tiptap/core": "^2.6.0",
+    "@tiptap/extension-blockquote": "^2.6.0",
+    "@tiptap/extension-bold": "^2.6.0",
+    "@tiptap/extension-bullet-list": "^2.6.0",
+    "@tiptap/extension-code": "^2.6.0",
+    "@tiptap/extension-code-block": "^2.6.0",
+    "@tiptap/extension-document": "^2.6.0",
+    "@tiptap/extension-dropcursor": "^2.6.0",
+    "@tiptap/extension-gapcursor": "^2.6.0",
+    "@tiptap/extension-hard-break": "^2.6.0",
+    "@tiptap/extension-heading": "^2.6.0",
+    "@tiptap/extension-highlight": "^2.6.0",
+    "@tiptap/extension-history": "^2.6.0",
+    "@tiptap/extension-horizontal-rule": "^2.6.0",
+    "@tiptap/extension-image": "^2.6.0",
+    "@tiptap/extension-italic": "^2.6.0",
+    "@tiptap/extension-link": "^2.6.0",
+    "@tiptap/extension-list-item": "^2.6.0",
+    "@tiptap/extension-ordered-list": "^2.6.0",
+    "@tiptap/extension-paragraph": "^2.6.0",
+    "@tiptap/extension-placeholder": "^2.6.0",
+    "@tiptap/extension-strike": "^2.6.0",
+    "@tiptap/extension-table": "^2.6.0",
+    "@tiptap/extension-table-cell": "^2.6.0",
+    "@tiptap/extension-table-header": "^2.6.0",
+    "@tiptap/extension-table-row": "^2.6.0",
+    "@tiptap/extension-task-item": "^2.6.0",
+    "@tiptap/extension-task-list": "^2.6.0",
+    "@tiptap/extension-text": "^2.6.0",
+    "@tiptap/extension-typography": "^2.6.0",
+    "@tiptap/extension-underline": "^2.6.0",
+    "@tiptap/pm": "^2.6.0",
+    "@tiptap/react": "^2.6.0",
+    "@tiptap/starter-kit": "^2.6.0",
+    commander: "^12.0.0",
+    inquirer: "^9.2.0",
+    mongodb: "^6.5.0",
+    sharp: "^0.33.0",
+    shiki: "^1.1.0",
+    zod: "^3.22.0"
+  },
+  peerDependencies: {
+    next: ">=14.0.0",
+    react: ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  devDependencies: {
+    "@testing-library/jest-dom": "^6.4.0",
+    "@testing-library/react": "^14.2.0",
+    "@types/node": "^20.11.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    eslint: "^8.56.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "mongodb-memory-server": "^9.5.0",
+    tsup: "^8.0.0",
+    typescript: "^5.3.0",
+    vitest: "^1.3.0"
+  }
+};
+
+// src/cli/index.ts
+function loadEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return;
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+var cwd = process.cwd();
+loadEnvFile((0, import_node_path.resolve)(cwd, ".env.local"));
+loadEnvFile((0, import_node_path.resolve)(cwd, ".env"));
+var program = new import_commander.Command();
+program.name("next-blogpanel").description("Next BlogPanel \u2014 Blog engine for Next.js").version(package_default.version);
+program.command("init").description("Initialize Next BlogPanel in your Next.js project").option("--blog-path <path>", "Blog base path", "/blog").option("--admin-path <path>", "Admin panel path", "/admin/blog").option("--api-path <path>", "API base path", "/api/blog").option("--no-example", "Skip creating example post").action(init);
+program.command("seed").description("Seed example blog content").action(seed);
+program.command("health").description("Check database and storage connectivity").action(health);
+program.command("migrate").description("Run database migrations").action(migrateCommand);
+program.parse();