Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): remove runtime filesystem access from OG images (#560)

Generc13e3d08cf92
diff --git a/scripts/ci/font-contract.test.ts b/scripts/ci/font-contract.test.ts
index fea9b0024..981762205 100644
--- a/scripts/ci/font-contract.test.ts
+++ b/scripts/ci/font-contract.test.ts
@@ -3,6 +3,7 @@ import { resolve } from "node:path"
import { describe, expect, it } from "vitest"
const appRoot = resolve(import.meta.dirname, "../../src/web/src/app")
+const publicRoot = resolve(import.meta.dirname, "../../src/web/public")
const layout = readFileSync(resolve(appRoot, "layout.tsx"), "utf8")
const ogRoute = readFileSync(resolve(appRoot, "og/route.tsx"), "utf8")
const fontDefinitions = readFileSync(resolve(appRoot, "fonts.ts"), "utf8")
@@ -17,11 +18,11 @@ describe("web font contract", () => {
it("references committed local font files", () => {
const paths = [...fontDefinitions.matchAll(/(?:src|path): "\.\/fonts\/([^\"]+)"/g)]
.map((match) => match[1])
- .concat("dm-sans-600.ttf")
- expect(paths).toHaveLength(8)
+ expect(paths).toHaveLength(7)
for (const path of paths) {
expect(existsSync(resolve(appRoot, "fonts", path))).toBe(true)
}
+ expect(existsSync(resolve(publicRoot, "fonts/dm-sans-600.ttf"))).toBe(true)
})
})
diff --git a/src/web/src/app/fonts/dm-sans-600.ttf b/src/web/public/fonts/dm-sans-600.ttf
similarity index 100%
rename from src/web/src/app/fonts/dm-sans-600.ttf
rename to src/web/public/fonts/dm-sans-600.ttf
diff --git a/src/web/src/app/_og/render-og-image.test.ts b/src/web/src/app/_og/render-og-image.test.ts
index 1eaeb59db..62e960279 100644
--- a/src/web/src/app/_og/render-og-image.test.ts
+++ b/src/web/src/app/_og/render-og-image.test.ts
@@ -1,6 +1,6 @@
import { inflateSync } from "node:zlib"
import { readFileSync } from "node:fs"
-import { describe, expect, it } from "vitest"
+import { beforeEach, describe, expect, it, vi } from "vitest"
import {
normalizeOgTitle,
OG_TITLE_FONT_SIZE,
@@ -11,6 +11,42 @@ import {
} from "./og-title"
import { renderOgImage } from "./render-og-image"
+const {
+ mockAssetFetch,
+ mockGetCloudflareContext,
+ mockHeaders,
+} = vi.hoisted(() => ({
+ mockAssetFetch: vi.fn(),
+ mockGetCloudflareContext: vi.fn(),
+ mockHeaders: vi.fn(),
+}))
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: mockGetCloudflareContext,
+}))
+
+vi.mock("next/headers", () => ({
+ headers: mockHeaders,
+}))
+
+const LOGO_ASSET_URL = "https://assets.local/icon-192.png"
+const FONT_ASSET_URL = "https://assets.local/fonts/dm-sans-600.ttf"
+const officialLogo = readFileSync(new URL("../../../public/icon-192.png", import.meta.url))
+const officialFont = readFileSync(new URL("../../../public/fonts/dm-sans-600.ttf", import.meta.url))
+
+beforeEach(() => {
+ mockHeaders.mockReset().mockResolvedValue(new Headers())
+ mockAssetFetch.mockReset().mockImplementation(async (input: string | URL | Request) => {
+ const url = String(input)
+ if (url === LOGO_ASSET_URL) return new Response(Uint8Array.from(officialLogo))
+ if (url === FONT_ASSET_URL) return new Response(Uint8Array.from(officialFont))
+ return new Response(null, { status: 404 })
+ })
+ mockGetCloudflareContext.mockReset().mockResolvedValue({
+ env: { ASSETS: { fetch: mockAssetFetch } },
+ })
+})
+
type DecodedPng = {
width: number
height: number
@@ -221,15 +257,55 @@ function countSmallColorComponents(
}
describe("OG image", () => {
- it("loads the generated raster logo instead of embedding manual base64 or requesting SVG", () => {
- const officialLogo = readFileSync(new URL("../../../public/icon-192.png", import.meta.url))
+ it("loads the canonical public assets through the request-scoped ASSETS binding", async () => {
const rendererSource = readFileSync(new URL("./render-og-image.tsx", import.meta.url), "utf8")
expect(officialLogo.byteLength).toBeGreaterThan(1_000)
- expect(rendererSource).toContain('processRoot.endsWith(join("src", "web"))')
- expect(rendererSource).toContain('join(webRoot, "public/icon-192.png")')
+ expect(officialFont.byteLength).toBeGreaterThan(30_000)
+ expect(rendererSource).toContain(`"${LOGO_ASSET_URL}"`)
+ expect(rendererSource).toContain(`"${FONT_ASSET_URL}"`)
+ expect(rendererSource).not.toContain("node:fs")
+ expect(rendererSource).not.toContain("node:path")
+ expect(rendererSource).not.toContain("process.cwd()")
+ expect(rendererSource).not.toContain("file://")
expect(rendererSource).not.toContain("iVBORw0KGgo")
expect(rendererSource).not.toContain("alook.svg")
+
+ await renderOgImage("OG asset binding regression")
+
+ expect(mockHeaders).toHaveBeenCalledOnce()
+ expect(mockGetCloudflareContext).toHaveBeenCalledWith({ async: true })
+ expect(mockAssetFetch.mock.calls.map(([input]) => input)).toEqual([
+ LOGO_ASSET_URL,
+ FONT_ASSET_URL,
+ ])
+ expect(mockHeaders.mock.invocationCallOrder[0]).toBeLessThan(
+ mockGetCloudflareContext.mock.invocationCallOrder[0],
+ )
+ expect(mockGetCloudflareContext.mock.invocationCallOrder[0]).toBeLessThan(
+ mockAssetFetch.mock.invocationCallOrder[0],
+ )
+ })
+
+ it("fails explicitly when the ASSETS binding is unavailable", async () => {
+ mockGetCloudflareContext.mockResolvedValueOnce({ env: {} })
+
+ await expect(renderOgImage("missing binding")).rejects.toThrow(
+ "Cloudflare ASSETS binding is unavailable",
+ )
+ expect(mockAssetFetch).not.toHaveBeenCalled()
+ })
+
+ it("fails explicitly when a required OG asset is unavailable", async () => {
+ mockAssetFetch.mockImplementation(async (input: string | URL | Request) => {
+ const url = String(input)
+ if (url === LOGO_ASSET_URL) return new Response(Uint8Array.from(officialLogo))
+ return new Response(null, { status: 404 })
+ })
+
+ await expect(renderOgImage("missing font")).rejects.toThrow(
+ "OG asset /fonts/dm-sans-600.ttf returned 404",
+ )
})
it("renders the official brand colors into the logo crop", async () => {
diff --git a/src/web/src/app/_og/render-og-image.tsx b/src/web/src/app/_og/render-og-image.tsx
index 6a20fefcd..64cadc19e 100644
--- a/src/web/src/app/_og/render-og-image.tsx
+++ b/src/web/src/app/_og/render-og-image.tsx
@@ -1,5 +1,5 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { getCloudflareContext } from "@opennextjs/cloudflare";
+import { headers } from "next/headers";
import { ImageResponse } from "next/og";
import { BRAND_SLOGAN } from "@/lib/brand-copy";
import {
@@ -12,15 +12,16 @@ import {
export const OG_IMAGE_SIZE = { width: 1200, height: 630 } as const;
export const OG_IMAGE_CONTENT_TYPE = "image/png";
-const processRoot = process.cwd();
-const webRoot = processRoot.endsWith(join("src", "web"))
- ? processRoot
- : join(processRoot, "src", "web");
+const OG_LOGO_ASSET_URL = "https://assets.local/icon-192.png";
+const OG_FONT_ASSET_URL = "https://assets.local/fonts/dm-sans-600.ttf";
-const assetsPromise = Promise.all([
- readFile(join(webRoot, "public/icon-192.png")),
- readFile(join(webRoot, "src/app/fonts/dm-sans-600.ttf")),
-]);
+async function fetchOgAsset(assets: Fetcher, url: string): Promise<ArrayBuffer> {
+ const response = await assets.fetch(url);
+ if (!response.ok) {
+ throw new Error(`OG asset ${new URL(url).pathname} returned ${response.status}`);
+ }
+ return response.arrayBuffer();
+}
function TypewriterIllustration() {
const keyRows = [9, 7, 9];
@@ -114,8 +115,15 @@ function TypewriterIllustration() {
export async function renderOgImage(rawTitle: string): Promise<ImageResponse> {
const title = normalizeOgTitle(rawTitle) || BRAND_SLOGAN;
- const [logoData, fontData] = await assetsPromise;
- const logoDataUri = `data:image/png;base64,${logoData.toString("base64")}`;
+ await headers();
+ const { env } = await getCloudflareContext({ async: true });
+ if (!env.ASSETS) throw new Error("Cloudflare ASSETS binding is unavailable");
+
+ const [logoData, fontData] = await Promise.all([
+ fetchOgAsset(env.ASSETS, OG_LOGO_ASSET_URL),
+ fetchOgAsset(env.ASSETS, OG_FONT_ASSET_URL),
+ ]);
+ const logoDataUri = `data:image/png;base64,${Buffer.from(logoData).toString("base64")}`;
return new ImageResponse(
(
@@ -211,7 +219,7 @@ export async function renderOgImage(rawTitle: string): Promise<ImageResponse> {
fonts: [
{
name: "DM Sans",
- data: Uint8Array.from(fontData).buffer,
+ data: fontData,
weight: 600,
style: "normal",
},
diff --git a/src/web/src/app/fonts/README.md b/src/web/src/app/fonts/README.md
index ea1c6a047..5b7b993f0 100644
--- a/src/web/src/app/fonts/README.md
+++ b/src/web/src/app/fonts/README.md
@@ -9,4 +9,6 @@ The WOFF2 files are the Latin subsets from Fontsource 5.3.0:
- `@fontsource/vt323`
- `@fontsource-variable/literata`
-`dm-sans-600.ttf` is the DM Sans 9pt SemiBold file used by the Open Graph image route. Each family is distributed under the SIL Open Font License 1.1; the corresponding license text is in `licenses/`.
+The Open Graph image route uses the DM Sans 9pt SemiBold file at
+`public/fonts/dm-sans-600.ttf`. Each family is distributed under the SIL Open
+Font License 1.1; the corresponding license text is in `licenses/`.
diff --git a/src/web/src/app/og/blog/[slug]/route.tsx b/src/web/src/app/og/blog/[slug]/route.tsx
index 79ad3921e..17d221cb8 100644
--- a/src/web/src/app/og/blog/[slug]/route.tsx
+++ b/src/web/src/app/og/blog/[slug]/route.tsx
@@ -1,5 +1,5 @@
import { renderOgImage } from "@/app/_og/render-og-image";
-import { getPostBySlug } from "@/lib/blog/posts";
+import { getPostBySlug } from "@/lib/blog/posts/get-post-by-slug";
export async function GET(
_request: Request,
diff --git a/src/web/src/components/home/landing-content.test.ts b/src/web/src/components/home/landing-content.test.ts
index c820e796c..57d137911 100644
--- a/src/web/src/components/home/landing-content.test.ts
+++ b/src/web/src/components/home/landing-content.test.ts
@@ -239,8 +239,13 @@ describe("landing content contract", () => {
expect(communityLayout).toContain('<SignupTracker redirectTo="/c/me/machines" />')
expect(ogRoute).toContain("renderOgImage(BRAND_SLOGAN)")
expect(ogRoute).not.toContain("searchParams")
- expect(ogRenderer).toContain('processRoot.endsWith(join("src", "web"))')
- expect(ogRenderer).toContain('join(webRoot, "public/icon-192.png")')
+ expect(ogRenderer).toContain('await getCloudflareContext({ async: true })')
+ expect(ogRenderer).toContain('env.ASSETS')
+ expect(ogRenderer).toContain('"https://assets.local/icon-192.png"')
+ expect(ogRenderer).toContain('"https://assets.local/fonts/dm-sans-600.ttf"')
+ expect(ogRenderer).not.toContain('node:fs')
+ expect(ogRenderer).not.toContain('node:path')
+ expect(ogRenderer).not.toContain('process.cwd()')
expect(ogRenderer).not.toContain("OG_LOGO_DATA_URI")
expect(ogRenderer).not.toContain("alook.svg")
expect(ogRenderer).toContain("width={120}")
diff --git a/src/web/src/lib/blog/posts/get-post-by-slug.ts b/src/web/src/lib/blog/posts/get-post-by-slug.ts
new file mode 100644
index 000000000..4973d2edc
--- /dev/null
+++ b/src/web/src/lib/blog/posts/get-post-by-slug.ts
@@ -0,0 +1,18 @@
+import type { BlogPost } from "../types";
+import { importMdxMetadata } from "./import-mdx";
+import { validateMetadata } from "./validate-metadata";
+
+export async function getPostBySlug(
+ slug: string
+): Promise<BlogPost | undefined> {
+ const metadata = await importMdxMetadata(slug);
+ if (
+ !metadata ||
+ !validateMetadata(metadata as Record<string, unknown>, `${slug}.mdx`) ||
+ metadata.slug !== slug ||
+ metadata.draft
+ ) {
+ return undefined;
+ }
+ return metadata;
+}
diff --git a/src/web/src/lib/blog/posts/import-mdx.test.ts b/src/web/src/lib/blog/posts/import-mdx.test.ts
new file mode 100644
index 000000000..1620a429b
--- /dev/null
+++ b/src/web/src/lib/blog/posts/import-mdx.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+ importMdxMetadata,
+ isMissingMdxMetadataModule,
+} from "./import-mdx";
+
+const { evaluationFailure, metadata } = vi.hoisted(() => ({
+ metadata: {
+ slug: "ai-agent-identity",
+ title: "Article",
+ date: "2026-08-26",
+ author: "Alook",
+ excerpt: "Article excerpt",
+ readingTime: "1 min read",
+ },
+ evaluationFailure: new Error("MDX evaluation failed"),
+}));
+
+vi.mock("@/content/ai-agent-identity.mdx", () => ({ metadata }));
+vi.mock("@/content/humans-and-ai-agents-in-one-room.mdx", () => ({
+ get metadata() {
+ throw evaluationFailure;
+ },
+}));
+
+describe("importMdxMetadata", () => {
+ it("returns undefined only when the requested MDX module is missing", async () => {
+ await expect(importMdxMetadata("definitely-missing-og-regression")).resolves.toBeUndefined();
+
+ const missing = Object.assign(
+ new Error("Cannot find module '@/content/definitely-missing-og-regression.mdx'"),
+ { code: "MODULE_NOT_FOUND" },
+ );
+ expect(isMissingMdxMetadataModule(missing, "definitely-missing-og-regression")).toBe(true);
+ });
+
+ it("does not hide missing dependencies or evaluation failures", () => {
+ const missingDependency = Object.assign(
+ new Error("Cannot find module 'missing-package' imported from article.mdx"),
+ { code: "ERR_MODULE_NOT_FOUND" },
+ );
+ expect(isMissingMdxMetadataModule(missingDependency, "article")).toBe(false);
+ expect(isMissingMdxMetadataModule(new Error("MDX evaluation failed"), "article")).toBe(false);
+ expect(isMissingMdxMetadataModule("not an error", "article")).toBe(false);
+ });
+
+ it("returns loaded metadata and propagates unexpected loader failures", async () => {
+ await expect(importMdxMetadata("ai-agent-identity")).resolves.toEqual(metadata);
+ await expect(
+ importMdxMetadata("humans-and-ai-agents-in-one-room"),
+ ).rejects.toBe(evaluationFailure);
+ });
+});
diff --git a/src/web/src/lib/blog/posts/import-mdx.ts b/src/web/src/lib/blog/posts/import-mdx.ts
index 33bf6f19a..f6aca4eac 100644
--- a/src/web/src/lib/blog/posts/import-mdx.ts
+++ b/src/web/src/lib/blog/posts/import-mdx.ts
@@ -1,8 +1,29 @@
import type { BlogPost } from "../types";
+export function isMissingMdxMetadataModule(error: unknown, slug: string): boolean {
+ if (!(error instanceof Error)) return false;
+ const expectedFile = `${slug}.mdx`;
+ if (
+ error.message.startsWith("Unknown variable dynamic import: ") &&
+ error.message.endsWith(`/${expectedFile}`)
+ ) {
+ return true;
+ }
+
+ const code = "code" in error ? String(error.code) : "";
+ if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") return false;
+ const missingSpecifier = error.message.match(/^Cannot find module ['"]([^'"]+)['"]/)?.[1];
+ return missingSpecifier === expectedFile || missingSpecifier?.endsWith(`/${expectedFile}`) === true;
+}
+
export async function importMdxMetadata(
slug: string
): Promise<BlogPost | undefined> {
- const mod = await import(`@/content/${slug}.mdx`);
- return mod.metadata;
+ try {
+ const mod = await import(`@/content/${slug}.mdx`);
+ return mod.metadata;
+ } catch (error) {
+ if (isMissingMdxMetadataModule(error, slug)) return undefined;
+ throw error;
+ }
}
diff --git a/src/web/src/lib/blog/posts/index.test.ts b/src/web/src/lib/blog/posts/index.test.ts
index 228fa5d68..2efbeace5 100644
--- a/src/web/src/lib/blog/posts/index.test.ts
+++ b/src/web/src/lib/blog/posts/index.test.ts
@@ -138,40 +138,59 @@ describe("getAllPosts", () => {
});
describe("getPostBySlug", () => {
- it("returns the post matching the given slug", async () => {
- mockReaddirSync.mockReturnValue(
- ["post-a.mdx", "post-b.mdx"] as unknown as ReturnType<
- typeof readdirSync
- >
- );
- mockImportMdxMetadata.mockImplementation(async (slug) => {
- if (slug === "post-a") return postA;
- if (slug === "post-b") return postB;
- return undefined;
- });
+ it("imports and returns only the requested canonical post without scanning", async () => {
+ mockImportMdxMetadata.mockResolvedValue(postA);
- const { getPostBySlug } = await import("./index");
+ const { getPostBySlug } = await import("./get-post-by-slug");
const post = await getPostBySlug("post-a");
- expect(post).toBeDefined();
- expect(post!.title).toBe("Post A");
+ expect(post).toEqual(postA);
+ expect(mockImportMdxMetadata).toHaveBeenCalledWith("post-a");
+ expect(mockReaddirSync).not.toHaveBeenCalled();
});
it("returns undefined for a draft slug", async () => {
- mockReaddirSync.mockReturnValue(
- ["post-a.mdx", "draft-post.mdx"] as unknown as ReturnType<
- typeof readdirSync
- >
- );
- mockImportMdxMetadata.mockImplementation(async (slug) => {
- if (slug === "post-a") return postA;
- if (slug === "draft-post") return draftPost;
- return undefined;
- });
+ mockImportMdxMetadata.mockResolvedValue(draftPost);
- const { getPostBySlug } = await import("./index");
+ const { getPostBySlug } = await import("./get-post-by-slug");
const post = await getPostBySlug("draft-post");
expect(post).toBeUndefined();
+ expect(mockReaddirSync).not.toHaveBeenCalled();
+ });
+
+ it("returns undefined for missing or incomplete metadata", async () => {
+ const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+ const { getPostBySlug } = await import("./get-post-by-slug");
+
+ mockImportMdxMetadata.mockResolvedValueOnce(undefined);
+ await expect(getPostBySlug("missing")).resolves.toBeUndefined();
+
+ mockImportMdxMetadata.mockResolvedValueOnce(incompletePost);
+ await expect(getPostBySlug("incomplete")).resolves.toBeUndefined();
+ expect(warnSpy).toHaveBeenCalledWith(
+ expect.stringContaining("missing required field")
+ );
+ expect(mockReaddirSync).not.toHaveBeenCalled();
+ warnSpy.mockRestore();
+ });
+
+ it("returns undefined when metadata slug does not match the requested module", async () => {
+ mockImportMdxMetadata.mockResolvedValue(postB);
+
+ const { getPostBySlug } = await import("./get-post-by-slug");
+
+ await expect(getPostBySlug("post-a")).resolves.toBeUndefined();
+ expect(mockReaddirSync).not.toHaveBeenCalled();
+ });
+
+ it("propagates unexpected MDX import failures", async () => {
+ const failure = new Error("MDX evaluation failed");
+ mockImportMdxMetadata.mockRejectedValue(failure);
+
+ const { getPostBySlug } = await import("./get-post-by-slug");
+
+ await expect(getPostBySlug("post-a")).rejects.toBe(failure);
+ expect(mockReaddirSync).not.toHaveBeenCalled();
});
});
diff --git a/src/web/src/lib/blog/posts/index.ts b/src/web/src/lib/blog/posts/index.ts
index bfee57f61..035ac715a 100644
--- a/src/web/src/lib/blog/posts/index.ts
+++ b/src/web/src/lib/blog/posts/index.ts
@@ -3,37 +3,15 @@ import { join, dirname } from "path";
import { fileURLToPath } from "url";
import type { BlogPost } from "../types";
import { importMdxMetadata } from "./import-mdx";
+import { validateMetadata } from "./validate-metadata";
const __dirname = dirname(fileURLToPath(import.meta.url));
const contentDir = join(__dirname, "..", "..", "..", "content");
-const REQUIRED_FIELDS: (keyof BlogPost)[] = [
- "slug",
- "title",
- "date",
- "author",
- "excerpt",
- "readingTime",
-];
-
-function validateMetadata(
- metadata: Record<string, unknown>,
- file: string
-): metadata is BlogPost {
- for (const field of REQUIRED_FIELDS) {
- if (!metadata[field]) {
- console.warn(
- `[blog] Skipping ${file}: missing required field "${field}"`
- );
- return false;
- }
- }
- return true;
-}
-
let cachedPosts: BlogPost[] | null = null;
export type { BlogPost } from "../types";
+export { getPostBySlug } from "./get-post-by-slug";
export async function getAllPosts(): Promise<BlogPost[]> {
if (cachedPosts) {
@@ -65,10 +43,3 @@ export async function getAllPosts(): Promise<BlogPost[]> {
(a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
);
}
-
-export async function getPostBySlug(
- slug: string
-): Promise<BlogPost | undefined> {
- const posts = await getAllPosts();
- return posts.find((p) => p.slug === slug);
-}
diff --git a/src/web/src/lib/blog/posts/validate-metadata.ts b/src/web/src/lib/blog/posts/validate-metadata.ts
new file mode 100644
index 000000000..cbcf5f1cf
--- /dev/null
+++ b/src/web/src/lib/blog/posts/validate-metadata.ts
@@ -0,0 +1,25 @@
+import type { BlogPost } from "../types";
+
+const REQUIRED_FIELDS: (keyof BlogPost)[] = [
+ "slug",
+ "title",
+ "date",
+ "author",
+ "excerpt",
+ "readingTime",
+];
+
+export function validateMetadata(
+ metadata: Record<string, unknown>,
+ file: string
+): metadata is BlogPost {
+ for (const field of REQUIRED_FIELDS) {
+ if (!metadata[field]) {
+ console.warn(
+ `[blog] Skipping ${file}: missing required field "${field}"`
+ );
+ return false;
+ }
+ }
+ return true;
+}