plotlink-ows 0.1.15 → 0.1.18

package/app/routes/config.ts

@@ -1,210 +0,0 @@
-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/oauth.ts

@@ -1,150 +0,0 @@
-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/web/components/Chat.tsx

@@ -1,272 +0,0 @@
-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>
-  );
-}