plotlink-ows 1.0.32 → 1.2.94

package/app/routes/publish.ts

@@ -1,8 +1,49 @@
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { publishStoryline, publishPlot, getEthBalance, estimatePublishCost, uploadCoverImage, uploadPlotImage, updateStoryline } from "../lib/publish";
+import { publishStoryline, publishPlot, getEthBalance, getCreationFee, estimatePublishCost, uploadCoverImage, uploadPlotImage, updateStoryline } from "../lib/publish";
 import { keccak256, toBytes } from "viem";
 import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+import path from "path";
+import { STORIES_DIR } from "../lib/paths";
+import { readCutsFile } from "../lib/cuts";
+import { checkMarkdownReadiness } from "../lib/cartoon-readiness";
+import { readStoryMeta } from "./stories";
+import { sniffImageType, findStaleAssetPaths } from "../lib/clean-image-sync";
+import { isValidImageAsset } from "../lib/image-asset-validate";
+import { extractOgTitle, leadingTitleSegment } from "../lib/public-title";
+import { canonicalizeGenre, GENRES } from "../../lib/genres";
+
+/**
+ * Resolve a request's genre to a canonical PlotLink value (#412). Returns the
+ * canonical string for a valid/aliased genre, `undefined` for an absent/blank
+ * genre (no metadata change), or an `{ error }` for a non-empty genre that can't
+ * be mapped — so the route fails locally with a clear message instead of letting
+ * PlotLink reject it and leave the public story UNCATEGORIZED.
+ */
+function resolveGenre(input: string | undefined): { genre?: string } | { error: string } {
+  if (!input || !input.trim()) return { genre: undefined };
+  const canonical = canonicalizeGenre(input);
+  if (!canonical) {
+    return { error: `Invalid genre "${input}". Use one of: ${GENRES.join(", ")}.` };
+  }
+  return { genre: canonical };
+}
+
+/**
+ * Validate that an uploaded image's actual magic bytes match its claimed
+ * WebP/JPEG MIME type, so a renamed PNG/text file labeled image/webp cannot be
+ * forwarded to the plotlink backend. Mirrors the byte check the cartoon
+ * clean-image upload uses (#266). Returns a user-facing error string, or null
+ * when the bytes are valid.
+ */
+async function imageBytesError(file: File): Promise<string | null> {
+  const expected = file.type === "image/webp" ? "webp" : "jpeg";
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  if (sniffImageType(bytes) !== expected) {
+    return "File content is not a valid WebP/JPEG image (bytes do not match the image type)";
+  }
+  return null;
+}
 
 const publish = new Hono();
 
@@ -21,41 +62,61 @@ publish.get("/preflight", async (c) => {
       return c.json({ ready: false, error: "No EVM address on wallet" });
     }
 
-    // Check ETH balance against real estimated cost
     const balance = await getEthBalance(address);
+
+    // The MCV2 Bond creation fee is a plain contract read and is the only hard
+    // on-chain cost we can always count on. Read it independently of gas
+    // estimation: a flaky gas estimate must not masquerade as an unreadable-chain
+    // failure. If the fee itself cannot be read, the RPC/contract config is
+    // genuinely broken — that is a real blocker.
+    let creationFee: bigint;
+    try {
+      creationFee = await getCreationFee();
+    } catch {
+      return c.json({
+        ready: false,
+        address,
+        ethBalance: balance.toString(),
+        error: "Could not read creation fee — check RPC and contract config",
+      });
+    }
+
+    // Gas estimation is best-effort. PlotLink owns Filebase/IPFS server-side and
+    // OWS uploads images/content through the PlotLink API, so there is NO local
+    // Filebase env requirement to gate on (#287). And gas estimation simulates
+    // createStoryline with dummy content the contract can reject — which is why
+    // the real #211 pilot publish succeeded while this estimate failed. So a
+    // failed estimate is a warning, not an absolute publish blocker.
     let totalCost: bigint | null = null;
-    let creationFee = BigInt(0);
-    let estimationFailed = false;
+    let estimateWarning: string | null = null;
     try {
       const dummyCid = "QmDummy";
       const dummyHash = keccak256(toBytes("estimation"));
       const estimate = await estimatePublishCost(address, "Test", dummyCid, dummyHash);
       totalCost = estimate.totalCost;
-      creationFee = estimate.creationFee;
     } catch {
-      estimationFailed = true;
+      estimateWarning =
+        "Could not estimate gas; using the creation fee as the minimum required balance — actual publish may still succeed";
     }
-    // Fail closed: if estimation fails, block publishing
-    const requiredBalance = totalCost ?? BigInt(0);
-    const hasEnoughEth = !estimationFailed && totalCost !== null && balance >= requiredBalance;
 
-    // Check Filebase config
-    const hasFilebase = !!(process.env.FILEBASE_ACCESS_KEY && process.env.FILEBASE_SECRET_KEY);
+    // Require enough ETH for at least the creation fee; when a full gas estimate
+    // is available, require that instead. Never block solely on a missing
+    // estimate — but a genuinely insufficient balance is still a real blocker.
+    const requiredBalance = totalCost ?? creationFee;
+    const hasEnoughEth = balance >= requiredBalance;
 
     return c.json({
-      ready: hasEnoughEth && hasFilebase,
+      ready: hasEnoughEth,
       address,
       ethBalance: balance.toString(),
       creationFee: creationFee.toString(),
       requiredBalance: requiredBalance.toString(),
       hasEnoughEth,
-      hasFilebase,
-      estimationFailed,
-      error: estimationFailed
-        ? "Could not estimate publish cost — check RPC and contract config"
-        : !hasEnoughEth
-        ? `Insufficient ETH. Need ~${(Number(requiredBalance) / 1e18).toFixed(6)} ETH (creation fee + gas)`
-        : !hasFilebase ? "Filebase not configured" : null,
+      estimationFailed: totalCost === null,
+      estimateWarning,
+      error: !hasEnoughEth
+        ? `Insufficient ETH. Need at least ~${(Number(requiredBalance) / 1e18).toFixed(6)} ETH (creation fee${totalCost !== null ? " + gas" : ""})`
+        : null,
     });
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : "Preflight check failed";
@@ -63,6 +124,58 @@ publish.get("/preflight", async (c) => {
   }
 });
 
+/**
+ * GET /api/publish/public-title — read the INDEXED public title from PlotLink
+ * after a publish (#379). There is no public JSON read endpoint, so this fetches
+ * the rendered public page server-side (no CORS) and extracts its og:title:
+ *   - genesis/storyline (`/story/<id>`)      → { storylineTitle }
+ *   - plot (`/story/<id>/<plotIndex>`)       → { plotTitle } (leading title segment)
+ * `fetched:false` when the page is unreachable / has no title, so the caller
+ * treats it as inconclusive rather than a false pass. The client then runs the
+ * pure title verifier on the result.
+ */
+publish.get("/public-title", async (c) => {
+  const storylineId = c.req.query("storylineId");
+  const plotIndex = c.req.query("plotIndex");
+  if (!storylineId || !/^\d+$/.test(storylineId)) {
+    return c.json({ ok: false, error: "Valid storylineId required" }, 400);
+  }
+  const isPlot = plotIndex != null && plotIndex !== "" && /^\d+$/.test(plotIndex);
+  const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
+  const url = isPlot
+    ? `${PLOTLINK_URL}/story/${storylineId}/${plotIndex}`
+    : `${PLOTLINK_URL}/story/${storylineId}`;
+  const storylineUrl = `${PLOTLINK_URL}/story/${storylineId}`;
+
+  try {
+    if (!isPlot) {
+      const res = await fetch(url);
+      if (!res.ok) return c.json({ ok: true, fetched: false });
+      const og = extractOgTitle(await res.text());
+      if (!og) return c.json({ ok: true, fetched: false });
+      return c.json({ ok: true, fetched: true, storylineTitle: og });
+    }
+
+    const plotRes = await fetch(url);
+    if (!plotRes.ok) return c.json({ ok: true, fetched: false });
+    const plotOg = extractOgTitle(await plotRes.text());
+    if (!plotOg) return c.json({ ok: true, fetched: false });
+    let storylineOg: string | null = null;
+    try {
+      const storylineRes = await fetch(storylineUrl);
+      storylineOg = storylineRes.ok ? extractOgTitle(await storylineRes.text()) : null;
+    } catch {
+      // Best-effort read only. If the storyline page fetch rejects, keep the
+      // successful plot-page title and fall back to last-segment stripping.
+      storylineOg = null;
+    }
+    return c.json({ ok: true, fetched: true, plotTitle: leadingTitleSegment(plotOg, storylineOg) });
+  } catch {
+    // Network/parse failure → inconclusive; never block on a flaky read.
+    return c.json({ ok: true, fetched: false });
+  }
+});
+
 /** POST /api/publish/file — publish a story file on-chain (streams progress) */
 publish.post("/file", async (c) => {
   const body = await c.req.json<{
@@ -74,12 +187,22 @@ publish.post("/file", async (c) => {
     language?: string;
     isNsfw?: boolean;
     storylineId?: number;
+    contentType?: string;
   }>();
 
   if (!body.title || !body.content) {
     return c.json({ error: "title and content required" }, 400);
   }
 
+  // Canonicalize the genre up-front (#412) so it's the canonical PlotLink value in
+  // the content metadata, and a non-mappable genre fails here with a clear message
+  // instead of after the on-chain publish.
+  const genreResult = resolveGenre(body.genre);
+  if ("error" in genreResult) {
+    return c.json({ error: genreResult.error }, 400);
+  }
+  const canonicalGenre = genreResult.genre;
+
   // Enforce character limits
   const isGenesis = body.fileName === "genesis.md";
   const isPlot = /^plot-\d+\.md$/.test(body.fileName);
@@ -90,6 +213,52 @@ publish.post("/file", async (c) => {
     }, 400);
   }
 
+  // Cartoon plot readiness — block invalid/incomplete publish markdown.
+  // Derive cartoon status from server-side .story.json metadata (NOT the
+  // request body) so a direct API caller cannot bypass by omitting/faking
+  // contentType.
+  if (isPlot) {
+    const storyDir = path.join(STORIES_DIR, body.storyName);
+    const isCartoon = readStoryMeta(storyDir).contentType === "cartoon";
+    if (isCartoon) {
+      const plotFile = body.fileName.replace(/\.md$/, "");
+      let cutsFile;
+      try {
+        cutsFile = readCutsFile(storyDir, plotFile);
+      } catch (err) {
+        return c.json({ error: `Cannot publish: ${(err as Error).message}` }, 400);
+      }
+      if (!cutsFile) {
+        return c.json({ error: `Cannot publish: ${plotFile}.cuts.json not found. Generate cuts and upload final images first.` }, 400);
+      }
+
+      // Block on stale recorded asset paths — a cut whose cleanImagePath /
+      // finalImagePath points to a missing/invalid local file is not actually
+      // ready, and the generic markdown issues would obscure why (#302). Skip
+      // already-uploaded cuts: their content is on IPFS (uploadedUrl), so a
+      // missing LOCAL asset must not block re-publish.
+      const stale = findStaleAssetPaths(
+        cutsFile.cuts,
+        (rel) => isValidImageAsset(storyDir, rel),
+      ).filter((issue) => {
+        const cut = cutsFile.cuts.find((ct) => ct.id === issue.cutId);
+        return !cut?.uploadedUrl;
+      });
+      if (stale.length > 0) {
+        const messages = stale.map((s) => s.message);
+        return c.json(
+          { error: `Cartoon plot not ready to publish: ${messages.join("; ")}`, issues: messages },
+          400,
+        );
+      }
+
+      const { ready, issues } = checkMarkdownReadiness(body.content, cutsFile.cuts);
+      if (!ready) {
+        return c.json({ error: `Cartoon plot not ready to publish: ${issues.join("; ")}`, issues }, 400);
+      }
+    }
+  }
+
   // Get wallet
   let wallets;
   try {
@@ -116,7 +285,7 @@ publish.post("/file", async (c) => {
           body.storylineId,
           body.title,
           body.content,
-          body.genre,
+          canonicalGenre,
           async (progress) => {
             await stream.writeSSE({ data: JSON.stringify(progress) });
           },
@@ -128,12 +297,13 @@ publish.post("/file", async (c) => {
           wallet.name,
           body.title,
           body.content,
-          body.genre,
+          canonicalGenre,
           async (progress) => {
             await stream.writeSSE({ data: JSON.stringify(progress) });
           },
           body.language,
           body.isNsfw,
+          body.contentType,
         );
       }
 
@@ -212,9 +382,9 @@ publish.post("/upload-cover", async (c) => {
       return c.json({ error: "No image file provided" }, 400);
     }
 
-    // Validate file size (500KB max)
-    if (file.size > 500 * 1024) {
-      return c.json({ error: "Image exceeds 500KB limit" }, 400);
+    // Validate file size (1MB max)
+    if (file.size > 1024 * 1024) {
+      return c.json({ error: "Image exceeds 1MB limit" }, 400);
     }
 
     // Validate file type — only WebP and JPEG accepted by the plotlink server
@@ -223,6 +393,9 @@ publish.post("/upload-cover", async (c) => {
       return c.json({ error: "Only WebP and JPEG images are accepted" }, 400);
     }
 
+    const bytesError = await imageBytesError(file);
+    if (bytesError) return c.json({ error: bytesError }, 400);
+
     const cid = await uploadCoverImage(wallet.name, address as `0x${string}`, file);
     return c.json({ cid });
   } catch (err: unknown) {
@@ -247,9 +420,9 @@ publish.post("/upload-plot-image", async (c) => {
       return c.json({ error: "No image file provided" }, 400);
     }
 
-    // Validate file size (500KB max)
-    if (file.size > 500 * 1024) {
-      return c.json({ error: "Image exceeds 500KB limit" }, 400);
+    // Validate file size (1MB max)
+    if (file.size > 1024 * 1024) {
+      return c.json({ error: "Image exceeds 1MB limit" }, 400);
     }
 
     // Validate file type — only WebP and JPEG accepted by the plotlink server
@@ -288,13 +461,21 @@ publish.post("/update-storyline", async (c) => {
       return c.json({ error: "storylineId required" }, 400);
     }
 
+    // Canonicalize the genre before the signed on-chain metadata update so a
+    // natural label (e.g. "Sci-Fi") becomes "Science Fiction" rather than being
+    // rejected by PlotLink and leaving the public story UNCATEGORIZED (#412).
+    const genreResult = resolveGenre(body.genre);
+    if ("error" in genreResult) {
+      return c.json({ error: genreResult.error }, 400);
+    }
+
     await updateStoryline(
       wallet.name,
       address as `0x${string}`,
       body.storylineId,
       {
         coverCid: body.coverCid,
-        genre: body.genre,
+        genre: genreResult.genre,
         language: body.language,
         isNsfw: body.isNsfw,
       },