plotlink-ows 0.1.13

package/app/routes/config.ts

@@ -0,0 +1,210 @@
+import { Hono } from "hono";
+import fs from "fs";
+import { AGENT_CONFIG_FILE, ENV_FILE } from "../lib/paths";
+
+const configPath = AGENT_CONFIG_FILE;
+const envPath = ENV_FILE;
+
+const config = new Hono();
+
+/** Provider catalog with metadata */
+const PROVIDERS = [
+  { id: "anthropic", name: "Anthropic", envKeys: ["ANTHROPIC_API_KEY", "ANTHROPIC_OAUTH_TOKEN"], models: ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"], tag: "recommended" },
+  { id: "openai", name: "OpenAI", envKeys: ["OPENAI_API_KEY", "OPENAI_OAUTH_TOKEN"], models: ["gpt-4.1", "gpt-4.1-mini", "o3-mini"], tag: null },
+  { id: "gemini", name: "Google Gemini", envKeys: ["GEMINI_API_KEY"], models: ["gemini-2.5-flash", "gemini-2.5-pro"], tag: null },
+  { id: "local", name: "Local (Ollama/LM Studio)", envKeys: [], models: [], tag: "free" },
+];
+
+/** Check if any env key for a provider is set */
+function isProviderConfigured(p: typeof PROVIDERS[number]): boolean {
+  return p.envKeys.some((k) => !!process.env[k]);
+}
+
+/** Get the active credential for a provider */
+function getProviderCredential(p: typeof PROVIDERS[number]): string | null {
+  for (const k of p.envKeys) {
+    if (process.env[k]) return process.env[k]!;
+  }
+  return null;
+}
+
+function readConfig(): Record<string, unknown> {
+  try {
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+function writeConfig(cfg: Record<string, unknown>) {
+  fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n");
+}
+
+function writeEnvVar(key: string, value: string) {
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, "utf-8");
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      fs.writeFileSync(envPath, content.replace(regex, `${key}=${value}`));
+    } else {
+      fs.appendFileSync(envPath, `\n${key}=${value}\n`);
+    }
+  } else {
+    fs.writeFileSync(envPath, `${key}=${value}\n`);
+  }
+  process.env[key] = value;
+}
+
+/** GET /api/config/llm — current LLM config */
+config.get("/llm", (c) => {
+  const cfg = readConfig() as { llm?: Record<string, unknown> };
+  const llm = cfg.llm || {};
+
+  // Check which providers are configured
+  const configured = PROVIDERS.filter((p) => {
+    if (p.id === "local") return !!(llm as Record<string, unknown>).local;
+    return isProviderConfigured(p);
+  }).map((p) => p.id);
+
+  return c.json({ llm, configured });
+});
+
+/** GET /api/config/llm/providers — provider catalog */
+config.get("/llm/providers", (c) => {
+  return c.json(
+    PROVIDERS.map((p) => ({
+      ...p,
+      configured: isProviderConfigured(p),
+    })),
+  );
+});
+
+/** POST /api/config/llm — save LLM config */
+config.post("/llm", async (c) => {
+  const body = await c.req.json<{
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    apiType?: string;
+    spendCap?: number;
+  }>();
+
+  if (!body.provider || !body.model) {
+    return c.json({ error: "provider and model required" }, 400);
+  }
+
+  const provider = PROVIDERS.find((p) => p.id === body.provider);
+  if (!provider) return c.json({ error: "Unknown provider" }, 400);
+
+  // Save API key to .env if provided (use first envKey as the primary)
+  if (body.apiKey && provider.envKeys.length > 0) {
+    writeEnvVar(provider.envKeys[0], body.apiKey);
+  }
+
+  // Build config
+  const cfg = readConfig();
+  const llmConfig: Record<string, unknown> = (cfg.llm as Record<string, unknown>) || {};
+
+  if (body.provider === "local") {
+    llmConfig.local = {
+      baseUrl: body.baseUrl || "http://localhost:11434",
+      apiType: body.apiType || "ollama",
+      model: body.model,
+    };
+  } else {
+    // Find which env key is active (API key or OAuth token)
+    const activeEnvKey = provider.envKeys.find((k) => !!process.env[k]) || provider.envKeys[0];
+    llmConfig[body.provider] = {
+      apiKey: activeEnvKey ? `env:${activeEnvKey}` : undefined,
+      model: body.model,
+    };
+  }
+
+  llmConfig.activeProvider = body.provider;
+  llmConfig.activeModel = body.model;
+
+  cfg.llm = llmConfig;
+
+  // Persist spending cap if provided
+  if (body.spendCap !== undefined) {
+    (cfg as Record<string, unknown>).spendCap = body.spendCap;
+  }
+
+  writeConfig(cfg);
+
+  return c.json({ success: true });
+});
+
+/** POST /api/config/llm/test — test LLM connection */
+config.post("/llm/test", async (c) => {
+  const body = await c.req.json<{
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+  }>();
+
+  try {
+    if (body.provider === "local") {
+      const baseUrl = body.baseUrl || "http://localhost:11434";
+      const res = await fetch(`${baseUrl}/api/tags`);
+      if (!res.ok) throw new Error(`Local server returned ${res.status}`);
+      return c.json({ success: true, message: "Connected to local model server" });
+    }
+
+    // For cloud providers, do a minimal test
+    const provider = PROVIDERS.find((p) => p.id === body.provider);
+    const apiKey = body.apiKey || (provider ? getProviderCredential(provider) : null);
+
+    if (!apiKey) {
+      return c.json({ success: false, message: "No API key configured" }, 400);
+    }
+
+    // Test with a minimal request based on provider
+    if (body.provider === "anthropic") {
+      const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          model: body.model,
+          max_tokens: 1,
+          messages: [{ role: "user", content: "hi" }],
+        }),
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error((err as Record<string, unknown>).error?.toString() || `HTTP ${res.status}`);
+      }
+    } else if (body.provider === "openai") {
+      const res = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+        body: JSON.stringify({ model: body.model, max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    } else if (body.provider === "gemini") {
+      const res = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${body.model}:generateContent?key=${apiKey}`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ contents: [{ parts: [{ text: "hi" }] }], generationConfig: { maxOutputTokens: 1 } }),
+        },
+      );
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    }
+
+    return c.json({ success: true, message: "Connection verified" });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Connection failed";
+    return c.json({ success: false, message }, 400);
+  }
+});
+
+export { config as configRoutes };

package/app/routes/dashboard.ts

@@ -0,0 +1,186 @@
+import { Hono } from "hono";
+import { createPublicClient, http } from "viem";
+import { base } from "viem/chains";
+import { db } from "../db";
+import { getEthBalance } from "../lib/publish";
+import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+import { mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
+
+const MCV2_BOND = "0xc5a076cad94176c2996B32d8466Be1cE757FAa27" as const;
+// Reserve token for PlotLink bonding curves (PLOT token on Base mainnet)
+const RESERVE_TOKEN = "0x4F567DACBF9D15A6acBe4A47FC2Ade0719Fb63C4" as const;
+
+const publicClient = createPublicClient({
+  chain: base,
+  transport: http(process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org"),
+});
+
+const dashboard = new Hono();
+
+/** GET /api/dashboard — writer dashboard data */
+dashboard.get("/", async (c) => {
+  // Get all drafts (published and unpublished)
+  const drafts = await db.draft.findMany({
+    orderBy: { createdAt: "desc" },
+  });
+
+  // Get wallet info
+  let walletInfo = null;
+  try {
+    const wallets = listAgentWallets();
+    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (wallet) {
+      const address = getBaseAddress(wallet);
+      if (address) {
+        const ethBalance = await getEthBalance(address);
+
+        // Fetch USDC balance
+        let usdcBalance = "0";
+        try {
+          const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+          const balanceOfSig = "0x70a08231000000000000000000000000" + address.slice(2).toLowerCase();
+          const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+          const res = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [{ to: USDC_BASE, data: balanceOfSig }, "latest"] }),
+          });
+          const data = await res.json() as { result?: string };
+          if (data.result && data.result !== "0x") {
+            usdcBalance = (Number(BigInt(data.result)) / 1e6).toFixed(2);
+          }
+        } catch { /* best effort */ }
+
+        walletInfo = {
+          address,
+          ethBalance: ethBalance.toString(),
+          ethFormatted: (Number(ethBalance) / 1e18).toFixed(6),
+          usdcBalance,
+        };
+      }
+    }
+  } catch { /* wallet not available */ }
+
+  // Published stories with cost data
+  const published = drafts.filter((d) => d.status === "published");
+  const unpublished = drafts.filter((d) => d.status !== "published");
+
+  // Compute total costs
+  const totalGasCostWei = published.reduce((sum, d) => {
+    if (d.gasCost) return sum + BigInt(d.gasCost);
+    return sum;
+  }, BigInt(0));
+  const totalGasCostEth = (Number(totalGasCostWei) / 1e18).toFixed(6);
+
+  // Query on-chain royalties (WETH on Base — bonding curve reserve)
+  let royaltiesEarned = "0";
+  let royaltiesClaimed = "0";
+  if (walletInfo?.address) {
+    try {
+      // getRoyaltyInfo returns (unclaimed, totalClaimed)
+      const [unclaimed, totalClaimed] = await publicClient.readContract({
+        address: MCV2_BOND,
+        abi: mcv2BondAbi,
+        functionName: "getRoyaltyInfo",
+        args: [walletInfo.address as `0x${string}`, RESERVE_TOKEN],
+      }) as [bigint, bigint];
+      // Total earned = unclaimed + previously claimed
+      royaltiesEarned = (Number(unclaimed + totalClaimed) / 1e18).toFixed(6);
+      royaltiesClaimed = (Number(totalClaimed) / 1e18).toFixed(6);
+    } catch { /* no royalties or contract not available */ }
+  }
+
+  // Fetch ETH/USD price for common-unit P&L
+  let ethUsdPrice = 0;
+  try {
+    const priceRes = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd");
+    const priceData = await priceRes.json() as { ethereum?: { usd?: number } };
+    ethUsdPrice = priceData.ethereum?.usd ?? 0;
+  } catch { /* price fetch best-effort */ }
+
+  const totalCostUsd = parseFloat(totalGasCostEth) * ethUsdPrice;
+
+  // Get PLOT/USD via existing price helper (HUNT-backed derivation)
+  let plotUsdPrice = 0;
+  try {
+    const { getPlotUsdPrice } = await import("../../lib/usd-price");
+    const price = await getPlotUsdPrice();
+    if (price) plotUsdPrice = price;
+  } catch { /* price estimation best-effort */ }
+
+  const totalRoyaltiesUsd = parseFloat(royaltiesEarned) * plotUsdPrice;
+  const netPnlUsd = totalRoyaltiesUsd - totalCostUsd;
+
+  // Session stats
+  const sessions = await db.storySession.findMany({
+    include: { _count: { select: { messages: true } } },
+  });
+
+  return c.json({
+    wallet: walletInfo,
+    stories: {
+      published: published.map((d) => ({
+        id: d.id,
+        title: d.title,
+        genre: d.genre,
+        status: d.status,
+        txHash: d.txHash,
+        storylineId: d.storylineId,
+        contentCid: d.contentCid,
+        gasCost: d.gasCost,
+        gasCostEth: d.gasCost ? (Number(BigInt(d.gasCost)) / 1e18).toFixed(6) : null,
+        gasCostUsd: d.gasCost && ethUsdPrice ? ((Number(BigInt(d.gasCost)) / 1e18) * ethUsdPrice).toFixed(2) : null,
+        createdAt: d.createdAt,
+        updatedAt: d.updatedAt,
+      })),
+      drafts: unpublished.map((d) => ({
+        id: d.id,
+        title: d.title,
+        genre: d.genre,
+        status: d.status,
+        createdAt: d.createdAt,
+      })),
+      totalPublished: published.length,
+      totalDrafts: unpublished.length,
+    },
+    costs: {
+      totalGasCostWei: totalGasCostWei.toString(),
+      totalGasCostEth,
+      totalCostUsd: totalCostUsd.toFixed(2),
+      ethUsdPrice,
+      storiesPublished: published.length,
+    },
+    royalties: {
+      earned: royaltiesEarned,
+      claimed: royaltiesClaimed,
+      // unclaimed = earned - claimed (already correct since earned = unclaimed + claimed)
+      unclaimed: (parseFloat(royaltiesEarned) - parseFloat(royaltiesClaimed)).toFixed(6),
+      token: "PLOT",
+    },
+    pnl: {
+      totalCostsEth: totalGasCostEth,
+      totalCostsUsd: totalCostUsd.toFixed(2),
+      totalRoyaltiesPlot: royaltiesEarned,
+      totalRoyaltiesUsd: totalRoyaltiesUsd.toFixed(2),
+      netPnlUsd: netPnlUsd.toFixed(2),
+      plotUsdPrice: plotUsdPrice.toFixed(4),
+    },
+    sessions: {
+      total: sessions.length,
+      totalMessages: sessions.reduce((sum, s) => sum + s._count.messages, 0),
+    },
+  });
+});
+
+/** DELETE /api/dashboard/drafts/:id — delete a draft */
+dashboard.delete("/drafts/:id", async (c) => {
+  const id = c.req.param("id");
+  try {
+    await db.draft.delete({ where: { id } });
+    return c.json({ success: true });
+  } catch {
+    return c.json({ error: "Draft not found" }, 404);
+  }
+});
+
+export { dashboard as dashboardRoutes };

package/app/routes/oauth.ts

@@ -0,0 +1,150 @@
+import { Hono } from "hono";
+import { randomBytes, createHash } from "crypto";
+import fs from "fs";
+import { ENV_FILE } from "../lib/paths";
+
+const envPath = ENV_FILE;
+
+const oauth = new Hono();
+
+// OAuth state store (in-memory, keyed by state param)
+const pendingFlows = new Map<string, { provider: string; codeVerifier: string; status: "pending" | "complete"; token?: string }>();
+
+const OAUTH_CONFIGS: Record<string, { authUrl: string; tokenUrl: string; clientId: string; envKey: string }> = {
+  anthropic: {
+    authUrl: "https://console.anthropic.com/oauth/authorize",
+    tokenUrl: "https://console.anthropic.com/oauth/token",
+    clientId: "plotlink-ows-local",
+    envKey: "ANTHROPIC_OAUTH_TOKEN",
+  },
+  openai: {
+    authUrl: "https://platform.openai.com/oauth/authorize",
+    tokenUrl: "https://platform.openai.com/oauth/token",
+    clientId: "plotlink-ows-local",
+    envKey: "OPENAI_OAUTH_TOKEN",
+  },
+};
+
+function writeEnvVar(key: string, value: string) {
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, "utf-8");
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      fs.writeFileSync(envPath, content.replace(regex, `${key}=${value}`));
+    } else {
+      fs.appendFileSync(envPath, `\n${key}=${value}\n`);
+    }
+  } else {
+    fs.writeFileSync(envPath, `${key}=${value}\n`);
+  }
+  process.env[key] = value;
+}
+
+/** GET /api/oauth/:provider/start — initiate OAuth PKCE flow */
+oauth.get("/:provider/start", (c) => {
+  const provider = c.req.param("provider");
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) return c.json({ error: "Unsupported OAuth provider" }, 400);
+
+  const state = randomBytes(16).toString("hex");
+  const codeVerifier = randomBytes(32).toString("base64url");
+
+  pendingFlows.set(state, { provider, codeVerifier, status: "pending" });
+
+  // Compute S256 code_challenge from verifier
+  const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+
+  // Build authorization URL with PKCE
+  const params = new URLSearchParams({
+    client_id: config.clientId,
+    response_type: "code",
+    redirect_uri: "http://localhost:7777/api/oauth/callback",
+    state,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    scope: "api",
+  });
+
+  const authUrl = `${config.authUrl}?${params}`;
+
+  return c.json({ authUrl, state });
+});
+
+/** GET /api/oauth/callback — OAuth redirect handler */
+oauth.get("/callback", async (c) => {
+  const code = c.req.query("code");
+  const state = c.req.query("state");
+  const error = c.req.query("error");
+
+  if (error) {
+    return c.html(`<html><body><h2>OAuth Error</h2><p>${error}</p><script>window.close()</script></body></html>`);
+  }
+
+  if (!code || !state) {
+    return c.html(`<html><body><h2>Missing parameters</h2><script>window.close()</script></body></html>`);
+  }
+
+  const flow = pendingFlows.get(state);
+  if (!flow) {
+    return c.html(`<html><body><h2>Invalid state</h2><script>window.close()</script></body></html>`);
+  }
+
+  const config = OAUTH_CONFIGS[flow.provider];
+  if (!config) {
+    return c.html(`<html><body><h2>Unknown provider</h2><script>window.close()</script></body></html>`);
+  }
+
+  try {
+    // Exchange code for token
+    const res = await fetch(config.tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: "http://localhost:7777/api/oauth/callback",
+        client_id: config.clientId,
+        code_verifier: flow.codeVerifier,
+      }),
+    });
+
+    const data = await res.json() as Record<string, unknown>;
+
+    if (!res.ok) {
+      throw new Error((data.error_description || data.error || "Token exchange failed") as string);
+    }
+
+    const accessToken = data.access_token as string;
+    writeEnvVar(config.envKey, accessToken);
+    flow.status = "complete";
+    flow.token = accessToken;
+
+    return c.html(`<html><body><h2>Connected!</h2><p>You can close this window.</p><script>window.close()</script></body></html>`);
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Token exchange failed";
+    return c.html(`<html><body><h2>Error</h2><p>${message}</p><script>window.close()</script></body></html>`);
+  }
+});
+
+/** GET /api/oauth/:provider/status — poll for OAuth completion */
+oauth.get("/:provider/status", (c) => {
+  const provider = c.req.param("provider");
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) return c.json({ error: "Unsupported provider" }, 400);
+
+  // Check if token is already in env
+  if (process.env[config.envKey]) {
+    return c.json({ complete: true });
+  }
+
+  // Check pending flows
+  for (const [, flow] of pendingFlows) {
+    if (flow.provider === provider && flow.status === "complete") {
+      return c.json({ complete: true });
+    }
+  }
+
+  return c.json({ complete: false });
+});
+
+export { oauth as oauthRoutes };

package/app/routes/publish.ts

@@ -0,0 +1,112 @@
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { db } from "../db";
+import { publishStoryline, getEthBalance, estimatePublishCost } from "../lib/publish";
+import { keccak256, toBytes } from "viem";
+import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+
+const publish = new Hono();
+
+/** GET /api/publish/preflight — check if publishing is possible */
+publish.get("/preflight", async (c) => {
+  try {
+    // Check wallet
+    const wallets = listAgentWallets();
+    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (!wallet) {
+      return c.json({ ready: false, error: "No OWS wallet found" });
+    }
+
+    const address = getBaseAddress(wallet);
+    if (!address) {
+      return c.json({ ready: false, error: "No EVM address on wallet" });
+    }
+
+    // Check ETH balance against real estimated cost
+    const balance = await getEthBalance(address);
+    let totalCost: bigint | null = null;
+    let creationFee = BigInt(0);
+    let estimationFailed = false;
+    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;
+    }
+    // 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);
+
+    return c.json({
+      ready: hasEnoughEth && hasFilebase,
+      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,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Preflight check failed";
+    return c.json({ ready: false, error: message });
+  }
+});
+
+/** POST /api/publish/:draftId — publish a draft on-chain (streams progress) */
+publish.post("/:draftId", async (c) => {
+  const draftId = c.req.param("draftId");
+
+  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);
+
+  // Get wallet
+  const wallets = listAgentWallets();
+  const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+  if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
+
+  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",
+          txHash: result.txHash,
+          storylineId: result.storylineId,
+          contentCid: result.contentCid,
+          gasCost: result.gasCost,
+        },
+      });
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Publish failed";
+      await stream.writeSSE({
+        data: JSON.stringify({ step: "error", message, error: message }),
+      });
+    }
+  });
+});
+
+export { publish as publishRoutes };