@agent-native/core-corpus 0.214.0 → 0.216.0

package/corpus/templates/slides-2/server/lib/google-fonts.ts

@@ -0,0 +1,509 @@
+import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
+
+const CATALOG_URL = "https://fonts.google.com/metadata/fonts";
+const CSS_ORIGIN = "https://fonts.googleapis.com";
+const FONT_ORIGIN = "https://fonts.gstatic.com";
+const CATALOG_TTL_MS = 60 * 60 * 1000;
+const MAX_CATALOG_BYTES = 8 * 1024 * 1024;
+const MAX_CSS_BYTES = 256 * 1024;
+export const MAX_GOOGLE_FONT_BYTES = 8 * 1024 * 1024;
+export const MAX_GOOGLE_FONT_RESULTS = 24;
+const MAX_CATALOG_FAMILIES = 20_000;
+const FONT_TIMEOUT_MS = 10_000;
+const LEGACY_UA = "Mozilla/5.0";
+
+const FONT_EXTENSIONS = ["ttf", "otf", "woff", "woff2"] as const;
+export type GoogleFontExtension = (typeof FONT_EXTENSIONS)[number];
+
+export type GoogleFontVariant =
+  | "regular"
+  | "italic"
+  | `${100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900}`
+  | `${100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900}italic`;
+
+export type GoogleFont = {
+  family: string;
+  category: string;
+  variants: GoogleFontVariant[];
+};
+
+export type DownloadedGoogleFont = {
+  data: Buffer;
+  extension: GoogleFontExtension;
+  mimeType: string;
+  family: string;
+  variant: GoogleFontVariant;
+};
+
+export class GoogleFontError extends Error {
+  constructor(
+    message: string,
+    readonly errorCode: string,
+    readonly statusCode: number,
+  ) {
+    super(message);
+    this.name = "GoogleFontError";
+  }
+}
+
+type SsrfFetchOptions = Parameters<typeof ssrfSafeFetch>[2];
+
+export type GoogleFontsRuntime = {
+  fetch: typeof ssrfSafeFetch;
+};
+
+const defaultRuntime: GoogleFontsRuntime = { fetch: ssrfSafeFetch };
+
+type CatalogRecord = GoogleFont & { popularity: number };
+let catalogCache: { at: number; entries: CatalogRecord[] } | null = null;
+let catalogInflight: Promise<CatalogRecord[]> | null = null;
+
+function assertGoogleOrigin(value: string, origin: string): URL {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new GoogleFontError(
+      "Google Fonts returned an invalid URL.",
+      "google_font_url_invalid",
+      502,
+    );
+  }
+  if (
+    url.origin !== origin ||
+    url.protocol !== "https:" ||
+    url.username ||
+    url.password ||
+    url.port
+  ) {
+    throw new GoogleFontError(
+      "Google Fonts returned an unsupported URL.",
+      "google_font_url_invalid",
+      502,
+    );
+  }
+  return url;
+}
+
+async function readBoundedBody(
+  response: Response,
+  maxBytes: number,
+): Promise<Buffer> {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength !== null) {
+    const declaredSize = Number(contentLength);
+    if (Number.isFinite(declaredSize) && declaredSize > maxBytes) {
+      throw new GoogleFontError(
+        "Google Fonts returned a file that is too large.",
+        "google_font_response_too_large",
+        413,
+      );
+    }
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new GoogleFontError(
+      "Google Fonts returned an empty response.",
+      "google_font_response_invalid",
+      502,
+    );
+  }
+
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel();
+        throw new GoogleFontError(
+          "Google Fonts returned a file that is too large.",
+          "google_font_response_too_large",
+          413,
+        );
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const body = Buffer.allocUnsafe(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+
+function parseVariant(value: string): GoogleFontVariant | null {
+  if (value === "regular" || value === "italic") return value;
+  if (/^(?:100|200|300|400|500|600|700|800|900)(?:italic)?$/.test(value)) {
+    return value as GoogleFontVariant;
+  }
+  return null;
+}
+
+function isGoogleFontFamily(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value === value.trim() &&
+    /^[A-Za-z0-9][A-Za-z0-9 ._-]{0,79}$/.test(value)
+  );
+}
+
+function parseCatalogEntry(value: unknown): CatalogRecord | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const entry = value as Record<string, unknown>;
+  if (!isGoogleFontFamily(entry.family)) return null;
+  const fonts = entry.fonts;
+  if (!fonts || typeof fonts !== "object" || Array.isArray(fonts)) return null;
+  const variants = Object.keys(fonts)
+    .map(parseVariant)
+    .filter((variant): variant is GoogleFontVariant => variant !== null);
+  if (variants.length === 0) return null;
+  const category =
+    typeof entry.category === "string"
+      ? entry.category.trim().slice(0, 40)
+      : "";
+  const popularity =
+    typeof entry.popularity === "number" && Number.isFinite(entry.popularity)
+      ? entry.popularity
+      : Number.MAX_SAFE_INTEGER;
+  return {
+    family: entry.family,
+    category,
+    variants: [...new Set(variants)].slice(0, 64),
+    popularity,
+  };
+}
+
+async function loadCatalog(
+  runtime: GoogleFontsRuntime,
+): Promise<CatalogRecord[]> {
+  if (catalogCache && Date.now() - catalogCache.at < CATALOG_TTL_MS) {
+    return catalogCache.entries;
+  }
+  if (catalogInflight) return catalogInflight;
+
+  catalogInflight = (async () => {
+    let response: Response;
+    try {
+      response = await runtime.fetch(
+        CATALOG_URL,
+        {
+          headers: { Accept: "application/json" },
+          signal: AbortSignal.timeout(FONT_TIMEOUT_MS),
+        },
+        {
+          httpsOnly: true,
+          maxRedirects: 0,
+          assertUrlAllowed: (candidate) => {
+            assertGoogleOrigin(candidate, new URL(CATALOG_URL).origin);
+          },
+        } satisfies SsrfFetchOptions,
+      );
+    } catch (error) {
+      if (error instanceof GoogleFontError) throw error;
+      throw new GoogleFontError(
+        "Google Fonts search is temporarily unavailable.",
+        "google_font_search_unavailable",
+        503,
+      );
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new GoogleFontError(
+        "Google Fonts search is temporarily unavailable.",
+        "google_font_search_unavailable",
+        503,
+      );
+    }
+
+    let parsed: unknown;
+    try {
+      const text = new TextDecoder("utf-8", { fatal: true }).decode(
+        await readBoundedBody(response, MAX_CATALOG_BYTES),
+      );
+      const start = text.indexOf("{");
+      parsed = JSON.parse(start > 0 ? text.slice(start) : text) as unknown;
+    } catch (error) {
+      if (error instanceof GoogleFontError) throw error;
+      throw new GoogleFontError(
+        "Google Fonts returned an invalid catalog.",
+        "google_font_catalog_invalid",
+        502,
+      );
+    }
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new GoogleFontError(
+        "Google Fonts returned an invalid catalog.",
+        "google_font_catalog_invalid",
+        502,
+      );
+    }
+    const rawEntries = (parsed as Record<string, unknown>).familyMetadataList;
+    if (
+      !Array.isArray(rawEntries) ||
+      rawEntries.length > MAX_CATALOG_FAMILIES
+    ) {
+      throw new GoogleFontError(
+        "Google Fonts returned an invalid catalog.",
+        "google_font_catalog_invalid",
+        502,
+      );
+    }
+    const entries = rawEntries
+      .map(parseCatalogEntry)
+      .filter((entry): entry is CatalogRecord => entry !== null);
+    catalogCache = { at: Date.now(), entries };
+    return entries;
+  })();
+
+  try {
+    return await catalogInflight;
+  } finally {
+    catalogInflight = null;
+  }
+}
+
+function normalizeQuery(query: string): string {
+  const normalized = query.trim();
+  if (!normalized || normalized.length > 120) {
+    throw new GoogleFontError(
+      "Search for a font with a query up to 120 characters.",
+      "google_font_query_invalid",
+      400,
+    );
+  }
+  return normalized.toLocaleLowerCase();
+}
+
+export async function searchGoogleFonts(
+  query: string,
+  runtime: GoogleFontsRuntime = defaultRuntime,
+): Promise<GoogleFont[]> {
+  const normalized = normalizeQuery(query);
+  const entries = await loadCatalog(runtime);
+  return entries
+    .filter((entry) => entry.family.toLocaleLowerCase().includes(normalized))
+    .sort((left, right) => left.popularity - right.popularity)
+    .slice(0, MAX_GOOGLE_FONT_RESULTS)
+    .map(({ family, category, variants }) => ({ family, category, variants }));
+}
+
+function variantCssStyle(variant: GoogleFontVariant): string {
+  if (variant === "regular") return "400";
+  if (variant === "italic") return "400italic";
+  return variant;
+}
+
+function parseFontUrl(css: string): {
+  url: string;
+  extension: GoogleFontExtension;
+} {
+  const matches = [
+    ...css.matchAll(/url\(\s*(["']?)(https:\/\/[^\s)"']+)\1\s*\)/gi),
+  ];
+  const accepted: Array<{ url: string; extension: GoogleFontExtension }> = [];
+  for (const match of matches) {
+    const rawUrl = match[2];
+    if (!rawUrl || rawUrl.length > 2_048) continue;
+    try {
+      const url = assertGoogleOrigin(rawUrl, FONT_ORIGIN);
+      if (url.hash) continue;
+      const extension = url.pathname.split(".").at(-1)?.toLowerCase() as
+        | GoogleFontExtension
+        | undefined;
+      if (extension && FONT_EXTENSIONS.includes(extension)) {
+        accepted.push({ url: url.toString(), extension });
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (accepted.length === 0) {
+    throw new GoogleFontError(
+      "Google Fonts did not provide a supported font file.",
+      "google_font_file_unavailable",
+      502,
+    );
+  }
+  return accepted[0]!;
+}
+
+function fontMimeType(extension: GoogleFontExtension): string {
+  switch (extension) {
+    case "otf":
+      return "font/otf";
+    case "ttf":
+      return "font/ttf";
+    case "woff":
+      return "font/woff";
+    case "woff2":
+      return "font/woff2";
+  }
+}
+
+function isAllowedFontFile(
+  data: Uint8Array,
+  extension: GoogleFontExtension,
+  contentType: string,
+): boolean {
+  const mime = contentType.split(";")[0]?.trim().toLowerCase();
+  const acceptedMime = new Set([
+    fontMimeType(extension),
+    ...(extension === "ttf" ? ["application/x-font-ttf"] : []),
+    ...(extension === "otf"
+      ? ["application/vnd.ms-opentype", "application/x-font-opentype"]
+      : []),
+    ...(extension === "woff" ? ["application/font-woff"] : []),
+  ]);
+  if (mime !== "application/octet-stream" && !acceptedMime.has(mime ?? "")) {
+    return false;
+  }
+  const bytes = Buffer.from(data);
+  switch (extension) {
+    case "woff2":
+      return bytes.toString("ascii", 0, 4) === "wOF2";
+    case "woff":
+      return bytes.toString("ascii", 0, 4) === "wOFF";
+    case "otf":
+      return bytes.toString("ascii", 0, 4) === "OTTO";
+    case "ttf":
+      return (
+        bytes.subarray(0, 4).equals(Buffer.from([0, 1, 0, 0])) ||
+        ["true", "typ1"].includes(bytes.toString("ascii", 0, 4))
+      );
+  }
+}
+
+export async function downloadGoogleFont(
+  family: string,
+  variant: string,
+  runtime: GoogleFontsRuntime = defaultRuntime,
+): Promise<DownloadedGoogleFont> {
+  if (!isGoogleFontFamily(family)) {
+    throw new GoogleFontError(
+      "The selected font family is invalid.",
+      "google_font_family_invalid",
+      400,
+    );
+  }
+  const normalizedVariant = parseVariant(variant);
+  if (!normalizedVariant) {
+    throw new GoogleFontError(
+      "The selected font variant is invalid.",
+      "google_font_variant_invalid",
+      400,
+    );
+  }
+  const entries = await loadCatalog(runtime);
+  const entry = entries.find((candidate) => candidate.family === family);
+  if (!entry || !entry.variants.includes(normalizedVariant)) {
+    throw new GoogleFontError(
+      "The selected font variant is not in the Google Fonts catalog.",
+      "google_font_variant_unavailable",
+      404,
+    );
+  }
+
+  const cssUrl = new URL("/css", CSS_ORIGIN);
+  cssUrl.searchParams.set(
+    "family",
+    `${family}:${variantCssStyle(normalizedVariant)}`,
+  );
+  let cssResponse: Response;
+  try {
+    cssResponse = await runtime.fetch(
+      cssUrl.toString(),
+      {
+        headers: { Accept: "text/css", "user-agent": LEGACY_UA },
+        signal: AbortSignal.timeout(FONT_TIMEOUT_MS),
+      },
+      {
+        httpsOnly: true,
+        maxRedirects: 0,
+        assertUrlAllowed: (candidate) => {
+          assertGoogleOrigin(candidate, CSS_ORIGIN);
+        },
+      } satisfies SsrfFetchOptions,
+    );
+  } catch (error) {
+    if (error instanceof GoogleFontError) throw error;
+    throw new GoogleFontError(
+      "The selected Google Font could not be resolved.",
+      "google_font_file_unavailable",
+      502,
+    );
+  }
+  if (!cssResponse.ok) {
+    await cssResponse.body?.cancel();
+    throw new GoogleFontError(
+      "The selected Google Font could not be resolved.",
+      "google_font_file_unavailable",
+      502,
+    );
+  }
+  const css = new TextDecoder("utf-8", { fatal: true }).decode(
+    await readBoundedBody(cssResponse, MAX_CSS_BYTES),
+  );
+  const resolved = parseFontUrl(css);
+
+  let fontResponse: Response;
+  try {
+    fontResponse = await runtime.fetch(
+      resolved.url,
+      {
+        headers: { Accept: fontMimeType(resolved.extension) },
+        signal: AbortSignal.timeout(FONT_TIMEOUT_MS),
+      },
+      {
+        httpsOnly: true,
+        maxRedirects: 0,
+        assertUrlAllowed: (candidate) => {
+          assertGoogleOrigin(candidate, FONT_ORIGIN);
+        },
+      } satisfies SsrfFetchOptions,
+    );
+  } catch (error) {
+    if (error instanceof GoogleFontError) throw error;
+    throw new GoogleFontError(
+      "The selected Google Font could not be downloaded.",
+      "google_font_download_failed",
+      502,
+    );
+  }
+  if (!fontResponse.ok) {
+    await fontResponse.body?.cancel();
+    throw new GoogleFontError(
+      "The selected Google Font could not be downloaded.",
+      "google_font_download_failed",
+      502,
+    );
+  }
+  const contentType = fontResponse.headers.get("content-type") ?? "";
+  const data = await readBoundedBody(fontResponse, MAX_GOOGLE_FONT_BYTES);
+  if (
+    !data.length ||
+    !isAllowedFontFile(data, resolved.extension, contentType)
+  ) {
+    throw new GoogleFontError(
+      "Google Fonts returned an unsupported font file.",
+      "google_font_file_invalid",
+      502,
+    );
+  }
+  return {
+    data,
+    extension: resolved.extension,
+    mimeType: fontMimeType(resolved.extension),
+    family,
+    variant: normalizedVariant,
+  };
+}

package/corpus/templates/slides-2/server/lib/google-oauth-preflight.ts

@@ -0,0 +1,119 @@
+const AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const PROBE_TIMEOUT_MS = 2_500;
+const CACHE_TTL_MS = 10 * 60 * 1_000;
+
+const REJECTION_CODES = [
+  "redirect_uri_mismatch",
+  "invalid_client",
+  "deleted_client",
+  "invalid_request",
+  "unauthorized_client",
+  "org_internal",
+  "admin_policy_enforced",
+  "access_denied",
+] as const;
+
+export type GoogleOAuthRejectionCode = (typeof REJECTION_CODES)[number];
+
+export type GoogleOAuthPreflight =
+  | { status: "ok" }
+  /** Google refused the request itself — no user can complete this flow. */
+  | { status: "rejected"; code: GoogleOAuthRejectionCode | "unrecognized" }
+  /**
+   * The probe could not reach a verdict. Distinct from `ok` on purpose: callers
+   * must not present an unverified flow as a verified-working one, and must not
+   * disable a working export just because the probe was blocked.
+   */
+  | { status: "unknown"; reason: string };
+
+interface CacheEntry {
+  expiresAt: number;
+  value: GoogleOAuthPreflight;
+}
+
+const cache = new Map<string, CacheEntry>();
+
+export function clearGoogleOAuthPreflightCache(): void {
+  cache.clear();
+}
+
+function decodeAuthError(authError: string): string | null {
+  const decoded = Buffer.from(authError, "base64").toString("utf8");
+  return decoded.match(/[a-z][a-z0-9_]{4,}/)?.[0] ?? null;
+}
+
+function classifyLocation(location: string): GoogleOAuthPreflight {
+  let url: URL;
+  try {
+    url = new URL(location, AUTHORIZE_URL);
+  } catch {
+    return { status: "unknown", reason: "unparsable-redirect" };
+  }
+  if (!url.pathname.includes("/signin/oauth/error")) return { status: "ok" };
+
+  const authError = url.searchParams.get("authError");
+  const code = authError ? decodeAuthError(authError) : null;
+  if (!code) return { status: "rejected", code: "unrecognized" };
+  return {
+    status: "rejected",
+    code: (REJECTION_CODES as readonly string[]).includes(code)
+      ? (code as GoogleOAuthRejectionCode)
+      : "unrecognized",
+  };
+}
+
+async function probe(
+  clientId: string,
+  redirectUri: string,
+  scopes: readonly string[],
+): Promise<GoogleOAuthPreflight> {
+  const params = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: scopes.join(" "),
+  });
+  let response: Response;
+  try {
+    response = await fetch(`${AUTHORIZE_URL}?${params.toString()}`, {
+      method: "GET",
+      redirect: "manual",
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+  } catch (error) {
+    return {
+      status: "unknown",
+      reason: error instanceof Error ? error.name : "probe-failed",
+    };
+  }
+
+  const location = response.headers.get("location");
+  if (!location) {
+    return { status: "unknown", reason: `no-redirect-http-${response.status}` };
+  }
+  return classifyLocation(location);
+}
+
+/**
+ * Asks Google whether it would accept this app's authorization request, without
+ * a user session. A `redirect_uri` that is not registered in the Google Cloud
+ * Console is only detectable here: the flow starts as a top-level navigation, so
+ * the failure happens on Google's domain where the app can never observe it.
+ *
+ * Cached per client/redirect/scope so a broken deployment costs one outbound
+ * request per TTL rather than one per page load.
+ */
+export async function checkGoogleOAuthPreflight(input: {
+  clientId: string;
+  redirectUri: string;
+  scopes: readonly string[];
+}): Promise<GoogleOAuthPreflight> {
+  const key = `${input.clientId}|${input.redirectUri}|${input.scopes.join(" ")}`;
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > Date.now()) return cached.value;
+
+  const value = await probe(input.clientId, input.redirectUri, input.scopes);
+  const ttl = value.status === "unknown" ? 30_000 : CACHE_TTL_MS;
+  cache.set(key, { expiresAt: Date.now() + ttl, value });
+  return value;
+}

package/corpus/templates/slides-2/server/lib/google-slides-export-availability.ts

@@ -0,0 +1,55 @@
+import { getWorkspaceConnectionProvider } from "@agent-native/core/connections";
+
+import {
+  checkGoogleOAuthPreflight,
+  type GoogleOAuthPreflight,
+} from "./google-oauth-preflight.js";
+
+export type GoogleSlidesExportAvailability =
+  | { available: true }
+  | {
+      available: false;
+      reason: "not-configured" | "oauth-rejected";
+      code?: string;
+    };
+
+const GOOGLE_DRIVE_CALLBACK_PATH = "/_agent-native/google/callback";
+
+function googleDriveScopes(): readonly string[] {
+  return getWorkspaceConnectionProvider("google_drive")?.oauth?.scopes ?? [];
+}
+
+export function googleDriveRedirectUri(origin: string): string {
+  return `${origin}${GOOGLE_DRIVE_CALLBACK_PATH}`;
+}
+
+export async function resolveGoogleSlidesExportAvailability(input: {
+  configured: boolean;
+  clientId: string | null;
+  origin: string;
+  hasUploadCapableAccount?: boolean;
+  preflight?: (args: {
+    clientId: string;
+    redirectUri: string;
+    scopes: readonly string[];
+  }) => Promise<GoogleOAuthPreflight>;
+}): Promise<GoogleSlidesExportAvailability> {
+  // This gate exists to stop a doomed authorization request. An already
+  // connected account never starts one, so there is nothing here to prevent -
+  // and disabling it would block an export that works.
+  if (input.hasUploadCapableAccount) return { available: true };
+  if (!input.configured || !input.clientId) {
+    return { available: false, reason: "not-configured" };
+  }
+
+  const result = await (input.preflight ?? checkGoogleOAuthPreflight)({
+    clientId: input.clientId,
+    redirectUri: googleDriveRedirectUri(input.origin),
+    scopes: googleDriveScopes(),
+  });
+
+  if (result.status === "rejected") {
+    return { available: false, reason: "oauth-rejected", code: result.code };
+  }
+  return { available: true };
+}

package/corpus/templates/slides-2/server/lib/image-proxy-response.ts

@@ -0,0 +1,16 @@
+export function buildImageProxyResponseHeaders(
+  contentType: string,
+  contentLength: number,
+  publicShare: boolean,
+): Record<string, string> {
+  return {
+    "Content-Type": contentType,
+    "Content-Length": String(contentLength),
+    "Cache-Control": publicShare
+      ? "private, no-store"
+      : "private, max-age=3600",
+    "Access-Control-Allow-Origin": "*",
+    "Content-Security-Policy": "default-src 'none'; sandbox",
+    "X-Content-Type-Options": "nosniff",
+  };
+}