plotlink-ows 0.1.15 → 1.0.0

package/app/routes/publish.ts

@@ -1,7 +1,6 @@
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { db } from "../db";
-import { publishStoryline, getEthBalance, estimatePublishCost } from "../lib/publish";
+import { publishStoryline, publishPlot, getEthBalance, estimatePublishCost } from "../lib/publish";
 import { keccak256, toBytes } from "viem";
 import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
 
@@ -64,41 +63,85 @@ publish.get("/preflight", async (c) => {
   }
 });
 
-/** POST /api/publish/:draftId — publish a draft on-chain (streams progress) */
-publish.post("/:draftId", async (c) => {
-  const draftId = c.req.param("draftId");
+/** POST /api/publish/file — publish a story file on-chain (streams progress) */
+publish.post("/file", async (c) => {
+  const body = await c.req.json<{
+    storyName: string;
+    fileName: string;
+    title: string;
+    content: string;
+    genre?: string;
+    storylineId?: number;
+  }>();
 
-  const draft = await db.draft.findUnique({ where: { id: draftId } });
-  if (!draft) return c.json({ error: "Draft not found" }, 404);
-  if (draft.status === "published") return c.json({ error: "Already published" }, 409);
+  if (!body.title || !body.content) {
+    return c.json({ error: "title and content required" }, 400);
+  }
+
+  // Enforce character limits
+  const isGenesis = body.fileName === "genesis.md";
+  const isPlot = /^plot-\d+\.md$/.test(body.fileName);
+  const charLimit = isGenesis ? 1000 : isPlot ? 10000 : null;
+  if (charLimit && body.content.length > charLimit) {
+    return c.json({
+      error: `Content exceeds ${charLimit.toLocaleString()} character limit (${body.content.length.toLocaleString()} chars). Reduce content before publishing.`,
+    }, 400);
+  }
 
   // Get wallet
-  const wallets = listAgentWallets();
+  let wallets;
+  try {
+    wallets = listAgentWallets();
+  } catch (err) {
+    console.error("[publish/file] listAgentWallets error:", err);
+    return c.json({ error: `OWS wallet error: ${err instanceof Error ? err.message : String(err)}` }, 500);
+  }
   const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
   if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
 
+  console.log("[publish/file] Starting publish for", body.storyName, body.fileName, "wallet:", wallet.name);
+
+  // Determine if this is genesis (createStoryline) or plot (chainPlot)
+  // isPlot already defined above from validation
+
   return streamSSE(c, async (stream) => {
     try {
-      const result = await publishStoryline(
-        wallet.name,
-        draft.title,
-        draft.content,
-        draft.genre || undefined,
-        async (progress) => {
-          await stream.writeSSE({ data: JSON.stringify(progress) });
-        },
-      );
-
-      // Only mark published after tx confirmed (publishStoryline waits for confirmation)
-      await db.draft.update({
-        where: { id: draftId },
-        data: {
-          status: "published",
+      let result;
+      if (isPlot && body.storylineId) {
+        // Chain plot to existing storyline
+        result = await publishPlot(
+          wallet.name,
+          body.storylineId,
+          body.title,
+          body.content,
+          body.genre,
+          async (progress) => {
+            await stream.writeSSE({ data: JSON.stringify(progress) });
+          },
+        );
+      } else {
+        // Create new storyline (genesis or first file)
+        result = await publishStoryline(
+          wallet.name,
+          body.title,
+          body.content,
+          body.genre,
+          async (progress) => {
+            await stream.writeSSE({ data: JSON.stringify(progress) });
+          },
+        );
+      }
+
+      await stream.writeSSE({
+        data: JSON.stringify({
+          step: "done",
           txHash: result.txHash,
           storylineId: result.storylineId,
+          plotIndex: result.plotIndex,
           contentCid: result.contentCid,
           gasCost: result.gasCost,
-        },
+          indexError: result.indexError,
+        }),
       });
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : "Publish failed";
@@ -109,4 +152,43 @@ publish.post("/:draftId", async (c) => {
   });
 });
 
+/** POST /api/publish/retry-index — retry indexing for a published file */
+publish.post("/retry-index", async (c) => {
+  const body = await c.req.json<{
+    storyName: string;
+    fileName: string;
+    txHash: string;
+    content: string;
+    storylineId?: number;
+  }>();
+
+  if (!body.txHash || !body.content) {
+    return c.json({ error: "txHash and content required" }, 400);
+  }
+
+  const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
+  const isPlot = /^plot-\d+\.md$/.test(body.fileName);
+  const endpoint = isPlot ? "plot" : "storyline";
+  const indexBody = isPlot
+    ? { txHash: body.txHash, content: body.content }
+    : { txHash: body.txHash, content: body.content, genre: undefined };
+
+  try {
+    const indexRes = await fetch(`${PLOTLINK_URL}/api/index/${endpoint}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(indexBody),
+    });
+    const indexData = await indexRes.json().catch(() => ({})) as Record<string, string>;
+    if (!indexRes.ok || indexData.error) {
+      const error = indexData.error || `Indexing failed: HTTP ${indexRes.status}`;
+      return c.json({ ok: false, error });
+    }
+    return c.json({ ok: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Indexing request failed";
+    return c.json({ ok: false, error: message });
+  }
+});
+
 export { publish as publishRoutes };

package/app/routes/settings.ts

@@ -0,0 +1,194 @@
+import { Hono } from "hono";
+import { createPublicClient, createWalletClient, http, decodeEventLog } from "viem";
+import { base } from "viem/chains";
+import { erc8004Abi } from "../../packages/cli/src/sdk/abi";
+import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+import { createOwsAccount } from "../lib/publish";
+import { db } from "../db";
+import {
+  signMessage as owsSignMsg,
+} from "@open-wallet-standard/core";
+
+const ERC_8004 = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432" as const;
+const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+
+const publicClient = createPublicClient({
+  chain: base,
+  transport: http(rpcUrl),
+});
+
+const settings = new Hono();
+
+/** POST /api/settings/generate-binding — generate wallet binding proof for PlotLink */
+settings.post("/generate-binding", async (c) => {
+  const body = await c.req.json<{ humanWallet: string }>();
+
+  if (!body.humanWallet || !/^0x[a-fA-F0-9]{40}$/.test(body.humanWallet)) {
+    return c.json({ error: "Valid wallet address required (0x...)" }, 400);
+  }
+
+  try {
+    const wallets = listAgentWallets();
+    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (!wallet) return c.json({ error: "No OWS wallet found. Create one in Wallet settings first." }, 400);
+
+    const owsWallet = getBaseAddress(wallet);
+    if (!owsWallet) return c.json({ error: "No EVM address on wallet" }, 400);
+
+    const message = `I authorize ${body.humanWallet} as my PlotLink owner. Wallet: ${owsWallet}`;
+    const passphrase = process.env.OWS_PASSPHRASE;
+
+    const result = owsSignMsg(wallet.name, "eip155:8453", message, passphrase);
+    const signature = result.signature.startsWith("0x") ? result.signature : `0x${result.signature}`;
+
+    return c.json({
+      message,
+      signature,
+      owsWallet,
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : "Failed to generate binding proof";
+    return c.json({ error: msg }, 500);
+  }
+});
+
+/** POST /api/settings/register-agent — OWS wallet self-registers on ERC-8004 */
+settings.post("/register-agent", async (c) => {
+  const body = await c.req.json<{ name: string; description: string; genre?: string }>();
+
+  if (!body.name?.trim()) {
+    return c.json({ error: "Agent name is required" }, 400);
+  }
+  if (!body.description?.trim()) {
+    return c.json({ error: "Agent description is required" }, 400);
+  }
+
+  try {
+    const wallets = listAgentWallets();
+    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (!wallet) return c.json({ error: "No OWS wallet found. Create one in Wallet settings first." }, 400);
+
+    const owsAddress = getBaseAddress(wallet);
+    if (!owsAddress) return c.json({ error: "No EVM address on wallet" }, 400);
+
+    // Check if already registered
+    try {
+      const existingId = await publicClient.readContract({
+        address: ERC_8004,
+        abi: erc8004Abi,
+        functionName: "agentIdByWallet",
+        args: [owsAddress as `0x${string}`],
+      }) as bigint;
+      if (existingId > 0n) {
+        return c.json({ error: `Already registered as Agent #${existingId}` }, 400);
+      }
+    } catch { /* not registered — continue */ }
+
+    // Build agentURI as inline JSON
+    const agentURI = JSON.stringify({
+      name: body.name.trim(),
+      description: body.description.trim(),
+      ...(body.genre?.trim() && { genre: body.genre.trim() }),
+      llmModel: "Claude",
+      registeredBy: "plotlink-ows",
+      registeredAt: new Date().toISOString(),
+    });
+
+    // Create OWS-backed wallet client and call register()
+    const account = createOwsAccount(wallet.name, owsAddress as `0x${string}`);
+    const walletClient = createWalletClient({ account, chain: base, transport: http(rpcUrl) });
+
+    const txHash = await walletClient.writeContract({
+      address: ERC_8004,
+      abi: erc8004Abi,
+      functionName: "register",
+      args: [agentURI],
+    });
+
+    // Wait for confirmation and decode Registered event
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+    });
+
+    if (receipt.status === "reverted") {
+      return c.json({ error: "Transaction reverted on-chain" }, 500);
+    }
+
+    let agentId: number | undefined;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog({
+          abi: erc8004Abi,
+          data: log.data,
+          topics: log.topics,
+        });
+        if (decoded.eventName === "Registered") {
+          agentId = Number((decoded.args as { agentId: bigint }).agentId);
+          break;
+        }
+      } catch { /* not our event */ }
+    }
+
+    if (!agentId) {
+      return c.json({ error: "Transaction succeeded but Registered event not found" }, 500);
+    }
+
+    // Store agentId locally
+    await db.setting.upsert({
+      where: { key: "agent_id" },
+      update: { value: String(agentId) },
+      create: { key: "agent_id", value: String(agentId) },
+    });
+
+    return c.json({
+      agentId,
+      owsWallet: owsAddress,
+      txHash,
+    });
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : "Registration failed";
+    return c.json({ error: msg }, 500);
+  }
+});
+
+/** GET /api/settings/link-status — check if OWS wallet is registered on ERC-8004 */
+settings.get("/link-status", async (c) => {
+  try {
+    const wallets = listAgentWallets();
+    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (!wallet) return c.json({ linked: false, error: "No wallet" });
+
+    const address = getBaseAddress(wallet);
+    if (!address) return c.json({ linked: false, error: "No EVM address" });
+
+    try {
+      const agentId = await publicClient.readContract({
+        address: ERC_8004,
+        abi: erc8004Abi,
+        functionName: "agentIdByWallet",
+        args: [address as `0x${string}`],
+      }) as bigint;
+
+      if (agentId > 0n) {
+        // Fetch NFT owner (ERC-721 ownerOf)
+        let owner: string | undefined;
+        try {
+          owner = await publicClient.readContract({
+            address: ERC_8004,
+            abi: [{ type: "function", name: "ownerOf", stateMutability: "view", inputs: [{ name: "tokenId", type: "uint256" }], outputs: [{ name: "", type: "address" }] }] as const,
+            functionName: "ownerOf",
+            args: [agentId],
+          }) as string;
+        } catch { /* best effort */ }
+        return c.json({ linked: true, agentId: Number(agentId), owsWallet: address, owner });
+      }
+    } catch { /* contract call may fail */ }
+
+    return c.json({ linked: false, owsWallet: address });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to check link status";
+    return c.json({ linked: false, error: message });
+  }
+});
+
+export { settings as settingsRoutes };

package/app/routes/stories.ts

@@ -0,0 +1,223 @@
+import { Hono } from "hono";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STORIES_DIR = path.join(__dirname, "..", "..", "stories");
+
+const stories = new Hono();
+
+/** Sanitize path params to prevent directory traversal */
+function safeName(name: string): string | null {
+  if (!name || name.includes("..") || name.includes("/") || name.includes("\\") || name.startsWith(".")) {
+    return null;
+  }
+  return name;
+}
+
+interface FileStatus {
+  file: string;
+  status: "published" | "published-not-indexed" | "pending" | "draft";
+  txHash?: string;
+  storylineId?: number;
+  plotIndex?: number;
+  contentCid?: string;
+  publishedAt?: string;
+  gasCost?: string;
+  indexError?: string;
+}
+
+interface StoryInfo {
+  name: string;
+  files: FileStatus[];
+  hasStructure: boolean;
+  hasGenesis: boolean;
+  plotCount: number;
+  publishedCount: number;
+}
+
+function readPublishStatus(storyDir: string): Record<string, FileStatus> {
+  const statusFile = path.join(storyDir, ".publish-status.json");
+  try {
+    if (fs.existsSync(statusFile)) {
+      return JSON.parse(fs.readFileSync(statusFile, "utf-8"));
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+function writePublishStatus(storyDir: string, status: Record<string, FileStatus>) {
+  const statusFile = path.join(storyDir, ".publish-status.json");
+  fs.writeFileSync(statusFile, JSON.stringify(status, null, 2) + "\n");
+}
+
+function scanStory(storyDir: string, name: string): StoryInfo {
+  const publishStatus = readPublishStatus(storyDir);
+  const entries = fs.readdirSync(storyDir).filter((f) => f.endsWith(".md"));
+
+  const files: FileStatus[] = entries.map((file) => {
+    const existing = publishStatus[file];
+    if (existing?.status === "published" || existing?.status === "published-not-indexed") {
+      return existing;
+    }
+    return { file, status: "pending" as const };
+  });
+
+  const hasStructure = entries.includes("structure.md");
+  const hasGenesis = entries.includes("genesis.md");
+  const plotCount = entries.filter((f) => f.match(/^plot-\d+\.md$/)).length;
+  const publishedCount = files.filter((f) => f.status === "published" || f.status === "published-not-indexed").length;
+
+  return { name, files, hasStructure, hasGenesis, plotCount, publishedCount };
+}
+
+/** GET /api/stories — list all stories */
+stories.get("/", (c) => {
+  if (!fs.existsSync(STORIES_DIR)) {
+    return c.json({ stories: [] });
+  }
+
+  const dirs = fs.readdirSync(STORIES_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
+    .map((d) => d.name)
+    .sort();
+
+  const result = dirs.map((name) => scanStory(path.join(STORIES_DIR, name), name));
+  return c.json({ stories: result });
+});
+
+/** GET /api/stories/:name — single story detail */
+stories.get("/:name", (c) => {
+  const name = safeName(c.req.param("name"));
+  if (!name) return c.json({ error: "Invalid story name" }, 400);
+  const storyDir = path.join(STORIES_DIR, name);
+
+  if (!fs.existsSync(storyDir) || !fs.statSync(storyDir).isDirectory()) {
+    return c.json({ error: "Story not found" }, 404);
+  }
+
+  const info = scanStory(storyDir, name);
+
+  // Include file contents
+  const filesWithContent = info.files.map((f) => {
+    const filePath = path.join(storyDir, f.file);
+    const content = fs.readFileSync(filePath, "utf-8");
+    return { ...f, content };
+  });
+
+  return c.json({ ...info, files: filesWithContent });
+});
+
+/** GET /api/stories/:name/:file — single file content */
+stories.get("/:name/:file", (c) => {
+  const name = safeName(c.req.param("name"));
+  const file = safeName(c.req.param("file"));
+  if (!name || !file) return c.json({ error: "Invalid path" }, 400);
+  const filePath = path.join(STORIES_DIR, name, file);
+
+  if (!fs.existsSync(filePath)) {
+    return c.json({ error: "File not found" }, 404);
+  }
+
+  const content = fs.readFileSync(filePath, "utf-8");
+  const publishStatus = readPublishStatus(path.join(STORIES_DIR, name));
+  const status = publishStatus[file] || { file, status: "pending" };
+
+  return c.json({ ...status, content });
+});
+
+/** PUT /api/stories/:name/:file — update file content */
+stories.put("/:name/:file", async (c) => {
+  const name = safeName(c.req.param("name"));
+  const file = safeName(c.req.param("file"));
+  if (!name || !file) return c.json({ error: "Invalid path" }, 400);
+  if (!file.endsWith(".md")) return c.json({ error: "Only .md files can be edited" }, 400);
+
+  const filePath = path.join(STORIES_DIR, name, file);
+  if (!fs.existsSync(filePath)) {
+    return c.json({ error: "File not found" }, 404);
+  }
+
+  const body = await c.req.json<{ content: string }>();
+  if (typeof body.content !== "string") {
+    return c.json({ error: "Content must be a string" }, 400);
+  }
+
+  // Only write and reset status if content actually changed
+  const existingContent = fs.readFileSync(filePath, "utf-8");
+  if (body.content === existingContent) {
+    return c.json({ ok: true, unchanged: true });
+  }
+
+  fs.writeFileSync(filePath, body.content, "utf-8");
+
+  // Reset publish status to pending if file was previously published
+  const storyDir = path.join(STORIES_DIR, name);
+  const status = readPublishStatus(storyDir);
+  if (status[file] && (status[file].status === "published" || status[file].status === "published-not-indexed")) {
+    status[file].status = "pending";
+    writePublishStatus(storyDir, status);
+  }
+
+  return c.json({ ok: true });
+});
+
+/** POST /api/stories/:name/:file/publish-status — update publish status after publishing */
+stories.post("/:name/:file/publish-status", async (c) => {
+  const name = safeName(c.req.param("name"));
+  const file = safeName(c.req.param("file"));
+  if (!name || !file) return c.json({ error: "Invalid path" }, 400);
+  const storyDir = path.join(STORIES_DIR, name);
+  const body = await c.req.json<{
+    txHash: string;
+    storylineId?: number;
+    plotIndex?: number;
+    contentCid: string;
+    gasCost?: string;
+    indexError?: string;
+  }>();
+
+  const status = readPublishStatus(storyDir);
+  const existing = status[file];
+  status[file] = {
+    file,
+    status: body.indexError ? "published-not-indexed" : "published",
+    txHash: body.txHash || existing?.txHash,
+    storylineId: body.storylineId ?? existing?.storylineId,
+    plotIndex: body.plotIndex ?? existing?.plotIndex,
+    contentCid: body.contentCid || existing?.contentCid,
+    gasCost: body.gasCost || existing?.gasCost,
+    publishedAt: new Date().toISOString(),
+    ...(body.indexError ? { indexError: body.indexError } : {}),
+  };
+  writePublishStatus(storyDir, status);
+
+  return c.json({ ok: true });
+});
+
+/** POST /api/stories/:name/:file/mark-not-indexed — manually mark as not indexed */
+stories.post("/:name/:file/mark-not-indexed", async (c) => {
+  const name = safeName(c.req.param("name"));
+  const file = safeName(c.req.param("file"));
+  if (!name || !file) return c.json({ error: "Invalid path" }, 400);
+  const storyDir = path.join(STORIES_DIR, name);
+
+  const status = readPublishStatus(storyDir);
+  const existing = status[file];
+  if (!existing || (existing.status !== "published" && existing.status !== "published-not-indexed")) {
+    return c.json({ error: "File is not published" }, 400);
+  }
+
+  const body = await c.req.json<{ indexError?: string }>().catch(() => ({}));
+  status[file] = {
+    ...existing,
+    status: "published-not-indexed",
+    indexError: body.indexError || "Manually marked as not indexed",
+  };
+  writePublishStatus(storyDir, status);
+
+  return c.json({ ok: true });
+});
+
+export { stories as storiesRoutes, readPublishStatus, STORIES_DIR };