nuxt-ai-ready 0.7.0 → 0.7.2

package/dist/module.d.mts

@@ -43,14 +43,10 @@ interface ModulePublicRuntimeConfig {
         enabled: boolean;
         ttl: number;
         batchSize: number;
-        secret?: string;
         pruneTtl: number;
     };
-    indexNow?: {
-        enabled: boolean;
-        key?: string;
-        host?: string;
-    };
+    runtimeSyncSecret?: string;
+    indexNowKey?: string;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -541,16 +541,27 @@ const module$1 = defineNuxtModule({
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
-      const runtimeSyncEnabled2 = config.runtimeSync?.enabled ?? false;
-      const cron = config.runtimeSync?.cron;
-      if (runtimeSyncEnabled2 && cron) {
-        nitroConfig.tasks = nitroConfig.tasks || {};
-        nitroConfig.tasks["ai-ready:index"] = {
-          handler: resolve("./runtime/server/tasks/ai-ready-index")
-        };
-        nitroConfig.scheduledTasks = nitroConfig.scheduledTasks || {};
-        nitroConfig.scheduledTasks[cron] = nitroConfig.scheduledTasks[cron] || [];
-        nitroConfig.scheduledTasks[cron].push("ai-ready:index");
+      if (config.cron) {
+        const cronSchedule = "* * * * *";
+        const isVercel = nitroConfig.preset === "vercel" || nitroConfig.preset === "vercel-edge";
+        if (isVercel) {
+          nitroConfig.vercel = nitroConfig.vercel || {};
+          nitroConfig.vercel.config = nitroConfig.vercel.config || {};
+          nitroConfig.vercel.config.crons = nitroConfig.vercel.config.crons || [];
+          nitroConfig.vercel.config.crons.push({
+            schedule: cronSchedule,
+            path: "/__ai-ready/cron"
+          });
+        } else {
+          nitroConfig.experimental.tasks = true;
+          nitroConfig.tasks = nitroConfig.tasks || {};
+          nitroConfig.tasks["ai-ready:cron"] = {
+            handler: resolve("./runtime/server/tasks/ai-ready-cron")
+          };
+          nitroConfig.scheduledTasks = nitroConfig.scheduledTasks || {};
+          nitroConfig.scheduledTasks[cronSchedule] = nitroConfig.scheduledTasks[cronSchedule] || [];
+          nitroConfig.scheduledTasks[cronSchedule].push("ai-ready:cron");
+        }
       }
       nitroConfig.virtual = nitroConfig.virtual || {};
       nitroConfig.virtual["#ai-ready-virtual/read-page-data.mjs"] = `
@@ -592,9 +603,9 @@ export async function readPageDataFromFilesystem() {
 export const errorRoutes = []`;
     });
     const database = refineDatabaseConfig(config.database || {}, nuxt.options.rootDir);
-    const runtimeSyncEnabled = config.runtimeSync?.enabled ?? false;
-    const indexNowKey = config.indexNow?.key || process.env.NUXT_AI_READY_INDEXNOW_KEY;
-    const indexNowEnabled = !!(config.indexNow?.enabled !== false && indexNowKey);
+    const runtimeSyncConfig = typeof config.runtimeSync === "object" ? config.runtimeSync : {};
+    const runtimeSyncEnabled = !!config.runtimeSync || !!config.cron;
+    const indexNowKey = config.indexNowKey || process.env.NUXT_AI_READY_INDEX_NOW_KEY;
     nuxt.options.runtimeConfig["nuxt-ai-ready"] = {
       version: version || "0.0.0",
       debug: config.debug || false,
@@ -609,16 +620,12 @@ export const errorRoutes = []`;
       database,
       runtimeSync: {
         enabled: runtimeSyncEnabled,
-        ttl: config.runtimeSync?.ttl ?? 3600,
-        batchSize: config.runtimeSync?.batchSize ?? 20,
-        secret: config.runtimeSync?.secret,
-        pruneTtl: config.runtimeSync?.pruneTtl ?? 0
+        ttl: runtimeSyncConfig.ttl ?? 3600,
+        batchSize: runtimeSyncConfig.batchSize ?? 20,
+        pruneTtl: runtimeSyncConfig.pruneTtl ?? 0
       },
-      indexNow: indexNowEnabled ? {
-        enabled: true,
-        key: indexNowKey,
-        host: config.indexNow?.host || "api.indexnow.org"
-      } : void 0
+      runtimeSyncSecret: config.runtimeSyncSecret,
+      indexNowKey
     };
     nuxt.options.nitro.plugins = nuxt.options.nitro.plugins || [];
     nuxt.options.nitro.plugins.push(resolve("./runtime/server/plugins/db-restore"));
@@ -648,13 +655,16 @@ export const errorRoutes = []`;
       addServerHandler({ route: "/__ai-ready/poll", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/poll.post") });
       addServerHandler({ route: "/__ai-ready/prune", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/prune.post") });
     }
-    if (indexNowEnabled && indexNowKey) {
+    if (indexNowKey) {
       addServerHandler({ route: `/${indexNowKey}.txt`, handler: resolve("./runtime/server/routes/indexnow-key.get") });
       addServerHandler({ route: "/__ai-ready/indexnow", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/indexnow.post") });
       if (!runtimeSyncEnabled) {
         addServerHandler({ route: "/__ai-ready/status", handler: resolve("./runtime/server/routes/__ai-ready/status.get") });
       }
     }
+    if (config.cron) {
+      addServerHandler({ route: "/__ai-ready/cron", handler: resolve("./runtime/server/routes/__ai-ready/cron.get") });
+    }
     const isStatic = nuxt.options.nitro.static || nuxt.options._generate || false;
     const hasPrerenderedRoutes = nuxt.options.nitro.prerender?.routes?.length;
     const isSPA = nuxt.options.ssr === false;

package/dist/runtime/mcp.d.ts

@@ -0,0 +1,25 @@
+export declare const tools: readonly [import("@nuxtjs/mcp-toolkit").McpToolDefinition<Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>, Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>>, import("@nuxtjs/mcp-toolkit").McpToolDefinition<Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>, Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>>];
+export declare const resources: readonly [{
+    uri: string;
+    name: string;
+    description: string;
+    metadata: {
+        mimeType: string;
+    };
+    cache: "1h";
+    handler(uri: URL): Promise<{
+        contents: {
+            uri: string;
+            mimeType: string;
+            text: string;
+        }[];
+    }>;
+}];

package/dist/runtime/mcp.js

@@ -0,0 +1,5 @@
+import pages from "./server/mcp/resources/pages.js";
+import listPages from "./server/mcp/tools/list-pages.js";
+import searchPages from "./server/mcp/tools/search-pages.js";
+export const tools = [listPages, searchPages];
+export const resources = [pages];

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

@@ -162,3 +162,49 @@ export interface IndexNowStats {
  * Get IndexNow stats
  */
 export declare function getIndexNowStats(event: H3Event | undefined): Promise<IndexNowStats>;
+export interface CronRunRow {
+    id: number;
+    started_at: number;
+    finished_at: number | null;
+    duration_ms: number | null;
+    pages_indexed: number;
+    pages_remaining: number;
+    indexnow_submitted: number;
+    indexnow_remaining: number;
+    errors: string;
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+export interface CronRun {
+    id: number;
+    startedAt: number;
+    finishedAt: number | null;
+    durationMs: number | null;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+/**
+ * Start a cron run and return its ID
+ */
+export declare function startCronRun(event: H3Event | undefined): Promise<number | null>;
+/**
+ * Complete a cron run with results
+ */
+export declare function completeCronRun(event: H3Event | undefined, runId: number, result: {
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}): Promise<void>;
+/**
+ * Get recent cron runs
+ */
+export declare function getRecentCronRuns(event: H3Event | undefined, limit?: number): Promise<CronRun[]>;
+/**
+ * Clean up old cron runs (keep last N)
+ */
+export declare function cleanupOldCronRuns(event: H3Event | undefined, keepCount?: number): Promise<number>;

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

@@ -374,3 +374,76 @@ export async function getIndexNowStats(event) {
     lastError: stats.indexnow_last_error || null
   };
 }
+function rowToCronRun(row) {
+  return {
+    id: row.id,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    durationMs: row.duration_ms,
+    pagesIndexed: row.pages_indexed,
+    pagesRemaining: row.pages_remaining,
+    indexNowSubmitted: row.indexnow_submitted,
+    indexNowRemaining: row.indexnow_remaining,
+    errors: JSON.parse(row.errors || "[]"),
+    status: row.status
+  };
+}
+export async function startCronRun(event) {
+  const db = await getDb(event);
+  if (!db)
+    return null;
+  const now = Date.now();
+  await db.exec(
+    "INSERT INTO ai_ready_cron_runs (started_at, status) VALUES (?, ?)",
+    [now, "running"]
+  );
+  const row = await db.first("SELECT last_insert_rowid() as id");
+  return row?.id || null;
+}
+export async function completeCronRun(event, runId, result) {
+  const db = await getDb(event);
+  if (!db)
+    return;
+  const now = Date.now();
+  const row = await db.first("SELECT started_at FROM ai_ready_cron_runs WHERE id = ?", [runId]);
+  const durationMs = row ? now - row.started_at : null;
+  const status = result.errors.length > 0 ? result.pagesIndexed > 0 ? "partial" : "error" : "success";
+  await db.exec(`
+    UPDATE ai_ready_cron_runs SET
+      finished_at = ?,
+      duration_ms = ?,
+      pages_indexed = ?,
+      pages_remaining = ?,
+      indexnow_submitted = ?,
+      indexnow_remaining = ?,
+      errors = ?,
+      status = ?
+    WHERE id = ?
+  `, [now, durationMs, result.pagesIndexed, result.pagesRemaining, result.indexNowSubmitted, result.indexNowRemaining, JSON.stringify(result.errors), status, runId]);
+}
+export async function getRecentCronRuns(event, limit = 10) {
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  const rows = await db.all(
+    "SELECT * FROM ai_ready_cron_runs ORDER BY started_at DESC LIMIT ?",
+    [limit]
+  );
+  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 = countRow?.count || 0;
+  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;
+}

package/dist/runtime/server/db/schema-sql.d.ts

@@ -1,3 +1,3 @@
-export declare const SCHEMA_VERSION = "v1.6.0";
+export declare const SCHEMA_VERSION = "v1.7.0";
 export declare const DROP_TABLES_SQL: string[];
 export declare const ALL_SCHEMA_SQL: string[];

package/dist/runtime/server/db/schema-sql.js

@@ -1,4 +1,4 @@
-export const SCHEMA_VERSION = "v1.6.0";
+export const SCHEMA_VERSION = "v1.7.0";
 const PAGES_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS ai_ready_pages (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -54,9 +54,24 @@ CREATE TABLE IF NOT EXISTS _ai_ready_info (
   checksum TEXT,
   ready INTEGER DEFAULT 0
 )`;
+const CRON_RUNS_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS ai_ready_cron_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at INTEGER NOT NULL,
+  finished_at INTEGER,
+  duration_ms INTEGER,
+  pages_indexed INTEGER DEFAULT 0,
+  pages_remaining INTEGER DEFAULT 0,
+  indexnow_submitted INTEGER DEFAULT 0,
+  indexnow_remaining INTEGER DEFAULT 0,
+  errors TEXT DEFAULT '[]',
+  status TEXT DEFAULT 'running'
+)`;
+const CRON_RUNS_INDEX_SQL = "CREATE INDEX IF NOT EXISTS idx_ai_ready_cron_runs_started ON ai_ready_cron_runs(started_at DESC)";
 export const DROP_TABLES_SQL = [
   "DROP TABLE IF EXISTS ai_ready_pages_fts",
   "DROP TABLE IF EXISTS ai_ready_pages",
+  "DROP TABLE IF EXISTS ai_ready_cron_runs",
   "DROP TABLE IF EXISTS _ai_ready_info",
   // Legacy unprefixed tables (migration from v1.0.0)
   "DROP TABLE IF EXISTS pages_fts",
@@ -67,5 +82,7 @@ export const ALL_SCHEMA_SQL = [
   ...PAGES_INDEXES_SQL,
   FTS_TABLE_SQL,
   ...FTS_TRIGGERS_SQL,
-  INFO_TABLE_SQL
+  INFO_TABLE_SQL,
+  CRON_RUNS_TABLE_SQL,
+  CRON_RUNS_INDEX_SQL
 ];

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

@@ -13,7 +13,8 @@ export default defineEventHandler(async (event) => {
   const { path, isExplicit } = renderInfo;
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
   const response = await event.fetch(path, {
-    headers: { [INTERNAL_HEADER]: "1" }
+    headers: { [INTERNAL_HEADER]: "1" },
+    redirect: "manual"
   }).catch((e) => {
     logger.error(`Failed to fetch HTML for ${path}`, e);
     return null;
@@ -28,6 +29,17 @@ export default defineEventHandler(async (event) => {
     }
     return;
   }
+  if (response.status >= 300 && response.status < 400) {
+    const location = response.headers.get("location");
+    if (location) {
+      const redirectTarget = location.endsWith("/") ? `${location.slice(0, -1)}.md` : `${location}.md`;
+      setHeader(event, "location", redirectTarget);
+      return createError({
+        statusCode: response.status,
+        statusMessage: response.statusText
+      });
+    }
+  }
   if (!response.ok) {
     if (isExplicit) {
       return createError({

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

@@ -0,0 +1,5 @@
+/**
+ * Cron endpoint for platforms that use HTTP-based cron (Vercel, etc.)
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../utils/runCron.js").CronResult>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { eventHandler } from "h3";
+import { runCron } from "../../utils/runCron.js";
+export default eventHandler((event) => runCron(event));

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

@@ -3,13 +3,13 @@ import { useRuntimeConfig } from "nitropack/runtime";
 import { syncToIndexNow } from "../../utils/indexnow.js";
 export default eventHandler(async (event) => {
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
-  if (!config.indexNow?.enabled) {
-    throw createError({ statusCode: 400, message: "IndexNow not enabled" });
+  if (!config.indexNowKey) {
+    throw createError({ statusCode: 400, message: "IndexNow not configured" });
   }
   const query = getQuery(event);
-  if (config.runtimeSync?.secret) {
+  if (config.runtimeSyncSecret) {
     const secret = query.secret;
-    if (secret !== config.runtimeSync.secret) {
+    if (secret !== config.runtimeSyncSecret) {
       throw createError({ statusCode: 401, message: "Unauthorized" });
     }
   }

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

@@ -4,9 +4,9 @@ import { batchIndexPages } from "../../utils/batchIndex.js";
 export default eventHandler(async (event) => {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const query = getQuery(event);
-  if (config.runtimeSync.secret) {
+  if (config.runtimeSyncSecret) {
     const secret = query.secret;
-    if (secret !== config.runtimeSync.secret) {
+    if (secret !== config.runtimeSyncSecret) {
       throw createError({ statusCode: 401, message: "Unauthorized" });
     }
   }

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

@@ -5,9 +5,9 @@ export default eventHandler(async (event) => {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const query = getQuery(event);
   const dry = query.dry === "true" || query.dry === "1";
-  if (!dry && config.runtimeSync.secret) {
+  if (!dry && config.runtimeSyncSecret) {
     const secret = query.secret;
-    if (secret !== config.runtimeSync.secret) {
+    if (secret !== config.runtimeSyncSecret) {
       throw createError({ statusCode: 401, message: "Unauthorized" });
     }
   }

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

@@ -12,7 +12,7 @@ export default eventHandler(async (event) => {
     indexed: total - pending,
     pending
   };
-  if (config.indexNow?.enabled) {
+  if (config.indexNowKey) {
     const [indexNowPending, indexNowStats] = await Promise.all([
       countPagesNeedingIndexNowSync(event),
       getIndexNowStats(event)

package/dist/runtime/server/routes/__ai-ready-debug.get.d.ts

@@ -1,3 +1,15 @@
+interface CronRunInfo {
+    id: number;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    status: string;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}
 interface DebugInfo {
     version: string;
     environment: {
@@ -10,6 +22,19 @@ interface DebugInfo {
         cacheMaxAgeSeconds: number;
         mdreamOptions: unknown;
     };
+    runtimeSync?: {
+        total: number;
+        indexed: number;
+        pending: number;
+        sitemapSeededAt: string | null;
+    };
+    indexNow?: {
+        pending: number;
+        totalSubmitted: number;
+        lastSubmittedAt: string | null;
+        lastError: string | null;
+    };
+    cronRuns?: CronRunInfo[];
     pageData: {
         source: string;
         pageCount: number;

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

@@ -1,6 +1,6 @@
 import { createError, eventHandler, setHeader } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { queryPages } from "../db/queries.js";
+import { countPages, countPagesNeedingIndexNowSync, getIndexNowStats, getRecentCronRuns, getSitemapSeededAt, queryPages } from "../db/queries.js";
 export default eventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
   if (!runtimeConfig.debug) {
@@ -90,6 +90,47 @@ export default eventHandler(async (event) => {
     issues.push("Prerender mode but no pages found");
     suggestions.push("Check if pages.db exists in .data/ai-ready/");
   }
+  let runtimeSyncInfo;
+  let indexNowInfo;
+  let cronRunsInfo;
+  if (!isDev && !isPrerender) {
+    const [total, pending, sitemapSeededAt, cronRuns] = await Promise.all([
+      countPages(event),
+      countPages(event, { where: { pending: true } }),
+      getSitemapSeededAt(event),
+      getRecentCronRuns(event, 20)
+    ]);
+    runtimeSyncInfo = {
+      total,
+      indexed: total - pending,
+      pending,
+      sitemapSeededAt: sitemapSeededAt ? new Date(sitemapSeededAt).toISOString() : null
+    };
+    cronRunsInfo = cronRuns.map((run) => ({
+      id: run.id,
+      startedAt: new Date(run.startedAt).toISOString(),
+      finishedAt: run.finishedAt ? new Date(run.finishedAt).toISOString() : null,
+      durationMs: run.durationMs,
+      status: run.status,
+      pagesIndexed: run.pagesIndexed,
+      pagesRemaining: run.pagesRemaining,
+      indexNowSubmitted: run.indexNowSubmitted,
+      indexNowRemaining: run.indexNowRemaining,
+      errors: run.errors
+    }));
+    if (runtimeConfig.indexNowKey) {
+      const [indexNowPending, indexNowStats] = await Promise.all([
+        countPagesNeedingIndexNowSync(event),
+        getIndexNowStats(event)
+      ]);
+      indexNowInfo = {
+        pending: indexNowPending,
+        totalSubmitted: indexNowStats.totalSubmitted,
+        lastSubmittedAt: indexNowStats.lastSubmittedAt ? new Date(indexNowStats.lastSubmittedAt).toISOString() : null,
+        lastError: indexNowStats.lastError
+      };
+    }
+  }
   const debugInfo = {
     version: runtimeConfig.version || "unknown",
     environment: {
@@ -102,6 +143,9 @@ export default eventHandler(async (event) => {
       cacheMaxAgeSeconds: runtimeConfig.cacheMaxAgeSeconds,
       mdreamOptions: runtimeConfig.mdreamOptions
     },
+    runtimeSync: runtimeSyncInfo,
+    indexNow: indexNowInfo,
+    cronRuns: cronRunsInfo,
     pageData: {
       source,
       pageCount: pages.length,

package/dist/runtime/server/tasks/ai-ready-cron.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").Task<import("../utils/runCron.js").CronResult>;
+export default _default;

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

@@ -0,0 +1,17 @@
+import { defineTask } from "nitropack/runtime";
+import { runCron } from "../utils/runCron.js";
+export default defineTask({
+  meta: {
+    name: "ai-ready:cron",
+    description: "Scheduled task for AI Ready - runs indexing and IndexNow sync"
+  },
+  async run({ payload }) {
+    const mockEvent = {
+      $fetch: globalThis.$fetch
+    };
+    const result = await runCron(mockEvent, {
+      batchSize: payload?.limit
+    });
+    return { result };
+  }
+});

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

@@ -5,11 +5,6 @@ export interface IndexNowResult {
     remaining: number;
     error?: string;
 }
-export interface IndexNowConfig {
-    enabled?: boolean;
-    key?: string;
-    host?: string;
-}
 /**
  * Submit URLs to IndexNow API
  */

package/dist/runtime/server/utils/indexnow.js

@@ -38,7 +38,7 @@ export async function submitToIndexNow(routes, config, siteUrl) {
 export async function syncToIndexNow(event, limit = 100) {
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
   const siteConfig = useSiteConfig();
-  if (!config.indexNow?.enabled || !config.indexNow?.key) {
+  if (!config.indexNowKey) {
     return { success: false, submitted: 0, remaining: 0, error: "IndexNow not configured" };
   }
   if (!siteConfig.url) {
@@ -49,7 +49,7 @@ export async function syncToIndexNow(event, limit = 100) {
     return { success: true, submitted: 0, remaining: 0 };
   }
   const routes = pages.map((p) => p.route);
-  const result = await submitToIndexNow(routes, config.indexNow, siteConfig.url);
+  const result = await submitToIndexNow(routes, { key: config.indexNowKey }, siteConfig.url);
   if (result.success) {
     await markIndexNowSynced(event, routes);
     await updateIndexNowStats(event, routes.length);

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

@@ -0,0 +1,21 @@
+import type { H3Event } from 'h3';
+export interface CronResult {
+    runId?: number | null;
+    index?: {
+        indexed: number;
+        remaining: number;
+        errors?: string[];
+        complete: boolean;
+    };
+    indexNow?: {
+        submitted: number;
+        remaining: number;
+        error?: string;
+    };
+}
+/**
+ * Run cron job logic - shared between scheduled task and HTTP endpoint
+ */
+export declare function runCron(event: H3Event, options?: {
+    batchSize?: number;
+}): Promise<CronResult>;

package/dist/runtime/server/utils/runCron.js

@@ -0,0 +1,52 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { cleanupOldCronRuns, completeCronRun, startCronRun } from "../db/queries.js";
+import { batchIndexPages } from "./batchIndex.js";
+import { syncToIndexNow } from "./indexnow.js";
+export async function runCron(event, options) {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  const results = {};
+  const allErrors = [];
+  const runId = await startCronRun(event);
+  results.runId = runId;
+  if (config.runtimeSync.enabled) {
+    const limit = options?.batchSize ?? config.runtimeSync.batchSize;
+    const indexResult = await batchIndexPages(event, {
+      limit,
+      all: false
+    });
+    results.index = {
+      indexed: indexResult.indexed,
+      remaining: indexResult.remaining,
+      errors: indexResult.errors.length > 0 ? indexResult.errors : void 0,
+      complete: indexResult.complete
+    };
+    if (indexResult.errors.length > 0) {
+      allErrors.push(...indexResult.errors);
+    }
+  }
+  if (config.indexNowKey) {
+    const indexNowResult = await syncToIndexNow(event, 100).catch((err) => {
+      console.warn("[ai-ready:cron] IndexNow sync failed:", err.message);
+      return { success: false, submitted: 0, remaining: 0, error: err.message };
+    });
+    results.indexNow = {
+      submitted: indexNowResult.submitted,
+      remaining: indexNowResult.remaining,
+      error: indexNowResult.error
+    };
+    if (indexNowResult.error) {
+      allErrors.push(`IndexNow: ${indexNowResult.error}`);
+    }
+  }
+  if (runId) {
+    await completeCronRun(event, runId, {
+      pagesIndexed: results.index?.indexed || 0,
+      pagesRemaining: results.index?.remaining || 0,
+      indexNowSubmitted: results.indexNow?.submitted || 0,
+      indexNowRemaining: results.indexNow?.remaining || 0,
+      errors: allErrors
+    });
+    await cleanupOldCronRuns(event, 50);
+  }
+  return results;
+}

package/dist/runtime/types.d.ts

@@ -103,18 +103,31 @@ export interface ModuleOptions {
          */
         authToken?: string;
     };
+    /**
+     * Enable scheduled cron task (runs every minute)
+     * When true, automatically enables runtimeSync for background indexing
+     * Also runs IndexNow sync if indexNowKey is configured
+     */
+    cron?: boolean;
+    /**
+     * IndexNow API key for instant search engine notifications
+     * When set, enables IndexNow submissions to Bing, Yandex, Naver, Seznam
+     * Get one from https://www.bing.com/indexnow
+     * Can also be set via NUXT_AI_READY_INDEX_NOW_KEY env var
+     */
+    indexNowKey?: string;
+    /**
+     * Secret token for authenticating runtime sync endpoints
+     * When set, requires ?secret=<token> query param for poll/prune/indexnow endpoints
+     */
+    runtimeSyncSecret?: string;
     /**
      * Runtime sync configuration (opt-in for dynamic content sites)
      * When enabled, pages are re-indexed at runtime from sitemap
-     * @default disabled - prerendered data is used
+     * Set to `true` for defaults or object to customize
+     * @default false - prerendered data is used
      */
-    runtimeSync?: {
-        /**
-         * Enable runtime sync
-         * When false (default), runtime uses prerendered data only
-         * @default false
-         */
-        enabled?: boolean;
+    runtimeSync?: boolean | {
         /**
          * TTL for refresh in seconds (sitemap + page re-indexing)
          * Controls how often to refresh sitemap routes and re-index stale pages
@@ -126,16 +139,6 @@ export interface ModuleOptions {
          * @default 20
          */
         batchSize?: number;
-        /**
-         * Cron expression for scheduled indexing (e.g. every 5 minutes)
-         * When set, enables automatic background indexing via Nitro task
-         */
-        cron?: string;
-        /**
-         * Secret token for authenticating poll endpoint
-         * When set, requires ?secret=<token> query param
-         */
-        secret?: string;
         /**
          * TTL for pruning stale routes in seconds
          * Routes not seen in sitemap for longer than this are deleted
@@ -144,27 +147,6 @@ export interface ModuleOptions {
          */
         pruneTtl?: number;
     };
-    /**
-     * IndexNow configuration for instant search engine notifications
-     * Submits changed URLs to Bing, Yandex, Naver, Seznam via IndexNow protocol
-     */
-    indexNow?: {
-        /**
-         * Enable IndexNow submissions
-         * @default false
-         */
-        enabled?: boolean;
-        /**
-         * Your IndexNow API key
-         * Get one from https://www.bing.com/indexnow
-         */
-        key?: string;
-        /**
-         * IndexNow endpoint host
-         * @default 'api.indexnow.org'
-         */
-        host?: string;
-    };
 }
 /**
  * Page-level entry for discovery and metadata queries

package/mcp.d.ts

@@ -0,0 +1,4 @@
+import type { McpResourceDefinition, McpToolDefinition } from '@nuxtjs/mcp-toolkit'
+
+export declare const tools: readonly [McpToolDefinition, McpToolDefinition]
+export declare const resources: readonly [McpResourceDefinition]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -25,11 +25,16 @@
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
+    },
+    "./mcp": {
+      "types": "./mcp.d.ts",
+      "import": "./dist/runtime/mcp.js"
     }
   },
   "main": "./dist/module.mjs",
   "files": [
-    "dist"
+    "dist",
+    "mcp.d.ts"
   ],
   "peerDependencies": {
     "@nuxtjs/sitemap": "^7.0.0",

package/dist/runtime/server/tasks/ai-ready-index.d.ts

@@ -1,11 +0,0 @@
-declare const _default: import("nitropack/types").Task<{
-    indexed: number;
-    remaining: number;
-    errors: string[];
-    complete: boolean;
-    indexNow: {
-        submitted: number;
-        error: any;
-    } | undefined;
-}>;
-export default _default;

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

@@ -1,39 +0,0 @@
-import { defineTask, useRuntimeConfig } from "nitropack/runtime";
-import { batchIndexPages } from "../utils/batchIndex.js";
-import { syncToIndexNow } from "../utils/indexnow.js";
-export default defineTask({
-  meta: {
-    name: "ai-ready:index",
-    description: "Index pending pages for AI Ready"
-  },
-  async run({ payload }) {
-    const config = useRuntimeConfig()["nuxt-ai-ready"];
-    const limit = payload?.limit ?? config.runtimeSync.batchSize;
-    const mockEvent = {
-      $fetch: globalThis.$fetch
-    };
-    const result = await batchIndexPages(mockEvent, {
-      limit,
-      all: false
-    });
-    let indexNowResult;
-    if (config.indexNow?.enabled) {
-      indexNowResult = await syncToIndexNow(mockEvent, 100).catch((err) => {
-        console.warn("[ai-ready:index] IndexNow sync failed:", err.message);
-        return { success: false, submitted: 0, error: err.message };
-      });
-    }
-    return {
-      result: {
-        indexed: result.indexed,
-        remaining: result.remaining,
-        errors: result.errors,
-        complete: result.complete,
-        indexNow: indexNowResult ? {
-          submitted: indexNowResult.submitted,
-          error: indexNowResult.error
-        } : void 0
-      }
-    };
-  }
-});