Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
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.tsindex 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.ttfsimilarity index 100%rename from src/web/src/app/fonts/dm-sans-600.ttfrename to src/web/public/fonts/dm-sans-600.ttfdiff --git a/src/web/src/app/_og/render-og-image.test.ts b/src/web/src/app/_og/render-og-image.test.tsindex 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: numberheight: 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.tsxindex 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.mdindex 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.tsxindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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;+}