plotlink-ows 0.1.15 → 1.0.0

package/app/routes/chat.ts

@@ -1,135 +0,0 @@
-import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
-import { db } from "../db";
-import { streamChat, type ChatMessage } from "../lib/llm-client";
-import { WRITER_SYSTEM_PROMPT } from "../lib/writer-prompt";
-
-const chat = new Hono();
-
-/** POST /api/chat/sessions — create a new story session */
-chat.post("/sessions", async (c) => {
-  const body = await c.req.json<{ title?: string; genre?: string }>();
-  const session = await db.storySession.create({
-    data: { title: body.title || "Untitled Story", genre: body.genre || null },
-  });
-  return c.json(session);
-});
-
-/** GET /api/chat/sessions — list all sessions */
-chat.get("/sessions", async (c) => {
-  const sessions = await db.storySession.findMany({
-    orderBy: { updatedAt: "desc" },
-    include: { _count: { select: { messages: true, drafts: true } } },
-  });
-  return c.json(sessions);
-});
-
-/** GET /api/chat/sessions/:id — get session with messages */
-chat.get("/sessions/:id", async (c) => {
-  const id = c.req.param("id");
-  const session = await db.storySession.findUnique({
-    where: { id },
-    include: { messages: { orderBy: { createdAt: "asc" } }, drafts: { orderBy: { createdAt: "desc" } } },
-  });
-  if (!session) return c.json({ error: "Session not found" }, 404);
-  return c.json(session);
-});
-
-/** DELETE /api/chat/sessions/:id — delete a session */
-chat.delete("/sessions/:id", async (c) => {
-  const id = c.req.param("id");
-  await db.storySession.delete({ where: { id } });
-  return c.json({ success: true });
-});
-
-/** POST /api/chat/sessions/:id/send — send a message and stream AI response */
-chat.post("/sessions/:id/send", async (c) => {
-  const id = c.req.param("id");
-  const body = await c.req.json<{ content: string }>();
-
-  if (!body.content?.trim()) {
-    return c.json({ error: "Message content required" }, 400);
-  }
-
-  // Save user message
-  await db.message.create({
-    data: { sessionId: id, role: "user", content: body.content },
-  });
-
-  // Build context from conversation history
-  const messages = await db.message.findMany({
-    where: { sessionId: id },
-    orderBy: { createdAt: "asc" },
-  });
-
-  const chatMessages: ChatMessage[] = [
-    { role: "system", content: WRITER_SYSTEM_PROMPT },
-    ...messages.map((m) => ({ role: m.role as ChatMessage["role"], content: m.content })),
-  ];
-
-  // Stream response via SSE
-  return streamSSE(c, async (stream) => {
-    let fullResponse = "";
-
-    try {
-      for await (const chunk of streamChat(chatMessages)) {
-        fullResponse += chunk;
-        await stream.writeSSE({ data: JSON.stringify({ type: "chunk", content: chunk }) });
-      }
-
-      // Save assistant message
-      await db.message.create({
-        data: { sessionId: id, role: "assistant", content: fullResponse },
-      });
-
-      // Update session title from first exchange if still "Untitled Story"
-      const session = await db.storySession.findUnique({ where: { id } });
-      if (session?.title === "Untitled Story" && messages.length <= 2) {
-        const title = body.content.slice(0, 60) + (body.content.length > 60 ? "..." : "");
-        await db.storySession.update({ where: { id }, data: { title } });
-      }
-
-      await stream.writeSSE({ data: JSON.stringify({ type: "done", messageId: fullResponse.slice(0, 20) }) });
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : "Stream error";
-      await stream.writeSSE({ data: JSON.stringify({ type: "error", message }) });
-    }
-  });
-});
-
-/** POST /api/chat/sessions/:id/finalize — create a draft from conversation */
-chat.post("/sessions/:id/finalize", async (c) => {
-  const id = c.req.param("id");
-  const body = await c.req.json<{ title: string; content: string; genre?: string }>();
-
-  if (!body.title || !body.content) {
-    return c.json({ error: "Title and content required" }, 400);
-  }
-
-  const draft = await db.draft.create({
-    data: {
-      sessionId: id,
-      title: body.title,
-      content: body.content,
-      genre: body.genre || null,
-      status: "ready",
-    },
-  });
-
-  await db.storySession.update({
-    where: { id },
-    data: { status: "finalized" },
-  });
-
-  return c.json(draft);
-});
-
-/** GET /api/chat/drafts — list all drafts */
-chat.get("/drafts", async (c) => {
-  const drafts = await db.draft.findMany({
-    orderBy: { createdAt: "desc" },
-  });
-  return c.json(drafts);
-});
-
-export { chat as chatRoutes };

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 };