@seo-console/package 1.0.0 → 1.0.1

package/dist/server.mjs

@@ -0,0 +1,1485 @@
+// src/lib/supabase/server.ts
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+async function createClient() {
+  const cookieStore = await cookies();
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(
+              ({ name, value, options }) => cookieStore.set(name, value, options)
+            );
+          } catch {
+          }
+        }
+      }
+    }
+  );
+}
+
+// src/lib/database/seo-records.ts
+function transformRowToSEORecord(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    routePath: row.route_path,
+    title: row.title ?? void 0,
+    description: row.description ?? void 0,
+    keywords: row.keywords ?? void 0,
+    ogTitle: row.og_title ?? void 0,
+    ogDescription: row.og_description ?? void 0,
+    ogImageUrl: row.og_image_url ?? void 0,
+    ogImageWidth: row.og_image_width ?? void 0,
+    ogImageHeight: row.og_image_height ?? void 0,
+    ogType: row.og_type ?? void 0,
+    ogUrl: row.og_url ?? void 0,
+    ogSiteName: row.og_site_name ?? void 0,
+    twitterCard: row.twitter_card ?? void 0,
+    twitterTitle: row.twitter_title ?? void 0,
+    twitterDescription: row.twitter_description ?? void 0,
+    twitterImageUrl: row.twitter_image_url ?? void 0,
+    twitterSite: row.twitter_site ?? void 0,
+    twitterCreator: row.twitter_creator ?? void 0,
+    canonicalUrl: row.canonical_url ?? void 0,
+    robots: row.robots ?? void 0,
+    author: row.author ?? void 0,
+    publishedTime: row.published_time ? new Date(row.published_time) : void 0,
+    modifiedTime: row.modified_time ? new Date(row.modified_time) : void 0,
+    structuredData: row.structured_data ? row.structured_data : void 0,
+    validationStatus: row.validation_status ?? void 0,
+    lastValidatedAt: row.last_validated_at ? new Date(row.last_validated_at) : void 0,
+    validationErrors: row.validation_errors ? row.validation_errors : void 0,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function transformToInsert(record) {
+  return {
+    user_id: record.userId,
+    route_path: record.routePath,
+    title: record.title ?? null,
+    description: record.description ?? null,
+    keywords: record.keywords ?? null,
+    og_title: record.ogTitle ?? null,
+    og_description: record.ogDescription ?? null,
+    og_image_url: record.ogImageUrl ?? null,
+    og_image_width: record.ogImageWidth ?? null,
+    og_image_height: record.ogImageHeight ?? null,
+    og_type: record.ogType ?? null,
+    og_url: record.ogUrl ?? null,
+    og_site_name: record.ogSiteName ?? null,
+    twitter_card: record.twitterCard ?? null,
+    twitter_title: record.twitterTitle ?? null,
+    twitter_description: record.twitterDescription ?? null,
+    twitter_image_url: record.twitterImageUrl ?? null,
+    twitter_site: record.twitterSite ?? null,
+    twitter_creator: record.twitterCreator ?? null,
+    canonical_url: record.canonicalUrl ?? null,
+    robots: record.robots ?? null,
+    author: record.author ?? null,
+    published_time: record.publishedTime?.toISOString() ?? null,
+    modified_time: record.modifiedTime?.toISOString() ?? null,
+    structured_data: record.structuredData ?? null
+  };
+}
+function transformToUpdate(record) {
+  const update = {};
+  if (record.routePath !== void 0) update.route_path = record.routePath;
+  if (record.title !== void 0) update.title = record.title ?? null;
+  if (record.description !== void 0)
+    update.description = record.description ?? null;
+  if (record.keywords !== void 0) update.keywords = record.keywords ?? null;
+  if (record.ogTitle !== void 0) update.og_title = record.ogTitle ?? null;
+  if (record.ogDescription !== void 0)
+    update.og_description = record.ogDescription ?? null;
+  if (record.ogImageUrl !== void 0)
+    update.og_image_url = record.ogImageUrl ?? null;
+  if (record.ogImageWidth !== void 0)
+    update.og_image_width = record.ogImageWidth ?? null;
+  if (record.ogImageHeight !== void 0)
+    update.og_image_height = record.ogImageHeight ?? null;
+  if (record.ogType !== void 0) update.og_type = record.ogType ?? null;
+  if (record.ogUrl !== void 0) update.og_url = record.ogUrl ?? null;
+  if (record.ogSiteName !== void 0)
+    update.og_site_name = record.ogSiteName ?? null;
+  if (record.twitterCard !== void 0)
+    update.twitter_card = record.twitterCard ?? null;
+  if (record.twitterTitle !== void 0)
+    update.twitter_title = record.twitterTitle ?? null;
+  if (record.twitterDescription !== void 0)
+    update.twitter_description = record.twitterDescription ?? null;
+  if (record.twitterImageUrl !== void 0)
+    update.twitter_image_url = record.twitterImageUrl ?? null;
+  if (record.twitterSite !== void 0)
+    update.twitter_site = record.twitterSite ?? null;
+  if (record.twitterCreator !== void 0)
+    update.twitter_creator = record.twitterCreator ?? null;
+  if (record.canonicalUrl !== void 0)
+    update.canonical_url = record.canonicalUrl ?? null;
+  if (record.robots !== void 0) update.robots = record.robots ?? null;
+  if (record.author !== void 0) update.author = record.author ?? null;
+  if (record.publishedTime !== void 0)
+    update.published_time = record.publishedTime?.toISOString() ?? null;
+  if (record.modifiedTime !== void 0)
+    update.modified_time = record.modifiedTime?.toISOString() ?? null;
+  if (record.structuredData !== void 0)
+    update.structured_data = record.structuredData ?? null;
+  if (record.validationStatus !== void 0)
+    update.validation_status = record.validationStatus ?? null;
+  if (record.lastValidatedAt !== void 0)
+    update.last_validated_at = record.lastValidatedAt?.toISOString() ?? null;
+  if (record.validationErrors !== void 0)
+    update.validation_errors = record.validationErrors ?? null;
+  return update;
+}
+async function getSEORecords() {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const { data, error } = await supabase.from("seo_records").select("*").eq("user_id", user.id).order("created_at", { ascending: false });
+    if (error) {
+      return { success: false, error };
+    }
+    const records = (data || []).map(transformRowToSEORecord);
+    return { success: true, data: records };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+async function getSEORecordById(id) {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const { data, error } = await supabase.from("seo_records").select("*").eq("id", id).eq("user_id", user.id).single();
+    if (error) {
+      return { success: false, error };
+    }
+    if (!data) {
+      return {
+        success: false,
+        error: new Error("SEO record not found")
+      };
+    }
+    return { success: true, data: transformRowToSEORecord(data) };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+async function getSEORecordByRoute(routePath) {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const { data, error } = await supabase.from("seo_records").select("*").eq("route_path", routePath).eq("user_id", user.id).maybeSingle();
+    if (error) {
+      return { success: false, error };
+    }
+    if (!data) {
+      return { success: true, data: null };
+    }
+    return { success: true, data: transformRowToSEORecord(data) };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+async function createSEORecord(record) {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const insertData = transformToInsert({ ...record, userId: user.id });
+    const { data, error } = await supabase.from("seo_records").insert(insertData).select().single();
+    if (error) {
+      return { success: false, error };
+    }
+    return { success: true, data: transformRowToSEORecord(data) };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+async function updateSEORecord(record) {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const { id, ...updateData } = record;
+    const transformedUpdate = transformToUpdate(updateData);
+    const { data, error } = await supabase.from("seo_records").update(transformedUpdate).eq("id", id).eq("user_id", user.id).select().single();
+    if (error) {
+      return { success: false, error };
+    }
+    if (!data) {
+      return {
+        success: false,
+        error: new Error("SEO record not found")
+      };
+    }
+    return { success: true, data: transformRowToSEORecord(data) };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+async function deleteSEORecord(id) {
+  try {
+    const supabase = await createClient();
+    const {
+      data: { user }
+    } = await supabase.auth.getUser();
+    if (!user) {
+      return {
+        success: false,
+        error: new Error("User not authenticated")
+      };
+    }
+    const { error } = await supabase.from("seo_records").delete().eq("id", id).eq("user_id", user.id);
+    if (error) {
+      return { success: false, error };
+    }
+    return { success: true, data: void 0 };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error")
+    };
+  }
+}
+
+// src/lib/validation/seo-schema.ts
+import { z } from "zod";
+var ogTypeSchema = z.enum([
+  "website",
+  "article",
+  "product",
+  "book",
+  "profile",
+  "music",
+  "video"
+]);
+var twitterCardSchema = z.enum([
+  "summary",
+  "summary_large_image",
+  "app",
+  "player"
+]);
+var validationStatusSchema = z.enum([
+  "pending",
+  "valid",
+  "invalid",
+  "warning"
+]);
+var seoMetadataSchema = z.object({
+  // Basic metadata
+  title: z.string().max(60, "Title must be 60 characters or less").optional(),
+  description: z.string().max(160, "Description must be 160 characters or less").optional(),
+  keywords: z.array(z.string()).optional(),
+  // Open Graph
+  ogTitle: z.string().max(60).optional(),
+  ogDescription: z.string().max(200).optional(),
+  ogImageUrl: z.string().url("Must be a valid URL").optional(),
+  ogImageWidth: z.number().int().positive().max(1200).optional(),
+  ogImageHeight: z.number().int().positive().max(1200).optional(),
+  ogType: ogTypeSchema.optional(),
+  ogUrl: z.string().url("Must be a valid URL").optional(),
+  ogSiteName: z.string().optional(),
+  // Twitter Card
+  twitterCard: twitterCardSchema.optional(),
+  twitterTitle: z.string().max(70).optional(),
+  twitterDescription: z.string().max(200).optional(),
+  twitterImageUrl: z.string().url("Must be a valid URL").optional(),
+  twitterSite: z.string().optional(),
+  twitterCreator: z.string().optional(),
+  // Additional metadata
+  canonicalUrl: z.string().url("Must be a valid URL").optional(),
+  robots: z.string().optional(),
+  author: z.string().optional(),
+  publishedTime: z.coerce.date().optional(),
+  modifiedTime: z.coerce.date().optional(),
+  // Structured data
+  structuredData: z.record(z.unknown()).optional()
+});
+var seoRecordSchema = seoMetadataSchema.extend({
+  id: z.string().uuid().optional(),
+  userId: z.string().uuid(),
+  routePath: z.string().min(1, "Route path is required").regex(/^\/.*/, "Route path must start with /"),
+  validationStatus: validationStatusSchema.optional(),
+  lastValidatedAt: z.coerce.date().optional(),
+  validationErrors: z.record(z.unknown()).optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional()
+});
+var createSEORecordSchema = seoRecordSchema.omit({
+  id: true,
+  validationStatus: true,
+  lastValidatedAt: true,
+  validationErrors: true,
+  createdAt: true,
+  updatedAt: true
+});
+var updateSEORecordSchema = seoRecordSchema.partial().required({ id: true }).omit({
+  userId: true,
+  createdAt: true
+});
+
+// src/lib/validation/image-validator.ts
+import sharp from "sharp";
+async function validateOGImage(imageUrl, expectedWidth, expectedHeight) {
+  const issues = [];
+  try {
+    const response = await fetch(imageUrl, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; SEO-Console/1.0; +https://example.com/bot)"
+      },
+      signal: AbortSignal.timeout(15e3)
+      // 15 second timeout for images
+    });
+    if (!response.ok) {
+      return {
+        isValid: false,
+        issues: [
+          {
+            field: "image",
+            severity: "critical",
+            message: `Failed to fetch image: ${response.status} ${response.statusText}`,
+            actual: imageUrl
+          }
+        ]
+      };
+    }
+    const imageBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(imageBuffer);
+    const sizeInMB = buffer.length / (1024 * 1024);
+    if (sizeInMB > 1) {
+      issues.push({
+        field: "image",
+        severity: "warning",
+        message: "Image file size exceeds 1MB recommendation",
+        actual: `${sizeInMB.toFixed(2)}MB`
+      });
+    }
+    const metadata = await sharp(buffer).metadata();
+    const { width, height, format } = metadata;
+    if (!width || !height) {
+      return {
+        isValid: false,
+        issues: [
+          {
+            field: "image",
+            severity: "critical",
+            message: "Could not determine image dimensions",
+            actual: imageUrl
+          }
+        ]
+      };
+    }
+    const recommendedWidth = 1200;
+    const recommendedHeight = 630;
+    const aspectRatio = width / height;
+    const recommendedAspectRatio = recommendedWidth / recommendedHeight;
+    if (width < recommendedWidth || height < recommendedHeight) {
+      issues.push({
+        field: "image",
+        severity: "warning",
+        message: `Image dimensions below recommended size (${recommendedWidth}x${recommendedHeight})`,
+        expected: `${recommendedWidth}x${recommendedHeight}`,
+        actual: `${width}x${height}`
+      });
+    }
+    if (Math.abs(aspectRatio - recommendedAspectRatio) > 0.1) {
+      issues.push({
+        field: "image",
+        severity: "info",
+        message: "Image aspect ratio differs from recommended 1.91:1",
+        expected: "1.91:1",
+        actual: `${aspectRatio.toFixed(2)}:1`
+      });
+    }
+    const supportedFormats = ["jpeg", "jpg", "png", "webp", "avif", "gif"];
+    if (!format || !supportedFormats.includes(format.toLowerCase())) {
+      issues.push({
+        field: "image",
+        severity: "warning",
+        message: "Image format may not be optimal for social sharing",
+        expected: "JPEG, PNG, WebP, or AVIF",
+        actual: format || "unknown"
+      });
+    }
+    if (expectedWidth && width !== expectedWidth) {
+      issues.push({
+        field: "image",
+        severity: "warning",
+        message: "Image width does not match expected value",
+        expected: `${expectedWidth}px`,
+        actual: `${width}px`
+      });
+    }
+    if (expectedHeight && height !== expectedHeight) {
+      issues.push({
+        field: "image",
+        severity: "warning",
+        message: "Image height does not match expected value",
+        expected: `${expectedHeight}px`,
+        actual: `${height}px`
+      });
+    }
+    return {
+      isValid: issues.filter((i) => i.severity === "critical").length === 0,
+      issues,
+      metadata: {
+        width,
+        height,
+        format: format || "unknown",
+        size: buffer.length
+      }
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      issues: [
+        {
+          field: "image",
+          severity: "critical",
+          message: error instanceof Error ? error.message : "Failed to validate image",
+          actual: imageUrl
+        }
+      ]
+    };
+  }
+}
+
+// src/lib/validation/html-validator.ts
+import * as cheerio from "cheerio";
+async function validateHTML(html, record, _baseUrl) {
+  const issues = [];
+  const $ = cheerio.load(html);
+  const title = $("title").text().trim();
+  if (record.title) {
+    if (!title) {
+      issues.push({
+        field: "title",
+        severity: "critical",
+        message: "Title tag is missing",
+        expected: record.title
+      });
+    } else if (title !== record.title) {
+      issues.push({
+        field: "title",
+        severity: "warning",
+        message: "Title tag does not match SEO record",
+        expected: record.title,
+        actual: title
+      });
+    }
+    if (title.length > 60) {
+      issues.push({
+        field: "title",
+        severity: "warning",
+        message: "Title exceeds recommended 60 characters",
+        actual: `${title.length} characters`
+      });
+    }
+  }
+  const metaDescription = $('meta[name="description"]').attr("content")?.trim();
+  if (record.description) {
+    if (!metaDescription) {
+      issues.push({
+        field: "description",
+        severity: "critical",
+        message: "Meta description is missing",
+        expected: record.description
+      });
+    } else if (metaDescription !== record.description) {
+      issues.push({
+        field: "description",
+        severity: "warning",
+        message: "Meta description does not match SEO record",
+        expected: record.description,
+        actual: metaDescription
+      });
+    }
+    if (metaDescription && metaDescription.length > 160) {
+      issues.push({
+        field: "description",
+        severity: "warning",
+        message: "Description exceeds recommended 160 characters",
+        actual: `${metaDescription.length} characters`
+      });
+    }
+  }
+  if (record.ogTitle || record.ogDescription || record.ogImageUrl) {
+    const ogTitle = $('meta[property="og:title"]').attr("content");
+    const ogDescription = $('meta[property="og:description"]').attr("content");
+    const ogImage = $('meta[property="og:image"]').attr("content");
+    const ogType = $('meta[property="og:type"]').attr("content");
+    const ogUrl = $('meta[property="og:url"]').attr("content");
+    if (record.ogTitle && !ogTitle) {
+      issues.push({
+        field: "og:title",
+        severity: "critical",
+        message: "Open Graph title is missing",
+        expected: record.ogTitle
+      });
+    }
+    if (record.ogDescription && !ogDescription) {
+      issues.push({
+        field: "og:description",
+        severity: "warning",
+        message: "Open Graph description is missing",
+        expected: record.ogDescription
+      });
+    }
+    if (record.ogImageUrl && !ogImage) {
+      issues.push({
+        field: "og:image",
+        severity: "critical",
+        message: "Open Graph image is missing",
+        expected: record.ogImageUrl
+      });
+    }
+    if (record.ogType && ogType !== record.ogType) {
+      issues.push({
+        field: "og:type",
+        severity: "warning",
+        message: "Open Graph type does not match",
+        expected: record.ogType,
+        actual: ogType
+      });
+    }
+    if (record.ogUrl && ogUrl !== record.ogUrl) {
+      issues.push({
+        field: "og:url",
+        severity: "warning",
+        message: "Open Graph URL does not match",
+        expected: record.ogUrl,
+        actual: ogUrl
+      });
+    }
+  }
+  if (record.twitterCard || record.twitterTitle || record.twitterImageUrl) {
+    const twitterCard = $('meta[name="twitter:card"]').attr("content");
+    const twitterTitle = $('meta[name="twitter:title"]').attr("content");
+    const _twitterDescription = $('meta[name="twitter:description"]').attr("content");
+    const twitterImage = $('meta[name="twitter:image"]').attr("content");
+    if (record.twitterCard && twitterCard !== record.twitterCard) {
+      issues.push({
+        field: "twitter:card",
+        severity: "warning",
+        message: "Twitter card type does not match",
+        expected: record.twitterCard,
+        actual: twitterCard
+      });
+    }
+    if (record.twitterTitle && !twitterTitle) {
+      issues.push({
+        field: "twitter:title",
+        severity: "warning",
+        message: "Twitter title is missing",
+        expected: record.twitterTitle
+      });
+    }
+    if (record.twitterImageUrl && !twitterImage) {
+      issues.push({
+        field: "twitter:image",
+        severity: "warning",
+        message: "Twitter image is missing",
+        expected: record.twitterImageUrl
+      });
+    }
+  }
+  if (record.canonicalUrl) {
+    const canonical = $('link[rel="canonical"]').attr("href");
+    if (!canonical) {
+      issues.push({
+        field: "canonical",
+        severity: "critical",
+        message: "Canonical URL is missing",
+        expected: record.canonicalUrl
+      });
+    } else if (canonical !== record.canonicalUrl) {
+      issues.push({
+        field: "canonical",
+        severity: "warning",
+        message: "Canonical URL does not match",
+        expected: record.canonicalUrl,
+        actual: canonical
+      });
+    }
+    if (canonical && !canonical.startsWith("http://") && !canonical.startsWith("https://")) {
+      issues.push({
+        field: "canonical",
+        severity: "warning",
+        message: "Canonical URL should be absolute",
+        actual: canonical
+      });
+    }
+  }
+  const robotsMeta = $('meta[name="robots"]').attr("content");
+  if (robotsMeta) {
+    const robots = robotsMeta.toLowerCase();
+    if (robots.includes("noindex")) {
+      issues.push({
+        field: "robots",
+        severity: "critical",
+        message: "Page has noindex meta tag - will NOT be indexed by search engines",
+        actual: robotsMeta
+      });
+    }
+    if (robots.includes("nofollow")) {
+      issues.push({
+        field: "robots",
+        severity: "warning",
+        message: "Page has nofollow meta tag - links won't be followed",
+        actual: robotsMeta
+      });
+    }
+  }
+  return {
+    isValid: issues.filter((i) => i.severity === "critical").length === 0,
+    issues,
+    validatedAt: /* @__PURE__ */ new Date()
+  };
+}
+async function validateURL(url, record) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; SEO-Console/1.0; +https://example.com/bot)"
+      },
+      // Timeout after 10 seconds
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return {
+        isValid: false,
+        issues: [
+          {
+            field: "fetch",
+            severity: "critical",
+            message: `Failed to fetch URL: ${response.status} ${response.statusText}`,
+            actual: url
+          }
+        ],
+        validatedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const html = await response.text();
+    return validateHTML(html, record, url);
+  } catch (error) {
+    return {
+      isValid: false,
+      issues: [
+        {
+          field: "fetch",
+          severity: "critical",
+          message: error instanceof Error ? error.message : "Failed to fetch URL",
+          actual: url
+        }
+      ],
+      validatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+
+// src/lib/storage/file-storage.ts
+import { promises as fs } from "fs";
+var FileStorage = class {
+  constructor(filePath = "seo-records.json") {
+    this.records = [];
+    this.initialized = false;
+    this.filePath = filePath;
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    try {
+      const data = await fs.readFile(this.filePath, "utf-8");
+      this.records = JSON.parse(data);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.records = [];
+        await this.save();
+      } else {
+        throw error;
+      }
+    }
+    this.initialized = true;
+  }
+  async save() {
+    await fs.writeFile(this.filePath, JSON.stringify(this.records, null, 2), "utf-8");
+  }
+  async isAvailable() {
+    try {
+      const dir = this.filePath.includes("/") ? this.filePath.substring(0, this.filePath.lastIndexOf("/")) : ".";
+      await fs.access(dir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getRecords() {
+    await this.ensureInitialized();
+    return [...this.records];
+  }
+  async getRecordById(id) {
+    await this.ensureInitialized();
+    return this.records.find((r) => r.id === id) || null;
+  }
+  async getRecordByRoute(routePath) {
+    await this.ensureInitialized();
+    return this.records.find((r) => r.routePath === routePath) || null;
+  }
+  async createRecord(record) {
+    await this.ensureInitialized();
+    const newRecord = {
+      id: typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      userId: "file-user",
+      // File storage doesn't need user IDs
+      routePath: record.routePath,
+      title: record.title,
+      description: record.description,
+      keywords: record.keywords,
+      ogTitle: record.ogTitle,
+      ogDescription: record.ogDescription,
+      ogImageUrl: record.ogImageUrl,
+      ogImageWidth: record.ogImageWidth,
+      ogImageHeight: record.ogImageHeight,
+      ogType: record.ogType,
+      ogUrl: record.ogUrl,
+      ogSiteName: record.ogSiteName,
+      twitterCard: record.twitterCard,
+      twitterTitle: record.twitterTitle,
+      twitterDescription: record.twitterDescription,
+      twitterImageUrl: record.twitterImageUrl,
+      twitterSite: record.twitterSite,
+      twitterCreator: record.twitterCreator,
+      canonicalUrl: record.canonicalUrl,
+      robots: record.robots,
+      author: record.author,
+      publishedTime: record.publishedTime,
+      modifiedTime: record.modifiedTime,
+      structuredData: record.structuredData,
+      validationStatus: "pending",
+      lastValidatedAt: void 0,
+      validationErrors: void 0
+    };
+    this.records.push(newRecord);
+    await this.save();
+    return newRecord;
+  }
+  async updateRecord(record) {
+    await this.ensureInitialized();
+    const index = this.records.findIndex((r) => r.id === record.id);
+    if (index === -1) {
+      throw new Error(`SEO record with id ${record.id} not found`);
+    }
+    const updated = {
+      ...this.records[index],
+      ...record
+    };
+    this.records[index] = updated;
+    await this.save();
+    return updated;
+  }
+  async deleteRecord(id) {
+    await this.ensureInitialized();
+    const index = this.records.findIndex((r) => r.id === id);
+    if (index === -1) {
+      throw new Error(`SEO record with id ${id} not found`);
+    }
+    this.records.splice(index, 1);
+    await this.save();
+  }
+};
+
+// src/lib/storage/supabase-storage.ts
+var SupabaseStorage = class {
+  constructor(supabaseUrl, supabaseKey) {
+    this.supabaseUrl = supabaseUrl;
+    this.supabaseKey = supabaseKey;
+    if (typeof process !== "undefined") {
+      process.env.NEXT_PUBLIC_SUPABASE_URL = supabaseUrl;
+      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY = supabaseKey;
+    }
+  }
+  async isAvailable() {
+    try {
+      const result = await getSEORecords();
+      return result.success;
+    } catch {
+      return false;
+    }
+  }
+  async getRecords() {
+    const result = await getSEORecords();
+    if (!result.success) {
+      throw new Error(result.error?.message || "Failed to get records");
+    }
+    return result.data;
+  }
+  async getRecordById(id) {
+    const result = await getSEORecordById(id);
+    if (!result.success) {
+      if (result.error?.message?.includes("not found")) {
+        return null;
+      }
+      throw new Error(result.error?.message || "Failed to get record");
+    }
+    return result.data || null;
+  }
+  async getRecordByRoute(routePath) {
+    const result = await getSEORecordByRoute(routePath);
+    if (!result.success) {
+      if (result.error?.message?.includes("not found")) {
+        return null;
+      }
+      throw new Error(result.error?.message || "Failed to get record");
+    }
+    return result.data || null;
+  }
+  async createRecord(record) {
+    const result = await createSEORecord(record);
+    if (!result.success) {
+      throw new Error(result.error?.message || "Failed to create record");
+    }
+    return result.data;
+  }
+  async updateRecord(record) {
+    const result = await updateSEORecord(record);
+    if (!result.success) {
+      throw new Error(result.error?.message || "Failed to update record");
+    }
+    return result.data;
+  }
+  async deleteRecord(id) {
+    const result = await deleteSEORecord(id);
+    if (!result.success) {
+      throw new Error(result.error?.message || "Failed to delete record");
+    }
+  }
+};
+
+// src/lib/storage/storage-factory.ts
+function createStorageAdapter(config) {
+  switch (config.type) {
+    case "file":
+      return new FileStorage(config.filePath || "seo-records.json");
+    case "supabase":
+      if (!config.supabaseUrl || !config.supabaseKey) {
+        throw new Error("Supabase URL and key are required for Supabase storage");
+      }
+      return new SupabaseStorage(config.supabaseUrl, config.supabaseKey);
+    case "memory":
+      return new FileStorage(":memory:");
+    default:
+      throw new Error(`Unsupported storage type: ${config.type}`);
+  }
+}
+function detectStorageConfig() {
+  if (process.env.NEXT_PUBLIC_SUPABASE_URL && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
+    return {
+      type: "supabase",
+      supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL,
+      supabaseKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
+    };
+  }
+  if (process.env.SEO_CONSOLE_STORAGE_PATH) {
+    return {
+      type: "file",
+      filePath: process.env.SEO_CONSOLE_STORAGE_PATH
+    };
+  }
+  return {
+    type: "file",
+    filePath: "seo-records.json"
+  };
+}
+
+// src/hooks/useGenerateMetadata.ts
+async function useGenerateMetadata(options = {}) {
+  const { routePath, fallback = {} } = options;
+  if (!routePath) {
+    return {
+      title: fallback.title,
+      description: fallback.description,
+      ...fallback
+    };
+  }
+  let record = null;
+  try {
+    const storageConfig = detectStorageConfig();
+    if (storageConfig.type === "file" || storageConfig.type === "memory") {
+      const storage = createStorageAdapter(storageConfig);
+      record = await storage.getRecordByRoute(routePath);
+    } else {
+      const result = await getSEORecordByRoute(routePath);
+      record = result.success ? result.data || null : null;
+    }
+  } catch (error) {
+    const result = await getSEORecordByRoute(routePath);
+    record = result.success ? result.data || null : null;
+  }
+  if (!record) {
+    return {
+      title: fallback.title,
+      description: fallback.description,
+      ...fallback
+    };
+  }
+  const metadata = {};
+  if (record.title) {
+    metadata.title = record.title;
+  }
+  if (record.description) {
+    metadata.description = record.description;
+  }
+  if (record.keywords && record.keywords.length > 0) {
+    metadata.keywords = record.keywords;
+  }
+  if (record.author) {
+    metadata.authors = [{ name: record.author }];
+  }
+  if (record.ogTitle || record.ogDescription || record.ogImageUrl || record.ogType) {
+    const supportedOGTypes = ["website", "article", "book", "profile"];
+    const ogType = record.ogType && supportedOGTypes.includes(record.ogType) ? record.ogType : "website";
+    const openGraph = {
+      type: ogType,
+      title: record.ogTitle || record.title || void 0,
+      description: record.ogDescription || record.description || void 0,
+      url: record.ogUrl || void 0,
+      siteName: record.ogSiteName || void 0
+    };
+    if (record.ogImageUrl) {
+      openGraph.images = [
+        {
+          url: record.ogImageUrl,
+          width: record.ogImageWidth || void 0,
+          height: record.ogImageHeight || void 0,
+          alt: record.ogTitle || record.title || void 0
+        }
+      ];
+    }
+    if (ogType === "article") {
+      const articleOpenGraph = {
+        ...openGraph,
+        ...record.publishedTime && {
+          publishedTime: record.publishedTime.toISOString()
+        },
+        ...record.modifiedTime && {
+          modifiedTime: record.modifiedTime.toISOString()
+        }
+      };
+      metadata.openGraph = articleOpenGraph;
+    } else {
+      metadata.openGraph = openGraph;
+    }
+  }
+  if (record.twitterCard || record.twitterTitle || record.twitterDescription || record.twitterImageUrl) {
+    metadata.twitter = {
+      card: record.twitterCard || "summary",
+      title: record.twitterTitle || record.ogTitle || record.title || void 0,
+      description: record.twitterDescription || record.ogDescription || record.description || void 0,
+      images: record.twitterImageUrl ? [record.twitterImageUrl] : void 0,
+      site: record.twitterSite || void 0,
+      creator: record.twitterCreator || void 0
+    };
+  }
+  if (record.canonicalUrl) {
+    metadata.alternates = {
+      canonical: record.canonicalUrl
+    };
+  }
+  if (record.robots) {
+    metadata.robots = record.robots;
+  }
+  return {
+    ...fallback,
+    ...metadata,
+    // Ensure title and description from record override fallback if present
+    title: record.title || fallback.title,
+    description: record.description || fallback.description,
+    // Merge openGraph if both exist
+    openGraph: fallback.openGraph ? { ...metadata.openGraph, ...fallback.openGraph } : metadata.openGraph,
+    // Merge twitter if both exist
+    twitter: fallback.twitter ? { ...metadata.twitter, ...fallback.twitter } : metadata.twitter
+  };
+}
+function getRoutePathFromParams(params, pattern) {
+  let routePath = pattern;
+  for (const [key, value] of Object.entries(params)) {
+    const paramValue = Array.isArray(value) ? value.join("/") : value;
+    routePath = routePath.replace(`[${key}]`, paramValue);
+    routePath = routePath.replace(`[...${key}]`, paramValue);
+  }
+  return routePath;
+}
+
+// src/lib/sitemap-generator.ts
+function generateSitemapXML(options) {
+  const { baseUrl, entries } = options;
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${entries.map((entry) => {
+    const loc = entry.loc.startsWith("http") ? entry.loc : new URL(entry.loc, baseUrl).toString();
+    return `  <url>
+    <loc>${escapeXML(loc)}</loc>${entry.lastmod ? `
+    <lastmod>${entry.lastmod}</lastmod>` : ""}${entry.changefreq ? `
+    <changefreq>${entry.changefreq}</changefreq>` : ""}${entry.priority !== void 0 ? `
+    <priority>${entry.priority}</priority>` : ""}
+  </url>`;
+  }).join("\n")}
+</urlset>`;
+  return xml;
+}
+function seoRecordsToSitemapEntries(records, baseUrl) {
+  return records.filter((record) => {
+    return record.canonicalUrl && record.canonicalUrl.trim() !== "";
+  }).map((record) => {
+    const entry = {
+      loc: record.canonicalUrl
+    };
+    if (record.modifiedTime) {
+      entry.lastmod = record.modifiedTime.toISOString().split("T")[0];
+    } else if (record.lastValidatedAt) {
+      entry.lastmod = record.lastValidatedAt.toISOString().split("T")[0];
+    }
+    if (record.routePath === "/") {
+      entry.changefreq = "daily";
+      entry.priority = 1;
+    } else if (record.routePath.includes("/blog/") || record.routePath.includes("/posts/")) {
+      entry.changefreq = "weekly";
+      entry.priority = 0.8;
+    } else {
+      entry.changefreq = "monthly";
+      entry.priority = 0.6;
+    }
+    return entry;
+  }).sort((a, b) => {
+    if (a.priority !== b.priority) {
+      return (b.priority || 0) - (a.priority || 0);
+    }
+    return a.loc.localeCompare(b.loc);
+  });
+}
+function generateSitemapFromRecords(records, baseUrl) {
+  const entries = seoRecordsToSitemapEntries(records, baseUrl);
+  return generateSitemapXML({ baseUrl, entries });
+}
+function escapeXML(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/lib/robots-generator.ts
+function generateRobotsTxt(options = {}) {
+  const { userAgents = [], sitemapUrl, crawlDelay } = options;
+  let content = "";
+  if (userAgents.length === 0) {
+    content += "User-agent: *\n";
+    if (crawlDelay) {
+      content += `Crawl-delay: ${crawlDelay}
+`;
+    }
+    content += "Allow: /\n";
+    content += "\n";
+  } else {
+    for (const ua of userAgents) {
+      content += `User-agent: ${ua.agent}
+`;
+      if (crawlDelay) {
+        content += `Crawl-delay: ${crawlDelay}
+`;
+      }
+      if (ua.allow) {
+        for (const path of ua.allow) {
+          content += `Allow: ${path}
+`;
+        }
+      }
+      if (ua.disallow) {
+        for (const path of ua.disallow) {
+          content += `Disallow: ${path}
+`;
+        }
+      }
+      content += "\n";
+    }
+  }
+  if (sitemapUrl) {
+    content += `Sitemap: ${sitemapUrl}
+`;
+  }
+  return content.trim();
+}
+function updateRobotsTxtWithSitemap(existingContent, sitemapUrl) {
+  const sitemapRegex = /^Sitemap:\s*.+$/m;
+  if (sitemapRegex.test(existingContent)) {
+    return existingContent.replace(sitemapRegex, `Sitemap: ${sitemapUrl}`);
+  }
+  const trimmed = existingContent.trim();
+  return trimmed ? `${trimmed}
+
+Sitemap: ${sitemapUrl}` : `Sitemap: ${sitemapUrl}`;
+}
+
+// src/lib/metadata-extractor.ts
+import * as cheerio2 from "cheerio";
+function extractMetadataFromHTML(html, baseUrl) {
+  const $ = cheerio2.load(html);
+  const metadata = {};
+  metadata.title = $("title").text() || void 0;
+  metadata.description = $('meta[name="description"]').attr("content") || void 0;
+  metadata.robots = $('meta[name="robots"]').attr("content") || void 0;
+  const keywords = $('meta[name="keywords"]').attr("content");
+  if (keywords) {
+    metadata.keywords = keywords.split(",").map((k) => k.trim());
+  }
+  metadata.ogTitle = $('meta[property="og:title"]').attr("content") || void 0;
+  metadata.ogDescription = $('meta[property="og:description"]').attr("content") || void 0;
+  metadata.ogImageUrl = $('meta[property="og:image"]').attr("content") || void 0;
+  metadata.ogType = $('meta[property="og:type"]').attr("content") || void 0;
+  metadata.ogUrl = $('meta[property="og:url"]').attr("content") || void 0;
+  metadata.canonicalUrl = $('link[rel="canonical"]').attr("href") || void 0;
+  if (baseUrl) {
+    if (metadata.ogImageUrl && !metadata.ogImageUrl.startsWith("http")) {
+      metadata.ogImageUrl = new URL(metadata.ogImageUrl, baseUrl).toString();
+    }
+    if (metadata.canonicalUrl && !metadata.canonicalUrl.startsWith("http")) {
+      metadata.canonicalUrl = new URL(metadata.canonicalUrl, baseUrl).toString();
+    }
+  }
+  return metadata;
+}
+async function extractMetadataFromURL(url) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "SEO-Console/1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+    }
+    const html = await response.text();
+    return extractMetadataFromHTML(html, url);
+  } catch (error) {
+    console.error(`Error extracting metadata from ${url}:`, error);
+    return {};
+  }
+}
+function metadataToSEORecord(metadata, routePath, userId = "extracted") {
+  return {
+    userId,
+    routePath,
+    title: metadata.title,
+    description: metadata.description,
+    keywords: metadata.keywords,
+    ogTitle: metadata.ogTitle,
+    ogDescription: metadata.ogDescription,
+    ogImageUrl: metadata.ogImageUrl,
+    ogType: metadata.ogType,
+    ogUrl: metadata.ogUrl,
+    canonicalUrl: metadata.canonicalUrl,
+    robots: metadata.robots,
+    validationStatus: "pending"
+  };
+}
+async function crawlSiteForSEO(baseUrl, routes) {
+  const results = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const url = new URL(route, baseUrl).toString();
+    try {
+      const metadata = await extractMetadataFromURL(url);
+      results.set(route, metadata);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch (error) {
+      console.error(`Failed to crawl ${url}:`, error);
+    }
+  }
+  return results;
+}
+
+// src/lib/route-discovery.ts
+import { join } from "path";
+import { glob } from "glob";
+async function discoverNextJSRoutes(appDir = "app", rootDir = process.cwd()) {
+  const routes = [];
+  const appPath = join(rootDir, appDir);
+  try {
+    const pageFiles = await glob("**/page.tsx", {
+      cwd: appPath,
+      absolute: false,
+      ignore: ["**/node_modules/**", "**/.next/**"]
+    });
+    for (const file of pageFiles) {
+      const route = fileToRoute(file, appDir);
+      if (route) {
+        routes.push(route);
+      }
+    }
+  } catch (error) {
+    console.error("Error discovering routes:", error);
+  }
+  return routes;
+}
+function fileToRoute(filePath, appDir) {
+  let routePath = filePath.replace(/^app\//, "").replace(/\/page\.tsx$/, "").replace(/\/page$/, "");
+  if (routePath === "page" || routePath === "") {
+    routePath = "/";
+  } else {
+    routePath = "/" + routePath;
+  }
+  const segments = routePath.split("/").filter(Boolean);
+  const params = [];
+  let isDynamic = false;
+  let isCatchAll = false;
+  for (const segment of segments) {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      const param = segment.slice(4, -1);
+      params.push(param);
+      isDynamic = true;
+      isCatchAll = true;
+    } else if (segment.startsWith("[") && segment.endsWith("]")) {
+      const param = segment.slice(1, -1);
+      params.push(param);
+      isDynamic = true;
+    }
+  }
+  return {
+    routePath,
+    filePath: join(appDir, filePath),
+    isDynamic,
+    isCatchAll,
+    params
+  };
+}
+
+// src/lib/validation/crawlability-validator.ts
+async function validateCrawlability(url, html) {
+  const issues = [];
+  const warnings = [];
+  try {
+    if (!html) {
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "SEO-Console-Bot/1.0"
+        },
+        redirect: "follow"
+      });
+      if (response.status === 404) {
+        issues.push({
+          type: "404",
+          severity: "error",
+          message: "Page returns 404 Not Found",
+          page: url
+        });
+        return {
+          crawlable: false,
+          indexable: false,
+          issues,
+          warnings
+        };
+      }
+      if (response.status !== 200) {
+        issues.push({
+          type: "404",
+          severity: "error",
+          message: `Page returns HTTP ${response.status}`,
+          page: url
+        });
+      }
+      if (response.status === 401 || response.status === 403) {
+        issues.push({
+          type: "auth_wall",
+          severity: "error",
+          message: "Page requires authentication (401/403)",
+          page: url
+        });
+      }
+      html = await response.text();
+    }
+    const metadata = extractMetadataFromHTML(html, url);
+    if (metadata.robots) {
+      const robots = metadata.robots.toLowerCase();
+      if (robots.includes("noindex")) {
+        issues.push({
+          type: "noindex",
+          severity: "error",
+          message: "Page has noindex meta tag - will not be indexed",
+          page: url
+        });
+      }
+      if (robots.includes("nofollow")) {
+        warnings.push({
+          type: "nofollow",
+          severity: "warning",
+          message: "Page has nofollow meta tag - links won't be followed",
+          page: url
+        });
+      }
+    }
+    if (!metadata.canonicalUrl) {
+      warnings.push({
+        type: "canonical_missing",
+        severity: "warning",
+        message: "Page missing canonical URL",
+        page: url
+      });
+    }
+    return {
+      crawlable: issues.filter((i) => i.type !== "noindex").length === 0,
+      indexable: !issues.some((i) => i.type === "noindex"),
+      issues,
+      warnings
+    };
+  } catch (error) {
+    issues.push({
+      type: "404",
+      severity: "error",
+      message: error instanceof Error ? error.message : "Failed to fetch page",
+      page: url
+    });
+    return {
+      crawlable: false,
+      indexable: false,
+      issues,
+      warnings
+    };
+  }
+}
+async function validateRobotsTxt(baseUrl, routePath) {
+  try {
+    const robotsUrl = new URL("/robots.txt", baseUrl).toString();
+    const response = await fetch(robotsUrl);
+    if (!response.ok) {
+      return { allowed: true, reason: "robots.txt not found (default: allow all)" };
+    }
+    const robotsTxt = await response.text();
+    const lines = robotsTxt.split("\n").map((l) => l.trim());
+    let currentUserAgent = "*";
+    let isAllowed = true;
+    for (const line of lines) {
+      if (line.startsWith("#") || !line) continue;
+      const [directive, ...valueParts] = line.split(":").map((s) => s.trim());
+      const value = valueParts.join(":").trim();
+      if (directive.toLowerCase() === "user-agent") {
+        currentUserAgent = value;
+      } else if (directive.toLowerCase() === "disallow") {
+        if (currentUserAgent === "*" || currentUserAgent.toLowerCase() === "googlebot") {
+          if (value === "/") {
+            isAllowed = false;
+            return { allowed: false, reason: "robots.txt disallows all pages" };
+          } else if (routePath.startsWith(value)) {
+            isAllowed = false;
+            return { allowed: false, reason: `robots.txt disallows ${routePath}` };
+          }
+        }
+      } else if (directive.toLowerCase() === "allow") {
+        if (value === "/" || routePath.startsWith(value)) {
+          isAllowed = true;
+        }
+      }
+    }
+    return { allowed: isAllowed };
+  } catch (error) {
+    return { allowed: true, reason: "Could not fetch robots.txt" };
+  }
+}
+async function validatePublicAccess(url) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "SEO-Console-Bot/1.0"
+      }
+    });
+    const requiresAuth = response.status === 401 || response.status === 403;
+    const accessible = response.ok && !requiresAuth;
+    return { accessible, requiresAuth };
+  } catch {
+    return { accessible: false, requiresAuth: false };
+  }
+}
+export {
+  crawlSiteForSEO,
+  createSEORecord,
+  createSEORecordSchema,
+  deleteSEORecord,
+  discoverNextJSRoutes,
+  extractMetadataFromURL,
+  generateRobotsTxt,
+  generateSitemapFromRecords,
+  generateSitemapXML,
+  getSEORecords as getAllSEORecords,
+  getRoutePathFromParams,
+  getSEORecordById,
+  getSEORecordByRoute,
+  getSEORecords,
+  metadataToSEORecord,
+  seoRecordsToSitemapEntries,
+  updateRobotsTxtWithSitemap,
+  updateSEORecord,
+  updateSEORecordSchema,
+  useGenerateMetadata,
+  validateCrawlability,
+  validateHTML,
+  validateOGImage,
+  validatePublicAccess,
+  validateRobotsTxt,
+  validateURL
+};
+//# sourceMappingURL=server.mjs.map