nuxt-ai-ready 0.8.1 → 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.1",
+  "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';
@@ -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");
@@ -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 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;
@@ -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,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.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.1",
+  "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": {