nuxt-ai-ready 0.8.0 → 0.8.2

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.json

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

package/dist/module.mjs

@@ -1,3 +1,4 @@
+import { 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';
@@ -11,11 +12,16 @@ import { parseSitemapXml } from '@nuxtjs/sitemap/utils';
 import { colorize } from 'consola/utils';
 import { withBase } from 'ufo';
 import { createAdapter, initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../dist/runtime/server/db/shared.js';
+import { comparePageHashes, submitToIndexNowShared } from '../dist/runtime/server/utils/indexnow-shared.js';
 import { buildLlmsFullTxtHeader, formatPageForLlmsFullTxt } from '../dist/runtime/server/utils/llms-full.js';
 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;
@@ -43,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");
@@ -67,84 +79,6 @@ function hookNuxtSeoProLicense() {
   }
 }
 
-const INDEXNOW_HOSTS = ["api.indexnow.org", "www.bing.com"];
-function getIndexNowEndpoints() {
-  const testEndpoint = process.env.INDEXNOW_TEST_ENDPOINT;
-  if (testEndpoint) {
-    return [testEndpoint];
-  }
-  return INDEXNOW_HOSTS.map((host) => `https://${host}/indexnow`);
-}
-function buildIndexNowBody(routes, key, siteUrl) {
-  const urlList = routes.map(
-    (route) => route.startsWith("http") ? route : `${siteUrl}${route}`
-  );
-  return {
-    host: new URL(siteUrl).host,
-    key,
-    keyLocation: `${siteUrl}/${key}.txt`,
-    urlList
-  };
-}
-async function submitToIndexNow(routes, key, siteUrl, options) {
-  if (!siteUrl) {
-    return { success: false, error: "Site URL not configured" };
-  }
-  const fetchFn = options?.fetchFn ?? globalThis.fetch;
-  const log = options?.logger;
-  const body = buildIndexNowBody(routes, key, siteUrl);
-  const endpoints = getIndexNowEndpoints();
-  let lastError;
-  for (const endpoint of endpoints) {
-    log?.debug(`[indexnow] Submitting ${body.urlList.length} URLs to ${endpoint}`);
-    const response = await fetchFn(endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    }).then((r) => r.ok ? { ok: true } : { error: `HTTP ${r.status}` }).catch((err) => ({ error: err.message }));
-    if ("error" in response) {
-      lastError = response.error;
-      if (lastError?.includes("429")) {
-        log?.warn(`[indexnow] Rate limited on ${endpoint}, trying fallback...`);
-        continue;
-      }
-      log?.warn(`[indexnow] Submission failed on ${endpoint}: ${lastError}`);
-      return { success: false, error: lastError, host: endpoint };
-    }
-    log?.debug(`[indexnow] Successfully submitted ${body.urlList.length} URLs via ${endpoint}`);
-    return { success: true, host: endpoint };
-  }
-  return {
-    success: false,
-    error: lastError || "All endpoints rate limited",
-    host: endpoints[endpoints.length - 1]
-  };
-}
-function comparePageHashes(currentPages, prevMeta) {
-  if (!prevMeta?.pages) {
-    return { changed: [], added: [], removed: [] };
-  }
-  const prevHashes = new Map(prevMeta.pages.map((p) => [p.route, p.hash]));
-  const currentRoutes = new Set(currentPages.map((p) => p.route));
-  const changed = [];
-  const added = [];
-  for (const page of currentPages) {
-    const prevHash = prevHashes.get(page.route);
-    if (!prevHash) {
-      added.push(page.route);
-    } else if (prevHash !== page.hash) {
-      changed.push(page.route);
-    }
-  }
-  const removed = [];
-  for (const route of prevHashes.keys()) {
-    if (!currentRoutes.has(route)) {
-      removed.push(route);
-    }
-  }
-  return { changed, added, removed };
-}
-
 async function fetchPreviousMeta(siteUrl, indexNowKey) {
   const metaUrl = `${siteUrl}/__ai-ready/pages.meta.json`;
   logger.debug(`[indexnow] Fetching previous meta from ${metaUrl}`);
@@ -169,7 +103,7 @@ async function handleStaticIndexNow(currentPages, siteUrl, indexNowKey, prevMeta
     return;
   }
   logger.info(`[indexnow] Submitting ${totalChanged} changed pages (${changed.length} modified, ${added.length} new)`);
-  const result = await submitToIndexNow(
+  const result = await submitToIndexNowShared(
     [...changed, ...added],
     indexNowKey,
     siteUrl,
@@ -701,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 indexNowKey = config.indexNowKey || 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: !!indexNowKey,
+        runtimeSync: runtimeSyncEnabled
+      }
+    });
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
@@ -713,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;
@@ -774,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,
@@ -795,7 +748,7 @@ export const errorRoutes = []`;
         batchSize: runtimeSyncConfig.batchSize ?? 20,
         pruneTtl: runtimeSyncConfig.pruneTtl ?? 0
       },
-      runtimeSyncSecret: config.runtimeSyncSecret,
+      runtimeSyncSecret,
       indexNowKey
     };
     addServerHandler({

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/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 } })

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-shared.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared IndexNow utilities for build-time and runtime
+ * This module has no Nuxt/Nitro dependencies so it can be used in both contexts
+ */
+export declare const INDEXNOW_HOSTS: string[];
+/**
+ * Get IndexNow endpoints, with test override support
+ */
+export declare function getIndexNowEndpoints(): string[];
+export interface IndexNowSubmitResult {
+    success: boolean;
+    error?: string;
+    host?: string;
+}
+export interface IndexNowRequestBody {
+    host: string;
+    key: string;
+    keyLocation: string;
+    urlList: string[];
+}
+/**
+ * Build the IndexNow API request body
+ */
+export declare function buildIndexNowBody(routes: string[], key: string, siteUrl: string): IndexNowRequestBody;
+export interface SubmitOptions {
+    /** Custom fetch implementation (defaults to globalThis.fetch) */
+    fetchFn?: typeof fetch;
+    /** Logger for debug/warn messages (optional) */
+    logger?: {
+        debug: (msg: string) => void;
+        warn: (msg: string) => void;
+    };
+}
+/**
+ * Submit URLs to IndexNow API with fallback on rate limit
+ * Works in both build-time (native fetch) and runtime ($fetch) contexts
+ */
+export declare function submitToIndexNowShared(routes: string[], key: string, siteUrl: string, options?: SubmitOptions): Promise<IndexNowSubmitResult>;
+export interface PageHashMeta {
+    route: string;
+    hash: string;
+}
+export interface BuildMeta {
+    buildId: string;
+    pageCount: number;
+    createdAt: string;
+    pages: PageHashMeta[];
+}
+/**
+ * Compare page hashes between current and previous builds
+ * Returns changed, added, and removed routes
+ */
+export declare function comparePageHashes(currentPages: PageHashMeta[], prevMeta: BuildMeta | null | undefined): {
+    changed: string[];
+    added: string[];
+    removed: string[];
+};

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

@@ -0,0 +1,77 @@
+export const INDEXNOW_HOSTS = ["api.indexnow.org", "www.bing.com"];
+export function getIndexNowEndpoints() {
+  const testEndpoint = process.env.INDEXNOW_TEST_ENDPOINT;
+  if (testEndpoint) {
+    return [testEndpoint];
+  }
+  return INDEXNOW_HOSTS.map((host) => `https://${host}/indexnow`);
+}
+export function buildIndexNowBody(routes, key, siteUrl) {
+  const urlList = routes.map(
+    (route) => route.startsWith("http") ? route : `${siteUrl}${route}`
+  );
+  return {
+    host: new URL(siteUrl).host,
+    key,
+    keyLocation: `${siteUrl}/${key}.txt`,
+    urlList
+  };
+}
+export async function submitToIndexNowShared(routes, key, siteUrl, options) {
+  if (!siteUrl) {
+    return { success: false, error: "Site URL not configured" };
+  }
+  const fetchFn = options?.fetchFn ?? globalThis.fetch;
+  const log = options?.logger;
+  const body = buildIndexNowBody(routes, key, siteUrl);
+  const endpoints = getIndexNowEndpoints();
+  let lastError;
+  for (const endpoint of endpoints) {
+    log?.debug(`[indexnow] Submitting ${body.urlList.length} URLs to ${endpoint}`);
+    const response = await fetchFn(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then((r) => r.ok ? { ok: true } : { error: `HTTP ${r.status}` }).catch((err) => ({ error: err.message }));
+    if ("error" in response) {
+      lastError = response.error;
+      if (lastError?.includes("429")) {
+        log?.warn(`[indexnow] Rate limited on ${endpoint}, trying fallback...`);
+        continue;
+      }
+      log?.warn(`[indexnow] Submission failed on ${endpoint}: ${lastError}`);
+      return { success: false, error: lastError, host: endpoint };
+    }
+    log?.debug(`[indexnow] Successfully submitted ${body.urlList.length} URLs via ${endpoint}`);
+    return { success: true, host: endpoint };
+  }
+  return {
+    success: false,
+    error: lastError || "All endpoints rate limited",
+    host: endpoints[endpoints.length - 1]
+  };
+}
+export function comparePageHashes(currentPages, prevMeta) {
+  if (!prevMeta?.pages) {
+    return { changed: [], added: [], removed: [] };
+  }
+  const prevHashes = new Map(prevMeta.pages.map((p) => [p.route, p.hash]));
+  const currentRoutes = new Set(currentPages.map((p) => p.route));
+  const changed = [];
+  const added = [];
+  for (const page of currentPages) {
+    const prevHash = prevHashes.get(page.route);
+    if (!prevHash) {
+      added.push(page.route);
+    } else if (prevHash !== page.hash) {
+      changed.push(page.route);
+    }
+  }
+  const removed = [];
+  for (const route of prevHashes.keys()) {
+    if (!currentRoutes.has(route)) {
+      removed.push(route);
+    }
+  }
+  return { changed, added, removed };
+}

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

@@ -1,5 +1,5 @@
 import type { H3Event } from 'h3';
-export type { BuildMeta, IndexNowSubmitResult, PageHashMeta } from '../../../shared/indexnow.js';
+export type { BuildMeta, IndexNowSubmitResult, PageHashMeta } from './indexnow-shared.js';
 export interface IndexNowResult {
     success: boolean;
     submitted: number;

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

@@ -1,6 +1,5 @@
 import { getSiteConfig } from "#site-config/server/composables";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { submitToIndexNow as submitToIndexNowShared } from "../../../shared/indexnow";
 import { useDatabase } from "../db/index.js";
 import {
   batchIndexNowUpdate,
@@ -10,6 +9,7 @@ import {
   updateIndexNowStats
 } from "../db/queries.js";
 import { logger } from "../logger.js";
+import { submitToIndexNowShared } from "./indexnow-shared.js";
 const BACKOFF_MINUTES = [5, 10, 20, 40, 60];
 async function getBackoffInfo(event) {
   const db = await useDatabase(event).catch(() => null);

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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": {