claude-code

web/app/api/chat/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const apiUrl = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3001";
+
+    const response = await fetch(`${apiUrl}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(process.env.ANTHROPIC_API_KEY
+          ? { Authorization: `Bearer ${process.env.ANTHROPIC_API_KEY}` }
+          : {}),
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: "Backend request failed" },
+        { status: response.status }
+      );
+    }
+
+    // Stream the response through
+    return new NextResponse(response.body, {
+      headers: {
+        "Content-Type": response.headers.get("Content-Type") ?? "application/json",
+      },
+    });
+  } catch (error) {
+    console.error("Chat API error:", error);
+    return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+  }
+}

web/app/api/export/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from "next/server";
+import type { Conversation, ExportOptions } from "@/lib/types";
+import { toMarkdown } from "@/lib/export/markdown";
+import { toJSON } from "@/lib/export/json";
+import { toHTML } from "@/lib/export/html";
+import { toPlainText } from "@/lib/export/plaintext";
+
+interface ExportRequest {
+  conversation: Conversation;
+  options: ExportOptions;
+}
+
+const MIME: Record<string, string> = {
+  markdown: "text/markdown; charset=utf-8",
+  json: "application/json",
+  html: "text/html; charset=utf-8",
+  plaintext: "text/plain; charset=utf-8",
+};
+
+const EXT: Record<string, string> = {
+  markdown: "md",
+  json: "json",
+  html: "html",
+  plaintext: "txt",
+};
+
+export async function POST(req: NextRequest) {
+  let body: ExportRequest;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const { conversation, options } = body;
+  if (!conversation || !options) {
+    return NextResponse.json(
+      { error: "Missing conversation or options" },
+      { status: 400 }
+    );
+  }
+
+  const { format } = options;
+
+  if (format === "pdf") {
+    // PDF is handled client-side via window.print()
+    return NextResponse.json(
+      { error: "PDF export is handled client-side" },
+      { status: 400 }
+    );
+  }
+
+  let content: string;
+  switch (format) {
+    case "markdown":
+      content = toMarkdown(conversation, options);
+      break;
+    case "json":
+      content = toJSON(conversation, options);
+      break;
+    case "html":
+      content = toHTML(conversation, options);
+      break;
+    case "plaintext":
+      content = toPlainText(conversation, options);
+      break;
+    default:
+      return NextResponse.json({ error: `Unknown format: ${format}` }, { status: 400 });
+  }
+
+  const slug = conversation.title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 50);
+  const filename = `${slug || "conversation"}.${EXT[format]}`;
+
+  return new NextResponse(content, {
+    status: 200,
+    headers: {
+      "Content-Type": MIME[format],
+      "Content-Disposition": `attachment; filename="${filename}"`,
+    },
+  });
+}

web/app/api/files/read/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs/promises";
+import path from "path";
+
+const IMAGE_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+};
+
+export async function GET(request: NextRequest) {
+  const filePath = request.nextUrl.searchParams.get("path");
+  if (!filePath) {
+    return NextResponse.json({ error: "path parameter required" }, { status: 400 });
+  }
+
+  const resolvedPath = path.resolve(filePath);
+
+  try {
+    const stats = await fs.stat(resolvedPath);
+    if (stats.isDirectory()) {
+      return NextResponse.json({ error: "path is a directory" }, { status: 400 });
+    }
+
+    const ext = resolvedPath.split(".").pop()?.toLowerCase() ?? "";
+
+    // Binary images: return base64 data URL
+    if (ext in IMAGE_MIME) {
+      const buffer = await fs.readFile(resolvedPath);
+      const base64 = buffer.toString("base64");
+      return NextResponse.json({
+        content: `data:${IMAGE_MIME[ext]};base64,${base64}`,
+        isImage: true,
+        size: stats.size,
+        modified: stats.mtime.toISOString(),
+      });
+    }
+
+    // Text (including SVG)
+    const content = await fs.readFile(resolvedPath, "utf-8");
+    return NextResponse.json({
+      content,
+      isImage: ext === "svg",
+      size: stats.size,
+      modified: stats.mtime.toISOString(),
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return NextResponse.json({ error: message }, { status: 404 });
+  }
+}

web/app/api/files/write/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs/promises";
+import path from "path";
+
+export async function POST(request: NextRequest) {
+  let body: { path?: string; content?: string };
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ error: "invalid JSON body" }, { status: 400 });
+  }
+
+  const { path: filePath, content } = body;
+  if (!filePath || content === undefined) {
+    return NextResponse.json(
+      { error: "path and content are required" },
+      { status: 400 }
+    );
+  }
+
+  const resolvedPath = path.resolve(filePath);
+
+  try {
+    await fs.writeFile(resolvedPath, content, "utf-8");
+    const stats = await fs.stat(resolvedPath);
+    return NextResponse.json({ success: true, size: stats.size });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

web/app/api/share/[shareId]/route.ts

@@ -0,0 +1,42 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getShare, revokeShare, verifySharePassword } from "@/lib/share-store";
+
+interface RouteContext {
+  params: { shareId: string };
+}
+
+export async function GET(req: NextRequest, { params }: RouteContext) {
+  const { shareId } = params;
+  const share = getShare(shareId);
+
+  if (!share) {
+    return NextResponse.json({ error: "Share not found or expired" }, { status: 404 });
+  }
+
+  if (share.visibility === "password") {
+    const pw = req.headers.get("x-share-password") ?? req.nextUrl.searchParams.get("password");
+    if (!pw || !verifySharePassword(shareId, pw)) {
+      return NextResponse.json({ error: "Password required", requiresPassword: true }, { status: 401 });
+    }
+  }
+
+  return NextResponse.json({
+    id: share.id,
+    title: share.conversation.title,
+    messages: share.conversation.messages,
+    model: share.conversation.model,
+    createdAt: share.conversation.createdAt,
+    shareCreatedAt: share.createdAt,
+  });
+}
+
+export async function DELETE(_req: NextRequest, { params }: RouteContext) {
+  const { shareId } = params;
+  const deleted = revokeShare(shareId);
+
+  if (!deleted) {
+    return NextResponse.json({ error: "Share not found" }, { status: 404 });
+  }
+
+  return NextResponse.json({ success: true });
+}

web/app/api/share/route.ts

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from "next/server";
+import { nanoid } from "nanoid";
+import type { Conversation } from "@/lib/types";
+import type { ShareVisibility, ShareExpiry } from "@/lib/share-store";
+import { createShare } from "@/lib/share-store";
+
+interface CreateShareRequest {
+  conversation: Conversation;
+  visibility: ShareVisibility;
+  password?: string;
+  expiry: ShareExpiry;
+}
+
+export async function POST(req: NextRequest) {
+  let body: CreateShareRequest;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const { conversation, visibility, password, expiry } = body;
+  if (!conversation || !visibility || !expiry) {
+    return NextResponse.json({ error: "Missing required fields" }, { status: 400 });
+  }
+
+  if (visibility === "password" && !password) {
+    return NextResponse.json(
+      { error: "Password required for password-protected shares" },
+      { status: 400 }
+    );
+  }
+
+  const shareId = nanoid(12);
+  const share = createShare(shareId, { conversation, visibility, password, expiry });
+
+  const origin = req.headers.get("origin") ?? "";
+  const url = `${origin}/share/${shareId}`;
+
+  return NextResponse.json({
+    id: share.id,
+    conversationId: share.conversationId,
+    visibility: share.visibility,
+    hasPassword: !!share.passwordHash,
+    expiry: share.expiry,
+    expiresAt: share.expiresAt,
+    createdAt: share.createdAt,
+    url,
+  });
+}