@vibecms/core 0.1.0

package/dist/engine/index.js

@@ -0,0 +1,1226 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/index.ts
+var engine_exports = {};
+__export(engine_exports, {
+  BrowserEngine: () => BrowserEngine,
+  DevEngine: () => DevEngine,
+  NodeEngine: () => NodeEngine,
+  VibeEngine: () => VibeEngine,
+  assertValidCollection: () => assertValidCollection,
+  assertValidCommitOid: () => assertValidCommitOid,
+  assertValidSlug: () => assertValidSlug,
+  initVibeEngine: () => initVibeEngine,
+  populate: () => populate,
+  sanitizeRedirectPath: () => sanitizeRedirectPath,
+  validateCollection: () => validateCollection,
+  validateCommitOid: () => validateCommitOid,
+  validateSlug: () => validateSlug
+});
+module.exports = __toCommonJS(engine_exports);
+
+// src/config.ts
+var schemaRegistry = /* @__PURE__ */ new Map();
+function registerCollectionSchemas(collections, singletons) {
+  schemaRegistry.clear();
+  if (collections) {
+    for (const [key, col] of Object.entries(collections)) {
+      schemaRegistry.set(key, col.schema);
+    }
+  }
+  if (singletons) {
+    for (const [key, col] of Object.entries(singletons)) {
+      schemaRegistry.set(key, col.schema);
+    }
+  }
+}
+function validateCollectionData(collection, data) {
+  const schema = schemaRegistry.get(collection);
+  if (!schema) {
+    return { success: true, data };
+  }
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.issues.map(
+    (issue) => `${issue.path.join(".")}: ${issue.message}`
+  );
+  return { success: false, errors };
+}
+
+// src/engine/validation.ts
+var SLUG_REGEX = /^[a-z0-9][a-z0-9_/-]{0,100}$/i;
+var COMMIT_OID_REGEX = /^[0-9a-f]{5,40}$/;
+var COLLECTION_REGEX = /^[a-z0-9][a-z0-9_-]{0,50}$/i;
+function validateSlug(slug) {
+  return typeof slug === "string" && SLUG_REGEX.test(slug);
+}
+function validateCommitOid(oid) {
+  return typeof oid === "string" && COMMIT_OID_REGEX.test(oid);
+}
+function validateCollection(collection) {
+  return typeof collection === "string" && COLLECTION_REGEX.test(collection);
+}
+function assertValidSlug(slug) {
+  if (!validateSlug(slug)) {
+    throw new Error(`Invalid slug: "${slug}". Slugs must match ${SLUG_REGEX}`);
+  }
+}
+function assertValidCommitOid(oid) {
+  if (!validateCommitOid(oid)) {
+    throw new Error(`Invalid commit OID: "${oid}". Must be a hex SHA hash.`);
+  }
+}
+function assertValidCollection(collection) {
+  if (!validateCollection(collection)) {
+    throw new Error(`Invalid collection name: "${collection}"`);
+  }
+}
+function sanitizeRedirectPath(path) {
+  if (!path) return "/";
+  if (!path.startsWith("/")) return "/";
+  if (path.startsWith("//")) return "/";
+  if (path.includes("://")) return "/";
+  if (path.includes("\\")) return "/";
+  return path;
+}
+
+// src/engine/engine-node.ts
+function hasReferenceToSlug(data, slug) {
+  if (data === slug) return true;
+  if (Array.isArray(data)) {
+    return data.some((item) => hasReferenceToSlug(item, slug));
+  }
+  if (data && typeof data === "object") {
+    for (const [key, value] of Object.entries(data)) {
+      if (key.startsWith("_")) continue;
+      if ([
+        "title",
+        "subtitle",
+        "description",
+        "content",
+        "body",
+        "text",
+        "html",
+        "seoTitle",
+        "seoDescription",
+        "label",
+        "name",
+        "placeholder",
+        "helpText",
+        "successMessage",
+        "quote",
+        "answer",
+        "question",
+        "caption",
+        "alt",
+        "icon",
+        "url",
+        "image",
+        "ogImage",
+        "backgroundColor",
+        "textColor",
+        "keywords"
+      ].includes(key)) {
+        continue;
+      }
+      if (hasReferenceToSlug(value, slug)) return true;
+    }
+  }
+  return false;
+}
+var ContentCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  ttlMs;
+  constructor(maxEntries = 200, ttlMs = 3e4) {
+    this.maxEntries = maxEntries;
+    this.ttlMs = ttlMs;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.data;
+  }
+  set(key, data) {
+    if (this.cache.size >= this.maxEntries) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, { data, expiresAt: Date.now() + this.ttlMs });
+  }
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  invalidateCollection(collection) {
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(`${collection}/`)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+var NodeEngine = class {
+  contentDir = "src/content";
+  publicDir = "public";
+  config;
+  contentCache = new ContentCache();
+  async init(config) {
+    this.config = config;
+    if (config?.contentDir) this.contentDir = config.contentDir;
+    if (config?.publicDir) this.publicDir = config.publicDir;
+  }
+  resolveFilename(slug, locale) {
+    const base = slug.endsWith(".json") ? slug.replace(/\.json$/, "") : slug;
+    return locale ? `${base}.${locale}.json` : `${base}.json`;
+  }
+  async read(collection, slug, options) {
+    if (typeof window !== "undefined") return null;
+    assertValidCollection(collection);
+    assertValidSlug(slug);
+    const filename = this.resolveFilename(slug, options?.locale);
+    const cacheKey = `${collection}/${filename}`;
+    const cached = this.contentCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filePath = path.join(process.cwd(), this.contentDir, collection, filename);
+    try {
+      const [content, stat] = await Promise.all([
+        fs.readFile(filePath, "utf-8"),
+        fs.stat(filePath)
+      ]);
+      const data = JSON.parse(content);
+      data._vibeVersion = stat.mtimeMs;
+      this.contentCache.set(cacheKey, data);
+      return data;
+    } catch (e) {
+      return null;
+    }
+  }
+  async write(collection, slug, data, options) {
+    if (typeof window !== "undefined") return;
+    assertValidCollection(collection);
+    assertValidSlug(slug);
+    const validation = validateCollectionData(collection, data);
+    if (!validation.success) {
+      throw new Error(
+        `Schema validation failed for ${collection}/${slug}: ${validation.errors.join("; ")}`
+      );
+    }
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filename = this.resolveFilename(slug, options?.locale);
+    const dir = path.join(process.cwd(), this.contentDir, collection);
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = path.join(dir, filename);
+    const dataToWrite = { ...validation.data };
+    const clientVersion = data._vibeVersion;
+    delete dataToWrite._vibeVersion;
+    if (clientVersion) {
+      try {
+        const stat = await fs.stat(filePath);
+        if (Math.abs(stat.mtimeMs - clientVersion) > 100) {
+          throw new Error(
+            `Conflict: "${collection}/${slug}" was modified by another editor. Reload to see the latest version.`
+          );
+        }
+      } catch (e) {
+        if (e.message.startsWith("Conflict:")) throw e;
+      }
+    }
+    await fs.writeFile(filePath, JSON.stringify(dataToWrite, null, 2), "utf-8");
+    this.contentCache.invalidate(`${collection}/${filename}`);
+  }
+  async delete(collection, slug, options) {
+    if (typeof window !== "undefined") return;
+    assertValidCollection(collection);
+    assertValidSlug(slug);
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filename = this.resolveFilename(slug, options?.locale);
+    const baseDir = path.join(process.cwd(), this.contentDir);
+    const cols = await fs.readdir(baseDir);
+    for (const col of cols) {
+      if (col === collection) continue;
+      const colDir = path.join(baseDir, col);
+      const stat = await fs.stat(colDir);
+      if (!stat.isDirectory()) continue;
+      const files = await fs.readdir(colDir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs.readFile(path.join(colDir, file), "utf8");
+        try {
+          const data = JSON.parse(raw);
+          if (hasReferenceToSlug(data, slug)) {
+            throw new Error(
+              `Referential Integrity Error: Cannot delete "${slug}" because it is referenced by ${col}/${file}`
+            );
+          }
+        } catch (e) {
+          if (e.message.startsWith("Referential Integrity")) throw e;
+        }
+      }
+    }
+    const filePath = path.join(baseDir, collection, filename);
+    await fs.unlink(filePath);
+    this.contentCache.invalidate(`${collection}/${filename}`);
+  }
+  async isDirty() {
+    return false;
+  }
+  async revert() {
+  }
+  async commit(_message, _author) {
+  }
+  async push() {
+  }
+  async pull() {
+  }
+  async writeMedia(file, author) {
+    if (this.config?.media?.driver) {
+      return this.config.media.driver.upload(file, { engine: this, author });
+    }
+    if (typeof window !== "undefined") return "";
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const dir = path.join(process.cwd(), this.publicDir, "assets", "uploads");
+    await fs.mkdir(dir, { recursive: true });
+    const safeName = file.name.replace(/[^a-z0-9.-]/gi, "_").toLowerCase();
+    const filePath = path.join(dir, safeName);
+    await fs.writeFile(filePath, buffer);
+    const url = `/assets/uploads/${safeName}`;
+    try {
+      const sizeOf = (await import("image-size")).default;
+      const dimensions = sizeOf(buffer);
+      if (dimensions && dimensions.width && dimensions.height) {
+        return {
+          url,
+          width: dimensions.width,
+          height: dimensions.height,
+          alt: file.name
+        };
+      }
+    } catch (e) {
+    }
+    return `/assets/uploads/${safeName}`;
+  }
+  async listMedia() {
+    if (this.config?.media?.driver?.list) {
+      return this.config.media.driver.list({ engine: this });
+    }
+    if (typeof window !== "undefined") return [];
+    try {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const uploadsDir = path.join(process.cwd(), this.publicDir, "assets", "uploads");
+      const files = await fs.readdir(uploadsDir);
+      return files.filter((f) => !f.startsWith(".")).map((f) => `/assets/uploads/${f}`);
+    } catch {
+      return [];
+    }
+  }
+  async deleteMedia(filename) {
+    if (this.config?.media?.driver?.delete) {
+      return this.config.media.driver.delete(filename, { engine: this });
+    }
+    if (typeof window !== "undefined") return;
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const safeName = filename.split("/").pop() || filename;
+    const filePath = path.join(process.cwd(), this.publicDir, "assets", "uploads", safeName);
+    try {
+      await fs.unlink(filePath);
+    } catch (e) {
+    }
+  }
+  async renameMedia(oldFilename, newFilename) {
+    if (this.config?.media?.driver?.rename) {
+      return this.config.media.driver.rename(oldFilename, newFilename, { engine: this });
+    }
+    if (typeof window !== "undefined") return;
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const safeOldName = oldFilename.split("/").pop() || oldFilename;
+    const safeNewName = newFilename.split("/").pop() || newFilename;
+    const oldPath = path.join(process.cwd(), this.publicDir, "assets", "uploads", safeOldName);
+    const newPath = path.join(process.cwd(), this.publicDir, "assets", "uploads", safeNewName);
+    try {
+      await fs.rename(oldPath, newPath);
+    } catch (e) {
+      throw new Error(`Failed to rename local media: ${e}`);
+    }
+  }
+  async pruneMedia() {
+    if (typeof window !== "undefined") return { deletedCount: 0, bytesFreed: 0 };
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    let usedMedia = /* @__PURE__ */ new Set();
+    const contentDir = path.join(process.cwd(), "src", "content");
+    const uploadsDir = path.join(process.cwd(), this.publicDir, "assets", "uploads");
+    async function scanDir(dir) {
+      if (!require("fs").existsSync(dir)) return;
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) await scanDir(fullPath);
+        else if (entry.name.endsWith(".json")) {
+          const content = await fs.readFile(fullPath, "utf-8");
+          const regex = /\/assets\/uploads\/([^"'\s\\]+)/g;
+          let match;
+          while ((match = regex.exec(content)) !== null) {
+            usedMedia.add(match[1]);
+          }
+        }
+      }
+    }
+    await scanDir(contentDir);
+    let deletedCount = 0;
+    let bytesFreed = 0;
+    if (require("fs").existsSync(uploadsDir)) {
+      const uFiles = await fs.readdir(uploadsDir);
+      for (const f of uFiles) {
+        if (!usedMedia.has(f) && !f.startsWith(".")) {
+          const stat = await fs.stat(path.join(uploadsDir, f));
+          bytesFreed += stat.size;
+          await fs.unlink(path.join(uploadsDir, f));
+          deletedCount++;
+        }
+      }
+    }
+    return { deletedCount, bytesFreed };
+  }
+  async getMediaUrl(relativePath) {
+    return relativePath;
+  }
+  async list(collection, options) {
+    if (typeof window !== "undefined") return [];
+    try {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const dir = path.join(process.cwd(), this.contentDir, collection);
+      const files = await fs.readdir(dir);
+      const slugs = files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+      if (options?.withMeta) {
+        const metaList = await Promise.all(slugs.map(async (slug) => {
+          try {
+            const content = await fs.readFile(path.join(dir, `${slug}.json`), "utf-8");
+            const data = JSON.parse(content);
+            return { slug, title: data.title || data.name || slug, ...data };
+          } catch (e) {
+            return { slug, title: slug };
+          }
+        }));
+        return metaList;
+      }
+      return slugs;
+    } catch {
+      return [];
+    }
+  }
+  async getHistory(collection, slug) {
+    if (typeof window !== "undefined") return [];
+    assertValidCollection(collection);
+    assertValidSlug(slug);
+    try {
+      const { execFileSync } = require("child_process");
+      const filePath = `${this.contentDir}/${collection}/${slug}.json`;
+      const raw = execFileSync(
+        "git",
+        ["log", "--follow", "--format=%H%x00%s%x00%an%x00%ae%x00%at", "--", filePath],
+        { cwd: process.cwd(), encoding: "utf-8", timeout: 5e3 }
+      ).trim();
+      if (!raw) return [];
+      return raw.split("\n").map((line) => {
+        const [oid, message, author, email, ts] = line.split("\0");
+        return { oid, message, author, email, timestamp: parseInt(ts, 10) * 1e3 };
+      });
+    } catch {
+      return [];
+    }
+  }
+  async getVersionContent(commitOid, collection, slug) {
+    if (typeof window !== "undefined") return null;
+    assertValidCollection(collection);
+    assertValidSlug(slug);
+    assertValidCommitOid(commitOid);
+    try {
+      const { execFileSync } = require("child_process");
+      const filePath = `${this.contentDir}/${collection}/${slug}.json`;
+      const content = execFileSync(
+        "git",
+        ["show", `${commitOid}:${filePath}`],
+        { cwd: process.cwd(), encoding: "utf-8", timeout: 5e3 }
+      );
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/engine/engine-browser.ts
+var DEFAULT_AUTHOR = { name: "VibeCMS Editor", email: "editor@vibecms.local" };
+function hasReferenceToSlug2(data, slug) {
+  if (data === slug) return true;
+  if (Array.isArray(data)) {
+    return data.some((item) => hasReferenceToSlug2(item, slug));
+  }
+  if (data && typeof data === "object") {
+    for (const [key, value] of Object.entries(data)) {
+      if (key.startsWith("_")) continue;
+      if ([
+        "title",
+        "subtitle",
+        "description",
+        "content",
+        "body",
+        "text",
+        "html",
+        "seoTitle",
+        "seoDescription",
+        "label",
+        "name",
+        "placeholder",
+        "helpText",
+        "successMessage",
+        "quote",
+        "answer",
+        "question",
+        "caption",
+        "alt",
+        "icon",
+        "url",
+        "image",
+        "ogImage",
+        "backgroundColor",
+        "textColor",
+        "keywords"
+      ].includes(key)) {
+        continue;
+      }
+      if (hasReferenceToSlug2(value, slug)) return true;
+    }
+  }
+  return false;
+}
+var BrowserEngine = class {
+  fs;
+  pfs;
+  dir = "/vibecms";
+  contentDir = "src/content";
+  publicDir = "public";
+  gitProxyUrl = "/api/git-proxy/";
+  isInitializing = false;
+  initialized = false;
+  config;
+  constructor() {
+    if (typeof window !== "undefined") {
+      try {
+        const LightningFS = require("@isomorphic-git/lightning-fs");
+        const FS = LightningFS.default || LightningFS;
+        this.fs = new FS("vibecms-fs");
+        this.pfs = this.fs.promises;
+      } catch (e) {
+        console.error("Failed to init lightning-fs", e);
+      }
+    }
+  }
+  async init(config) {
+    if (typeof window === "undefined") return;
+    this.config = config;
+    if (config?.contentDir) this.contentDir = config.contentDir;
+    if (config?.publicDir) this.publicDir = config.publicDir;
+    if (this.initialized || this.isInitializing) return;
+    this.isInitializing = true;
+    const git = await import("isomorphic-git");
+    const http = (await import("isomorphic-git/http/web")).default;
+    try {
+      await this.pfs.readdir(this.dir);
+      this.initialized = true;
+      this.isInitializing = false;
+    } catch (e) {
+      try {
+        await git.clone({
+          fs: this.fs,
+          http,
+          dir: this.dir,
+          corsProxy: config?.corsProxy || this.gitProxyUrl,
+          url: config?.repoUrl || "",
+          singleBranch: true,
+          depth: 1
+        });
+        this.initialized = true;
+      } catch (cloneErr) {
+        console.error("Failed to clone repository:", cloneErr);
+      } finally {
+        this.isInitializing = false;
+      }
+    }
+  }
+  resolveFilename(slug, locale) {
+    const base = slug.endsWith(".json") ? slug.replace(/\.json$/, "") : slug;
+    return locale ? `${base}.${locale}.json` : `${base}.json`;
+  }
+  async read(collection, slug, options) {
+    if (typeof window === "undefined" || !this.pfs) return null;
+    try {
+      const filename = this.resolveFilename(slug, options?.locale);
+      const filePath = `${this.dir}/${this.contentDir}/${collection}/${filename}`;
+      const content = await this.pfs.readFile(filePath, { encoding: "utf8" });
+      return JSON.parse(content);
+    } catch (e) {
+      return null;
+    }
+  }
+  async write(collection, slug, data, options) {
+    if (typeof window === "undefined" || !this.pfs) return;
+    const validation = validateCollectionData(collection, data);
+    if (!validation.success) {
+      throw new Error(
+        `Schema validation failed for ${collection}/${slug}: ${validation.errors.join("; ")}`
+      );
+    }
+    const filename = this.resolveFilename(slug, options?.locale);
+    const dirPath = `${this.dir}/${this.contentDir}/${collection}`;
+    const filePath = `${dirPath}/${filename}`;
+    const parts = dirPath.split("/").filter(Boolean);
+    let currentPath = "";
+    for (const part of parts) {
+      currentPath += `/${part}`;
+      try {
+        await this.pfs.mkdir(currentPath);
+      } catch (e) {
+      }
+    }
+    await this.pfs.writeFile(filePath, JSON.stringify(validation.data, null, 2), "utf8");
+  }
+  async delete(collection, slug, options) {
+    if (typeof window === "undefined" || !this.pfs) return;
+    const baseDir = `${this.dir}/${this.contentDir}`;
+    const cols = await this.pfs.readdir(baseDir);
+    for (const col of cols) {
+      if (col === collection) continue;
+      const colDir = `${baseDir}/${col}`;
+      try {
+        const files = await this.pfs.readdir(colDir);
+        for (const file of files) {
+          if (!file.endsWith(".json")) continue;
+          const raw = await this.pfs.readFile(`${colDir}/${file}`, { encoding: "utf8" });
+          try {
+            const data = JSON.parse(raw);
+            if (hasReferenceToSlug2(data, slug)) {
+              throw new Error(
+                `Referential Integrity Error: Cannot delete "${slug}" because it is referenced by ${col}/${file}`
+              );
+            }
+          } catch (e) {
+            if (e.message.startsWith("Referential Integrity")) throw e;
+          }
+        }
+      } catch (e) {
+        if (e.message?.startsWith("Referential Integrity")) throw e;
+      }
+    }
+    const filename = this.resolveFilename(slug, options?.locale);
+    await this.pfs.unlink(`${baseDir}/${collection}/${filename}`);
+  }
+  async isDirty(collection, slug) {
+    if (typeof window === "undefined" || !this.pfs) return false;
+    try {
+      const git = await import("isomorphic-git");
+      const relativeFilePath = `${this.contentDir}/${collection}/${slug}.json`;
+      const status = await git.status({ fs: this.fs, dir: this.dir, filepath: relativeFilePath });
+      return status !== "unmodified" && status !== "ignored";
+    } catch (e) {
+      return false;
+    }
+  }
+  async revert(collection, slug) {
+    if (typeof window === "undefined" || !this.pfs) return;
+    try {
+      const git = await import("isomorphic-git");
+      const relativeFilePath = `${this.contentDir}/${collection}/${slug}.json`;
+      await git.checkout({
+        fs: this.fs,
+        dir: this.dir,
+        filepaths: [relativeFilePath],
+        force: true
+      });
+    } catch (e) {
+      console.error("Failed to revert", e);
+    }
+  }
+  async commit(message, author) {
+    if (typeof window === "undefined" || !this.pfs) return;
+    const git = await import("isomorphic-git");
+    const commitAuthor = author || DEFAULT_AUTHOR;
+    const listFiles = async (dirPath) => {
+      const entries = await this.pfs.readdir(dirPath);
+      let files = [];
+      for (const entry of entries) {
+        if (entry === ".git") continue;
+        const internalPath = `${dirPath}/${entry}`;
+        const stat = await this.pfs.stat(internalPath);
+        if (stat.isDirectory()) {
+          files = files.concat(await listFiles(internalPath));
+        } else if (entry.endsWith(".json")) {
+          files.push(internalPath.replace(`${this.dir}/`, ""));
+        }
+      }
+      return files;
+    };
+    try {
+      const formFiles = await listFiles(`${this.dir}/${this.contentDir}`);
+      for (const filepath of formFiles) {
+        await git.add({ fs: this.fs, dir: this.dir, filepath });
+      }
+      await git.commit({
+        fs: this.fs,
+        dir: this.dir,
+        author: { name: commitAuthor.name, email: commitAuthor.email },
+        message: message || "CMS Content Update"
+      });
+    } catch (e) {
+      console.error("Commit failed", e);
+    }
+  }
+  async push(oauthToken) {
+    if (typeof window === "undefined" || !this.pfs) return;
+    const git = await import("isomorphic-git");
+    const http = (await import("isomorphic-git/http/web")).default;
+    await git.push({
+      fs: this.fs,
+      http,
+      dir: this.dir,
+      remote: "origin",
+      ref: "main",
+      onAuth: () => ({ oauth2format: "github", password: oauthToken })
+    });
+  }
+  async pull() {
+    if (typeof window === "undefined" || !this.pfs) return;
+    const git = await import("isomorphic-git");
+    const http = (await import("isomorphic-git/http/web")).default;
+    await git.pull({
+      fs: this.fs,
+      http,
+      dir: this.dir,
+      ref: "main",
+      singleBranch: true,
+      corsProxy: this.gitProxyUrl,
+      author: { name: DEFAULT_AUTHOR.name, email: DEFAULT_AUTHOR.email }
+    });
+  }
+  async writeMedia(file, author) {
+    if (this.config?.media?.driver) {
+      return this.config.media.driver.upload(file, { engine: this, author });
+    }
+    if (typeof window === "undefined" || !this.pfs) return "";
+    const git = await import("isomorphic-git");
+    const dirPath = `${this.dir}/${this.publicDir}/assets/uploads`;
+    try {
+      const parts = `${this.publicDir}/assets/uploads`.split("/").filter(Boolean);
+      let currentPath = this.dir;
+      for (const part of parts) {
+        currentPath += `/${part}`;
+        try {
+          await this.pfs.mkdir(currentPath);
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+    }
+    const safeName = file.name.replace(/[^a-z0-9.-]/gi, "_").toLowerCase();
+    const filePath = `${dirPath}/${safeName}`;
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = new Uint8Array(arrayBuffer);
+    await this.pfs.writeFile(filePath, buffer);
+    await git.add({ fs: this.fs, dir: this.dir, filepath: `${this.publicDir}/assets/uploads/${safeName}` });
+    const commitAuthor = author || DEFAULT_AUTHOR;
+    await git.commit({
+      fs: this.fs,
+      dir: this.dir,
+      author: { name: commitAuthor.name, email: commitAuthor.email },
+      message: `Upload media ${safeName}`
+    });
+    try {
+      const blob = new Blob([buffer], { type: file.type });
+      const src = URL.createObjectURL(blob);
+      const img = new Image();
+      img.src = src;
+      await new Promise((resolve) => {
+        img.onload = resolve;
+        img.onerror = resolve;
+      });
+      return {
+        url: `/assets/uploads/${safeName}`,
+        width: img.naturalWidth,
+        height: img.naturalHeight,
+        alt: file.name
+      };
+    } catch {
+      return `/assets/uploads/${safeName}`;
+    }
+  }
+  async pruneMedia() {
+    return { deletedCount: 0, bytesFreed: 0 };
+  }
+  async listMedia() {
+    if (this.config?.media?.driver?.list) {
+      return this.config.media.driver.list({ engine: this });
+    }
+    if (typeof window === "undefined" || !this.pfs) return [];
+    try {
+      const dirPath = `${this.dir}/${this.publicDir}/assets/uploads`;
+      const files = await this.pfs.readdir(dirPath);
+      return files.filter((f) => !f.startsWith(".")).map((f) => `/assets/uploads/${f}`);
+    } catch {
+      return [];
+    }
+  }
+  async deleteMedia(filename) {
+    if (this.config?.media?.driver?.delete) {
+      return this.config.media.driver.delete(filename, { engine: this });
+    }
+    if (typeof window === "undefined" || !this.pfs) return;
+    const safeName = filename.split("/").pop() || filename;
+    const filePath = `${this.dir}/${this.publicDir}/assets/uploads/${safeName}`;
+    try {
+      await this.pfs.unlink(filePath);
+      const git = await import("isomorphic-git");
+      await git.remove({ fs: this.fs, dir: this.dir, filepath: `${this.publicDir}/assets/uploads/${safeName}` });
+    } catch {
+    }
+  }
+  async renameMedia(oldFilename, newFilename) {
+    if (this.config?.media?.driver?.rename) {
+      return this.config.media.driver.rename(oldFilename, newFilename, { engine: this });
+    }
+    if (typeof window === "undefined" || !this.pfs) return;
+    const safeOldName = oldFilename.split("/").pop() || oldFilename;
+    const safeNewName = newFilename.split("/").pop() || newFilename;
+    const oldPath = `${this.dir}/${this.publicDir}/assets/uploads/${safeOldName}`;
+    const newPath = `${this.dir}/${this.publicDir}/assets/uploads/${safeNewName}`;
+    try {
+      const buffer = await this.pfs.readFile(oldPath);
+      await this.pfs.writeFile(newPath, buffer);
+      await this.pfs.unlink(oldPath);
+      const git = await import("isomorphic-git");
+      await git.remove({ fs: this.fs, dir: this.dir, filepath: `${this.publicDir}/assets/uploads/${safeOldName}` });
+      await git.add({ fs: this.fs, dir: this.dir, filepath: `${this.publicDir}/assets/uploads/${safeNewName}` });
+    } catch {
+    }
+  }
+  async getMediaUrl(relativePath) {
+    if (typeof window === "undefined" || !this.pfs) return relativePath;
+    try {
+      const filePath = `${this.dir}/${this.publicDir}${relativePath}`;
+      const uint8Array = await this.pfs.readFile(filePath);
+      const ext = relativePath.split(".").pop()?.toLowerCase();
+      let mime = "image/png";
+      if (ext === "jpg" || ext === "jpeg") mime = "image/jpeg";
+      else if (ext === "svg") mime = "image/svg+xml";
+      else if (ext === "gif") mime = "image/gif";
+      else if (ext === "webp") mime = "image/webp";
+      const blob = new Blob([uint8Array], { type: mime });
+      return URL.createObjectURL(blob);
+    } catch (e) {
+      return relativePath;
+    }
+  }
+  async list(collection, options) {
+    if (typeof window === "undefined" || !this.pfs) return [];
+    try {
+      const files = await this.pfs.readdir(`${this.dir}/${this.contentDir}/${collection}`);
+      const slugs = files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+      if (options?.withMeta) {
+        const metaList = await Promise.all(slugs.map(async (slug) => {
+          try {
+            const content = await this.pfs.readFile(`${this.dir}/${this.contentDir}/${collection}/${slug}.json`, { encoding: "utf8" });
+            const data = JSON.parse(content);
+            return { slug, title: data.title || data.name || slug, ...data };
+          } catch (e) {
+            return { slug, title: slug };
+          }
+        }));
+        return metaList;
+      }
+      return slugs;
+    } catch {
+      return [];
+    }
+  }
+  async getHistory(collection, slug) {
+    if (typeof window === "undefined" || !this.pfs) return [];
+    try {
+      const git = await import("isomorphic-git");
+      const relativeFilePath = `${this.contentDir}/${collection}/${slug}.json`;
+      const commits = await git.log({
+        fs: this.fs,
+        dir: this.dir,
+        filepath: relativeFilePath
+      });
+      return commits.map((c) => ({
+        oid: c.oid,
+        message: c.commit.message,
+        author: c.commit.author.name,
+        email: c.commit.author.email,
+        timestamp: c.commit.author.timestamp * 1e3
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getVersionContent(commitOid, collection, slug) {
+    if (typeof window === "undefined" || !this.pfs) return null;
+    try {
+      const git = await import("isomorphic-git");
+      const relativeFilePath = `${this.contentDir}/${collection}/${slug}.json`;
+      const { blob } = await git.readBlob({
+        fs: this.fs,
+        dir: this.dir,
+        oid: commitOid,
+        filepath: relativeFilePath
+      });
+      const content = new TextDecoder("utf-8").decode(blob);
+      return JSON.parse(content);
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/engine/engine-dev.ts
+var DevEngine = class {
+  apiBase = "/__vibecms/api";
+  config;
+  async init(config) {
+    this.config = config;
+    if (config?.devMode === false) {
+      console.warn("DevEngine initialized but devMode is false");
+    }
+  }
+  async fetchApi(method, body) {
+    const res = await fetch(this.apiBase, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ method, ...body })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.message || "API Error");
+    }
+    return res.json();
+  }
+  async read(collection, slug, options) {
+    return this.fetchApi("read", { collection, slug, options }).catch(() => null);
+  }
+  async write(collection, slug, data, options) {
+    await this.fetchApi("write", { collection, slug, data, options });
+  }
+  async delete(collection, slug, options) {
+    await this.fetchApi("delete", { collection, slug, options });
+  }
+  async isDirty() {
+    return false;
+  }
+  async revert() {
+  }
+  async commit(_message, _author) {
+  }
+  async push() {
+  }
+  async pull() {
+  }
+  async writeMedia(file, author) {
+    if (this.config?.media?.driver) {
+      return this.config.media.driver.upload(file, { engine: this, author });
+    }
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("method", "writeMedia");
+    const res = await fetch(this.apiBase, {
+      method: "POST",
+      body: formData
+    });
+    if (!res.ok) throw new Error("Failed to upload media");
+    const data = await res.json();
+    return data.url && data.width ? data : data.url;
+  }
+  async listMedia() {
+    if (this.config?.media?.driver?.list) {
+      return this.config.media.driver.list({ engine: this });
+    }
+    const res = await this.fetchApi("listMedia");
+    return res.files || [];
+  }
+  async deleteMedia(filename) {
+    if (this.config?.media?.driver?.delete) {
+      return this.config.media.driver.delete(filename, { engine: this });
+    }
+    await this.fetchApi("deleteMedia", { file: filename });
+  }
+  async renameMedia(oldFilename, newFilename) {
+    if (this.config?.media?.driver?.rename) {
+      return this.config.media.driver.rename(oldFilename, newFilename, { engine: this });
+    }
+    await this.fetchApi("renameMedia", { oldFile: oldFilename, newFile: newFilename });
+  }
+  async pruneMedia() {
+    return this.fetchApi("pruneMedia");
+  }
+  async getMediaUrl(relativePath) {
+    return relativePath;
+  }
+  async list(collection, options) {
+    return this.fetchApi("list", { collection, options });
+  }
+  async getHistory(_collection, _slug) {
+    return this.fetchApi("getHistory", { collection: _collection, slug: _slug }).catch(() => []);
+  }
+  async getVersionContent(commitOid, collection, slug) {
+    return this.fetchApi("getVersionContent", { commitOid, collection, slug }).catch(() => null);
+  }
+};
+
+// src/license.ts
+var VIBE_PUBLIC_KEY_B64 = "MCowBQYDK2VwAyEAhoV+ydoo3GG0wM0tjBmtBWKMaHo7gVg25J5lsSfoBI0=";
+var VALIDATION_API = "https://api.vibecms.com/v1/license/validate";
+var _remoteCache = null;
+var REMOTE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var _revokedAt = null;
+var GRACE_PERIOD_MS = 72 * 60 * 60 * 1e3;
+function base64urlDecode(str) {
+  let b64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (b64.length % 4 !== 0) b64 += "=";
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function validateLicenseLocal(key) {
+  if (!key || !key.startsWith("vibe_")) {
+    throw new Error(
+      '[VibeCMS] Invalid license key format. Keys start with "vibe_".\nGet your key at https://vibecms.com/pricing'
+    );
+  }
+  const body = key.slice(5);
+  const dotIndex = body.lastIndexOf(".");
+  if (dotIndex === -1) {
+    throw new Error(
+      "[VibeCMS] Malformed license key. Expected format: vibe_<payload>.<signature>\nGet a new key at https://vibecms.com/pricing"
+    );
+  }
+  const payloadB64 = body.slice(0, dotIndex);
+  const signatureB64 = body.slice(dotIndex + 1);
+  let payload;
+  try {
+    const payloadBytes = base64urlDecode(payloadB64);
+    const payloadJson = new TextDecoder().decode(payloadBytes);
+    payload = JSON.parse(payloadJson);
+  } catch {
+    throw new Error(
+      "[VibeCMS] Invalid license key. Could not decode payload.\nCheck your key or get a new one at https://vibecms.com/pricing"
+    );
+  }
+  if (!payload.sub || !payload.plan || !payload.iat || !payload.exp || !payload.kid) {
+    throw new Error(
+      "[VibeCMS] Invalid license key. Missing required fields.\nGet a new key at https://vibecms.com/pricing"
+    );
+  }
+  try {
+    const crypto = require("crypto");
+    const pubKeyDer = Buffer.from(VIBE_PUBLIC_KEY_B64, "base64");
+    const publicKey = crypto.createPublicKey({
+      key: pubKeyDer,
+      format: "der",
+      type: "spki"
+    });
+    const payloadBytes = base64urlDecode(payloadB64);
+    const signatureBytes = base64urlDecode(signatureB64);
+    const isValid = crypto.verify(null, payloadBytes, publicKey, signatureBytes);
+    if (!isValid) {
+      throw new Error("signature mismatch");
+    }
+  } catch (e) {
+    if (e.message?.includes("[VibeCMS]")) throw e;
+    throw new Error(
+      "[VibeCMS] Invalid license key. Signature verification failed.\nCheck your key or get a new one at https://vibecms.com/pricing"
+    );
+  }
+  const nowSec = Math.floor(Date.now() / 1e3);
+  if (payload.exp < nowSec) {
+    const expDate = new Date(payload.exp * 1e3).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+    throw new Error(
+      `[VibeCMS] License expired on ${expDate}.
+Renew at https://vibecms.com/account`
+    );
+  }
+  return payload;
+}
+async function validateLicenseRemote(key, version) {
+  if (_remoteCache && Date.now() - _remoteCache.checkedAt < REMOTE_CACHE_TTL_MS) {
+    if (!_remoteCache.valid) {
+      handleRevocation();
+    }
+    return;
+  }
+  try {
+    const res = await fetch(VALIDATION_API, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ key, version }),
+      signal: AbortSignal.timeout(5e3)
+      // 5s timeout
+    });
+    if (res.ok) {
+      const data = await res.json();
+      _remoteCache = {
+        valid: data.valid !== false,
+        reason: data.reason,
+        checkedAt: Date.now()
+      };
+      if (!_remoteCache.valid) {
+        handleRevocation();
+      } else {
+        _revokedAt = null;
+      }
+    }
+  } catch {
+  }
+}
+function handleRevocation() {
+  if (!_revokedAt) {
+    _revokedAt = Date.now();
+    console.warn(
+      "[VibeCMS] \u26A0 Warning: Your license key has been revoked.\nVibeCMS will stop working in 72 hours.\nContact support@vibecms.com or visit https://vibecms.com/account"
+    );
+  }
+  const elapsed = Date.now() - _revokedAt;
+  if (elapsed > GRACE_PERIOD_MS) {
+    throw new Error(
+      "[VibeCMS] License has been revoked and the grace period has expired.\nContact support@vibecms.com or get a new key at https://vibecms.com/pricing"
+    );
+  }
+}
+function resolveLicenseKey(configKey) {
+  const key = (typeof process !== "undefined" ? process.env?.VIBE_LICENSE_KEY : void 0) ?? configKey;
+  if (!key) {
+    throw new Error(
+      "[VibeCMS] License key required.\nSet the VIBE_LICENSE_KEY environment variable or pass licenseKey in defineConfig().\nGet your free key at https://vibecms.com/pricing"
+    );
+  }
+  return key;
+}
+
+// src/engine/index.ts
+var _licensed = false;
+var getEngine = () => {
+  if (typeof window === "undefined") return new NodeEngine();
+  const isLocal = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1";
+  return isLocal ? new DevEngine() : new BrowserEngine();
+};
+var _raw = getEngine();
+var VibeEngine = new Proxy(_raw, {
+  get(target, prop, receiver) {
+    const value = Reflect.get(target, prop, receiver);
+    if (!_licensed && typeof value === "function" && prop !== "init") {
+      return (...args) => {
+        throw new Error(
+          "[VibeCMS] License key required. Call initVibeEngine() with a valid key.\nGet your key at https://vibecms.com/pricing"
+        );
+      };
+    }
+    return value;
+  }
+});
+function initVibeEngine(config, collections, singletons) {
+  const key = resolveLicenseKey(config.licenseKey);
+  validateLicenseLocal(key);
+  _licensed = true;
+  validateLicenseRemote(key, "0.1.0").catch(() => {
+  });
+  if (collections || singletons) {
+    registerCollectionSchemas(collections, singletons);
+  }
+  return VibeEngine.init(config);
+}
+async function populate(document, refs) {
+  if (!document) return document;
+  const doc = { ...document };
+  for (const ref of refs) {
+    if (typeof doc[ref.field] === "string") {
+      const data = await VibeEngine.read(ref.collection, doc[ref.field]);
+      if (data) doc[ref.field] = data;
+    } else if (Array.isArray(doc[ref.field])) {
+      doc[ref.field] = await Promise.all(doc[ref.field].map(async (item) => {
+        if (typeof item === "string") {
+          const data = await VibeEngine.read(ref.collection, item);
+          return data || item;
+        }
+        return item;
+      }));
+    }
+  }
+  return doc;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserEngine,
+  DevEngine,
+  NodeEngine,
+  VibeEngine,
+  assertValidCollection,
+  assertValidCommitOid,
+  assertValidSlug,
+  initVibeEngine,
+  populate,
+  sanitizeRedirectPath,
+  validateCollection,
+  validateCommitOid,
+  validateSlug
+});
+//# sourceMappingURL=index.js.map