qarpeo 0.0.0-alpha.10

package/dist/runtime/server/routes/realtime/history.delete.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DELETE /api/realtime/history
+ *
+ * Clears the persistent message history replay buffer for a room from Durable Object storage.
+ * Query parameters:
+ * - room: Room ID (default: "general")
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    success: boolean;
+    room: string;
+    cleared: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/realtime/history.delete.mjs

@@ -0,0 +1,12 @@
+import { defineEventHandler, getQuery } from "nuxt/server";
+import { clearRoomHistory } from "../../utils/realtime.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const room = query.room || "general";
+  const ok = await clearRoomHistory(event, room);
+  return {
+    success: ok,
+    room,
+    cleared: true
+  };
+});

package/dist/runtime/server/routes/realtime/history.get.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/realtime/history
+ *
+ * Retrieves the recent message history buffer for a room from Durable Object storage.
+ * Query parameters:
+ * - room: Room ID (default: "general")
+ * - limit: Maximum messages to return (default: 50)
+ * - sinceSeq: Monotonic sequence offset for incremental history retrieval
+ * - since: Timestamp offset (ms)
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    room: string;
+    history: import("../../..").RealtimeMessage<unknown>[];
+    count: number;
+}>>;
+export default _default;

package/dist/runtime/server/routes/realtime/history.get.mjs

@@ -0,0 +1,15 @@
+import { defineEventHandler, getQuery } from "nuxt/server";
+import { getRoomHistory } from "../../utils/realtime.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const room = query.room || "general";
+  const limit = query.limit ? parseInt(query.limit, 10) : void 0;
+  const sinceSeq = query.sinceSeq ? parseInt(query.sinceSeq, 10) : void 0;
+  const since = query.since ? parseInt(query.since, 10) : void 0;
+  const history = await getRoomHistory(event, room, { limit, sinceSeq, since });
+  return {
+    room,
+    history,
+    count: history.length
+  };
+});

package/dist/runtime/server/routes/realtime/presence.get.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    room: string;
+    presence: import("../../..").RealtimeUser<Record<string, any>>[];
+    count: number;
+}>>;
+export default _default;

package/dist/runtime/server/routes/realtime/presence.get.mjs

@@ -0,0 +1,27 @@
+import { defineEventHandler, getQuery, createError } from "nuxt/server";
+import { getAuthContext } from "../../utils/context.mjs";
+import { getRoomPresence } from "../../utils/realtime.mjs";
+export default defineEventHandler(async (event) => {
+  const auth = await getAuthContext(event).catch(() => null);
+  if (!auth?.user?.id) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized",
+      message: "Authentication required to view room presence."
+    });
+  }
+  const query = getQuery(event);
+  const room = query.room;
+  if (!room) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Query parameter 'room' is required."
+    });
+  }
+  const presence = await getRoomPresence(event, room);
+  return {
+    room,
+    presence,
+    count: presence.length
+  };
+});

package/dist/runtime/server/routes/realtime/state.get.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    room: string;
+    state: Record<string, any>;
+}>>;
+export default _default;

package/dist/runtime/server/routes/realtime/state.get.mjs

@@ -0,0 +1,26 @@
+import { defineEventHandler, getQuery, createError } from "nuxt/server";
+import { getAuthContext } from "../../utils/context.mjs";
+import { getRoomState } from "../../utils/realtime.mjs";
+export default defineEventHandler(async (event) => {
+  const auth = await getAuthContext(event).catch(() => null);
+  if (!auth?.user?.id) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized",
+      message: "Authentication required to view room state."
+    });
+  }
+  const query = getQuery(event);
+  const room = query.room;
+  if (!room) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Query parameter 'room' is required."
+    });
+  }
+  const state = await getRoomState(event, room);
+  return {
+    room,
+    state
+  };
+});

package/dist/runtime/server/routes/realtime/state.post.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    ok: boolean;
+    room: string;
+    state: Record<string, any>;
+}>>;
+export default _default;

package/dist/runtime/server/routes/realtime/state.post.mjs

@@ -0,0 +1,37 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { getAuthContext } from "../../utils/context.mjs";
+import { patchRoomState, setRoomState } from "../../utils/realtime.mjs";
+export default defineEventHandler(async (event) => {
+  const auth = await getAuthContext(event).catch(() => null);
+  if (!auth?.user?.id) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized",
+      message: "Authentication required to update room state."
+    });
+  }
+  const body = await readBody(event) || {};
+  if (!body.room) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Field 'room' is required."
+    });
+  }
+  if (!body.state && !body.patch) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Either 'state' or 'patch' is required."
+    });
+  }
+  let state;
+  if (body.patch) {
+    state = await patchRoomState(event, body.room, body.patch);
+  } else {
+    state = await setRoomState(event, body.room, body.state);
+  }
+  return {
+    ok: true,
+    room: body.room,
+    state
+  };
+});

package/dist/runtime/server/routes/realtime/ws.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<Response>>;
+export default _default;

package/dist/runtime/server/routes/realtime/ws.get.mjs

@@ -0,0 +1,73 @@
+import { defineEventHandler, getQuery, createError, getRequestURL } from "nuxt/server";
+import { getQarpeoConfig } from "../../utils/config.mjs";
+import { getAuthContext } from "../../utils/context.mjs";
+import { getRoomDurableObject } from "../../utils/realtime.mjs";
+function resolveWebRequest(event) {
+  if (event.web?.request) {
+    return event.web.request;
+  }
+  const url = getRequestURL(event);
+  const reqHeaders = new Headers();
+  if (event.headers && typeof event.headers.forEach === "function") {
+    event.headers.forEach((v, k) => reqHeaders.set(k, v));
+  } else if (event.node?.req?.headers) {
+    for (const [k, v] of Object.entries(event.node.req.headers)) {
+      if (typeof v === "string") reqHeaders.set(k, v);
+      else if (Array.isArray(v)) reqHeaders.set(k, v.join(", "));
+    }
+  }
+  return new Request(url.href, {
+    method: event.method || event.node?.req?.method || "GET",
+    headers: reqHeaders
+  });
+}
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const room = query.room || "general";
+  const realtimeConfig = getQarpeoConfig(event).realtime;
+  const requireAuth = realtimeConfig.requireAuth === true || realtimeConfig.auth === true;
+  let user = null;
+  try {
+    const authCtx = await getAuthContext(event);
+    user = authCtx?.user;
+  } catch {
+  }
+  if (requireAuth && !user?.id) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Authentication required to connect to realtime rooms."
+    });
+  }
+  const bindingName = realtimeConfig.binding || "QARPEO_ROOM_DO";
+  const stub = getRoomDurableObject(event, room, bindingName);
+  const webReq = resolveWebRequest(event);
+  const headers = new Headers(webReq.headers);
+  if (user?.id) {
+    headers.set("x-qarpeo-user-id", user.id);
+    if (user.name) headers.set("x-qarpeo-user-name", user.name);
+    if (user.avatar || user.picture) {
+      headers.set("x-qarpeo-user-avatar", user.avatar || user.picture);
+    }
+    if (user.metadata) {
+      headers.set("x-qarpeo-user-meta", JSON.stringify(user.metadata));
+    }
+  } else {
+    const anonId = `peer_${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
+    headers.set("x-qarpeo-user-id", anonId);
+    headers.set("x-qarpeo-user-name", "Anonymous");
+    headers.set("x-qarpeo-is-anonymous", "1");
+  }
+  if (query.presence && typeof query.presence === "string") {
+    headers.set("x-qarpeo-user-presence", query.presence);
+  }
+  const init = {
+    method: webReq.method,
+    headers
+  };
+  if (webReq.method !== "GET" && webReq.method !== "HEAD" && webReq.body) {
+    init.body = webReq.body;
+    init.duplex = "half";
+  }
+  const forwardReq = new Request(webReq.url, init);
+  return stub.fetch(forwardReq);
+});

package/dist/runtime/server/routes/robots.txt.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Response>;
+export default _default;

package/dist/runtime/server/routes/robots.txt.get.mjs

@@ -0,0 +1,41 @@
+import { defineEventHandler } from "nuxt/server";
+export default defineEventHandler((event) => {
+  const runtimeConfig = globalThis.__NUXT_RUNTIME_CONFIG__ || {};
+  const site = runtimeConfig.public?.qarpeo?.site || {};
+  const procEnv = globalThis.process?.env || {};
+  const isDev = procEnv.NODE_ENV !== "production";
+  const isPreview = Boolean(procEnv.CF_PAGES_BRANCH && procEnv.CF_PAGES_BRANCH !== "main");
+  const robotsConfig = typeof site.robots === "object" ? site.robots : {};
+  const shouldBlock = site.robots === false || robotsConfig.index === false || isDev && robotsConfig.index !== true || isPreview && robotsConfig.index !== true;
+  let content = "";
+  if (shouldBlock) {
+    content = `# Qarpeo Edge Robots \u2014 Indexing Disabled
+User-agent: *
+Disallow: /
+`;
+  } else {
+    const disallowRules = Array.from(
+      /* @__PURE__ */ new Set(["/api/", "/devtools/", "/_qarpeo/", ...robotsConfig.disallow || []])
+    );
+    const allowRules = Array.from(/* @__PURE__ */ new Set(["/", ...robotsConfig.allow || []]));
+    const lines = ["# Qarpeo Edge Robots", "User-agent: *"];
+    for (const rule of allowRules) {
+      lines.push(`Allow: ${rule}`);
+    }
+    for (const rule of disallowRules) {
+      lines.push(`Disallow: ${rule}`);
+    }
+    if (site.url && site.sitemap !== false) {
+      const sitemapUrl = `${site.url.replace(/\/$/, "")}/sitemap.xml`;
+      lines.push("", `Sitemap: ${sitemapUrl}`);
+    }
+    content = `${lines.join("\n")}
+`;
+  }
+  return new Response(content, {
+    headers: {
+      "Content-Type": "text/plain; charset=UTF-8",
+      "Cache-Control": "public, max-age=3600, s-maxage=86400"
+    }
+  });
+});

package/dist/runtime/server/routes/rss.xml.get.d.ts

@@ -0,0 +1,2 @@
+import handler from "./feed.xml.get";
+export default handler;

package/dist/runtime/server/routes/rss.xml.get.mjs

@@ -0,0 +1,2 @@
+import handler from "./feed.xml.get.mjs";
+export default handler;

package/dist/runtime/server/routes/sitemap.xml.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<Response>>;
+export default _default;

package/dist/runtime/server/routes/sitemap.xml.get.mjs

@@ -0,0 +1,84 @@
+import { defineEventHandler } from "nuxt/server";
+import { getCloudflareEnv } from "../../bindings.mjs";
+function matchesPattern(path, pattern) {
+  const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
+  return new RegExp(`^${regexPattern}$`).test(path);
+}
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = globalThis.__NUXT_RUNTIME_CONFIG__ || {};
+  const site = runtimeConfig.public?.qarpeo?.site || {};
+  const sitemapConfig = typeof site.sitemap === "object" ? site.sitemap : {};
+  const baseUrl = (site.url || "").replace(/\/$/, "");
+  const defaultExcludes = ["/api/**", "/devtools/**", "/_qarpeo/**", "/admin/**"];
+  const excludes = [...defaultExcludes, ...sitemapConfig.exclude || []];
+  const urls = [
+    {
+      loc: `${baseUrl}/`,
+      changefreq: "daily",
+      priority: 1,
+      lastmod: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    },
+    ...sitemapConfig.urls || []
+  ];
+  if (sitemapConfig.cms !== false && baseUrl) {
+    try {
+      const env = getCloudflareEnv(event);
+      const d1Binding = env.DB || env.DATABASE || env.d1;
+      if (d1Binding && typeof d1Binding.prepare === "function") {
+        const stmt = d1Binding.prepare(
+          "SELECT slug, path, collection, updated_at FROM _qarpeo_cms_entries WHERE status = 'published' AND visibility = 'public'"
+        );
+        const res = await stmt.all();
+        if (res && Array.isArray(res.results)) {
+          for (const row of res.results) {
+            const rowPath = row.path || (row.collection ? `/${row.collection}/${row.slug}` : `/${row.slug}`);
+            const cleanPath = rowPath.startsWith("/") ? rowPath : `/${rowPath}`;
+            const isExcluded = excludes.some((pattern) => matchesPattern(cleanPath, pattern));
+            if (!isExcluded) {
+              const lastmod = row.updated_at ? new Date(row.updated_at).toISOString().split("T")[0] : void 0;
+              urls.push({
+                loc: `${baseUrl}${cleanPath}`,
+                lastmod,
+                changefreq: "weekly",
+                priority: 0.8
+              });
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const dedupedUrls = [];
+  for (const u of urls) {
+    if (!seen.has(u.loc)) {
+      seen.add(u.loc);
+      dedupedUrls.push(u);
+    }
+  }
+  const xmlEntries = dedupedUrls.map((u) => {
+    let entry = `  <url>
+    <loc>${u.loc}</loc>
+`;
+    if (u.lastmod) entry += `    <lastmod>${u.lastmod}</lastmod>
+`;
+    if (u.changefreq) entry += `    <changefreq>${u.changefreq}</changefreq>
+`;
+    if (typeof u.priority === "number") entry += `    <priority>${u.priority.toFixed(1)}</priority>
+`;
+    entry += `  </url>`;
+    return entry;
+  }).join("\n");
+  const sitemapXml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${xmlEntries}
+</urlset>
+`;
+  return new Response(sitemapXml, {
+    headers: {
+      "Content-Type": "application/xml; charset=UTF-8",
+      "Cache-Control": "public, max-age=3600, s-maxage=86400"
+    }
+  });
+});

package/dist/runtime/server/routes/storage/file/[...key].delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    success: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/storage/file/[...key].delete.mjs

@@ -0,0 +1,23 @@
+import { defineEventHandler, createError, getRequestURL } from "nuxt/server";
+import { deleteStorageFile } from "../../../utils/storage.mjs";
+export default defineEventHandler(async (event) => {
+  let key = event.context.params?.key || event.context.params?._ || event.context.matchedParams?.key;
+  if (Array.isArray(key)) {
+    key = key.join("/");
+  }
+  if (!key) {
+    const url = getRequestURL(event);
+    const match = url.pathname.match(/\/file\/(.+)$/);
+    if (match?.[1]) {
+      key = decodeURIComponent(match[1]);
+    }
+  }
+  if (!key) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "Storage key is required"
+    });
+  }
+  return await deleteStorageFile(event, key);
+});

package/dist/runtime/server/routes/storage/file/[...key].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<Response | null>>;
+export default _default;

package/dist/runtime/server/routes/storage/file/[...key].get.mjs

@@ -0,0 +1,23 @@
+import { defineEventHandler, createError, getRequestURL } from "nuxt/server";
+import { serveStorageFile } from "../../../utils/storage.mjs";
+export default defineEventHandler(async (event) => {
+  let key = event.context.params?.key || event.context.params?._ || event.context.matchedParams?.key;
+  if (Array.isArray(key)) {
+    key = key.join("/");
+  }
+  if (!key) {
+    const url = getRequestURL(event);
+    const match = url.pathname.match(/\/file\/(.+)$/);
+    if (match?.[1]) {
+      key = decodeURIComponent(match[1]);
+    }
+  }
+  if (!key) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: `Storage key is required. Context params: ${JSON.stringify(event.context.params || {})}`
+    });
+  }
+  return await serveStorageFile(event, key);
+});

package/dist/runtime/server/routes/storage/files.get.d.ts

@@ -0,0 +1,14 @@
+/** GET /api/storage/files Lists uploaded files from Cloudflare R2 bucket with access tier filtering. */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    files: Array<{
+        key: string;
+        size: number;
+        uploaded: string;
+        url: string;
+        pathname: string;
+        access: import("../../../../types").BlobAccessTier;
+    }>;
+    cursor?: string;
+    truncated: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/storage/files.get.mjs

@@ -0,0 +1,11 @@
+import { defineEventHandler, getQuery } from "nuxt/server";
+import { listStorageFiles } from "../../utils/storage.mjs";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  return await listStorageFiles(event, {
+    prefix: query.prefix || void 0,
+    limit: query.limit ? Number(query.limit) : 60,
+    cursor: query.cursor || void 0,
+    access: query.access || void 0
+  });
+});

package/dist/runtime/server/routes/storage/presigned.post.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    key: string;
+    uploadUrl: string;
+    ticket: string;
+    expiresAt: number;
+    access: import("../../../../types").BlobAccessTier;
+}>>;
+export default _default;

package/dist/runtime/server/routes/storage/presigned.post.mjs

@@ -0,0 +1,39 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { getAuthContext } from "../../utils/context.mjs";
+import { createPresignedUploadTicket, getStorageConfig } from "../../utils/storage.mjs";
+export default defineEventHandler(async (event) => {
+  const config = getStorageConfig(event);
+  const body = await readBody(event) || {};
+  const filename = body.filename || body.name;
+  const type = body.type || body.contentType || "application/octet-stream";
+  const access = body.access || config.defaultAccess || "public";
+  if (!filename) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "filename is required"
+    });
+  }
+  const authCtx = await getAuthContext(event).catch(() => null);
+  if (access === "private" && !authCtx?.user) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized",
+      message: "Authentication required to generate presigned upload ticket for private storage"
+    });
+  }
+  if (!config.allowAnonymousUploads && !authCtx?.user) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized",
+      message: "Authentication required to generate presigned upload ticket"
+    });
+  }
+  return await createPresignedUploadTicket(event, {
+    filename,
+    type,
+    size: body.size,
+    expiresIn: body.expiresIn,
+    access
+  });
+});

package/dist/runtime/server/routes/storage/sign.post.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    url: string;
+    token: string;
+    expiresAt: number;
+}>>;
+export default _default;

package/dist/runtime/server/routes/storage/sign.post.mjs

@@ -0,0 +1,24 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { createSignedBlobToken } from "../../utils/storage.mjs";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event) || {};
+  const key = body.key;
+  if (!key || typeof key !== "string") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "key is required"
+    });
+  }
+  const expiresIn = body.expiresIn || "1h";
+  const download = Boolean(body.download);
+  const result = await createSignedBlobToken(event, key, { expiresIn, download });
+  let url = result.url;
+  if (body.filename) {
+    url += `&filename=${encodeURIComponent(body.filename)}`;
+  }
+  return {
+    ...result,
+    url
+  };
+});

package/dist/runtime/server/routes/storage/upload.post.d.ts

@@ -0,0 +1,22 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    key: string;
+    pathname: string;
+    url: string;
+    size: number;
+    type: string;
+    etag: string;
+    access: import("../../../../types").BlobAccessTier;
+    customMetadata?: Record<string, string>;
+} | {
+    files: {
+        key: string;
+        pathname: string;
+        url: string;
+        size: number;
+        type: string;
+        etag: string;
+        access: import("../../../../types").BlobAccessTier;
+        customMetadata?: Record<string, string>;
+    }[];
+}>>;
+export default _default;