plotlink-ows 0.1.13

package/app/routes/wallet.ts

@@ -0,0 +1,99 @@
+import { Hono } from "hono";
+import fs from "fs";
+import { ENV_FILE } from "../lib/paths";
+
+const envPath = ENV_FILE;
+
+const wallet = new Hono();
+
+function readEnvPassphrase(): string | null {
+  if (process.env.OWS_PASSPHRASE) return process.env.OWS_PASSPHRASE;
+  try {
+    if (fs.existsSync(envPath)) {
+      const content = fs.readFileSync(envPath, "utf-8");
+      const match = content.match(/^OWS_PASSPHRASE=(.+)$/m);
+      if (match) return match[1].trim();
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/** GET /api/wallet — get wallet info */
+wallet.get("/", async (c) => {
+  try {
+    const { getAgentWallet, getBaseAddress } = await import("../../lib/ows/wallet");
+
+    // Try to find existing wallet
+    const { listAgentWallets } = await import("../../lib/ows/wallet");
+    const wallets = listAgentWallets();
+    const plotlinkWallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+
+    if (!plotlinkWallet) {
+      return c.json({ exists: false });
+    }
+
+    const address = getBaseAddress(plotlinkWallet);
+
+    // Fetch USDC balance on Base via RPC
+    let usdcBalance = "0";
+    if (address) {
+      try {
+        const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base mainnet
+        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") {
+          const raw = BigInt(data.result);
+          usdcBalance = (Number(raw) / 1e6).toFixed(2); // USDC has 6 decimals
+        }
+      } catch { /* balance fetch best-effort */ }
+    }
+
+    return c.json({
+      exists: true,
+      walletId: plotlinkWallet.id,
+      name: plotlinkWallet.name,
+      address,
+      usdcBalance,
+      accounts: plotlinkWallet.accounts,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to get wallet";
+    return c.json({ exists: false, error: message });
+  }
+});
+
+/** POST /api/wallet/create — create OWS wallet */
+wallet.post("/create", async (c) => {
+  try {
+    const passphrase = readEnvPassphrase();
+    if (!passphrase) {
+      return c.json({ error: "Passphrase not configured" }, 400);
+    }
+
+    const { createAgentWallet, getBaseAddress, listAgentWallets } = await import("../../lib/ows/wallet");
+
+    // Check if wallet already exists
+    const wallets = listAgentWallets();
+    const existing = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    if (existing) {
+      const address = getBaseAddress(existing);
+      return c.json({ walletId: existing.id, address, alreadyExisted: true });
+    }
+
+    const wallet = createAgentWallet("plotlink-writer", passphrase);
+    const address = getBaseAddress(wallet);
+
+    return c.json({ walletId: wallet.id, address, alreadyExisted: false });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Wallet creation failed";
+    return c.json({ error: message }, 500);
+  }
+});
+
+export { wallet as walletRoutes };

package/app/server.ts

@@ -0,0 +1,154 @@
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ENV_FILE } from "./lib/paths";
+
+// Load .env from ~/.plotlink-ows/ before anything else
+const __dirnamePre = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: ENV_FILE });
+
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { authRoutes, requireAuth } from "./routes/auth";
+import { configRoutes } from "./routes/config";
+import { walletRoutes } from "./routes/wallet";
+import { oauthRoutes } from "./routes/oauth";
+import { chatRoutes } from "./routes/chat";
+import { publishRoutes } from "./routes/publish";
+import { dashboardRoutes } from "./routes/dashboard";
+import { initDb } from "./db";
+import { execSync } from "child_process";
+import fs from "fs";
+
+const __dirname = __dirnamePre;
+
+const app = new Hono();
+const { upgradeWebSocket, injectWebSocket } = createNodeWebSocket({ app });
+
+// CORS for local dev
+app.use("/*", cors({ origin: "http://localhost:5173", credentials: true }));
+
+// API routes
+app.route("/api/auth", authRoutes);
+// Protected routes
+app.use("/api/config/*", requireAuth);
+app.use("/api/wallet/*", requireAuth);
+// OAuth: protect start/status but NOT callback (provider redirects without auth)
+app.use("/api/oauth/:provider/start", requireAuth);
+app.use("/api/oauth/:provider/status", requireAuth);
+app.route("/api/config", configRoutes);
+app.route("/api/wallet", walletRoutes);
+app.route("/api/oauth", oauthRoutes);
+app.use("/api/chat/*", requireAuth);
+app.use("/api/publish/*", requireAuth);
+app.route("/api/chat", chatRoutes);
+app.route("/api/publish", publishRoutes);
+app.use("/api/dashboard/*", requireAuth);
+app.route("/api/dashboard", dashboardRoutes);
+
+// Health check
+app.get("/api/health", (c) => c.json({ status: "ok" }));
+
+// WebSocket chat endpoint (auth via query param since WS can't send headers)
+app.get(
+  "/ws/chat",
+  upgradeWebSocket((c) => {
+    const wsToken = new URL(c.req.url).searchParams.get("token");
+    let authenticated = false;
+
+    return {
+    async onOpen(_event, ws) {
+      if (!wsToken) { ws.close(4001, "Missing token"); return; }
+      const { db } = await import("./db");
+      const session = await db.session.findUnique({ where: { token: wsToken } });
+      if (!session || session.expiresAt < new Date()) { ws.close(4001, "Invalid token"); return; }
+      authenticated = true;
+    },
+    async onMessage(event, ws) {
+      if (!authenticated) { ws.close(4001, "Not authenticated"); return; }
+      try {
+        const data = JSON.parse(String(event.data));
+        if (data.type === "message" && data.sessionId && data.content) {
+          const { db } = await import("./db");
+          const { streamChat } = await import("./lib/llm-client");
+          const { WRITER_SYSTEM_PROMPT } = await import("./lib/writer-prompt");
+
+          // Save user message
+          await db.message.create({
+            data: { sessionId: data.sessionId, role: "user", content: data.content },
+          });
+
+          // Build context
+          const messages = await db.message.findMany({
+            where: { sessionId: data.sessionId },
+            orderBy: { createdAt: "asc" },
+          });
+
+          const chatMessages = [
+            { role: "system" as const, content: WRITER_SYSTEM_PROMPT },
+            ...messages.map((m: { role: string; content: string }) => ({
+              role: m.role as "user" | "assistant" | "system",
+              content: m.content,
+            })),
+          ];
+
+          // Stream response
+          let fullResponse = "";
+          for await (const chunk of streamChat(chatMessages)) {
+            fullResponse += chunk;
+            ws.send(JSON.stringify({ type: "chunk", content: chunk }));
+          }
+
+          // Save assistant message
+          await db.message.create({
+            data: { sessionId: data.sessionId, role: "assistant", content: fullResponse },
+          });
+
+          ws.send(JSON.stringify({ type: "done" }));
+        }
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : "WebSocket error";
+        ws.send(JSON.stringify({ type: "error", message }));
+      }
+    },
+  };
+  }),
+);
+
+// In production, serve the built frontend
+const distPath = path.join(__dirname, "web", "dist");
+if (fs.existsSync(distPath)) {
+  app.use("/*", serveStatic({ root: "./app/web/dist" }));
+  app.get("*", (c) => {
+    const html = fs.readFileSync(path.join(distPath, "index.html"), "utf-8");
+    return c.html(html);
+  });
+}
+
+async function start() {
+  // Ensure data directory exists
+  const dataDir = path.join(__dirname, "..", "data");
+  if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+
+  // Run Prisma db push to ensure schema is up to date
+  const schemaPath = path.join(__dirname, "prisma", "schema.prisma");
+  execSync(`npx prisma db push --schema ${schemaPath} --skip-generate`, {
+    stdio: "inherit",
+    env: { ...process.env, DATABASE_URL: `file:${path.join(dataDir, "local.db")}` },
+  });
+
+  // Initialize database connection
+  await initDb();
+
+  const port = Number(process.env.APP_PORT) || 7777;
+  const server = serve({ fetch: app.fetch, port }, (info) => {
+    console.log(`\n  PlotLink OWS running at http://localhost:${info.port}\n`);
+  });
+
+  injectWebSocket(server);
+}
+
+start().catch(console.error);

package/app/vite.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+export default defineConfig({
+  root: "app/web",
+  plugins: [react(), tailwindcss()],
+  server: {
+    port: 5173,
+    proxy: {
+      "/api": "http://localhost:7777",
+      "/ws": { target: "ws://localhost:7777", ws: true },
+    },
+  },
+  build: {
+    outDir: "dist",
+    emptyOutDir: true,
+  },
+});

package/app/web/App.tsx

@@ -0,0 +1,102 @@
+import React, { useState, useEffect } from "react";
+import { Login } from "./components/Login";
+import { Setup } from "./components/Setup";
+import { Layout } from "./components/Layout";
+
+const API_BASE = "http://localhost:7777";
+
+export function App() {
+  const [token, setToken] = useState<string | null>(() =>
+    localStorage.getItem("ows-token"),
+  );
+  const [configured, setConfigured] = useState<boolean | null>(null);
+  const [checking, setChecking] = useState(true);
+
+  useEffect(() => {
+    // Check if passphrase is configured (first-run detection)
+    fetch(`${API_BASE}/api/auth/status`)
+      .then((r) => r.json())
+      .then((d) => setConfigured(d.configured))
+      .catch(() => setConfigured(null));
+  }, []);
+
+  useEffect(() => {
+    if (!token) {
+      // eslint-disable-next-line react-hooks/set-state-in-effect -- sync guard before async work
+      setChecking(false);
+      return;
+    }
+    fetch(`${API_BASE}/api/auth/verify`, {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+      .then((r) => {
+        if (!r.ok) {
+          localStorage.removeItem("ows-token");
+          setToken(null);
+        }
+      })
+      .catch(() => {
+        localStorage.removeItem("ows-token");
+        setToken(null);
+      })
+      .finally(() => setChecking(false));
+  }, [token]);
+
+  const handleLogin = async (passphrase: string): Promise<string | null> => {
+    try {
+      const res = await fetch(`${API_BASE}/api/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ passphrase }),
+      });
+      const data = await res.json();
+      if (!res.ok) return data.error || "Login failed";
+      localStorage.setItem("ows-token", data.token);
+      setToken(data.token);
+      return null;
+    } catch {
+      return "Cannot connect to server";
+    }
+  };
+
+  const handleSetup = async (passphrase: string): Promise<string | null> => {
+    try {
+      const res = await fetch(`${API_BASE}/api/auth/setup`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ passphrase }),
+      });
+      const data = await res.json();
+      if (!res.ok) return data.error || "Setup failed";
+      localStorage.setItem("ows-token", data.token);
+      setToken(data.token);
+      setConfigured(true);
+      return null;
+    } catch {
+      return "Cannot connect to server";
+    }
+  };
+
+  const handleLogout = () => {
+    localStorage.removeItem("ows-token");
+    setToken(null);
+  };
+
+  if (checking || configured === null) {
+    return (
+      <div className="flex h-screen items-center justify-center">
+        <span className="text-muted text-sm">connecting...</span>
+      </div>
+    );
+  }
+
+  if (!configured) {
+    return <Setup onSetup={handleSetup} />;
+  }
+
+  if (!token) {
+    return <Login onLogin={handleLogin} />;
+  }
+
+  return <Layout token={token} onLogout={handleLogout} />;
+}

package/app/web/components/Chat.tsx

@@ -0,0 +1,272 @@
+import React, { useState, useEffect, useRef } from "react";
+import Markdown from "react-markdown";
+
+const API_BASE = "http://localhost:7777";
+
+interface Message {
+  id: string;
+  role: "user" | "assistant" | "system";
+  content: string;
+  createdAt: string;
+}
+
+interface StorySession {
+  id: string;
+  title: string;
+  genre: string | null;
+  status: string;
+  messages: Message[];
+  drafts: Array<{ id: string; title: string; content: string; genre: string | null; status: string }>;
+}
+
+export function Chat({ token }: { token: string }) {
+  const [sessions, setSessions] = useState<Array<{ id: string; title: string; status: string; _count: { messages: number } }>>([]);
+  const [activeSession, setActiveSession] = useState<StorySession | null>(null);
+  const [input, setInput] = useState("");
+  const [streaming, setStreaming] = useState(false);
+  const [streamContent, setStreamContent] = useState("");
+  const messagesEndRef = useRef<HTMLDivElement>(null);
+
+  const authFetch = (url: string, opts?: RequestInit) =>
+    fetch(url, { ...opts, headers: { ...opts?.headers, Authorization: `Bearer ${token}`, "Content-Type": "application/json" } });
+
+  const loadSessions = () => {
+    authFetch(`${API_BASE}/api/chat/sessions`)
+      .then((r) => r.json())
+      .then((data) => setSessions(data));
+  };
+
+  const loadSession = (id: string) => {
+    authFetch(`${API_BASE}/api/chat/sessions/${id}`)
+      .then((r) => r.json())
+      .then((data) => setActiveSession(data));
+  };
+
+  useEffect(() => { loadSessions(); }, []);
+  useEffect(() => { messagesEndRef.current?.scrollIntoView({ behavior: "smooth" }); }, [activeSession?.messages, streamContent]);
+
+  const createSession = async () => {
+    const res = await authFetch(`${API_BASE}/api/chat/sessions`, {
+      method: "POST",
+      body: JSON.stringify({}),
+    });
+    const session = await res.json();
+    loadSessions();
+    loadSession(session.id);
+  };
+
+  const sendMessage = async () => {
+    if (!input.trim() || !activeSession || streaming) return;
+    const content = input.trim();
+    setInput("");
+    setStreaming(true);
+    setStreamContent("");
+
+    // Optimistically add user message
+    setActiveSession((prev) => prev ? {
+      ...prev,
+      messages: [...prev.messages, { id: "temp", role: "user", content, createdAt: new Date().toISOString() }],
+    } : null);
+
+    try {
+      // Use WebSocket for streaming
+      const ws = new WebSocket(`ws://localhost:7777/ws/chat?token=${encodeURIComponent(token)}`);
+      let fullContent = "";
+
+      await new Promise<void>((resolve, reject) => {
+        ws.onopen = () => {
+          ws.send(JSON.stringify({ type: "message", sessionId: activeSession.id, content }));
+        };
+        ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            if (data.type === "chunk") {
+              fullContent += data.content;
+              setStreamContent(fullContent);
+            } else if (data.type === "done") {
+              ws.close();
+              resolve();
+            } else if (data.type === "error") {
+              ws.close();
+              reject(new Error(data.message));
+            }
+          } catch { /* ignore */ }
+        };
+        ws.onerror = () => reject(new Error("WebSocket error"));
+        ws.onclose = () => resolve();
+      });
+
+      // Reload session to get persisted messages
+      loadSession(activeSession.id);
+      loadSessions();
+    } catch (err) {
+      console.error("Send error:", err);
+    }
+
+    setStreaming(false);
+    setStreamContent("");
+  };
+
+  const handleFinalize = async () => {
+    if (!activeSession) return;
+    const lastAssistant = [...activeSession.messages].reverse().find((m) => m.role === "assistant");
+    if (!lastAssistant) return;
+
+    // Try to extract title and content from the formatted output
+    const content = lastAssistant.content;
+    const titleMatch = content.match(/TITLE:\s*(.+)/);
+    const genreMatch = content.match(/GENRE:\s*(.+)/);
+    const storyMatch = content.match(/---\n([\s\S]+)$/);
+
+    const title = titleMatch?.[1]?.trim() || activeSession.title;
+    const genre = genreMatch?.[1]?.trim() || activeSession.genre;
+    const storyContent = storyMatch?.[1]?.trim() || content;
+
+    await authFetch(`${API_BASE}/api/chat/sessions/${activeSession.id}/finalize`, {
+      method: "POST",
+      body: JSON.stringify({ title, content: storyContent, genre }),
+    });
+
+    loadSession(activeSession.id);
+    loadSessions();
+  };
+
+  return (
+    <div className="flex h-full">
+      {/* Sidebar — session list */}
+      <div className="border-border w-56 shrink-0 border-r">
+        <div className="p-3">
+          <button
+            onClick={createSession}
+            className="border-accent text-accent hover:bg-accent/10 w-full rounded border px-3 py-1.5 text-xs font-medium transition-colors"
+          >
+            + new story
+          </button>
+        </div>
+        <div className="space-y-0.5 px-2">
+          {sessions.map((s) => (
+            <button
+              key={s.id}
+              onClick={() => loadSession(s.id)}
+              className={`w-full rounded px-2 py-1.5 text-left text-xs truncate transition-colors ${
+                activeSession?.id === s.id ? "bg-surface text-accent" : "text-muted hover:text-foreground"
+              }`}
+            >
+              {s.title}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* Main chat area */}
+      <div className="flex flex-1 flex-col">
+        {!activeSession ? (
+          <div className="flex flex-1 items-center justify-center">
+            <div className="text-center">
+              <p className="text-muted text-sm">select or create a story session</p>
+            </div>
+          </div>
+        ) : (
+          <>
+            {/* Chat header */}
+            <div className="border-border flex items-center justify-between border-b px-4 py-2">
+              <div>
+                <h3 className="text-foreground text-sm font-medium">{activeSession.title}</h3>
+                <span className="text-muted text-[10px]">{activeSession.genre || "no genre"} · {activeSession.status}</span>
+              </div>
+              {activeSession.status === "active" && activeSession.messages.length > 0 && (
+                <button
+                  onClick={handleFinalize}
+                  className="border-accent text-accent hover:bg-accent/10 rounded border px-3 py-1 text-[10px] font-medium transition-colors"
+                >
+                  finalize draft
+                </button>
+              )}
+              {activeSession.drafts?.length > 0 && (
+                <span className="rounded border border-green-700/30 px-2 py-0.5 text-[10px] text-accent">
+                  draft ready
+                </span>
+              )}
+            </div>
+
+            {/* Messages */}
+            <div className="flex-1 overflow-y-auto p-4 space-y-4">
+              {activeSession.messages.map((msg) => (
+                <div key={msg.id} className={`flex ${msg.role === "user" ? "justify-end" : "justify-start"}`}>
+                  <div className={`max-w-[80%] rounded px-3 py-2 text-sm ${
+                    msg.role === "user"
+                      ? "bg-accent/10 text-foreground"
+                      : "bg-surface text-foreground border border-border"
+                  }`}>
+                    <div className="prose prose-xs max-w-none text-xs leading-relaxed"><Markdown>{msg.content}</Markdown></div>
+                  </div>
+                </div>
+              ))}
+
+              {/* Streaming response */}
+              {streaming && streamContent && (
+                <div className="flex justify-start">
+                  <div className="bg-surface border-border max-w-[80%] rounded border px-3 py-2">
+                    <div className="prose prose-xs max-w-none text-xs leading-relaxed"><Markdown>{streamContent}</Markdown></div>
+                    <span className="text-accent animate-pulse">▌</span>
+                  </div>
+                </div>
+              )}
+
+              {streaming && !streamContent && (
+                <div className="flex justify-start">
+                  <div className="text-muted text-xs">thinking...</div>
+                </div>
+              )}
+
+              <div ref={messagesEndRef} />
+            </div>
+
+            {/* Input */}
+            <div className="border-border border-t p-3">
+              <div className="flex gap-2">
+                <input
+                  type="text"
+                  value={input}
+                  onChange={(e) => setInput(e.target.value)}
+                  onKeyDown={(e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendMessage(); } }}
+                  placeholder="describe your story idea..."
+                  disabled={streaming || activeSession.status !== "active"}
+                  className="bg-surface border-border text-foreground placeholder:text-muted/50 flex-1 rounded border px-3 py-2 text-sm outline-none focus:border-accent disabled:opacity-40"
+                />
+                <button
+                  onClick={sendMessage}
+                  disabled={streaming || !input.trim() || activeSession.status !== "active"}
+                  className="border-accent text-accent hover:bg-accent/10 disabled:opacity-40 rounded border px-4 py-2 text-sm font-medium transition-colors"
+                >
+                  send
+                </button>
+              </div>
+            </div>
+          </>
+        )}
+      </div>
+
+      {/* Draft preview panel */}
+      {activeSession?.drafts && activeSession.drafts.length > 0 && (
+        <div className="border-border w-80 shrink-0 overflow-y-auto border-l p-4">
+          <h3 className="text-accent mb-3 text-xs font-bold uppercase tracking-wider">Draft Preview</h3>
+          {activeSession.drafts.map((draft) => (
+            <div key={draft.id} className="border-border space-y-2 rounded border p-3">
+              <div className="flex items-center justify-between">
+                <h4 className="text-foreground text-sm font-medium">{draft.title}</h4>
+                <span className="rounded border border-green-700/30 px-1.5 py-0.5 text-[9px] text-accent">{draft.status}</span>
+              </div>
+              {draft.genre && <span className="text-accent text-[10px]">{draft.genre}</span>}
+              <div className="bg-surface max-h-[60vh] overflow-y-auto rounded p-3">
+                <div className="prose prose-xs max-w-none text-xs leading-relaxed">
+                  <Markdown>{draft.content}</Markdown>
+                </div>
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}