proto-plugin 0.1.0

package/src/server/gallery/gallery-route.ts

@@ -0,0 +1,150 @@
+import { del, put } from "@vercel/blob";
+import { kv } from "@vercel/kv";
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "node:crypto";
+
+import { getGalleryStorageStatus } from "./gallery-env";
+import type { GalleryItem } from "./gallery-types";
+
+export const maxDuration = 60;
+
+const GALLERY_KEY = "gallery:items";
+
+export async function GET() {
+  const status = getGalleryStorageStatus();
+  if (!status.ok) {
+    return NextResponse.json(
+      {
+        error: "Gallery storage is not configured.",
+        missing: status.missing,
+      },
+      { status: 503 },
+    );
+  }
+
+  try {
+    const items = (await kv.get<GalleryItem[]>(GALLERY_KEY)) ?? [];
+    return NextResponse.json(items);
+  } catch (error) {
+    console.error("Gallery GET error:", error);
+    return NextResponse.json({ error: "Failed to fetch gallery" }, { status: 500 });
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const status = getGalleryStorageStatus();
+  if (!status.ok) {
+    return NextResponse.json(
+      {
+        error: "Gallery storage is not configured.",
+        missing: status.missing,
+      },
+      { status: 503 },
+    );
+  }
+
+  try {
+    const formData = await request.formData();
+    const file = formData.get("file") as File | null;
+    const originalFile = formData.get("originalFile") as File | null;
+    const title = (formData.get("title") as string) || "Untitled";
+    const tagsRaw = formData.get("tags") as string | null;
+    const width = parseInt(formData.get("width") as string, 10) || 0;
+    const height = parseInt(formData.get("height") as string, 10) || 0;
+    const sourceFrameId = (formData.get("sourceFrameId") as string) || undefined;
+
+    if (!file || !(file instanceof Blob)) {
+      return NextResponse.json({ error: "No image file provided" }, { status: 400 });
+    }
+
+    const tags: string[] = tagsRaw
+      ? (JSON.parse(tagsRaw) as string[]).filter(
+          (t) => typeof t === "string" && t.trim().length > 0,
+        )
+      : [];
+
+    const id = randomUUID();
+
+    const contentType = file.type === "image/jpeg" ? "image/jpeg" : "image/png";
+    const ext = contentType === "image/jpeg" ? "jpg" : "png";
+    const fileBuffer = Buffer.from(await file.arrayBuffer());
+    const resultBlob = await put(`gallery/${id}.${ext}`, fileBuffer, {
+      access: "public",
+      contentType,
+    });
+
+    const blobUrl = typeof resultBlob?.url === "string" ? resultBlob.url : "";
+    if (!blobUrl) {
+      console.error("Gallery POST: put() did not return a url", resultBlob);
+      return NextResponse.json(
+        { error: "Failed to get image URL from storage" },
+        { status: 500 },
+      );
+    }
+
+    let originalBlobUrl: string | undefined;
+    if (originalFile && originalFile instanceof Blob) {
+      const origBuffer = Buffer.from(await originalFile.arrayBuffer());
+      const origBlob = await put(`gallery/${id}-original.png`, origBuffer, {
+        access: "public",
+        contentType: "image/png",
+      });
+      if (typeof origBlob?.url === "string") originalBlobUrl = origBlob.url;
+    }
+
+    const item: GalleryItem = {
+      id,
+      blobUrl,
+      originalBlobUrl,
+      title,
+      tags,
+      width,
+      height,
+      sourceFrameId,
+      uploadedBy: "anonymous",
+      createdAt: new Date().toISOString(),
+    };
+
+    const items = (await kv.get<GalleryItem[]>(GALLERY_KEY)) ?? [];
+    items.push(item);
+    await kv.set(GALLERY_KEY, items);
+
+    return NextResponse.json(item);
+  } catch (error) {
+    console.error("Gallery POST error:", error);
+    const message = error instanceof Error ? error.message : "Failed to upload image";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+/** DELETE: clear all gallery items (KV + Blob). No auth. */
+export async function DELETE() {
+  const status = getGalleryStorageStatus();
+  if (!status.ok) {
+    return NextResponse.json(
+      {
+        error: "Gallery storage is not configured.",
+        missing: status.missing,
+      },
+      { status: 503 },
+    );
+  }
+
+  try {
+    const items = (await kv.get<GalleryItem[]>(GALLERY_KEY)) ?? [];
+    const urlsToDelete: string[] = [];
+    for (const item of items) {
+      if (item.blobUrl) urlsToDelete.push(item.blobUrl);
+      if (item.originalBlobUrl) urlsToDelete.push(item.originalBlobUrl);
+    }
+    if (urlsToDelete.length > 0) {
+      await del(urlsToDelete);
+    }
+    await kv.set(GALLERY_KEY, []);
+    return NextResponse.json({ ok: true, deleted: items.length });
+  } catch (error) {
+    console.error("Gallery DELETE error:", error);
+    const message = error instanceof Error ? error.message : "Failed to clear gallery";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/src/server/gallery/gallery-types.ts

@@ -0,0 +1,15 @@
+/** Marker type — gallery routes enabled when config is present (not `false`). */
+export type GalleryConfig = Record<string, never>;
+
+export interface GalleryItem {
+  id: string;
+  blobUrl: string;
+  originalBlobUrl?: string;
+  title: string;
+  tags: string[];
+  width: number;
+  height: number;
+  sourceFrameId?: string;
+  uploadedBy: string;
+  createdAt: string;
+}

package/src/server/gallery/image-route.ts

@@ -0,0 +1,59 @@
+import { kv } from "@vercel/kv";
+import { NextRequest, NextResponse } from "next/server";
+
+import { getGalleryKvStatus } from "./gallery-env";
+
+const GALLERY_KEY = "gallery:items";
+
+interface GalleryItemStored {
+  id?: string;
+  blobUrl?: string;
+  blob_url?: string;
+  originalBlobUrl?: string;
+  original_blob_url?: string;
+}
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const status = getGalleryKvStatus();
+  if (!status.ok) {
+    return NextResponse.json({ error: "Gallery not configured" }, { status: 503 });
+  }
+
+  const { id } = await params;
+  if (!id) return NextResponse.json({ error: "Missing id" }, { status: 400 });
+
+  try {
+    const items = (await kv.get<GalleryItemStored[]>(GALLERY_KEY)) ?? [];
+    const item = items.find((i) => String(i?.id) === id);
+    const blobUrl = item?.blobUrl ?? item?.blob_url;
+    if (!blobUrl) {
+      return NextResponse.json({ error: "Not found" }, { status: 404 });
+    }
+    const imageUrl = blobUrl;
+    const headers: Record<string, string> = { "User-Agent": "PrototypeGallery/1.0" };
+    const blobToken = process.env.BLOB_READ_WRITE_TOKEN;
+    if (blobToken && imageUrl.includes("blob.vercel-storage.com")) {
+      headers["Authorization"] = `Bearer ${blobToken}`;
+    }
+    const res = await fetch(imageUrl, { cache: "no-store", headers });
+    if (!res.ok) {
+      console.error("Gallery image proxy: fetch failed", res.status, imageUrl.slice(0, 80));
+      return NextResponse.json({ error: "Failed to fetch image" }, { status: 502 });
+    }
+    const blob = await res.arrayBuffer();
+    const contentType = res.headers.get("content-type") || "image/png";
+    return new NextResponse(blob, {
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "public, max-age=300",
+        Vary: "Accept",
+      },
+    });
+  } catch (error) {
+    console.error("Gallery image proxy error:", error);
+    return NextResponse.json({ error: "Failed to load image" }, { status: 500 });
+  }
+}

package/src/server/gallery/item-route.ts

@@ -0,0 +1,92 @@
+import { del } from "@vercel/blob";
+import { kv } from "@vercel/kv";
+import { NextRequest, NextResponse } from "next/server";
+
+import { getGalleryKvStatus, getGalleryStorageStatus } from "./gallery-env";
+
+const GALLERY_KEY = "gallery:items";
+
+interface GalleryItemStored {
+  id?: string;
+  blobUrl?: string;
+  originalBlobUrl?: string;
+  tags?: string[];
+  [key: string]: unknown;
+}
+
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const status = getGalleryKvStatus();
+  if (!status.ok) {
+    return NextResponse.json({ error: "Gallery not configured" }, { status: 503 });
+  }
+
+  const { id } = await params;
+  if (!id) return NextResponse.json({ error: "Missing id" }, { status: 400 });
+
+  try {
+    const body = await request.json();
+    const newTags: string[] | undefined = body.tags;
+    if (!newTags || !Array.isArray(newTags)) {
+      return NextResponse.json({ error: "tags array required" }, { status: 400 });
+    }
+    const validTags = newTags.filter((t) => typeof t === "string" && t.trim().length > 0);
+    if (validTags.length === 0) {
+      return NextResponse.json({ error: "At least one tag required" }, { status: 400 });
+    }
+
+    const items = (await kv.get<GalleryItemStored[]>(GALLERY_KEY)) ?? [];
+    const idx = items.findIndex((i) => String(i?.id) === id);
+    if (idx === -1) {
+      return NextResponse.json({ error: "Not found" }, { status: 404 });
+    }
+
+    items[idx] = { ...items[idx], tags: validTags };
+    await kv.set(GALLERY_KEY, items);
+
+    return NextResponse.json({ ok: true, id, tags: validTags });
+  } catch (error) {
+    console.error("Gallery item PATCH error:", error);
+    const message = error instanceof Error ? error.message : "Failed to update item";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const status = getGalleryStorageStatus();
+  if (!status.ok) {
+    return NextResponse.json({ error: "Gallery not configured" }, { status: 503 });
+  }
+
+  const { id } = await params;
+  if (!id) return NextResponse.json({ error: "Missing id" }, { status: 400 });
+
+  try {
+    const items = (await kv.get<GalleryItemStored[]>(GALLERY_KEY)) ?? [];
+    const item = items.find((i) => String(i?.id) === id);
+    if (!item) {
+      return NextResponse.json({ error: "Not found" }, { status: 404 });
+    }
+
+    const urlsToDelete: string[] = [];
+    if (item.blobUrl) urlsToDelete.push(item.blobUrl);
+    if (item.originalBlobUrl) urlsToDelete.push(item.originalBlobUrl);
+    if (urlsToDelete.length > 0) {
+      await del(urlsToDelete);
+    }
+
+    const remaining = items.filter((i) => String(i?.id) !== id);
+    await kv.set(GALLERY_KEY, remaining);
+
+    return NextResponse.json({ ok: true, id });
+  } catch (error) {
+    console.error("Gallery item DELETE error:", error);
+    const message = error instanceof Error ? error.message : "Failed to delete item";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/src/server/pr-vercel-preview-route.ts

@@ -0,0 +1,162 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { NextRequest, NextResponse } from "next/server";
+
+import {
+  parseGithubPrUrl,
+  parseVercelGithubCommentBody,
+  type VercelPreviewFromPr,
+} from "../lib/vercel-preview/parse-vercel-github-comment";
+
+type GithubIssueComment = {
+  user?: { login?: string };
+  body?: string;
+};
+
+const execFileAsync = promisify(execFile);
+
+async function fetchGithubIssueComments(
+  owner: string,
+  repo: string,
+  number: number,
+  token: string,
+): Promise<GithubIssueComment[]> {
+  const response = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/issues/${number}/comments`,
+    {
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+      next: { revalidate: 300 },
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error(`GitHub API error (${response.status})`);
+  }
+
+  return (await response.json()) as GithubIssueComment[];
+}
+
+async function fetchGithubIssueCommentsViaGhCli(
+  owner: string,
+  repo: string,
+  number: number,
+): Promise<GithubIssueComment[]> {
+  const { stdout } = await execFileAsync(
+    "gh",
+    ["api", `repos/${owner}/${repo}/issues/${number}/comments`],
+    { timeout: 20_000 },
+  );
+  return JSON.parse(stdout) as GithubIssueComment[];
+}
+
+function extractVercelPreviewFromComments(
+  comments: GithubIssueComment[],
+): VercelPreviewFromPr | null {
+  for (const comment of comments) {
+    const login = comment.user?.login?.toLowerCase() ?? "";
+    if (!login.includes("vercel")) continue;
+    const preview = parseVercelGithubCommentBody(comment.body ?? "");
+    if (preview) return preview;
+  }
+  return null;
+}
+
+async function fetchVercelPreviewForPr(
+  prUrl: string,
+  token?: string,
+): Promise<VercelPreviewFromPr | null> {
+  const parsed = parseGithubPrUrl(prUrl);
+  if (!parsed) return null;
+
+  let comments: GithubIssueComment[] | null = null;
+
+  if (token) {
+    try {
+      comments = await fetchGithubIssueComments(
+        parsed.owner,
+        parsed.repo,
+        parsed.number,
+        token,
+      );
+    } catch (error) {
+      console.warn("GitHub token fetch failed, trying gh CLI:", error);
+    }
+  }
+
+  if (!comments) {
+    try {
+      comments = await fetchGithubIssueCommentsViaGhCli(
+        parsed.owner,
+        parsed.repo,
+        parsed.number,
+      );
+    } catch (error) {
+      console.error("gh CLI fetch failed:", error);
+      return null;
+    }
+  }
+
+  return extractVercelPreviewFromComments(comments);
+}
+
+export async function GET(request: NextRequest) {
+  const token = process.env.GITHUB_TOKEN;
+
+  const prUrl = request.nextUrl.searchParams.get("prUrl");
+  const prUrlsParam = request.nextUrl.searchParams.get("prUrls");
+
+  const prUrls = [
+    ...(prUrl ? [prUrl] : []),
+    ...(prUrlsParam
+      ? prUrlsParam.split(",").map((value) => value.trim()).filter(Boolean)
+      : []),
+  ];
+
+  if (prUrls.length === 0) {
+    return NextResponse.json(
+      { error: "Provide prUrl or prUrls query parameter." },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const previews = await Promise.all(
+      prUrls.map(async (url) => {
+        try {
+          const preview = await fetchVercelPreviewForPr(url, token);
+          return { prUrl: url, preview };
+        } catch (error) {
+          console.error("PR Vercel preview fetch error:", url, error);
+          return {
+            prUrl: url,
+            preview: null,
+            error: "Failed to fetch preview.",
+          };
+        }
+      }),
+    );
+
+    if (prUrls.length === 1) {
+      const [entry] = previews;
+      if (!entry.preview) {
+        return NextResponse.json(
+          { error: entry.error ?? "No Vercel preview found for this PR." },
+          { status: 404 },
+        );
+      }
+      return NextResponse.json(entry.preview);
+    }
+
+    return NextResponse.json({ previews });
+  } catch (error) {
+    console.error("PR Vercel preview route error:", error);
+    return NextResponse.json(
+      { error: "Failed to load Vercel previews." },
+      { status: 500 },
+    );
+  }
+}

package/src/server/redis/client.ts

@@ -0,0 +1,55 @@
+import { Redis } from "@upstash/redis";
+
+/** Copy legacy KV_* env names so Redis.fromEnv() can connect. */
+export function normalizeRedisEnv(): void {
+  if (!process.env.UPSTASH_REDIS_REST_URL && process.env.KV_REST_API_URL) {
+    process.env.UPSTASH_REDIS_REST_URL = process.env.KV_REST_API_URL;
+  }
+  if (!process.env.UPSTASH_REDIS_REST_TOKEN && process.env.KV_REST_API_TOKEN) {
+    process.env.UPSTASH_REDIS_REST_TOKEN = process.env.KV_REST_API_TOKEN;
+  }
+
+  if (!process.env.KV_REST_API_URL) {
+    const urlKey = Object.keys(process.env).find((k) => k.endsWith("_KV_REST_API_URL"));
+    if (urlKey) process.env.KV_REST_API_URL = process.env[urlKey];
+  }
+  if (!process.env.KV_REST_API_TOKEN) {
+    const tokenKey = Object.keys(process.env).find((k) =>
+      k.endsWith("_KV_REST_API_TOKEN"),
+    );
+    if (tokenKey) process.env.KV_REST_API_TOKEN = process.env[tokenKey];
+  }
+
+  if (!process.env.UPSTASH_REDIS_REST_URL && process.env.KV_REST_API_URL) {
+    process.env.UPSTASH_REDIS_REST_URL = process.env.KV_REST_API_URL;
+  }
+  if (!process.env.UPSTASH_REDIS_REST_TOKEN && process.env.KV_REST_API_TOKEN) {
+    process.env.UPSTASH_REDIS_REST_TOKEN = process.env.KV_REST_API_TOKEN;
+  }
+}
+
+export function getRedisStatus(): { ok: boolean; missing: string[] } {
+  normalizeRedisEnv();
+  const missing: string[] = [];
+  const hasUpstash =
+    process.env.UPSTASH_REDIS_REST_URL && process.env.UPSTASH_REDIS_REST_TOKEN;
+  const hasLegacy = process.env.KV_REST_API_URL && process.env.KV_REST_API_TOKEN;
+  if (!hasUpstash && !hasLegacy) {
+    if (!process.env.UPSTASH_REDIS_REST_URL && !process.env.KV_REST_API_URL) {
+      missing.push("UPSTASH_REDIS_REST_URL or KV_REST_API_URL");
+    }
+    if (!process.env.UPSTASH_REDIS_REST_TOKEN && !process.env.KV_REST_API_TOKEN) {
+      missing.push("UPSTASH_REDIS_REST_TOKEN or KV_REST_API_TOKEN");
+    }
+  }
+  return { ok: missing.length === 0, missing };
+}
+
+export function getRedis(): Redis {
+  normalizeRedisEnv();
+  return Redis.fromEnv();
+}
+
+export function prototypeCommentsRedisKey(slug: string): string {
+  return `prototype-comments:${slug}`;
+}

package/src/server/redis/prototype-changelog-meta.ts

@@ -0,0 +1,31 @@
+import {
+  normalizeChangelogMetaPayload,
+  parseChangelogMeta,
+  prototypeChangelogMetaRedisKey,
+  type PrototypeChangelogMeta,
+} from "@prototype/lib/prototypes/changelog-meta";
+
+import { getRedis } from "./client";
+
+export async function getPrototypeChangelogMeta(
+  slug: string,
+): Promise<PrototypeChangelogMeta> {
+  const redis = getRedis();
+  const key = prototypeChangelogMetaRedisKey(slug);
+  const stored = await redis.get<unknown>(key);
+  return parseChangelogMeta(stored);
+}
+
+export async function setPrototypeChangelogMeta(
+  slug: string,
+  meta: unknown,
+): Promise<void> {
+  const normalized = normalizeChangelogMetaPayload(meta);
+  if (!normalized) {
+    throw new Error("Invalid change log meta.");
+  }
+
+  const redis = getRedis();
+  const key = prototypeChangelogMetaRedisKey(slug);
+  await redis.set(key, normalized);
+}

package/src/server/redis/prototype-comments.ts

@@ -0,0 +1,92 @@
+import { isAnnotationDeleted } from "@prototype/lib/prototype-comments/core/annotation-status";
+import type { CommentAnnotationFields } from "@prototype/lib/prototype-comments/core/types";
+import { isValidAnnotation } from "@prototype/lib/prototype-comments/core/validation";
+
+import { getRedis, prototypeCommentsRedisKey } from "./client";
+
+function asStoredComment(value: unknown): CommentAnnotationFields | null {
+  if (!isValidAnnotation(value)) return null;
+  return value as CommentAnnotationFields;
+}
+
+export function filterStoredAnnotations(
+  annotations: unknown[],
+): CommentAnnotationFields[] {
+  return annotations.flatMap((value) => {
+    const comment = asStoredComment(value);
+    if (!comment || isAnnotationDeleted(comment)) return [];
+    return [comment];
+  });
+}
+
+export async function listPrototypeComments(
+  slug: string,
+): Promise<CommentAnnotationFields[]> {
+  const redis = getRedis();
+  const stored = (await redis.get<unknown[]>(prototypeCommentsRedisKey(slug))) ?? [];
+  if (!Array.isArray(stored)) return [];
+  return filterStoredAnnotations(stored);
+}
+
+export async function upsertPrototypeComment(
+  slug: string,
+  comment: unknown,
+): Promise<void> {
+  if (!isValidAnnotation(comment)) {
+    throw new Error("Invalid comment annotation.");
+  }
+
+  const incoming = comment as CommentAnnotationFields;
+  const redis = getRedis();
+  const key = prototypeCommentsRedisKey(slug);
+  const stored = (await redis.get<unknown[]>(key)) ?? [];
+  const annotations = Array.isArray(stored)
+    ? stored.flatMap((value) => {
+        const item = asStoredComment(value);
+        return item ? [item] : [];
+      })
+    : [];
+
+  const index = annotations.findIndex((item) => item.id === incoming.id);
+
+  if (index >= 0) {
+    annotations[index] = { ...annotations[index], ...incoming };
+  } else {
+    annotations.push(incoming);
+  }
+
+  await redis.set(key, annotations);
+}
+
+/** Merge incoming comments by id without removing stored comments missing from the payload. */
+export async function mergePrototypeComments(
+  slug: string,
+  incoming: unknown[],
+): Promise<number> {
+  if (!Array.isArray(incoming)) {
+    throw new Error("Body must be an array.");
+  }
+
+  const redis = getRedis();
+  const key = prototypeCommentsRedisKey(slug);
+  const stored = (await redis.get<unknown[]>(key)) ?? [];
+  const annotations = Array.isArray(stored)
+    ? stored.flatMap((value) => {
+        const item = asStoredComment(value);
+        return item ? [item] : [];
+      })
+    : [];
+
+  const byId = new Map(annotations.map((item) => [item.id, item]));
+
+  for (const value of incoming) {
+    if (!isValidAnnotation(value)) continue;
+    const comment = value as CommentAnnotationFields;
+    const existing = byId.get(comment.id);
+    byId.set(comment.id, existing ? { ...existing, ...comment } : comment);
+  }
+
+  const merged = [...byId.values()];
+  await redis.set(key, merged);
+  return merged.filter((item) => !isAnnotationDeleted(item)).length;
+}

package/src/server/redis/prototype-design-exploration-default.ts

@@ -0,0 +1,32 @@
+import {
+  normalizeDesignExplorationDefaultPayload,
+  parseDesignExplorationDefault,
+  prototypeDesignExplorationDefaultRedisKey,
+  type DesignExplorationDefaultRecord,
+} from "@prototype/lib/prototypes/design-exploration-default";
+
+import { getRedis } from "./client";
+
+export async function getPrototypeDesignExplorationDefault(
+  storageKeyPrefix: string,
+): Promise<DesignExplorationDefaultRecord | null> {
+  const redis = getRedis();
+  const key = prototypeDesignExplorationDefaultRedisKey(storageKeyPrefix);
+  const stored = await redis.get<unknown>(key);
+  return parseDesignExplorationDefault(stored);
+}
+
+export async function setPrototypeDesignExplorationDefault(
+  storageKeyPrefix: string,
+  record: unknown,
+  validValues?: readonly string[],
+): Promise<void> {
+  const normalized = normalizeDesignExplorationDefaultPayload(record, validValues);
+  if (!normalized) {
+    throw new Error("Invalid design exploration default record.");
+  }
+
+  const redis = getRedis();
+  const key = prototypeDesignExplorationDefaultRedisKey(storageKeyPrefix);
+  await redis.set(key, normalized);
+}