nuxt-ai-ready 2.1.0 → 2.2.0

package/dist/runtime/server/db/queries.js

@@ -1,18 +1,41 @@
+import { randomUUID } from "uncrypto";
 import { getRequestURL } from "#nuxtseo/h3";
 import { useEvent, useRuntimeConfig } from "#nuxtseo/nitro";
-import { resolveLocaleFromRoute } from "../utils/i18n.js";
+import { createUniversalContext } from "../utils/context.js";
+import { hostMatchesLocaleDomain, resolveLocaleFromRoute } from "../utils/i18n.js";
 import { parseSitemapCrawlState, serializeSitemapCrawlState } from "../utils/sitemap-crawl-state.js";
 import { initSchema } from "./drizzle/queries.js";
 import { useRawDb } from "./drizzle/raw.js";
-import { normalizeRoute, normalizeRouteKey } from "./shared.js";
-function deriveLocale(event, route, explicit) {
+import { LIKE_ESCAPE, likeSubstring, maxRowsPerInsert, normalizeRoute, normalizeRouteKey } from "./shared.js";
+function hostFromUrl(url) {
+  if (!url)
+    return void 0;
+  try {
+    return new URL(url).host || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deriveLocale(event, route, explicit, pageUrl) {
   if (explicit !== void 0)
     return explicit;
   const cfg = useRuntimeConfig(event);
   const i18n = cfg["nuxt-ai-ready"]?.i18n;
   if (!i18n)
     return "";
-  return resolveLocaleFromRoute(route, i18n, event ? { host: getRequestURL(event).host } : void 0).locale;
+  const entryHost = hostFromUrl(pageUrl);
+  if (entryHost)
+    return resolveLocaleFromRoute(route, i18n, { host: entryHost }).locale;
+  let requestHost;
+  if (event) {
+    try {
+      requestHost = getRequestURL(event).host;
+    } catch {
+      requestHost = void 0;
+    }
+  }
+  const host = requestHost && hostMatchesLocaleDomain(requestHost, i18n) ? requestHost : hostFromUrl(createUniversalContext(event).siteUrl);
+  return resolveLocaleFromRoute(route, i18n, host ? { host } : void 0).locale;
 }
 function getEventFromContext(providedEvent) {
   if (providedEvent)
@@ -208,7 +231,7 @@ export async function queryPages(event, options = {}) {
     return includeMarkdown ? rowToData(row) : rowToEntry(row);
   }
   const { sql: whereClause, params } = buildWhereClause(where);
-  let sql = `SELECT ${cols} FROM ai_ready_pages ${whereClause}`;
+  let sql = `SELECT ${cols} FROM ai_ready_pages ${whereClause} ORDER BY route`;
   if (limit) {
     sql += ` LIMIT ?`;
     params.push(limit);
@@ -264,15 +287,15 @@ export async function searchPages(event, query, options = {}) {
   if (!sanitized)
     return [];
   if (db.dialect === "postgres") {
-    const searchTerm = `%${sanitized}%`;
+    const searchTerm = likeSubstring(sanitized);
     return db.all(`
       SELECT route, title, description, 0 AS score
       FROM ai_ready_pages
       WHERE is_error = 0
-        AND (title ILIKE ? OR description ILIKE ? OR markdown ILIKE ? OR headings ILIKE ?)
+        AND (title ILIKE ? ESCAPE ? OR description ILIKE ? ESCAPE ? OR markdown ILIKE ? ESCAPE ? OR headings ILIKE ? ESCAPE ?)
       ORDER BY route
       LIMIT ?
-    `, [searchTerm, searchTerm, searchTerm, searchTerm, limit]);
+    `, [searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, searchTerm, LIKE_ESCAPE, limit]);
   }
   const terms = sanitized.split(RE_WHITESPACE).map((t) => `${t}*`).join(" ");
   return db.all(`
@@ -295,9 +318,10 @@ export async function upsertPage(event, page) {
   const source = page.source || "runtime";
   const lastSeenAt = source === "runtime" ? indexedAt : null;
   const locale = deriveLocale(event, route, page.locale);
+  const localeTrusted = page.locale !== void 0;
   await db.exec(`
     INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, content_hash, updated_at, indexed_at, is_error, indexed, source, last_seen_at, locale)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(route) DO UPDATE SET
       title = excluded.title,
       description = excluded.description,
@@ -308,11 +332,11 @@ export async function upsertPage(event, page) {
       updated_at = excluded.updated_at,
       indexed_at = excluded.indexed_at,
       is_error = excluded.is_error,
-      indexed = 1,
+      indexed = excluded.indexed,
       source = excluded.source,
-      last_seen_at = excluded.last_seen_at,
-      locale = excluded.locale
-  `, [route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.contentHash || null, page.updatedAt, indexedAt, page.isError ? 1 : 0, source, lastSeenAt, locale]);
+      last_seen_at = excluded.last_seen_at${localeTrusted ? `,
+      locale = excluded.locale` : ""}
+  `, [route, routeKey, page.title, page.description, page.markdown, page.headings, keywordsJson, page.contentHash || null, page.updatedAt, indexedAt, page.isError ? 1 : 0, page.isError ? 0 : 1, source, lastSeenAt, locale]);
 }
 export async function isPageFresh(event, route, ttlSeconds) {
   if (ttlSeconds <= 0)
@@ -359,22 +383,27 @@ export async function seedRoutes(event, routes) {
   for (const entry of routes) {
     const route = normalizeRoute(typeof entry === "string" ? entry : entry.route);
     const explicitLocale = typeof entry === "string" ? void 0 : entry.locale;
+    const entryUrl = typeof entry === "string" ? void 0 : entry.url;
     byRoute.set(route, {
       route,
       routeKey: normalizeRouteKey(route),
-      locale: deriveLocale(event, route, explicitLocale)
+      locale: deriveLocale(event, route, explicitLocale, entryUrl)
     });
   }
-  const ROWS_PER_INSERT = 20;
+  const rowsPerInsert = maxRowsPerInsert(5);
   const stmts = [];
-  for (const batch of chunk([...byRoute.values()], ROWS_PER_INSERT)) {
+  for (const batch of chunk([...byRoute.values()], rowsPerInsert)) {
     const valuesSql = batch.map(() => `(?, ?, '', '', '', '[]', '[]', ?, 0, 0, 0, 'runtime', ?, ?)`).join(", ");
     const params = batch.flatMap((r) => [r.route, r.routeKey, now, nowMs, r.locale]);
     stmts.push({
       sql: `
         INSERT INTO ai_ready_pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error, indexed, source, last_seen_at, locale)
         VALUES ${valuesSql}
-        ON CONFLICT(route) DO UPDATE SET last_seen_at = excluded.last_seen_at, locale = excluded.locale
+        ON CONFLICT(route) DO UPDATE SET
+          last_seen_at = excluded.last_seen_at,
+          locale = excluded.locale,
+          is_error = 0,
+          indexed = CASE WHEN ai_ready_pages.is_error = 1 THEN 0 ELSE ai_ready_pages.indexed END
       `,
       params
     });
@@ -382,22 +411,6 @@ export async function seedRoutes(event, routes) {
   await db.batch(stmts);
   return byRoute.size;
 }
-export async function getSitemapSeededAt(event) {
-  const db = await getDb(event);
-  if (!db)
-    return void 0;
-  const row = await db.first("SELECT value FROM _ai_ready_info WHERE id = ?", ["sitemap_seeded_at"]);
-  return row ? Number.parseInt(row.value, 10) : void 0;
-}
-export async function setSitemapSeededAt(event, timestamp) {
-  const db = await getDb(event);
-  if (!db)
-    return;
-  await db.exec(`
-    INSERT INTO _ai_ready_info (id, value) VALUES (?, ?)
-    ON CONFLICT(id) DO UPDATE SET value = excluded.value
-  `, ["sitemap_seeded_at", String(timestamp)]);
-}
 export async function pruneStaleRoutes(event, staleThresholdSeconds, protectedSince) {
   const db = await getDb(event);
   if (!db)
@@ -477,22 +490,6 @@ export async function getRecentCronRuns(event, limit = 10) {
   );
   return rows.map(rowToCronRun);
 }
-export async function cleanupOldCronRuns(event, keepCount = 50) {
-  const db = await getDb(event);
-  if (!db)
-    return 0;
-  const countRow = await db.first("SELECT COUNT(*) as count FROM ai_ready_cron_runs");
-  const total = toNumber(countRow?.count);
-  if (total <= keepCount)
-    return 0;
-  const deleteCount = total - keepCount;
-  await db.exec(`
-    DELETE FROM ai_ready_cron_runs WHERE id IN (
-      SELECT id FROM ai_ready_cron_runs ORDER BY started_at ASC LIMIT ?
-    )
-  `, [deleteCount]);
-  return deleteCount;
-}
 export async function pruneCronRunsByAge(event, maxAgeMs = 24 * 60 * 60 * 1e3) {
   const db = await getDb(event);
   if (!db)
@@ -532,25 +529,50 @@ export async function getCronFastPathStatus(event, sitemapIntervalMinutes = 5) {
   };
 }
 const CRON_LOCK_TTL_MS = 3e5;
+function cronLockField(db, column, key) {
+  if (db.dialect !== "postgres")
+    return `json_extract(${column}, '$.${key}')`;
+  const jsonb = `${column}::jsonb`;
+  return `CASE WHEN jsonb_typeof(${jsonb}) = 'object' THEN (${jsonb} ->> '${key}') END`;
+}
 export async function tryAcquireCronLock(event) {
+  const token = randomUUID();
   const db = await getDb(event);
   if (!db)
-    return true;
+    return { _tag: "acquired", token };
   const now = Date.now();
-  const staleThreshold = now - CRON_LOCK_TTL_MS;
-  await db.exec(`
-    INSERT INTO _ai_ready_info (id, value) VALUES ('cron_lock', ?)
-    ON CONFLICT(id) DO UPDATE SET value = ?
-    WHERE CAST(_ai_ready_info.value AS BIGINT) < ?
-  `, [String(now), String(now), staleThreshold]);
-  const row = await db.first("SELECT value FROM _ai_ready_info WHERE id = ?", ["cron_lock"]);
-  return row?.value === String(now);
-}
-export async function releaseCronLock(event) {
+  const value = JSON.stringify({ t: token, a: now, e: now + CRON_LOCK_TTL_MS });
+  try {
+    await db.exec(`
+      INSERT INTO _ai_ready_info (id, value) VALUES ('cron_lock', ?)
+      ON CONFLICT(id) DO UPDATE SET value = excluded.value
+      WHERE CAST(coalesce(${cronLockField(db, "_ai_ready_info.value", "e")}, '0') AS BIGINT) < ?
+    `, [value, now]);
+    const row = await db.first(
+      `SELECT value FROM _ai_ready_info WHERE id = 'cron_lock' AND ${cronLockField(db, "value", "t")} = ?`,
+      [token]
+    );
+    return row ? { _tag: "acquired", token } : { _tag: "held" };
+  } catch (error) {
+    await releaseCronLock(event, token).catch(() => {
+    });
+    throw error;
+  }
+}
+export async function releaseCronLock(event, token) {
   const db = await getDb(event);
   if (!db)
     return;
-  await db.exec("DELETE FROM _ai_ready_info WHERE id = ?", ["cron_lock"]);
+  await db.exec(`DELETE FROM _ai_ready_info WHERE id = 'cron_lock' AND ${cronLockField(db, "value", "t")} = ?`, [token]);
+}
+const RE_CRON_LOCK_NUMERIC = /^\d+$/;
+function parseCronLockValue(value) {
+  if (RE_CRON_LOCK_NUMERIC.test(value))
+    return { acquiredAt: Number(value), expiresAt: Number(value) + CRON_LOCK_TTL_MS };
+  const parsed = safeJsonParse(value, null);
+  if (parsed && typeof parsed === "object" && typeof parsed.a === "number" && typeof parsed.e === "number")
+    return { acquiredAt: parsed.a, expiresAt: parsed.e };
+  return null;
 }
 export async function getCronLockStatus(event) {
   const db = await getDb(event);
@@ -562,14 +584,15 @@ export async function getCronLockStatus(event) {
   );
   if (!row)
     return { held: false, since: null, elapsedMs: null, stale: false };
-  const lockTime = Number.parseInt(row.value, 10);
+  const record = parseCronLockValue(row.value);
+  if (!record)
+    return { held: false, since: null, elapsedMs: null, stale: false };
   const now = Date.now();
-  const elapsed = now - lockTime;
-  const stale = elapsed >= CRON_LOCK_TTL_MS;
+  const stale = now >= record.expiresAt;
   return {
     held: !stale,
-    since: lockTime,
-    elapsedMs: elapsed,
+    since: record.acquiredAt,
+    elapsedMs: now - record.acquiredAt,
     stale
   };
 }

package/dist/runtime/server/db/shared.d.ts

@@ -44,6 +44,22 @@ export declare function initSchema(db: DatabaseAdapter, options?: InitSchemaOpti
  * one row. Widening it would let both spellings persist and race for the key.
  */
 export declare function normalizeRoute(route: string): string;
+/**
+ * Escape LIKE/ILIKE wildcard characters in a search term so the term matches
+ * literal text. Pair with an `ESCAPE` clause (see `LIKE_ESCAPE`): SQLite has no
+ * default escape character, so without the clause the escaping is inert.
+ */
+export declare function escapeLikeTerm(term: string): string;
+/** Substring LIKE/ILIKE pattern for a term, with wildcards escaped. */
+export declare function likeSubstring(term: string): string;
+/** Escape character to bind next to `likeSubstring` patterns. */
+export declare const LIKE_ESCAPE = "\\";
+/**
+ * Multi-row INSERT chunk size that keeps one statement within the 100-bind
+ * cap shared by SQLite and D1, derived from the row's bind count so an added
+ * column resizes the chunk instead of breaking the insert.
+ */
+export declare function maxRowsPerInsert(paramsPerRow: number): number;
 /**
  * Normalize route to storage key format
  * e.g., '/about/team' -> 'about:team', '/' -> 'index'

package/dist/runtime/server/db/shared.js

@@ -57,6 +57,18 @@ export function normalizeRoute(route) {
     return "/";
   return route.startsWith("/") ? route : `/${route}`;
 }
+const RE_LIKE_META = /[\\%_]/g;
+export function escapeLikeTerm(term) {
+  return term.replace(RE_LIKE_META, (ch) => `\\${ch}`);
+}
+export function likeSubstring(term) {
+  return `%${escapeLikeTerm(term)}%`;
+}
+export const LIKE_ESCAPE = "\\";
+const MAX_BIND_PARAMS_PER_STATEMENT = 100;
+export function maxRowsPerInsert(paramsPerRow) {
+  return Math.max(1, Math.floor(MAX_BIND_PARAMS_PER_STATEMENT / paramsPerRow));
+}
 export function normalizeRouteKey(route) {
   return normalizeRoute(route).replace(RE_LEADING_SLASH, "").replace(RE_SLASH, ":") || "index";
 }

package/dist/runtime/server/middleware/markdown.js

@@ -1,10 +1,11 @@
 import { createError, defineEventHandler, setHeader, setResponseStatus } from "#nuxtseo/h3";
-import { useNitroApp } from "#nuxtseo/nitro";
+import { useNitroApp, useRuntimeConfig } from "#nuxtseo/nitro";
 import { resolveLocaleAlternateUrl } from "../../i18n-url.js";
 import { logger } from "../logger.js";
 import { computeLocaleAlternates, resolveLocaleFromRoute } from "../utils/i18n.js";
 import { INTERNAL_HEADER } from "../utils/negotiation-decision.js";
 import { applyNegotiation, buildNegotiationContext, decideNegotiation, ensureSiteConfig, setMarkdownHeaders } from "../utils/negotiation-response.js";
+import { appendSitemapSection, isSitemapMdRequest, SITEMAP_MD_ROUTE } from "../utils/sitemap-md.js";
 function notFoundMarkdown(ctx, canonicalUrl, build) {
   const { path, config, resolveUrl, routeContext } = ctx;
   const body = [
@@ -37,6 +38,9 @@ function notFoundMarkdown(ctx, canonicalUrl, build) {
 ${body}`;
 }
 export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event);
+  if (isSitemapMdRequest(event.path, runtimeConfig.app.baseURL, runtimeConfig["nuxt-ai-ready"]?.sitemapMd !== false))
+    return;
   const decision = decideNegotiation(event, "middleware");
   const negotiationResponse = await applyNegotiation(event, decision);
   if (decision._tag !== "render")
@@ -45,6 +49,7 @@ export default defineEventHandler(async (event) => {
   const ctx = buildNegotiationContext(event, decision.path);
   const { path, config, resolvePath, resolveUrl, routeContext } = ctx;
   const canonicalUrl = resolveUrl(path);
+  const finalizeMarkdown = (markdown) => config.sitemapMd === false ? markdown : appendSitemapSection(markdown, resolvePath(SITEMAP_MD_ROUTE));
   const [
     { tryGetContentMarkdown },
     { fetchRawWithEvent },
@@ -65,7 +70,7 @@ export default defineEventHandler(async (event) => {
       last_updated: updatedAt || (/* @__PURE__ */ new Date()).toISOString()
     }, markdown);
     setMarkdownHeaders(event, ctx);
-    return responseMarkdown;
+    return finalizeMarkdown(responseMarkdown);
   }
   const contentPage = await tryGetContentMarkdown(event, path).catch((e) => {
     logger.debug(`[markdown] Content lookup failed for ${path}`, e);
@@ -80,8 +85,8 @@ export default defineEventHandler(async (event) => {
       last_updated: contentPage.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
     });
     setMarkdownHeaders(event, ctx);
-    return `${frontmatter}
-${contentPage.markdown}`;
+    return finalizeMarkdown(`${frontmatter}
+${contentPage.markdown}`);
   }
   logger.debug(`[markdown] Fetching HTML for ${path}`);
   const response = await fetchRawWithEvent(event, resolvePath(path), {
@@ -152,5 +157,5 @@ ${contentPage.markdown}`;
     }
   );
   setMarkdownHeaders(event, ctx);
-  return result.markdown;
+  return finalizeMarkdown(result.markdown);
 });

package/dist/runtime/server/middleware/markdown.prerender.js

@@ -10,6 +10,7 @@ import { buildFrontmatter } from "../utils/frontmatter.js";
 import { extractKeywords } from "../utils/keywords.js";
 import { getMarkdownRenderInfo } from "../utils/markdown-request.js";
 import { consumePrerenderedHtml } from "../utils/prerender-html.js";
+import { isSitemapMdRequest } from "../utils/sitemap-md.js";
 function extractHeadingsFromMarkdown(markdown) {
   const headings = [];
   for (const m of markdown.matchAll(/^(#{1,6}) ([^\n]+)$/gm)) {
@@ -27,11 +28,13 @@ export default defineEventHandler(async (event) => {
   if (!import.meta.prerender) {
     return;
   }
+  const fullRuntimeConfig = useRuntimeConfig(event);
+  if (isSitemapMdRequest(event.path, fullRuntimeConfig.app.baseURL, fullRuntimeConfig["nuxt-ai-ready"]?.sitemapMd !== false))
+    return;
   const renderInfo = getMarkdownRenderInfo(event, { _tag: "prerender" });
   if (!renderInfo || "notAcceptable" in renderInfo)
     return;
   const { path } = renderInfo;
-  const fullRuntimeConfig = useRuntimeConfig(event);
   const runtimeConfig = fullRuntimeConfig["nuxt-ai-ready"];
   const deployedPath = toDeployedRoute(path, fullRuntimeConfig.app.baseURL);
   const canonicalUrl = withSiteUrl(event, deployedPath);

package/dist/runtime/server/plugins/sitemap-seeder.js

@@ -13,6 +13,7 @@ function recordDiagnostic(event, message) {
   list.push(message);
 }
 const SEED_INTERVAL_MS = 5 * 60 * 1e3;
+const lastSeedAt = /* @__PURE__ */ new Map();
 const READ_TIMEOUT_MS = 3e3;
 const SLOW_READ_WARN_MS = 1e3;
 const SLOW_SEED_WARN_MS = 1e4;
@@ -87,9 +88,11 @@ export default function sitemapSeederPlugin(nitroApp) {
       logger.warn(`[sitemap-seeder] ${message} for ${sitemapName}`);
       record?.(message);
     }
-    if (lastCrawled && Date.now() - lastCrawled < SEED_INTERVAL_MS)
+    const lastSeed = Math.max(lastCrawled ?? 0, lastSeedAt.get(sitemapName) ?? 0);
+    if (Date.now() - lastSeed < SEED_INTERVAL_MS)
       return;
-    const routes = [...routeToUrl.keys()];
+    lastSeedAt.set(sitemapName, Date.now());
+    const routes = [...routeToUrl.entries()].map(([route, url]) => ({ route, url: url.loc }));
     const urlCount = urls.length;
     const seed = async () => {
       const seedStart = Date.now();

package/dist/runtime/server/routes/__ai-ready/cron.get.js

@@ -1,7 +1,15 @@
-import { eventHandler } from "#nuxtseo/h3";
+import { createError, eventHandler } from "#nuxtseo/h3";
 import { runCron } from "../../utils/runCron.js";
 export default eventHandler(async (event) => {
   const { requireAuth } = await import("../../utils/auth.js");
   requireAuth(event);
-  return runCron(event);
+  const result = await runCron(event);
+  if (result.failed) {
+    throw createError({
+      statusCode: 500,
+      message: `Cron run failed at the ${result.failed.stage} stage: ${result.failed.message}`,
+      data: result.failed
+    });
+  }
+  return result;
 });

package/dist/runtime/server/routes/__ai-ready/poll.post.js

@@ -1,21 +1,37 @@
-import { eventHandler, getQuery } from "#nuxtseo/h3";
+import { eventHandler, getQuery, setResponseStatus } from "#nuxtseo/h3";
+import { useRuntimeConfig } from "#nuxtseo/nitro";
+import { releaseCronLock, tryAcquireCronLock } from "../../db/queries.js";
+import { logger } from "../../logger.js";
 import { batchIndexPages } from "../../utils/batchIndex.js";
 export default eventHandler(async (event) => {
   const { requireAuth } = await import("../../utils/auth.js");
   requireAuth(event);
+  const lock = await tryAcquireCronLock(event);
+  if (lock._tag === "held") {
+    setResponseStatus(event, 409);
+    return { locked: true };
+  }
   const query = getQuery(event);
-  const limit = query.limit ? Math.max(1, Math.min(50, Math.trunc(Number(query.limit)) || 10)) : void 0;
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const defaultLimit = Math.max(1, Math.trunc(Math.min(config.runtimeSync?.batchSize ?? 10, 50))) || 10;
+  const limit = query.limit ? Math.max(1, Math.min(50, Math.trunc(Number(query.limit)) || defaultLimit)) : defaultLimit;
   const timeout = query.timeout ? Math.max(1e3, Math.trunc(Number(query.timeout)) || 3e4) : void 0;
-  const result = await batchIndexPages(event, {
-    limit,
-    all: query.all === "true" || query.all === "1",
-    timeout
-  });
-  return {
-    indexed: result.indexed,
-    remaining: result.remaining,
-    errors: result.errors.length > 0 ? result.errors : void 0,
-    duration: result.duration,
-    complete: result.complete
-  };
+  try {
+    const result = await batchIndexPages(event, {
+      limit,
+      all: query.all === "true" || query.all === "1",
+      timeout
+    });
+    return {
+      indexed: result.indexed,
+      remaining: result.remaining,
+      errors: result.errors.length > 0 ? result.errors : void 0,
+      duration: result.duration,
+      complete: result.complete
+    };
+  } finally {
+    await releaseCronLock(event, lock.token).catch((err) => {
+      logger.warn(`[poll] Failed to release lock: ${err?.message || err}`);
+    });
+  }
 });

package/dist/runtime/server/routes/__ai-ready/reindex.post.d.ts

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

package/dist/runtime/server/routes/__ai-ready/reindex.post.js

@@ -0,0 +1,23 @@
+import { createError, eventHandler, getQuery, setResponseStatus } from "#nuxtseo/h3";
+import { indexPageByRoute } from "../../utils/indexPage.js";
+export default eventHandler(async (event) => {
+  const { requireAuth } = await import("../../utils/auth.js");
+  requireAuth(event);
+  const query = getQuery(event);
+  const route = typeof query.route === "string" ? query.route.trim() : "";
+  if (!route.startsWith("/")) {
+    throw createError({ statusCode: 400, message: 'Invalid route. It must be an absolute path starting with "/", for example "/about".' });
+  }
+  const force = query.force !== "false" && query.force !== "0";
+  const result = await indexPageByRoute(route, event, { force });
+  if (!result.success) {
+    setResponseStatus(event, 502);
+    return { route, indexed: false, error: result.error ?? `Failed to index ${route}` };
+  }
+  return {
+    route,
+    indexed: !result.skipped,
+    skipped: result.skipped || void 0,
+    contentChanged: result.contentChanged
+  };
+});

package/dist/runtime/server/routes/api-catalog.js

@@ -1,10 +1,19 @@
-import { assertMethod, defineEventHandler, setHeader } from "#nuxtseo/h3";
+import { assertMethod, createError, defineEventHandler, setHeader, setHeaders, setResponseStatus } from "#nuxtseo/h3";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 export default defineEventHandler((event) => {
+  setHeader(event, "Access-Control-Allow-Origin", "*");
+  if (event.method === "OPTIONS") {
+    setHeaders(event, {
+      "Access-Control-Allow-Headers": "Content-Type, If-None-Match",
+      "Access-Control-Allow-Methods": "GET, HEAD"
+    });
+    setResponseStatus(event, 204);
+    return null;
+  }
   assertMethod(event, ["GET", "HEAD"]);
   const config = useRuntimeConfig(event)["nuxt-ai-ready"].apiCatalog;
   if (!config)
-    return;
+    throw createError({ statusCode: 404, message: "API catalog is not configured" });
   setHeader(event, "content-type", config.mediaType);
   setHeader(event, "link", `<${config.href}>; rel="api-catalog"`);
   if (event.method === "HEAD")

package/dist/runtime/server/routes/llms.txt.get.js

@@ -1,23 +1,28 @@
 import { eventHandler, setHeader } from "#nuxtseo/h3";
 import { defineCachedFunction, useRuntimeConfig } from "#nuxtseo/nitro";
 import { buildLlmsTxt } from "../../llms-txt-utils.js";
-const buildLlmsTxtCached = defineCachedFunction(
-  buildLlmsTxt,
-  {
-    name: "llms-txt",
-    group: "ai-ready",
-    maxAge: 60 * 10,
-    // 10 minutes
-    swr: true
+const cachedBuilders = /* @__PURE__ */ new Map();
+function getBuildLlmsTxtCached(maxAge) {
+  let cached = cachedBuilders.get(maxAge);
+  if (!cached) {
+    cached = defineCachedFunction(buildLlmsTxt, {
+      name: "llms-txt",
+      group: "ai-ready",
+      maxAge,
+      swr: true
+    });
+    cachedBuilders.set(maxAge, cached);
   }
-);
+  return cached;
+}
 export default eventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
-  const cacheEnabled = !import.meta.dev && runtimeConfig.llmsTxtCacheSeconds > 0;
-  const content = cacheEnabled ? await buildLlmsTxtCached(event) : await buildLlmsTxt(event);
+  const cacheSeconds = runtimeConfig.llmsTxtCacheSeconds;
+  const cacheEnabled = !import.meta.dev && cacheSeconds > 0;
+  const content = cacheEnabled ? await getBuildLlmsTxtCached(cacheSeconds)(event) : await buildLlmsTxt(event);
   setHeader(event, "Content-Type", "text/plain; charset=utf-8");
   if (cacheEnabled) {
-    setHeader(event, "Cache-Control", `public, max-age=${runtimeConfig.llmsTxtCacheSeconds}, s-maxage=${runtimeConfig.llmsTxtCacheSeconds}, stale-while-revalidate=3600`);
+    setHeader(event, "Cache-Control", `public, max-age=${cacheSeconds}, s-maxage=${cacheSeconds}, stale-while-revalidate=3600`);
   }
   return content;
 });

package/dist/runtime/server/routes/sitemap.md.get.d.ts

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

package/dist/runtime/server/routes/sitemap.md.get.js

@@ -0,0 +1,51 @@
+import { eventHandler, setHeader } from "#nuxtseo/h3";
+import { defineCachedFunction, useRuntimeConfig } from "#nuxtseo/nitro";
+import { getSiteConfig } from "#site-config/server/composables";
+import { toMarkdownPath } from "../../markdown-path.js";
+import { toDeployedRoute } from "../../route-path.js";
+import { queryPages } from "../db/queries.js";
+import { logger } from "../logger.js";
+import { buildSitemapMd } from "../utils/sitemap-md.js";
+async function buildSitemapMarkdown(event) {
+  let pages = [];
+  try {
+    pages = await queryPages(event);
+  } catch (err) {
+    logger.warn(
+      `[ai-ready] Database unavailable for sitemap.md, serving an empty sitemap: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const baseURL = useRuntimeConfig(event).app.baseURL;
+  return buildSitemapMd(
+    pages.map((page) => ({ route: page.route, title: page.title, updatedAt: page.updatedAt })),
+    {
+      siteName: getSiteConfig(event).name,
+      resolveHref: (route) => toDeployedRoute(toMarkdownPath(route), baseURL)
+    }
+  );
+}
+const cachedBuilders = /* @__PURE__ */ new Map();
+function getBuildSitemapMdCached(maxAge) {
+  let cached = cachedBuilders.get(maxAge);
+  if (!cached) {
+    cached = defineCachedFunction(buildSitemapMarkdown, {
+      name: "sitemap-md",
+      group: "ai-ready",
+      maxAge,
+      swr: true
+    });
+    cachedBuilders.set(maxAge, cached);
+  }
+  return cached;
+}
+export default eventHandler(async (event) => {
+  const fullRuntimeConfig = useRuntimeConfig(event);
+  const runtimeConfig = fullRuntimeConfig["nuxt-ai-ready"];
+  const cacheSeconds = runtimeConfig.llmsTxtCacheSeconds ?? 600;
+  const cacheEnabled = !import.meta.dev && cacheSeconds > 0;
+  setHeader(event, "Content-Type", "text/markdown; charset=utf-8");
+  if (cacheEnabled) {
+    setHeader(event, "Cache-Control", `public, max-age=${cacheSeconds}, s-maxage=${cacheSeconds}, stale-while-revalidate=3600`);
+  }
+  return cacheEnabled ? await getBuildSitemapMdCached(cacheSeconds)(event) : await buildSitemapMarkdown(event);
+});

package/dist/runtime/server/tasks/ai-ready-cron.js

@@ -1,4 +1,5 @@
 import { defineTask } from "#nuxtseo/nitro";
+import { logger } from "../logger.js";
 import { runCron } from "../utils/runCron.js";
 export default defineTask({
   meta: {
@@ -11,6 +12,8 @@ export default defineTask({
     const result = await runCron(void 0, {
       batchSize: payload?.limit
     });
+    if (result.failed)
+      logger.error(`[ai-ready:cron] Run failed at the ${result.failed.stage} stage: ${result.failed.message}`);
     return { result };
   }
 });

package/dist/runtime/server/utils/i18n.d.ts

@@ -5,3 +5,7 @@ export type { LocaleAlternate, LocaleAlternateResolution, LocalePages, RouteLoca
 export declare function getRuntimeI18n(aiReadyConfig: {
     i18n?: RuntimeI18nConfig | null;
 }): RuntimeI18nConfig | null;
+/** Normalize a host or URL into a comparable hostname (lowercase, no scheme, no path). */
+export declare function normalizeHost(value: string): string;
+/** True when the host equals a domain configured on any i18n locale. */
+export declare function hostMatchesLocaleDomain(host: string | undefined, i18n: RuntimeI18nConfig): boolean;