// scripts/generate-indexnow-key.ts
import crypto from "crypto";
 
// Genera una key hexadecimal de 32 caracteres
const key = crypto.randomBytes(16).toString("hex");
console.log("Tu API key:", key);
console.log("Guarda esto en INDEXNOW_API_KEY en tus env vars");

npx tsx scripts/generate-indexnow-key.ts

INDEXNOW_API_KEY=tu-key-generada-aqui

# Reemplaza {key} con tu key real
echo "tu-key-aqui" > public/tu-key-aqui.txt

# En local
curl http://localhost:3000/tu-key-aqui.txt
 
# En produccion
curl https://tudominio.com/tu-key-aqui.txt

// lib/indexnow.ts
 
const INDEXNOW_API = "https://api.indexnow.org/indexnow";
const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "https://rodalexanderson.com";
 
export interface IndexNowResult {
  success: boolean;
  status?: number;
  error?: string;
}
 
// Envio de una sola URL (GET)
export async function submitUrlToIndexNow(url: string): Promise<IndexNowResult> {
  const apiKey = process.env.INDEXNOW_API_KEY;
 
  if (!apiKey) {
    return { success: false, error: "INDEXNOW_API_KEY no esta configurada" };
  }
 
  try {
    const encodedUrl = encodeURIComponent(url);
    const keyLocation = encodeURIComponent(`${SITE_URL}/${apiKey}.txt`);
    const endpoint = `${INDEXNOW_API}?url=${encodedUrl}&key=${apiKey}&keyLocation=${keyLocation}`;
 
    const response = await fetch(endpoint, {
      method: "GET",
      headers: { "User-Agent": "NextJS/IndexNow-Client" },
    });
 
    if (response.status === 200 || response.status === 202) {
      return { success: true, status: response.status };
    }
 
    return {
      success: false,
      status: response.status,
      error: `Error HTTP ${response.status}`,
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : "Error desconocido",
    };
  }
}
 
// Envio de multiples URLs (POST batch)
export async function submitBatchToIndexNow(urls: string[]): Promise<IndexNowResult> {
  const apiKey = process.env.INDEXNOW_API_KEY;
 
  if (!apiKey) {
    return { success: false, error: "INDEXNOW_API_KEY no esta configurada" };
  }
 
  if (urls.length === 0) {
    return { success: false, error: "La lista de URLs esta vacia" };
  }
 
  const host = new URL(SITE_URL).hostname;
  const keyLocation = `${SITE_URL}/${apiKey}.txt`;
 
  const payload = {
    host,
    key: apiKey,
    keyLocation,
    urlList: urls,
  };
 
  try {
    const response = await fetch(INDEXNOW_API, {
      method: "POST",
      headers: {
        "Content-Type": "application/json; charset=utf-8",
        "User-Agent": "NextJS/IndexNow-Client",
      },
      body: JSON.stringify(payload),
    });
 
    if (response.status === 200 || response.status === 202) {
      return { success: true, status: response.status };
    }
 
    return {
      success: false,
      status: response.status,
      error: `Error HTTP ${response.status}`,
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : "Error desconocido",
    };
  }
}

// lib/get-site-urls.ts
import { getAllPosts } from "@/lib/content";
 
const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "https://rodalexanderson.com";
 
export async function getSiteUrls(): Promise<string[]> {
  // Paginas estaticas
  const staticUrls = [
    SITE_URL,
    `${SITE_URL}/blog`,
    `${SITE_URL}/sobre-mi`,
    `${SITE_URL}/docs`,
  ];
 
  // Posts del blog (desde tu pipeline de contenido)
  const posts = await getAllPosts();
  const blogUrls = posts.map((post) => `${SITE_URL}/blog/${post.slug}`);
 
  return [...staticUrls, ...blogUrls];
}

// scripts/submit-all-urls.ts
import { getSiteUrls } from "../lib/get-site-urls";
import { submitBatchToIndexNow } from "../lib/indexnow";
 
async function main() {
  console.log("Obteniendo URLs del sitio...");
  const urls = await getSiteUrls();
  console.log(`Total de URLs: ${urls.length}`);
 
  const result = await submitBatchToIndexNow(urls);
 
  if (result.success) {
    console.log(`Envio exitoso. Status: ${result.status}`);
  } else {
    console.error(`Error en envio: ${result.error}`);
    process.exit(1);
  }
}
 
main().catch(console.error);

{
  "scripts": {
    "build": "next build",
    "postbuild": "tsx scripts/submit-all-urls.ts"
  }
}

// app/api/indexnow/route.ts
import { NextRequest, NextResponse } from "next/server";
import { getSiteUrls } from "@/lib/get-site-urls";
import { submitBatchToIndexNow } from "@/lib/indexnow";
 
export async function POST(request: NextRequest) {
  // Verifica el token de seguridad para evitar llamadas no autorizadas
  const authHeader = request.headers.get("authorization");
  const expectedToken = process.env.INDEXNOW_WEBHOOK_SECRET;
 
  if (!expectedToken || authHeader !== `Bearer ${expectedToken}`) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  try {
    const urls = await getSiteUrls();
    const result = await submitBatchToIndexNow(urls);
 
    if (!result.success) {
      return NextResponse.json(
        { error: result.error, status: result.status },
        { status: 500 }
      );
    }
 
    return NextResponse.json({
      success: true,
      urlsSubmitted: urls.length,
      indexNowStatus: result.status,
    });
  } catch (error) {
    return NextResponse.json(
      { error: "Error interno del servidor" },
      { status: 500 }
    );
  }
}

// Ejemplo de payload para batch submission
const payload = {
  host: "rodalexanderson.com",
  key: process.env.INDEXNOW_API_KEY, // Nunca el valor literal
  keyLocation: "https://rodalexanderson.com/f790fd5bff194046a27c7c2ed7ad836f.txt",
  urlList: [
    "https://rodalexanderson.com/blog/indexnow-nextjs-guia-completa",
    "https://rodalexanderson.com/blog/seo-nextjs-metadata-og-sitemap",
    "https://rodalexanderson.com/",
  ],
};

// lib/indexnow.ts -- funcion para dividir en chunks si es necesario
export async function submitAllUrlsInBatches(urls: string[]): Promise<IndexNowResult[]> {
  const CHUNK_SIZE = 10_000;
  const results: IndexNowResult[] = [];
 
  for (let i = 0; i < urls.length; i += CHUNK_SIZE) {
    const chunk = urls.slice(i, i + CHUNK_SIZE);
    const result = await submitBatchToIndexNow(chunk);
    results.push(result);
 
    // Pequeña pausa entre batches para no saturar el API
    if (i + CHUNK_SIZE < urls.length) {
      await new Promise((resolve) => setTimeout(resolve, 1000));
    }
  }
 
  return results;
}

# Prueba un envio individual
curl -v "https://api.indexnow.org/indexnow?url=https://tudominio.com/blog/tu-post&key=tu-api-key"
 
# Respuesta esperada: 200 OK o 202 Accepted

// lib/google-ping.ts
export async function pingGoogleSitemap(sitemapUrl: string): Promise<boolean> {
  try {
    const pingUrl = `https://www.google.com/ping?sitemap=${encodeURIComponent(sitemapUrl)}`;
    const response = await fetch(pingUrl);
    return response.ok;
  } catch {
    return false;
  }
}

// scripts/notify-search-engines.ts
import { submitBatchToIndexNow } from "../lib/indexnow";
import { pingGoogleSitemap } from "../lib/google-ping";
import { getSiteUrls } from "../lib/get-site-urls";
 
async function main() {
  const siteUrl = process.env.NEXT_PUBLIC_SITE_URL ?? "https://rodalexanderson.com";
 
  // IndexNow para Bing y Yandex
  const urls = await getSiteUrls();
  const indexNowResult = await submitBatchToIndexNow(urls);
  console.log("IndexNow:", indexNowResult.success ? "OK" : indexNowResult.error);
 
  // Ping de sitemap para Google
  const sitemapUrl = `${siteUrl}/sitemap.xml`;
  const googleResult = await pingGoogleSitemap(sitemapUrl);
  console.log("Google Ping:", googleResult ? "OK" : "Error");
}
 
main().catch(console.error);

# 1. Verifica que el archivo existe
curl https://tudominio.com/tu-api-key.txt
 
# 2. El contenido debe ser exactamente la key
# Sin espacios, sin saltos de linea al final
 
# 3. Verifica que el keyLocation en el payload es correcto
# Debe coincidir con la URL del archivo que creaste

// MAL: mezclando hosts
const payload = {
  host: "rodalexanderson.com",
  urlList: [
    "https://rodalexanderson.com/blog/post-1",
    "https://otro-dominio.com/pagina", // Este causa el 422
  ],
};
 
// BIEN: solo URLs del host declarado
const payload = {
  host: "rodalexanderson.com",
  urlList: [
    "https://rodalexanderson.com/blog/post-1",
    "https://rodalexanderson.com/blog/post-2",
  ],
};