nuxt-ai-ready 0.8.1 → 0.9.0

package/dist/cli.d.mts

@@ -0,0 +1 @@
+

package/dist/cli.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import fsp from 'node:fs/promises';
+import { defineCommand, runMain } from 'citty';
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import { resolve, join } from 'pathe';
+
+async function getSecret(cwd) {
+  const secretPath = join(cwd, "node_modules/.cache/nuxt/ai-ready/secret");
+  if (!existsSync(secretPath)) {
+    return null;
+  }
+  return fsp.readFile(secretPath, "utf-8").then((s) => s.trim()).catch(() => null);
+}
+const main = defineCommand({
+  meta: {
+    name: "nuxt-ai-ready",
+    description: "Nuxt AI Ready CLI"
+  },
+  subCommands: {
+    status: defineCommand({
+      meta: {
+        name: "status",
+        description: "Show indexing status and IndexNow sync progress"
+      },
+      args: {
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await getSecret(cwd);
+        if (!secret) {
+          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first to generate one.");
+          return;
+        }
+        const url = `${args.url}/__ai-ready/status?secret=${secret}`;
+        consola.info(`Fetching status from ${args.url}...`);
+        const res = await fetch(url).then((r) => r.json()).catch((err) => {
+          consola.error(`Failed to connect: ${err.message}`);
+          return null;
+        });
+        if (!res)
+          return;
+        consola.box("AI Ready Status");
+        consola.info(`Total pages: ${colors.cyan(res.total?.toString() || "0")}`);
+        consola.info(`Indexed: ${colors.green(res.indexed?.toString() || "0")}`);
+        consola.info(`Pending: ${colors.yellow(res.pending?.toString() || "0")}`);
+        if (res.indexNow) {
+          consola.log("");
+          consola.info(colors.bold("IndexNow:"));
+          consola.info(`  Pending: ${colors.yellow(res.indexNow.pending?.toString() || "0")}`);
+          consola.info(`  Total submitted: ${colors.green(res.indexNow.totalSubmitted?.toString() || "0")}`);
+          if (res.indexNow.lastSubmittedAt) {
+            const date = new Date(res.indexNow.lastSubmittedAt);
+            consola.info(`  Last submitted: ${colors.dim(date.toISOString())}`);
+          }
+          if (res.indexNow.lastError) {
+            consola.info(`  Last error: ${colors.red(res.indexNow.lastError)}`);
+          }
+        }
+      }
+    }),
+    poll: defineCommand({
+      meta: {
+        name: "poll",
+        description: "Trigger page indexing"
+      },
+      args: {
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        limit: {
+          type: "string",
+          alias: "l",
+          description: "Max pages to process",
+          default: "10"
+        },
+        all: {
+          type: "boolean",
+          alias: "a",
+          description: "Process all pending pages"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await getSecret(cwd);
+        if (!secret) {
+          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+          return;
+        }
+        const params = new URLSearchParams({ secret });
+        if (args.all) {
+          params.set("all", "true");
+        } else {
+          params.set("limit", args.limit || "10");
+        }
+        const url = `${args.url}/__ai-ready/poll?${params}`;
+        consola.info(`Triggering poll at ${args.url}...`);
+        const res = await fetch(url, { method: "POST" }).then((r) => r.json()).catch((err) => {
+          consola.error(`Failed: ${err.message}`);
+          return null;
+        });
+        if (!res)
+          return;
+        consola.success(`Indexed: ${colors.green(res.indexed?.toString() || "0")} pages`);
+        consola.info(`Remaining: ${colors.yellow(res.remaining?.toString() || "0")}`);
+        if (res.errors?.length) {
+          consola.warn(`Errors: ${res.errors.length}`);
+        }
+        if (res.duration) {
+          consola.info(`Duration: ${colors.dim(`${res.duration}ms`)}`);
+        }
+      }
+    }),
+    restore: defineCommand({
+      meta: {
+        name: "restore",
+        description: "Restore database from prerendered dump"
+      },
+      args: {
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        clear: {
+          type: "boolean",
+          description: "Clear existing pages first (default: true)",
+          default: true
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await getSecret(cwd);
+        if (!secret) {
+          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+          return;
+        }
+        const params = new URLSearchParams({ secret });
+        if (!args.clear) {
+          params.set("clear", "false");
+        }
+        const url = `${args.url}/__ai-ready/restore?${params}`;
+        consola.info(`Restoring database at ${args.url}...`);
+        const res = await fetch(url, { method: "POST" }).then((r) => r.json()).catch((err) => {
+          consola.error(`Failed: ${err.message}`);
+          return null;
+        });
+        if (!res)
+          return;
+        consola.success(`Restored: ${colors.green(res.restored?.toString() || "0")} pages`);
+        if (res.cleared) {
+          consola.info(`Cleared: ${colors.yellow(res.cleared?.toString() || "0")} existing pages`);
+        }
+      }
+    }),
+    prune: defineCommand({
+      meta: {
+        name: "prune",
+        description: "Remove stale routes from database"
+      },
+      args: {
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        dry: {
+          type: "boolean",
+          alias: "d",
+          description: "Preview without deleting"
+        },
+        ttl: {
+          type: "string",
+          description: "Override pruneTtl config"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await getSecret(cwd);
+        if (!secret && !args.dry) {
+          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+          return;
+        }
+        const params = new URLSearchParams();
+        if (secret)
+          params.set("secret", secret);
+        if (args.dry)
+          params.set("dry", "true");
+        if (args.ttl)
+          params.set("ttl", args.ttl);
+        const url = `${args.url}/__ai-ready/prune?${params}`;
+        consola.info(`${args.dry ? "Previewing" : "Pruning"} stale routes at ${args.url}...`);
+        const res = await fetch(url, { method: "POST" }).then((r) => r.json()).catch((err) => {
+          consola.error(`Failed: ${err.message}`);
+          return null;
+        });
+        if (!res)
+          return;
+        if (args.dry) {
+          consola.info(`Would prune: ${colors.yellow(res.count?.toString() || "0")} routes`);
+          if (res.routes?.length) {
+            for (const route of res.routes.slice(0, 20)) {
+              consola.log(`  ${colors.dim("\u2022")} ${route}`);
+            }
+            if (res.routes.length > 20) {
+              consola.log(`  ${colors.dim(`... and ${res.routes.length - 20} more`)}`);
+            }
+          }
+        } else {
+          consola.success(`Pruned: ${colors.green(res.pruned?.toString() || "0")} routes`);
+        }
+      }
+    }),
+    indexnow: defineCommand({
+      meta: {
+        name: "indexnow",
+        description: "Trigger IndexNow sync"
+      },
+      args: {
+        url: {
+          type: "string",
+          alias: "u",
+          description: "Site URL (default: http://localhost:3000)",
+          default: "http://localhost:3000"
+        },
+        limit: {
+          type: "string",
+          alias: "l",
+          description: "Max URLs to submit",
+          default: "100"
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory",
+          default: "."
+        }
+      },
+      async run({ args }) {
+        const cwd = resolve(args.cwd || ".");
+        const secret = await getSecret(cwd);
+        if (!secret) {
+          consola.error("No secret found. Run `nuxi dev` or `nuxi build` first.");
+          return;
+        }
+        const params = new URLSearchParams({
+          secret,
+          limit: args.limit || "100"
+        });
+        const url = `${args.url}/__ai-ready/indexnow?${params}`;
+        consola.info(`Triggering IndexNow sync at ${args.url}...`);
+        const res = await fetch(url, { method: "POST" }).then((r) => r.json()).catch((err) => {
+          consola.error(`Failed: ${err.message}`);
+          return null;
+        });
+        if (!res)
+          return;
+        if (res.success) {
+          consola.success(`Submitted: ${colors.green(res.submitted?.toString() || "0")} URLs`);
+          consola.info(`Remaining: ${colors.yellow(res.remaining?.toString() || "0")}`);
+        } else {
+          consola.error(`Failed: ${res.error || "Unknown error"}`);
+        }
+      }
+    })
+  }
+});
+runMain(main);

package/dist/module.d.mts

@@ -46,7 +46,7 @@ interface ModulePublicRuntimeConfig {
         pruneTtl: number;
     };
     runtimeSyncSecret?: string;
-    indexNowKey?: string;
+    indexNow?: 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.8.1",
+  "version": "0.9.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,3 +1,4 @@
+import { createHash, randomBytes } from 'node:crypto';
 import { mkdir, writeFile, appendFile, stat, access } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { useLogger, useNuxt, addTemplate, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addServerHandler, addPlugin } from '@nuxt/kit';
@@ -17,6 +18,10 @@ import { join as join$1, isAbsolute } from 'pathe';
 
 const logger = useLogger("nuxt-ai-ready");
 
+const moduleRegistrations = [];
+function registerModule(registration) {
+  moduleRegistrations.push(registration);
+}
 function hookNuxtSeoProLicense() {
   const nuxt = useNuxt();
   const isBuild = !nuxt.options.dev && !nuxt.options._prepare;
@@ -44,7 +49,13 @@ function hookNuxtSeoProLicense() {
       const siteName = siteConfig.name || void 0;
       const res = await $fetch("https://nuxtseo.com/api/pro/verify", {
         method: "POST",
-        body: { apiKey: license, siteUrl, siteName }
+        body: {
+          apiKey: license,
+          siteUrl,
+          siteName,
+          // Include registered modules for dashboard integration
+          modules: moduleRegistrations.length > 0 ? moduleRegistrations : void 0
+        }
       }).catch((err) => {
         if (err?.response?.status === 401) {
           spinner.stop("\u274C Invalid API key");
@@ -68,7 +79,7 @@ function hookNuxtSeoProLicense() {
   }
 }
 
-async function fetchPreviousMeta(siteUrl, indexNowKey) {
+async function fetchPreviousMeta(siteUrl, indexNow) {
   const metaUrl = `${siteUrl}/__ai-ready/pages.meta.json`;
   logger.debug(`[indexnow] Fetching previous meta from ${metaUrl}`);
   const prevMeta = await fetch(metaUrl).then((r) => r.ok ? r.json() : null).catch(() => null);
@@ -76,7 +87,7 @@ async function fetchPreviousMeta(siteUrl, indexNowKey) {
     logger.info("[indexnow] First deploy or no previous meta - skipping IndexNow");
     return null;
   }
-  const keyUrl = `${siteUrl}/${indexNowKey}.txt`;
+  const keyUrl = `${siteUrl}/${indexNow}.txt`;
   const keyLive = await fetch(keyUrl).then((r) => r.ok).catch(() => false);
   if (!keyLive) {
     logger.info("[indexnow] Key file not live yet - skipping IndexNow");
@@ -84,7 +95,7 @@ async function fetchPreviousMeta(siteUrl, indexNowKey) {
   }
   return prevMeta;
 }
-async function handleStaticIndexNow(currentPages, siteUrl, indexNowKey, prevMeta) {
+async function handleStaticIndexNow(currentPages, siteUrl, indexNow, prevMeta) {
   const { changed, added } = comparePageHashes(currentPages, prevMeta);
   const totalChanged = changed.length + added.length;
   if (totalChanged === 0) {
@@ -94,7 +105,7 @@ async function handleStaticIndexNow(currentPages, siteUrl, indexNowKey, prevMeta
   logger.info(`[indexnow] Submitting ${totalChanged} changed pages (${changed.length} modified, ${added.length} new)`);
   const result = await submitToIndexNowShared(
     [...changed, ...added],
-    indexNowKey,
+    indexNow,
     siteUrl,
     { logger }
   );
@@ -104,7 +115,7 @@ async function handleStaticIndexNow(currentPages, siteUrl, indexNowKey, prevMeta
     logger.warn(`[indexnow] Failed to submit: ${result.error}`);
   }
 }
-function createCrawlerState(dbPath, llmsFullTxtPath, siteInfo, llmsTxtConfig, indexNowKey) {
+function createCrawlerState(dbPath, llmsFullTxtPath, siteInfo, llmsTxtConfig, indexNow) {
   return {
     prerenderedRoutes: /* @__PURE__ */ new Set(),
     errorRoutes: /* @__PURE__ */ new Set(),
@@ -114,7 +125,7 @@ function createCrawlerState(dbPath, llmsFullTxtPath, siteInfo, llmsTxtConfig, in
     llmsFullTxtPath,
     siteInfo,
     llmsTxtConfig,
-    indexNowKey
+    indexNow
   };
 }
 async function initCrawler(state) {
@@ -265,11 +276,11 @@ async function prerenderRoute(nitro, route) {
   nitro._prerenderedRoutes.push(_route);
   return stat(filePath);
 }
-function setupPrerenderHandler(dbPath, siteInfo, llmsTxtConfig, indexNowKey) {
+function setupPrerenderHandler(dbPath, siteInfo, llmsTxtConfig, indexNow) {
   const nuxt = useNuxt();
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const llmsFullTxtPath = join(nitro.options.output.publicDir, "llms-full.txt");
-    const state = createCrawlerState(dbPath, llmsFullTxtPath, siteInfo, llmsTxtConfig, indexNowKey);
+    const state = createCrawlerState(dbPath, llmsFullTxtPath, siteInfo, llmsTxtConfig, indexNow);
     let initPromise = null;
     nitro.hooks.hook("prerender:generate", async (route) => {
       if (route.error) {
@@ -334,8 +345,8 @@ function setupPrerenderHandler(dbPath, siteInfo, llmsTxtConfig, indexNowKey) {
         logger.debug(`Created database dump at __ai-ready/pages.dump (${(dumpData.length / 1024).toFixed(1)}kb compressed)`);
         const pageHashes = pages.filter((p) => p.contentHash).map((p) => ({ route: p.route, hash: p.contentHash }));
         let prevMeta = null;
-        if (state.indexNowKey && state.siteInfo?.url) {
-          prevMeta = await fetchPreviousMeta(state.siteInfo.url, state.indexNowKey);
+        if (state.indexNow && state.siteInfo?.url) {
+          prevMeta = await fetchPreviousMeta(state.siteInfo.url, state.indexNow);
         }
         const buildId = Date.now().toString(36);
         const metaContent = JSON.stringify({
@@ -346,8 +357,8 @@ function setupPrerenderHandler(dbPath, siteInfo, llmsTxtConfig, indexNowKey) {
         });
         await writeFile(join(publicDataDir, "pages.meta.json"), metaContent, "utf-8");
         logger.debug(`Wrote build metadata: buildId=${buildId}, ${pageHashes.length} page hashes`);
-        if (state.indexNowKey && state.siteInfo?.url && prevMeta) {
-          await handleStaticIndexNow(pageHashes, state.siteInfo.url, state.indexNowKey, prevMeta);
+        if (state.indexNow && state.siteInfo?.url && prevMeta) {
+          await handleStaticIndexNow(pageHashes, state.siteInfo.url, state.indexNow, prevMeta);
         }
       }
       const llmsStats = await prerenderRoute(nitro, "/llms.txt");
@@ -624,6 +635,28 @@ const module$1 = defineNuxtModule({
     mergedLlmsTxt.notes = llmsTxtPayload.notes.length > 0 ? llmsTxtPayload.notes : void 0;
     const prerenderCacheDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt-seo/ai-ready/routes");
     const buildDbPath = join(nuxt.options.buildDir, ".data/ai-ready/build.db");
+    const runtimeSyncConfig = typeof config.runtimeSync === "object" ? config.runtimeSync : {};
+    const runtimeSyncEnabled = !!config.runtimeSync || !!config.cron;
+    const indexNow = config.indexNow === true ? createHash("sha256").update(useSiteConfig().url || "nuxt-ai-ready").digest("hex").slice(0, 32) : config.indexNow || process.env.NUXT_AI_READY_INDEX_NOW_KEY;
+    let runtimeSyncSecret = config.runtimeSyncSecret || process.env.NUXT_AI_READY_RUNTIME_SYNC_SECRET;
+    if (!runtimeSyncSecret && runtimeSyncEnabled) {
+      runtimeSyncSecret = randomBytes(32).toString("hex");
+      logger.info(`Generated runtimeSyncSecret (use NUXT_AI_READY_RUNTIME_SYNC_SECRET env to set explicitly)`);
+    }
+    if (runtimeSyncSecret) {
+      const cacheDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt/ai-ready");
+      await mkdir(cacheDir, { recursive: true });
+      await writeFile(join(cacheDir, "secret"), runtimeSyncSecret);
+    }
+    registerModule({
+      name: "nuxt-ai-ready",
+      secret: runtimeSyncSecret,
+      features: {
+        cron: !!config.cron,
+        indexNow: !!indexNow,
+        runtimeSync: runtimeSyncEnabled
+      }
+    });
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
@@ -636,7 +669,7 @@ const module$1 = defineNuxtModule({
           nitroConfig.vercel.config.crons = nitroConfig.vercel.config.crons || [];
           nitroConfig.vercel.config.crons.push({
             schedule: cronSchedule,
-            path: "/__ai-ready/cron"
+            path: runtimeSyncSecret ? `/__ai-ready/cron?secret=${runtimeSyncSecret}` : "/__ai-ready/cron"
           });
         } else {
           nitroConfig.experimental.tasks = true;
@@ -697,9 +730,6 @@ export async function readPageDataFromFilesystem() {
 export const errorRoutes = []`;
     });
     const database = refineDatabaseConfig(config.database || {}, nuxt.options.rootDir);
-    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,
@@ -718,8 +748,8 @@ export const errorRoutes = []`;
         batchSize: runtimeSyncConfig.batchSize ?? 20,
         pruneTtl: runtimeSyncConfig.pruneTtl ?? 0
       },
-      runtimeSyncSecret: config.runtimeSyncSecret,
-      indexNowKey
+      runtimeSyncSecret,
+      indexNow
     };
     addServerHandler({
       middleware: true,
@@ -746,8 +776,8 @@ export const errorRoutes = []`;
       addServerHandler({ route: "/__ai-ready/prune", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/prune.post") });
       addServerHandler({ route: "/__ai-ready/restore", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/restore.post") });
     }
-    if (indexNowKey) {
-      addServerHandler({ route: `/${indexNowKey}.txt`, handler: resolve("./runtime/server/routes/indexnow-key.get") });
+    if (indexNow) {
+      addServerHandler({ route: `/${indexNow}.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") });
@@ -773,7 +803,7 @@ export const errorRoutes = []`;
         name: siteConfig.name,
         url: siteConfig.url,
         description: siteConfig.description
-      }, mergedLlmsTxt, indexNowKey);
+      }, mergedLlmsTxt, indexNow);
     }
     nuxt.options.nitro.routeRules = nuxt.options.nitro.routeRules || {};
     nuxt.options.nitro.routeRules["/llms.txt"] = { headers: { "Content-Type": "text/plain; charset=utf-8" } };

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

@@ -1,3 +1,13 @@
-import { eventHandler } from "h3";
+import { createError, eventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
 import { runCron } from "../../utils/runCron.js";
-export default eventHandler((event) => runCron(event));
+export default eventHandler((event) => {
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  if (config.runtimeSyncSecret) {
+    const { secret } = getQuery(event);
+    if (secret !== config.runtimeSyncSecret) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  return runCron(event);
+});

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

@@ -3,7 +3,7 @@ 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.indexNowKey) {
+  if (!config.indexNow) {
     throw createError({ statusCode: 400, message: "IndexNow not configured" });
   }
   const query = getQuery(event);

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

@@ -1,8 +1,14 @@
-import { eventHandler } from "h3";
+import { createError, eventHandler, getQuery } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { countPages, countPagesNeedingIndexNowSync, getIndexNowStats } from "../../db/queries.js";
 export default eventHandler(async (event) => {
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  if (config.runtimeSyncSecret) {
+    const { secret } = getQuery(event);
+    if (secret !== config.runtimeSyncSecret) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
   const [total, pending] = await Promise.all([
     countPages(event),
     countPages(event, { where: { pending: true } })
@@ -12,7 +18,7 @@ export default eventHandler(async (event) => {
     indexed: total - pending,
     pending
   };
-  if (config.indexNowKey) {
+  if (config.indexNow) {
     const [indexNowPending, indexNowStats] = await Promise.all([
       countPagesNeedingIndexNowSync(event),
       getIndexNowStats(event)

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

@@ -135,7 +135,7 @@ export default eventHandler(async (event) => {
         indexNowRemaining: run.indexNowRemaining,
         errors: run.errors
       }));
-      if (runtimeConfig.indexNowKey) {
+      if (runtimeConfig.indexNow) {
         const [indexNowPending, indexNowStats, indexNowLogEntries] = await Promise.all([
           countPagesNeedingIndexNowSync(event),
           getIndexNowStats(event),

package/dist/runtime/server/routes/indexnow-key.get.js

@@ -2,8 +2,8 @@ import { eventHandler, setHeader } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 export default eventHandler((event) => {
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
-  if (!config.indexNowKey)
+  if (!config.indexNow)
     return null;
   setHeader(event, "Content-Type", "text/plain; charset=utf-8");
-  return config.indexNowKey;
+  return config.indexNow;
 });

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

@@ -1,4 +1,5 @@
-import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
+import { useSiteConfig } from "#site-config/server/composables/useSiteConfig";
+import { useEvent, useNitroApp, useRuntimeConfig } from "nitropack/runtime";
 import { getPageHash, isPageFresh, queryPages, upsertPage } from "../db/queries.js";
 import { computeContentHash } from "../db/shared.js";
 import { logger } from "../logger.js";
@@ -15,7 +16,9 @@ export async function indexPage(route, html, options = {}, event) {
   const existing = await queryPages(event, { route });
   const isUpdate = !!existing;
   const isError = html.includes("__NUXT_ERROR__") || html.includes("nuxt-error-page");
-  const result = await convertHtmlToMarkdown(html, route, config.mdreamOptions, { extractUpdatedAt: true });
+  const siteConfig = useSiteConfig(event || useEvent());
+  const fullUrl = `${siteConfig.url}${route}`;
+  const result = await convertHtmlToMarkdown(html, fullUrl, config.mdreamOptions, { extractUpdatedAt: true });
   const updatedAt = result.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
   const headings = JSON.stringify(result.headings);
   const keywords = extractKeywords(result.textContent, result.metaKeywords);

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

@@ -53,7 +53,7 @@ export async function submitToIndexNow(routes, config, siteUrl) {
 export async function syncToIndexNow(event, limit = 100, options) {
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
   const siteConfig = getSiteConfig(event);
-  if (!config.indexNowKey) {
+  if (!config.indexNow) {
     return { success: false, submitted: 0, remaining: 0, error: "IndexNow not configured" };
   }
   if (!siteConfig.url) {
@@ -80,7 +80,7 @@ export async function syncToIndexNow(event, limit = 100, options) {
     return { success: true, submitted: 0, remaining: 0 };
   }
   const routes = pages.map((p) => p.route);
-  const result = await submitToIndexNow(routes, { key: config.indexNowKey }, siteConfig.url);
+  const result = await submitToIndexNow(routes, { key: config.indexNow }, siteConfig.url);
   const dbUpdates = async () => {
     if (config.debug) {
       await logIndexNowSubmission(event, routes.length, result.success, result.error);

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

@@ -28,7 +28,7 @@ export async function runCron(providedEvent, options) {
   const results = {};
   const allErrors = [];
   if (debug) {
-    logger.info(`[cron] Starting cron run (batchSize: ${options?.batchSize ?? config.runtimeSync.batchSize}, indexNow: ${!!config.indexNowKey})`);
+    logger.info(`[cron] Starting cron run (batchSize: ${options?.batchSize ?? config.runtimeSync.batchSize}, indexNow: ${!!config.indexNow})`);
   }
   if (config.runtimeSync.enabled) {
     results.stale = await checkAndHandleStale(event).catch((err) => {
@@ -72,7 +72,7 @@ export async function runCron(providedEvent, options) {
       logger.info(`[cron] Index: ${indexResult.indexed} pages (${indexResult.remaining} remaining${indexResult.errors.length > 0 ? `, ${indexResult.errors.length} errors` : ""})`);
     }
   }
-  if (config.indexNowKey) {
+  if (config.indexNow) {
     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 };

package/dist/runtime/server/utils.js

@@ -35,7 +35,8 @@ function buildMdreamOptions(url, mdreamOptions, meta, extractUpdatedAt = false)
       }
     }
   });
-  let options = { origin: url, ...mdreamOptions };
+  const origin = new URL(url).origin;
+  let options = { origin, ...mdreamOptions };
   if (mdreamOptions?.preset === "minimal") {
     options = withMinimalPreset(options);
   }

package/dist/runtime/types.d.ts

@@ -106,16 +106,15 @@ export interface ModuleOptions {
     /**
      * Enable scheduled cron task (runs every minute)
      * When true, automatically enables runtimeSync for background indexing
-     * Also runs IndexNow sync if indexNowKey is configured
+     * Also runs IndexNow sync if indexNow is enabled
      */
     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
+     * Enable IndexNow for instant search engine notifications
+     * Submits to Bing, Yandex, Naver, Seznam when content changes
+     * Set to `true` to derive key from site URL, or provide your own string
      */
-    indexNowKey?: string;
+    indexNow?: boolean | string;
     /**
      * Secret token for authenticating runtime sync endpoints
      * When set, requires ?secret=<token> query param for poll/prune/indexnow endpoints

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -32,6 +32,9 @@
     }
   },
   "main": "./dist/module.mjs",
+  "bin": {
+    "nuxt-ai-ready": "./dist/cli.mjs"
+  },
   "files": [
     "dist",
     "mcp.d.ts"
@@ -48,6 +51,7 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "@nuxt/kit": "^4.2.2",
+    "citty": "^0.1.6",
     "consola": "^3.4.2",
     "db0": "^0.3.4",
     "defu": "^6.1.4",
@@ -78,12 +82,12 @@
     "@vue/test-utils": "^2.4.6",
     "@vueuse/nuxt": "^14.1.0",
     "agents": "^0.3.5",
-    "ai": "^6.0.35",
+    "ai": "^6.0.38",
     "better-sqlite3": "^12.6.0",
     "bumpp": "^10.4.0",
     "eslint": "^9.39.2",
     "execa": "^9.6.1",
-    "happy-dom": "^20.3.0",
+    "happy-dom": "^20.3.1",
     "nuxt": "^4.2.2",
     "nuxt-site-config": "^3.2.17",
     "playwright": "^1.57.0",
@@ -94,7 +98,7 @@
     "vue": "^3.5.26",
     "vue-router": "^4.6.4",
     "vue-tsc": "^3.2.2",
-    "wrangler": "^4.59.1",
+    "wrangler": "^4.59.2",
     "zod": "^4.3.5"
   },
   "resolutions": {