@monkeyplus/flow 6.0.16 → 6.0.18

package/cms/server/utils/github_token.mjs

@@ -0,0 +1,377 @@
+const REVALIDATE_INTERVAL = 6e4;
+export class GHToken {
+  token;
+  valid;
+  remaining;
+  limit;
+  reset;
+  _lastValidated;
+  _app;
+  _appInstallationId;
+  constructor(token, opts) {
+    this.token = token;
+    this._app = opts?.app;
+    this._appInstallationId = opts?.appInstallationId;
+  }
+  get maskedToken() {
+    return this.token.length > 8 ? `${this.token.slice(0, 4)}***${this.token.slice(-4)}` : "***";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  toJSON() {
+    return {
+      token: this.maskedToken,
+      valid: this.valid,
+      remaining: this.remaining,
+      limit: this.limit,
+      reset: this.reset
+    };
+  }
+  toString() {
+    const type = this._app ? "app" : "pat";
+    return `[GitHub ${type} token ${this.maskedToken}]`;
+  }
+  updateStatus(res) {
+    this.valid = res.status !== 401;
+    const remaining = res.headers.get("x-ratelimit-remaining");
+    const limit = res.headers.get("x-ratelimit-limit");
+    const resetEpoch = res.headers.get("x-ratelimit-reset");
+    if (remaining)
+      this.remaining = Number.parseInt(remaining);
+    if (limit)
+      this.limit = Number.parseInt(limit);
+    if (resetEpoch)
+      this.reset = Number.parseInt(resetEpoch) * 1e3;
+  }
+  /** NOTE: Each call consumes one API request to fetch rate limit info. */
+  async validate() {
+    try {
+      const res = await fetch("https://api.github.com/meta", {
+        headers: {
+          "User-Agent": "fetch",
+          "Authorization": `token ${this.token}`
+        }
+      });
+      this.updateStatus(res);
+      this._lastValidated = Date.now();
+      const resetInfo = this.reset ? ` resets in ${formatDuration(this.reset - Date.now())}` : "";
+      const resource = res.headers.get("x-ratelimit-resource") || "";
+      console.log(
+        `GitHub token ${this.valid ? "validated" : "invalid"} (${res.status}): ${this.remaining}/${this.limit}${resource ? ` [${resource}]` : ""}${resetInfo}`
+      );
+    } catch (error) {
+      console.error("Error validating GitHub token:", error);
+    }
+  }
+  /** Returns true if this token needs revalidation */
+  isStale(now = Date.now()) {
+    if (!this._lastValidated)
+      return true;
+    if (this.reset && this.reset > now)
+      return false;
+    return now - this._lastValidated > REVALIDATE_INTERVAL;
+  }
+  /** Clears expired rate limit state */
+  clearExpiredLimits(now = Date.now()) {
+    if (this.valid !== false && this.remaining === 0 && this.reset && this.reset < now) {
+      this.remaining = void 0;
+      this.limit = void 0;
+      this.reset = void 0;
+    }
+  }
+  /** Whether this token is usable for requests */
+  get available() {
+    return this.valid && (this.remaining ?? 1) > 0;
+  }
+}
+export const ghTokens = (process.env.GH_TOKEN || "").split(",").map((t) => t.trim()).filter(Boolean).map((t) => new GHToken(t));
+export async function ensureAllTokensValidated() {
+  await _ensureAllAppTokensOnce();
+  await Promise.all(ghTokens.map((t) => t.validate()));
+}
+export const ensureTokensValidated = idempotent(async () => {
+  await _validateUntilOneAvailable();
+  if (!getGHToken()) {
+    await revalidateGHTokens();
+  }
+});
+async function _validateUntilOneAvailable() {
+  const tasks = [
+    ...ghTokens.map((t) => t.validate()),
+    ...process.env.GH_APP_ID && process.env.GH_APP_PRIVATE_KEY ? [ensureAppToken()] : []
+  ];
+  if (tasks.length > 0) {
+    await Promise.allSettled(tasks);
+  }
+}
+export const revalidateGHTokens = idempotent(_doRevalidateGHTokens, { once: false });
+async function _doRevalidateGHTokens() {
+  const now = Date.now();
+  const staleTokens = ghTokens.filter((t) => t.isStale(now));
+  if (staleTokens.length === 0 && getGHToken()) {
+    return false;
+  }
+  await Promise.all([...staleTokens.map((t) => t.validate()), ensureAppToken()]);
+  return true;
+}
+export function getGHToken() {
+  const now = Date.now();
+  for (const token of ghTokens) {
+    token.clearExpiredLimits(now);
+  }
+  let best;
+  for (const t of ghTokens) {
+    if (t.available && (t.remaining ?? 1) > (best?.remaining ?? 0)) {
+      best = t;
+    }
+  }
+  return best;
+}
+export async function acquireGHToken() {
+  await ensureTokensValidated();
+  const token = getGHToken();
+  if (token)
+    return token;
+  await revalidateGHTokens();
+  return getGHToken();
+}
+export function getAggregateRateLimit() {
+  const validTokens = ghTokens.filter((t) => t.valid);
+  const totalRemaining = validTokens.reduce((sum, t) => sum + (t.remaining ?? 0), 0);
+  const totalLimit = validTokens.reduce((sum, t) => sum + (t.limit ?? 0), 0);
+  const soonestReset = ghTokens.filter((t) => t.valid && t.reset).sort((a, b) => (a.reset || 0) - (b.reset || 0))[0];
+  return { remaining: totalRemaining, limit: totalLimit, reset: soonestReset?.reset };
+}
+const RETRY_JITTER_MAX = 30 * 60;
+export function retryAfterSeconds(resetMs, fallback = 60) {
+  const base = resetMs ? Math.max(1, Math.ceil((resetMs - Date.now()) / 1e3)) : fallback;
+  const jitter = Math.floor(Math.random() * RETRY_JITTER_MAX);
+  return base + jitter;
+}
+export function formatDuration(ms) {
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 1)
+    return "<1m";
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const rem = minutes % 60;
+  return rem > 0 ? `${hours}h${rem}m` : `${hours}h`;
+}
+export const ensureAppToken = idempotent(() => _refreshAppToken(false), { once: false });
+const _ensureAllAppTokensOnce = idempotent(() => _refreshAppToken(true));
+async function _refreshAppToken(all) {
+  try {
+    const appId = process.env.GH_APP_ID;
+    const privateKey = process.env.GH_APP_PRIVATE_KEY;
+    if (!appId || !privateKey) {
+      return;
+    }
+    const jwt = await _createAppJWT(appId, privateKey);
+    const installationsRes = await fetch("https://api.github.com/app/installations", {
+      headers: {
+        "Authorization": `Bearer ${jwt}`,
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "fetch"
+      }
+    });
+    if (!installationsRes.ok) {
+      throw new Error(`Failed to fetch installations: ${installationsRes.status}`);
+    }
+    const installations = await installationsRes.json();
+    const safeInstallations = installations.filter((i) => {
+      const perms = Object.values(i.permissions || {});
+      return perms.every((p) => p === "read");
+    });
+    if (safeInstallations.length < installations.length) {
+      console.log(
+        `Filtered ${installations.length - safeInstallations.length} installation(s) with write permissions`
+      );
+    }
+    let installationIds = safeInstallations.map((i) => String(i.id));
+    if (installationIds.length === 0) {
+      console.log("No GitHub App installations found");
+      return;
+    }
+    if (!all && installationIds.length > 5) {
+      for (let i = installationIds.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        const tmp = installationIds[i];
+        installationIds[i] = installationIds[j];
+        installationIds[j] = tmp;
+      }
+      installationIds = installationIds.slice(0, 5);
+    }
+    let earliestRefresh = Number.POSITIVE_INFINITY;
+    await Promise.all(
+      installationIds.map(async (installationId) => {
+        try {
+          const tokenRes = await fetch(
+            `https://api.github.com/app/installations/${installationId}/access_tokens`,
+            {
+              method: "POST",
+              headers: {
+                "Authorization": `Bearer ${jwt}`,
+                "Accept": "application/vnd.github+json",
+                "User-Agent": "fetch"
+              }
+            }
+          );
+          if (!tokenRes.ok) {
+            throw new Error(`Failed to create installation token: ${tokenRes.status}`);
+          }
+          const res = await tokenRes.json();
+          const existing = ghTokens.find((t) => t._appInstallationId === installationId);
+          if (existing) {
+            existing.token = res.token;
+            existing.valid = true;
+            existing.remaining = void 0;
+            existing.limit = void 0;
+            existing.reset = void 0;
+            await existing.validate();
+          } else {
+            const newToken = new GHToken(res.token, {
+              app: true,
+              appInstallationId: installationId
+            });
+            newToken.valid = true;
+            ghTokens.push(newToken);
+            await newToken.validate();
+          }
+          const expiresAt = new Date(res.expires_at).getTime();
+          const refreshIn = Math.max(expiresAt - Date.now() - 5 * 6e4, 6e4);
+          earliestRefresh = Math.min(earliestRefresh, refreshIn);
+          console.log(
+            `GitHub App token acquired for installation ${installationId} (expires ${res.expires_at})`
+          );
+        } catch (error) {
+          console.error(
+            `Failed to get GitHub App token for installation ${installationId}:`,
+            error
+          );
+        }
+      })
+    );
+    if (earliestRefresh < Number.POSITIVE_INFINITY) {
+      setTimeout(ensureAppToken, earliestRefresh);
+    }
+  } catch (error) {
+    console.error("Failed to initialize GitHub App tokens:", error);
+  }
+}
+export async function _createAppJWT(appId, privateKey) {
+  const now = Math.floor(Date.now() / 1e3);
+  const header = _base64url(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = _base64url(JSON.stringify({ iat: now - 60, exp: now + 600, iss: appId }));
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    _pemToKeyData(privateKey),
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign(
+    "RSASSA-PKCS1-v1_5",
+    key,
+    new TextEncoder().encode(`${header}.${payload}`)
+  );
+  const signature = _bufferToBase64url(sig);
+  return `${header}.${payload}.${signature}`;
+}
+export function _base64url(str) {
+  return _bufferToBase64url(new TextEncoder().encode(str));
+}
+function _bufferToBase64url(buf) {
+  const bytes = new Uint8Array(buf);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function _pemToKeyData(pem) {
+  const normalized = pem.replace(/\\n/g, "\n");
+  const isPkcs1 = normalized.includes("BEGIN RSA PRIVATE KEY");
+  const base64 = normalized.replace(/-----BEGIN [\w ]+-----/, "").replace(/-----END [\w ]+-----/, "").replace(/\s/g, "");
+  const der = _base64ToBinary(base64);
+  return isPkcs1 ? _pkcs1ToPkcs8(der) : der;
+}
+function _base64ToBinary(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function _pkcs1ToPkcs8(pkcs1) {
+  const pkcs1Bytes = new Uint8Array(pkcs1);
+  const algorithmId = new Uint8Array([
+    48,
+    13,
+    6,
+    9,
+    42,
+    134,
+    72,
+    134,
+    247,
+    13,
+    1,
+    1,
+    1,
+    5,
+    0
+  ]);
+  const version = new Uint8Array([2, 1, 0]);
+  const octetString = _asn1Wrap(4, pkcs1Bytes);
+  const totalLen = version.length + algorithmId.length + octetString.length;
+  const seq = _asn1Wrap(48, _concat(version, algorithmId, octetString), totalLen);
+  return seq.buffer;
+}
+function _asn1Wrap(tag, content, knownLen) {
+  const len = knownLen ?? content.length;
+  const lenBytes = _asn1Length(len);
+  const result = new Uint8Array(1 + lenBytes.length + content.length);
+  result[0] = tag;
+  result.set(lenBytes, 1);
+  result.set(content, 1 + lenBytes.length);
+  return result;
+}
+function _asn1Length(len) {
+  if (len < 128)
+    return new Uint8Array([len]);
+  if (len < 256)
+    return new Uint8Array([129, len]);
+  if (len < 65536)
+    return new Uint8Array([130, len >> 8 & 255, len & 255]);
+  return new Uint8Array([131, len >> 16 & 255, len >> 8 & 255, len & 255]);
+}
+function _concat(...arrays) {
+  const total = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+function idempotent(fn, opts) {
+  const once = opts?.once !== false;
+  let pending;
+  const wrapped = () => {
+    if (!pending) {
+      pending = fn().finally(() => {
+        if (!once)
+          pending = void 0;
+      });
+    }
+    return pending;
+  };
+  wrapped.reset = () => {
+    pending = void 0;
+  };
+  return wrapped;
+}

package/modules/cms/module.d.ts

@@ -0,0 +1,11 @@
+export interface NetlifyCmsModuleOptions {
+    base?: string;
+    dirContent?: string;
+    dirSchema?: string;
+    branch?: string;
+    mediaFolder?: string;
+    publicFolder?: string;
+    playground?: false;
+}
+declare const _default: import("../../src/runtime/config.ts").FlowModuleDefinition<NetlifyCmsModuleOptions>;
+export default _default;

package/modules/cms/module.mjs

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import { resolve } from "node:path";
+import { consola } from "consola";
+import { resolvePackageFile, resolvePackagePath, resolvePath } from "../../src/public/shared.mjs";
+import { defineFlowModule } from "../../src/runtime/config.mjs";
+export default defineFlowModule({
+  meta: {
+    name: "cms",
+    configKey: "cms"
+  },
+  defaults: {
+    base: "",
+    dirContent: "content",
+    dirSchema: "cms",
+    branch: "master",
+    mediaFolder: "media",
+    publicFolder: "public",
+    playground: false
+  },
+  setup(options, context) {
+    consola.log("[cms] options", options);
+    if (!context.nitro.runtimeConfig?.flow) {
+      context.nitro.runtimeConfig.flow = {};
+    }
+    context.nitro.runtimeConfig.flow.cms = options;
+    context.nitro.alias = context.nitro.alias || {};
+    const cmsUtilsPath = context.projectRoot === resolvePackagePath() ? resolve(context.projectRoot, "cms/server/utils") : resolvePackagePath("cms/server/utils");
+    context.nitro.alias["#cms-utils"] = cmsUtilsPath;
+    context.vite.resolve.alias["#cms-utils"] = cmsUtilsPath;
+    const base = "cms/server/routes/api/repos/remote/[repo]";
+    const paths = {
+      draft: resolvePath(context.projectRoot, "cms/server/routes/api/draft"),
+      //
+      blobsFileIndex: resolvePath(context.projectRoot, `${base}/blobs/[file]/index`),
+      blobsIndexPost: resolvePath(context.projectRoot, `${base}/blobs/index.post`),
+      branchesBranchIndex: resolvePath(context.projectRoot, `${base}/branches/[branch]/index`),
+      commitsIndexPost: resolvePath(context.projectRoot, `${base}/commits/index.post`),
+      filesBranchIndex: resolvePath(context.projectRoot, `${base}/files/[branch]/index`),
+      filesIndexPost: resolvePath(context.projectRoot, `${base}/files/index.post`),
+      refsHeadsBranchIndexPatch: resolvePath(context.projectRoot, `${base}/refs/heads/[branch]/index.patch`),
+      //
+      config: resolvePath(context.projectRoot, `modules/cms/server/api/config`),
+      meta: resolvePath(context.projectRoot, `modules/cms/server/api/meta`),
+      localFs: resolvePath(context.projectRoot, `modules/cms/server/api/localFs`)
+    };
+    const locales = context.flowConfig.locale?.locales || ["es"];
+    if (!context.nitro.handlers) {
+      context.nitro.handlers = [];
+    }
+    const baseRemote = "/api/repos/remote/";
+    context.nitro.handlers.push({
+      route: `/api/repos/local/:repo/**`,
+      handler: paths.localFs
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/blobs/:file`,
+      handler: paths.blobsFileIndex
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/blobs`,
+      handler: paths.blobsIndexPost,
+      method: "POST"
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/branches/:branch`,
+      handler: paths.branchesBranchIndex
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/commits`,
+      handler: paths.commitsIndexPost,
+      method: "POST"
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/files/:branch`,
+      handler: paths.filesBranchIndex
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/files`,
+      handler: paths.filesIndexPost
+    });
+    context.nitro.handlers.push({
+      route: `${baseRemote}:repo/refs/heads/:branch`,
+      handler: paths.refsHeadsBranchIndexPatch,
+      method: "PATCH"
+    });
+    context.nitro.handlers.push({
+      route: "/api/draft",
+      handler: paths.draft
+    });
+    context.nitro.handlers.push({
+      route: "/cms/_/meta.json",
+      handler: paths.meta
+    });
+    context.prerenderRoutes?.add("/cms/_/meta.json");
+    if (!options.playground) {
+      context.nitro.handlers.push({
+        route: "/cms/v3",
+        handler: resolvePath(context.projectRoot, "modules/cms/server/api/admin")
+      });
+      context.nitro.handlers.push({
+        route: "/cms/v3/**",
+        handler: resolvePath(context.projectRoot, "modules/cms/server/api/admin")
+      });
+      context.nitro.publicAssets = context.nitro.publicAssets || [];
+      context.nitro.publicAssets.push({
+        dir: resolvePackagePath("cms/dist/assets"),
+        baseURL: "/cms/v3/assets",
+        maxAge: 60 * 60 * 24 * 365
+      });
+      context.vite.plugins = context.vite.plugins || [];
+      context.vite.plugins.push({
+        name: "cms-serve-assets",
+        configureServer(server) {
+          server.middlewares.use("/cms/v3/assets", (req, res, next) => {
+            const url = req.url.split("?")[0];
+            const file = resolvePackagePath("cms/dist/assets", url.slice(1));
+            if (fs.existsSync(file)) {
+              const content = fs.readFileSync(file);
+              if (file.endsWith(".js"))
+                res.setHeader("Content-Type", "application/javascript");
+              if (file.endsWith(".css"))
+                res.setHeader("Content-Type", "text/css");
+              res.end(content);
+              return;
+            }
+            next();
+          });
+        }
+      });
+    }
+    for (const locale of locales) {
+      consola.log("[cms] locale", locale);
+      const configRoute = `/cms/_/configs/${locale}.json`;
+      context.nitro.handlers.push({
+        method: "GET",
+        route: configRoute,
+        handler: paths.config
+      });
+      context.prerenderRoutes?.add(configRoute);
+    }
+    context.nitro.imports = context.nitro.imports || { imports: [] };
+    context.nitro.imports.imports?.push({
+      name: "defineCmsItems",
+      from: resolvePackageFile("modules/cms/server/lib/composables.ts", "modules/cms/server/lib/composables.mjs", "modules/cms/server/lib/composables.js")
+    });
+    context.nitro.imports.imports?.push({
+      name: "defineCmsPage",
+      from: resolvePackageFile("modules/cms/server/lib/composables.ts", "modules/cms/server/lib/composables.mjs", "modules/cms/server/lib/composables.js")
+    });
+    context.nitro.imports.imports?.push({
+      name: "defineCmsPages",
+      from: resolvePackageFile("modules/cms/server/lib/composables.ts", "modules/cms/server/lib/composables.mjs", "modules/cms/server/lib/composables.js")
+    });
+    context.nitro.imports.imports?.push({
+      name: "defineCmsPosts",
+      from: resolvePackageFile("modules/cms/server/lib/composables.ts", "modules/cms/server/lib/composables.mjs", "modules/cms/server/lib/composables.js")
+    });
+    context.nitro.imports.imports?.push({
+      name: "defineCmsSettings",
+      from: resolvePackageFile("modules/cms/server/lib/composables.ts", "modules/cms/server/lib/composables.mjs", "modules/cms/server/lib/composables.js")
+    });
+  }
+});

package/modules/cms/server/api/admin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/cms/server/api/admin.mjs

@@ -0,0 +1,18 @@
+import { defineEventHandler, setResponseHeader } from "nitro/h3";
+const adminHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CMS</title>
+    <script type="module" crossorigin src="/cms/v3/assets/index-1Es5a0_Z.js"><\/script>
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>
+`;
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Content-Type", "text/html;charset=utf-8");
+  return adminHtml;
+});

package/modules/cms/server/api/config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/modules/cms/server/api/config.mjs

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import { resolve } from "node:path";
+import process from "node:process";
+import { consola } from "consola";
+import defu from "defu";
+import { createJiti } from "jiti";
+import { defineEventHandler } from "nitro/h3";
+import { getUrl } from "../../../../server/lib/pages.mjs";
+import { defineCmsItems, defineCmsPage, defineCmsPages, defineCmsPosts, defineCmsSettings } from "../lib/composables.mjs";
+import { collections, defineCms } from "../lib/helpers.mjs";
+import { widgets } from "../lib/widgets.mjs";
+export default defineEventHandler(async (event) => {
+  if (!globalThis.defineCmsItems) {
+    globalThis.defineCmsItems = defineCmsItems;
+  }
+  if (!globalThis.defineCmsPage) {
+    globalThis.defineCmsPage = defineCmsPage;
+  }
+  if (!globalThis.defineCmsPages) {
+    globalThis.defineCmsPages = defineCmsPages;
+  }
+  if (!globalThis.defineCmsPosts) {
+    globalThis.defineCmsPosts = defineCmsPosts;
+  }
+  if (!globalThis.defineCmsSettings) {
+    globalThis.defineCmsSettings = defineCmsSettings;
+  }
+  const urlParts = event.path?.split("?")[0].split("/") || [];
+  const locale = (urlParts.pop() || "es").replace(".json", "");
+  const options = {};
+  const defaultOptions = {
+    config: {
+      // public_folder: '/media',
+      locale
+    },
+    base: "/"
+  };
+  const { config, base } = defu(options, defaultOptions);
+  const projectRoot = process.cwd();
+  const cmsDir = resolve(projectRoot, "cms");
+  const loadedCollections = [];
+  try {
+    if (fs.existsSync(cmsDir)) {
+      const jiti = createJiti(resolve(projectRoot, "cms", "dummy.ts"), { interopDefault: true, fsCache: false, requireCache: false });
+      const walkSync = (dir, filelist = []) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          const filepath = resolve(dir, file);
+          const stat = fs.statSync(filepath);
+          if (stat.isDirectory()) {
+            filelist = walkSync(filepath, filelist);
+          } else if (file.endsWith(".ts")) {
+            filelist.push(filepath);
+          }
+        }
+        return filelist;
+      };
+      const cmsFiles = walkSync(cmsDir);
+      for (const filePath of cmsFiles) {
+        const mod = jiti(filePath);
+        const colFn = mod.default || mod;
+        if (typeof colFn === "function") {
+          loadedCollections.push(colFn);
+        }
+      }
+    }
+  } catch (e) {
+    consola.error("[CMS CONFIG] Error loading collections dynamically:", e);
+  }
+  const resolvedCollections = loadedCollections.map((c) => c({ widgets, collections }));
+  const manifest = defineCms(config, resolvedCollections)(`${base}content/${locale}/`, { rootDir: base });
+  if (manifest.collections) {
+    for (const col of manifest.collections) {
+      console.log("pageeee.............", col);
+      if (col.preview?.pageName) {
+        const pageName = col.preview?.pageName;
+        try {
+          const url = await getUrl(pageName, locale);
+          col.prefix.url = url;
+        } catch (e) {
+          consola.error("[CMS CONFIG] Error resolving url for injectContext:", e);
+        }
+      }
+      delete col.injectContext;
+    }
+  }
+  return manifest;
+});

package/modules/cms/server/api/localFs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;