Fix MCP-generated cards showing the wrong logo for every non-nyuchi brand

generate_studio_card and generate_article_banner never registered any
brand icons with the SVG engines — loadBrandIcons() is browser-only
(fetches a site-relative path against the page's own origin), and
nothing in mcp/src ever called it. Every MCP-generated card for every
brand therefore fell back to the engines' generic placeholder mark
(a synthetic node graph, drawn in the theme's default accent color —
nyuchi's gold in dark mode), regardless of which brand was requested.
Reported as "wrong logos for Mukoko"; confirmed the same is true for
every brand except nyuchi, where the generic mark happens to roughly
match by coincidence of color.

Fix: give loadBrandIcons() an injectable fetch implementation (default
unchanged — the browser call sites need no changes), and add
mcp/src/brand-icons.ts, which loads the same vendored PNGs through the
Worker's ASSETS binding instead of a page-relative fetch. Wired into
generate_studio_card/generate_article_banner, cached per isolate since
the icon set never changes at runtime.

Verified against a real local `wrangler dev` (not just the test stub):
generate_studio_card for brand=mukoko now embeds the actual vendored
Mukoko mark. Added two worker tests asserting a real <image> tag
appears when ASSETS is available, guarding against regressing to the
placeholder. 247 tests green (173 + 74).

Author: claude

mcp/src/brand-icons.ts

@@ -0,0 +1,37 @@
+/**
+ * Registers the real per-brand icons (the same vendored PNGs the SPA's
+ * Studio/Banner pages use) with both SVG engines' icon stores, so
+ * generate_studio_card/generate_article_banner draw the actual brand mark
+ * instead of falling back to the engines' generic placeholder mark.
+ *
+ * loadBrandIcons() normally resolves its icon paths with the browser's own
+ * fetch — there's no page origin to resolve a relative path against inside
+ * a Worker, so this passes a fetch implementation backed by the `ASSETS`
+ * binding instead (the vendored PNGs/`.b64.txt` files are static-passthrough
+ * assets, bundled into the same `signature-generator/dist` the Worker
+ * serves everything else from).
+ *
+ * Cached per isolate: the icon set never changes at runtime, so this only
+ * does real work once per cold start.
+ */
+
+import { loadBrandIcons } from "../../signature-generator/src/lib/loadBrandIcons";
+import { setBrandIcon as setStudioIcon } from "../../signature-generator/src/engines/nyuchi";
+import { setBrandIcon as setBannerIcon } from "../../signature-generator/src/engines/banner";
+
+let cached: Promise<void> | null = null;
+
+export function ensureBrandIconsLoaded(assets: Fetcher | undefined): Promise<void> {
+  if (!assets) return Promise.resolve();
+  if (!cached) {
+    const assetsFetch: typeof fetch = (input) => {
+      const path = typeof input === "string" ? input : input instanceof URL ? input.pathname : input.url;
+      return assets.fetch(new Request(new URL(path, "https://assets.internal")));
+    };
+    cached = Promise.all([
+      loadBrandIcons(setStudioIcon, assetsFetch),
+      loadBrandIcons(setBannerIcon, assetsFetch),
+    ]).then(() => undefined);
+  }
+  return cached;
+}

mcp/src/index.ts

@@ -79,6 +79,7 @@ import {
   buildSVG as buildArticleBanner,
   type Params as BannerParams,
 } from "../../signature-generator/src/engines/banner";
+import { ensureBrandIconsLoaded } from "./brand-icons.js";
 
 /** One-line brand taxonomy, appended to every `brand` param description. */
 const BRAND_TAXONOMY =
@@ -150,7 +151,7 @@ class WorkerHttpTransport implements Transport {
 // MCP server + tool registrations.
 // -----------------------------------------------------------------------------
 
-function buildServer(): McpServer {
+function buildServer(env: Env): McpServer {
   const server = new McpServer({
     name: SERVER_NAME,
     version: SERVER_VERSION,
@@ -249,6 +250,7 @@ function buildServer(): McpServer {
       brand?: StudioParams["brand"];
       seedKey?: string;
     }) => {
+      await ensureBrandIconsLoaded(env.ASSETS);
       const layout = args.layout ?? 5;
       const params: StudioParams = {
         format: args.format ?? "ig",
@@ -331,6 +333,7 @@ function buildServer(): McpServer {
       brand?: BannerParams["brand"];
       seedKey?: string;
     }) => {
+      await ensureBrandIconsLoaded(env.ASSETS);
       const layout = args.layout ?? 1;
       const params: BannerParams = {
         format: args.format ?? "16x9",
@@ -631,7 +634,7 @@ app.post("/mcp", async (c) => {
   }
 
   const messages = Array.isArray(body) ? body : [body];
-  const server = buildServer();
+  const server = buildServer(c.env);
   const transport = new WorkerHttpTransport();
   await server.connect(transport);
 

mcp/tests/worker.test.ts

@@ -38,6 +38,20 @@ const SITE_ENV = { SESSION_SECRET: TEST_SESSION_SECRET }
  * (`app.all("*", (c) => c.env.ASSETS.fetch(...))`) provide this instead. */
 const ASSETS_STUB = { fetch: async () => new Response('stub-asset') }
 
+/** Stub ASSETS binding that answers brand-icon `.b64.txt` requests with a
+ * fixed fake payload, so tests can verify generate_studio_card/
+ * generate_article_banner actually embed a real per-brand icon (via
+ * mcp/src/brand-icons.ts) instead of falling back to the engines' generic
+ * placeholder mark — the exact bug this guards against regressing to. */
+const FAKE_ICON_B64 = 'ZmFrZS1pY29uLWJ5dGVz'
+const ICON_ASSETS_STUB = {
+  fetch: async (req: Request) => {
+    const url = new URL(req.url)
+    if (url.pathname.endsWith('.b64.txt')) return new Response(FAKE_ICON_B64)
+    return new Response('not found', { status: 404 })
+  },
+}
+
 type Env = Record<string, unknown>
 
 function get(path: string, env: Env = OPEN_ENV, headers?: HeadersInit): Promise<Response> {
@@ -467,6 +481,53 @@ describe('POST /mcp — JSON-RPC', () => {
     expect(result.content[0].text).toContain('-32602')
   })
 
+  // These two run last in the describe block: loading brand icons populates
+  // a module-level cache shared by every call in this test file (mirroring
+  // one Worker isolate's lifetime), so once these run, every studio/banner
+  // test after them would also see real icons instead of the wordmark-only
+  // fallback the tests above assert around.
+  it('generate_studio_card embeds the real brand icon when ASSETS is available', async () => {
+    const res = await post(
+      '/mcp',
+      rpc(
+        'tools/call',
+        {
+          name: 'generate_studio_card',
+          arguments: { title: 'What is nhimbe?', category: 'malachite', brand: 'mukoko' },
+        },
+        18,
+      ),
+      { ...OPEN_ENV, ASSETS: ICON_ASSETS_STUB },
+    )
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as JsonRpcResponse
+    expect(body.error).toBeUndefined()
+    const svg = (body.result as { content: { text: string }[] }).content[0].text
+    expect(svg).toContain(`<image href="data:image/png;base64,${FAKE_ICON_B64}"`)
+    expect(svg).toContain('>mukoko.com</text>')
+  })
+
+  it('generate_article_banner embeds the real brand icon when ASSETS is available', async () => {
+    const res = await post(
+      '/mcp',
+      rpc(
+        'tools/call',
+        {
+          name: 'generate_article_banner',
+          arguments: { title: 'X', category: 'malachite', brand: 'mukoko' },
+        },
+        19,
+      ),
+      { ...OPEN_ENV, ASSETS: ICON_ASSETS_STUB },
+    )
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as JsonRpcResponse
+    expect(body.error).toBeUndefined()
+    const svg = (body.result as { content: { text: string }[] }).content[0].text
+    expect(svg).toContain(`<image href="data:image/png;base64,${FAKE_ICON_B64}"`)
+    expect(svg).toContain('>mukoko.com</text>')
+  })
+
   it('malformed JSON gets a -32700 parse error with HTTP 400', async () => {
     const res = await post('/mcp', '{not json')
     expect(res.status).toBe(400)

signature-generator/src/lib/loadBrandIcons.ts

@@ -8,17 +8,25 @@ import { TOP_BRANDS, type TopBrandKey } from '../engines/brands'
  *
  * Missing files resolve silently — the engines draw a wordmark-only lockup
  * (or their built-in mark) for brands without a registered icon.
+ *
+ * `fetchImpl` defaults to the global `fetch`, which resolves the site-
+ * relative icon paths correctly in a browser. The `nyuchi-tools` Worker has
+ * no browser origin to resolve a relative path against, so it passes a
+ * fetch implementation backed by its `ASSETS` binding instead (see
+ * `mcp/src/brand-icons.ts`) — same paths, same `.b64.txt` files, different
+ * transport.
  */
 export async function loadBrandIcons(
   setBrandIcon: (brand: TopBrandKey, dataUri: string, theme?: 'light' | 'dark') => void,
+  fetchImpl: typeof fetch = fetch,
 ): Promise<void> {
   const jobs: Promise<void>[] = []
   for (const brand of Object.values(TOP_BRANDS)) {
     for (const theme of ['light', 'dark'] as const) {
       const path = brand.icon[theme]
       if (!path || !path.endsWith('.png')) continue
       jobs.push(
-        fetch(path.replace(/\.png$/, '.b64.txt'))
+        fetchImpl(path.replace(/\.png$/, '.b64.txt'))
           .then((r) => (r.ok ? r.text() : Promise.reject(new Error(`${path}: ${r.status}`))))
           .then((txt) => setBrandIcon(brand.key, 'data:image/png;base64,' + txt.trim(), theme))
           .catch(() => {