@morphika/webframe 0.1.0

package/app/api/admin/assets/registry/route.ts

@@ -0,0 +1,98 @@
+import { NextRequest, NextResponse } from "next/server";
+import { client } from "../../../../../lib/sanity/client";
+import { writeClient } from "../../../../../lib/sanity/writeClient";
+import { assetRegistryQuery } from "../../../../../lib/sanity/queries";
+import { isAdminAuthenticated } from "../../../../../lib/auth";
+import { validateCsrf, csrfErrorResponse } from "../../../../../lib/csrf";
+import { isBodyTooLarge, MAX_JSON_BODY_SIZE } from "../../../../../lib/security";
+import { logger } from "../../../../../lib/logger";
+
+/**
+ * GET /api/admin/assets/registry — Fetch the full asset registry
+ */
+export async function GET() {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  try {
+    let registry = await client.fetch(assetRegistryQuery);
+
+    // Auto-create if it doesn't exist
+    if (!registry) {
+      registry = await writeClient.createIfNotExists({
+        _id: "assetRegistry",
+        _type: "assetRegistry",
+        scan_status: "ready",
+        assets: [],
+        relink_log: [],
+      });
+    }
+
+    return NextResponse.json({ registry });
+  } catch (err) {
+    logger.error("[Admin:Registry]", "Failed to fetch asset registry", err);
+    return NextResponse.json(
+      { error: "Failed to fetch asset registry" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/admin/assets/registry — Update registry settings
+ * Body: { seed_url? }
+ */
+export async function POST(request: NextRequest) {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!validateCsrf(request)) {
+    return csrfErrorResponse();
+  }
+  if (isBodyTooLarge(request, MAX_JSON_BODY_SIZE)) {
+    return NextResponse.json({ error: "Request body too large" }, { status: 413 });
+  }
+
+  try {
+    const body = await request.json();
+    const { seed_url } = body;
+
+    // Validate seed_url if provided and non-empty
+    if (seed_url && typeof seed_url === "string" && seed_url.length > 0) {
+      if (!seed_url.startsWith("http://") && !seed_url.startsWith("https://")) {
+        return NextResponse.json(
+          { error: "seed_url must start with http:// or https://" },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Ensure the document exists
+    await writeClient.createIfNotExists({
+      _id: "assetRegistry",
+      _type: "assetRegistry",
+      scan_status: "ready",
+      assets: [],
+      relink_log: [],
+    });
+
+    // Build patch — only safe fields allowed
+    const patch: Record<string, unknown> = {};
+    if (seed_url !== undefined) patch.seed_url = seed_url;
+
+    if (Object.keys(patch).length > 0) {
+      await writeClient.patch("assetRegistry").set(patch).commit();
+    }
+
+    // Return updated registry
+    const registry = await client.fetch(assetRegistryQuery);
+    return NextResponse.json({ registry });
+  } catch (err) {
+    logger.error("[Admin:Registry]", "Failed to update registry", err);
+    return NextResponse.json(
+      { error: "Failed to update registry" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/admin/assets/relink/confirm/route.ts

@@ -0,0 +1,242 @@
+import { NextRequest, NextResponse } from "next/server";
+import { client } from "../../../../../../lib/sanity/client";
+import { writeClient } from "../../../../../../lib/sanity/writeClient";
+import { isAdminAuthenticated } from "../../../../../../lib/auth";
+import { validateCsrf, csrfErrorResponse } from "../../../../../../lib/csrf";
+import { logger } from "../../../../../../lib/logger";
+
+/**
+ * Confirmed match from the user
+ */
+interface ConfirmedMatch {
+  old_path: string;
+  new_path: string | null; // null = mark as missing
+  strategy: string;
+}
+
+/**
+ * Recursively walk a JSON structure and replace asset path string values.
+ * Uses structured JSON traversal instead of fragile regex replacement.
+ */
+function replaceAssetPaths(obj: unknown, pathMap: Map<string, string>): { result: unknown; changed: boolean } {
+  if (obj === null || obj === undefined) return { result: obj, changed: false };
+
+  // If it's a string and matches a path in the map, replace it
+  if (typeof obj === "string") {
+    if (pathMap.has(obj)) {
+      return { result: pathMap.get(obj)!, changed: true };
+    }
+    return { result: obj, changed: false };
+  }
+
+  // If it's an array, recurse into each element
+  if (Array.isArray(obj)) {
+    let hasChanged = false;
+    const newArr = obj.map((item) => {
+      const { result, changed } = replaceAssetPaths(item, pathMap);
+      if (changed) hasChanged = true;
+      return result;
+    });
+    return { result: hasChanged ? newArr : obj, changed: hasChanged };
+  }
+
+  // If it's an object, recurse into each value
+  if (typeof obj === "object") {
+    let hasChanged = false;
+    const newObj: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const { result, changed } = replaceAssetPaths(value, pathMap);
+      newObj[key] = result;
+      if (changed) hasChanged = true;
+    }
+    return { result: hasChanged ? newObj : obj, changed: hasChanged };
+  }
+
+  // Primitives (number, boolean) pass through
+  return { result: obj, changed: false };
+}
+
+/**
+ * POST /api/admin/assets/relink/confirm — Apply confirmed relink matches
+ *
+ * Updates all Sanity documents that reference old asset paths,
+ * replaces with new paths, and updates the asset registry.
+ *
+ * Body: {
+ *   new_seed_url: string,
+ *   matches: ConfirmedMatch[]
+ * }
+ */
+export async function POST(request: NextRequest) {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!validateCsrf(request)) {
+    return csrfErrorResponse();
+  }
+
+  try {
+    const body = await request.json();
+    const { new_seed_url, matches } = body as {
+      new_seed_url: string;
+      matches: ConfirmedMatch[];
+    };
+
+    if (!matches || !Array.isArray(matches)) {
+      return NextResponse.json(
+        { error: "matches array is required" },
+        { status: 400 }
+      );
+    }
+
+    // Get current registry
+    const registry = await client.fetch(
+      `*[_type == "assetRegistry"][0]{ _id, seed_url, assets, relink_log }`
+    );
+
+    if (!registry) {
+      return NextResponse.json(
+        { error: "Asset registry not found" },
+        { status: 404 }
+      );
+    }
+
+    const oldSeed = registry.seed_url || "";
+
+    // Build path mapping: old_path → new_path
+    const pathMap = new Map<string, string>();
+    for (const match of matches) {
+      if (match.new_path && match.old_path !== match.new_path) {
+        pathMap.set(match.old_path, match.new_path);
+      }
+    }
+
+    // Find all page documents that might reference assets
+    const allPages = await client.fetch(
+      `*[_type == "page"]{ _id, content_rows }`
+    );
+
+    // Find and update documents with old asset paths
+    let documentsUpdated = 0;
+    const transaction = writeClient.transaction();
+
+    for (const page of allPages) {
+      const rows = page.content_rows || [];
+      const { result, changed } = replaceAssetPaths(rows, pathMap);
+
+      if (changed) {
+        transaction.patch(page._id, { set: { content_rows: result } });
+        documentsUpdated++;
+      }
+    }
+
+    // Update asset registry
+    const now = new Date().toISOString();
+    const currentAssets = registry.assets || [];
+
+    const updatedAssets = currentAssets.map(
+      (asset: { _key: string; path: string; previous_paths?: string[] }) => {
+        const newPath = pathMap.get(asset.path);
+        const matchInfo = matches.find((m) => m.old_path === asset.path);
+
+        if (newPath) {
+          return {
+            ...asset,
+            path: newPath,
+            status: "active",
+            previous_paths: [
+              ...(asset.previous_paths || []),
+              asset.path,
+            ],
+            last_checked_at: now,
+          };
+        }
+
+        if (matchInfo && matchInfo.new_path === null) {
+          return {
+            ...asset,
+            status: "missing",
+            last_checked_at: now,
+          };
+        }
+
+        // Exact match (path didn't change) — keep active
+        if (matchInfo && matchInfo.new_path === matchInfo.old_path) {
+          return {
+            ...asset,
+            status: "active",
+            last_checked_at: now,
+          };
+        }
+
+        return asset;
+      }
+    );
+
+    // Build relink log entry
+    const relinkEntry = {
+      _key: crypto.randomUUID().replace(/-/g, "").slice(0, 12),
+      date: now,
+      old_seed: oldSeed,
+      new_seed: new_seed_url || oldSeed,
+      assets_relinked: matches.filter((m) => m.new_path !== null).length,
+      assets_missing: matches.filter((m) => m.new_path === null).length,
+      details: JSON.stringify({
+        documents_updated: documentsUpdated,
+        strategies: {
+          exact_path: matches.filter((m) => m.strategy === "exact_path").length,
+          hash_match: matches.filter((m) => m.strategy === "hash_match").length,
+          filename_size_match: matches.filter(
+            (m) => m.strategy === "filename_size_match"
+          ).length,
+          filename_match: matches.filter(
+            (m) => m.strategy === "filename_match"
+          ).length,
+          no_match: matches.filter((m) => m.strategy === "no_match").length,
+        },
+      }),
+    };
+
+    // Update registry in the same transaction
+    transaction.patch("assetRegistry", {
+      set: {
+        seed_url: new_seed_url || registry.seed_url,
+        assets: updatedAssets,
+        relink_log: [...(registry.relink_log || []), relinkEntry],
+        last_scanned_at: now,
+      },
+    });
+
+    // Also update siteSettings seed_url if it changed
+    if (new_seed_url && new_seed_url !== oldSeed) {
+      const settings = await client.fetch(
+        `*[_type == "siteSettings"][0]._id`
+      );
+      if (settings) {
+        transaction.patch(settings, {
+          set: {
+            seed_url: new_seed_url,
+            last_scanned_at: now,
+          },
+        });
+      }
+    }
+
+    // Execute atomically
+    await transaction.commit();
+
+    return NextResponse.json({
+      success: true,
+      documents_updated: documentsUpdated,
+      assets_relinked: matches.filter((m) => m.new_path !== null).length,
+      assets_missing: matches.filter((m) => m.new_path === null).length,
+      relink_log_entry: relinkEntry,
+    });
+  } catch (err) {
+    logger.error("[Admin:Relink]", "Relink confirm failed", err);
+    return NextResponse.json(
+      { error: "Relink operation failed" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/admin/assets/relink/route.ts

@@ -0,0 +1,202 @@
+import { NextRequest, NextResponse } from "next/server";
+import { client } from "../../../../../lib/sanity/client";
+import { isAdminAuthenticated } from "../../../../../lib/auth";
+import { validateCsrf, csrfErrorResponse } from "../../../../../lib/csrf";
+import { getStorageAdapter } from "../../../../../lib/storage";
+import { logger } from "../../../../../lib/logger";
+import type { RegisteredAsset } from "../../../../../lib/sanity/types";
+import type { ScannedFile } from "../../../../../lib/storage/types";
+
+/**
+ * Relink match result for a single asset
+ */
+interface RelinkMatch {
+  old_path: string;
+  new_path: string | null;
+  strategy:
+    | "exact_path"
+    | "hash_match"
+    | "filename_size_match"
+    | "filename_match"
+    | "no_match";
+  confidence: number;
+  candidates?: { path: string; confidence: number }[];
+}
+
+/**
+ * POST /api/admin/assets/relink — Analyze relink candidates
+ *
+ * Compares current registry assets against a new file listing from
+ * the active storage provider. Returns match suggestions without
+ * applying any changes.
+ *
+ * Body: { new_seed_url?: string, new_files?: ScannedFile[] }
+ */
+export async function POST(request: NextRequest) {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!validateCsrf(request)) {
+    return csrfErrorResponse();
+  }
+
+  try {
+    const body = await request.json();
+    const { new_seed_url, new_files } = body;
+
+    // Get current registry
+    const registry = await client.fetch(
+      `*[_type == "assetRegistry"][0]{ seed_url, assets }`
+    );
+
+    if (!registry || !registry.assets?.length) {
+      return NextResponse.json(
+        { error: "No assets in registry to relink" },
+        { status: 400 }
+      );
+    }
+
+    // Get new file listing
+    let newFiles: ScannedFile[];
+
+    if (new_files && Array.isArray(new_files)) {
+      newFiles = new_files;
+    } else {
+      // Use the active storage adapter to list files
+      try {
+        const adapter = await getStorageAdapter();
+        newFiles = await adapter.listFiles();
+      } catch {
+        return NextResponse.json(
+          { error: "Storage provider not connected. Go to /admin/storage to connect." },
+          { status: 400 }
+        );
+      }
+    }
+
+    // Build lookup structures for new files
+    const newByPath = new Map<string, ScannedFile>();
+    const newByHash = new Map<string, ScannedFile[]>();
+    const newByFilename = new Map<string, ScannedFile[]>();
+
+    for (const file of newFiles) {
+      newByPath.set(file.path, file);
+
+      if (file.file_hash) {
+        const existing = newByHash.get(file.file_hash) || [];
+        existing.push(file);
+        newByHash.set(file.file_hash, existing);
+      }
+
+      const existing = newByFilename.get(file.filename) || [];
+      existing.push(file);
+      newByFilename.set(file.filename, existing);
+    }
+
+    // Match each existing asset
+    const matches: RelinkMatch[] = [];
+    const currentAssets: RegisteredAsset[] = registry.assets;
+
+    for (const asset of currentAssets) {
+      // Strategy 1: Exact path match (100% confidence)
+      if (newByPath.has(asset.path)) {
+        matches.push({
+          old_path: asset.path,
+          new_path: asset.path,
+          strategy: "exact_path",
+          confidence: 1.0,
+        });
+        continue;
+      }
+
+      // Strategy 2: Hash match (99% confidence)
+      if (asset.file_hash) {
+        const hashMatches = newByHash.get(asset.file_hash);
+        if (hashMatches && hashMatches.length > 0) {
+          matches.push({
+            old_path: asset.path,
+            new_path: hashMatches[0].path,
+            strategy: "hash_match",
+            confidence: 0.99,
+            candidates:
+              hashMatches.length > 1
+                ? hashMatches.map((f) => ({ path: f.path, confidence: 0.99 }))
+                : undefined,
+          });
+          continue;
+        }
+      }
+
+      // Strategy 3: Filename + size match (95% confidence)
+      const filenameMatches = newByFilename.get(asset.filename) || [];
+      const sizeMatch = filenameMatches.find(
+        (f) => asset.file_size && f.file_size === asset.file_size
+      );
+      if (sizeMatch) {
+        matches.push({
+          old_path: asset.path,
+          new_path: sizeMatch.path,
+          strategy: "filename_size_match",
+          confidence: 0.95,
+        });
+        continue;
+      }
+
+      // Strategy 4: Filename match only (60% confidence)
+      if (filenameMatches.length > 0) {
+        matches.push({
+          old_path: asset.path,
+          new_path: filenameMatches[0].path,
+          strategy: "filename_match",
+          confidence: 0.6,
+          candidates: filenameMatches.map((f) => ({
+            path: f.path,
+            confidence: 0.6,
+          })),
+        });
+        continue;
+      }
+
+      // No match
+      matches.push({
+        old_path: asset.path,
+        new_path: null,
+        strategy: "no_match",
+        confidence: 0,
+      });
+    }
+
+    // Summarize
+    const exact = matches.filter((m) => m.strategy === "exact_path").length;
+    const hashMatched = matches.filter((m) => m.strategy === "hash_match").length;
+    const filenameSizeMatched = matches.filter(
+      (m) => m.strategy === "filename_size_match"
+    ).length;
+    const filenameOnly = matches.filter(
+      (m) => m.strategy === "filename_match"
+    ).length;
+    const missing = matches.filter((m) => m.strategy === "no_match").length;
+
+    return NextResponse.json({
+      old_seed: registry.seed_url,
+      new_seed: new_seed_url,
+      matches,
+      summary: {
+        total: matches.length,
+        exact,
+        hash_matched: hashMatched,
+        filename_size_matched: filenameSizeMatched,
+        filename_only: filenameOnly,
+        missing,
+        auto_resolvable: exact + hashMatched + filenameSizeMatched,
+        needs_review: filenameOnly,
+      },
+    });
+  } catch (err) {
+    logger.error("[Admin:Relink]", "Relink analysis failed", err);
+    return NextResponse.json(
+      { error: "Relink analysis failed" },
+      { status: 500 }
+    );
+  }
+}