feat: branded two-zone header for public viewer (#222)

Add implementor brand (far left) and platform brand (far right) zones
to the public viewer header. The implementor zone is optional and only
renders when portal.implementor.name or logo is configured. Both zones
support clickable links when URLs are provided.

- Add ImplementorConfig (name/logo/url) to PortalConfig
- Add BrandURL, ImplementorName/LogoSVG/URL to portal.Deps
- Resolve platform brand_name and brand_url from mcpapps config
- Add ResolveImplementorLogo() with fetch + cache pattern
- Redesign template: left (implementor) / center (asset) / right (platform)

Author: cjimti

cmd/mcp-data-platform/main.go

@@ -498,6 +498,15 @@ func mountPortalAPI(mux *http.ServeMux, p *platform.Platform) {
 		}
 	}
 
+	// Platform brand (far right): prefer mcpapps platform-info config, then portal title.
+	brandName := mcpappsBrandName(p)
+	if brandName == "" {
+		brandName = p.Config().Portal.Title
+	}
+	if brandName == "" {
+		brandName = p.Config().Server.Name
+	}
+
 	deps := portal.Deps{
 		AssetStore:    p.PortalAssetStore(),
 		ShareStore:    p.PortalShareStore(),
@@ -508,8 +517,14 @@ func mountPortalAPI(mux *http.ServeMux, p *platform.Platform) {
 			RequestsPerMinute: p.Config().Portal.RateLimit.RequestsPerMinute,
 			BurstSize:         p.Config().Portal.RateLimit.BurstSize,
 		},
-		OIDCEnabled: p.BrowserSessionFlow() != nil,
-		AdminRoles:  adminRoles,
+		OIDCEnabled:        p.BrowserSessionFlow() != nil,
+		AdminRoles:         adminRoles,
+		BrandName:          brandName,
+		BrandLogoSVG:       p.BrandLogoSVG(),
+		BrandURL:           p.BrandURL(),
+		ImplementorName:    p.Config().Portal.Implementor.Name,
+		ImplementorLogoSVG: p.ResolveImplementorLogo(),
+		ImplementorURL:     p.Config().Portal.Implementor.URL,
 	}
 
 	wirePortalOptionalDeps(&deps, p)
@@ -520,6 +535,17 @@ func mountPortalAPI(mux *http.ServeMux, p *platform.Platform) {
 	log.Println("Portal API enabled on /api/v1/portal/")
 }
 
+// mcpappsBrandName extracts brand_name from the mcpapps platform-info config,
+// or returns empty string if not configured.
+func mcpappsBrandName(p *platform.Platform) string {
+	appCfg, ok := p.Config().MCPApps.Apps["platform-info"]
+	if !ok {
+		return ""
+	}
+	name, _ := appCfg.Config["brand_name"].(string)
+	return name
+}
+
 // wirePortalOptionalDeps populates optional portal dependencies (audit, knowledge, persona).
 func wirePortalOptionalDeps(deps *portal.Deps, p *platform.Platform) {
 	if p.AuditStore() != nil {

cmd/mcp-data-platform/main_test.go

@@ -1017,3 +1017,55 @@ func TestMountPortalUI_NoAssets(t *testing.T) {
 	mux := http.NewServeMux()
 	mountPortalUI(mux, p, false) // no assets available
 }
+
+func TestMcpappsBrandName(t *testing.T) {
+	t.Run("returns brand_name from mcpapps config", func(t *testing.T) {
+		p := newTestPlatform(t, &platform.Config{
+			Server: platform.ServerConfig{Name: "test"},
+			MCPApps: platform.MCPAppsConfig{
+				Apps: map[string]platform.AppConfig{
+					"platform-info": {
+						Config: map[string]any{"brand_name": "Plexara"},
+					},
+				},
+			},
+		})
+		defer func() { _ = p.Close() }()
+
+		got := mcpappsBrandName(p)
+		if got != "Plexara" {
+			t.Errorf("mcpappsBrandName() = %q, want %q", got, "Plexara")
+		}
+	})
+
+	t.Run("returns empty when no platform-info app", func(t *testing.T) {
+		p := newTestPlatform(t, &platform.Config{
+			Server: platform.ServerConfig{Name: "test"},
+		})
+		defer func() { _ = p.Close() }()
+
+		got := mcpappsBrandName(p)
+		if got != "" {
+			t.Errorf("mcpappsBrandName() = %q, want empty", got)
+		}
+	})
+
+	t.Run("returns empty when brand_name not in config", func(t *testing.T) {
+		p := newTestPlatform(t, &platform.Config{
+			Server: platform.ServerConfig{Name: "test"},
+			MCPApps: platform.MCPAppsConfig{
+				Apps: map[string]platform.AppConfig{
+					"platform-info": {
+						Config: map[string]any{"other_key": "value"},
+					},
+				},
+			},
+		})
+		defer func() { _ = p.Close() }()
+
+		got := mcpappsBrandName(p)
+		if got != "" {
+			t.Errorf("mcpappsBrandName() = %q, want empty", got)
+		}
+	})
+}

configs/platform.yaml

@@ -319,6 +319,10 @@ tuning:
 #   public_base_url: "https://portal.example.com"
 #   s3_connection: data_lake                                   # S3 toolkit instance for artifact storage
 #   s3_bucket: portal-assets                                   # bucket for artifact storage
+#   implementor:                                               # optional implementor brand (far-left header zone)
+#     name: "ACME Corp"
+#     logo: "https://acme.com/logo.svg"
+#     url: "https://acme.com"
 
 # Admin REST API
 # admin:

pkg/platform/config.go

@@ -113,9 +113,18 @@ type PortalConfig struct {
 	S3Prefix       string                `yaml:"s3_prefix"`        // key prefix within the bucket
 	PublicBaseURL  string                `yaml:"public_base_url"`  // base URL for portal links (e.g., "https://portal.example.com")
 	MaxContentSize int                   `yaml:"max_content_size"` // max artifact size in bytes (default: 10MB)
+	Implementor    ImplementorConfig     `yaml:"implementor"`      // optional implementor brand (far-left header zone)
 	RateLimit      PortalRateLimitConfig `yaml:"rate_limit"`
 }
 
+// ImplementorConfig configures the optional implementor brand shown in the
+// far-left zone of the public viewer header (e.g., "ACME Corp").
+type ImplementorConfig struct {
+	Name string `yaml:"name"` // display name (e.g., "ACME Corp")
+	Logo string `yaml:"logo"` // URL to logo SVG (fetched at startup for inline rendering)
+	URL  string `yaml:"url"`  // link URL (e.g., "https://acme.com")
+}
+
 // PortalRateLimitConfig configures rate limiting for the public portal viewer.
 type PortalRateLimitConfig struct {
 	RequestsPerMinute int `yaml:"requests_per_minute"` // default: 60

pkg/platform/platform.go

@@ -125,10 +125,13 @@ type Platform struct {
 	knowledgeDataHubWriter  knowledgekit.DataHubWriter
 
 	// Portal stores (exposed for REST API in Phase 3)
-	portalAssetStore  portal.AssetStore
-	portalShareStore  portal.ShareStore
-	portalS3Client    portal.S3Client
-	provenanceTracker *middleware.ProvenanceTracker
+	portalAssetStore        portal.AssetStore
+	portalShareStore        portal.ShareStore
+	portalS3Client          portal.S3Client
+	provenanceTracker       *middleware.ProvenanceTracker
+	resolvedBrandLogoSVG    string // cached SVG from portal.logo or mcpapps config
+	resolvedBrandURL        string // cached brand_url from mcpapps platform-info config
+	resolvedImplementorLogo string // cached SVG fetched from portal.implementor.logo
 
 	// Workflow gating
 	workflowTracker *middleware.SessionWorkflowTracker
@@ -981,23 +984,40 @@ func (p *Platform) registerBuiltinPlatformInfo() error {
 // explicitly. When the logo is an SVG URL, it is fetched and inlined as
 // logo_svg so the logo renders in sandboxed contexts (MCP App iframes)
 // that block external resource loading.
+//
+// Also caches brand_url from the app config for use by BrandURL().
 func (p *Platform) injectPortalLogo(cfg any) any {
+	m, ok := cfg.(map[string]any)
+	if !ok {
+		m = make(map[string]any)
+	}
+
+	// Cache brand_url from the mcpapps platform-info config.
+	if brandURL, _ := m["brand_url"].(string); brandURL != "" {
+		p.resolvedBrandURL = brandURL
+	}
+
 	portalLogo := p.config.Portal.Logo
 	if portalLogo == "" {
-		return cfg
+		// Still cache logo_svg if present in the app config.
+		if svg, _ := m["logo_svg"].(string); svg != "" {
+			p.resolvedBrandLogoSVG = svg
+		}
+		return m
 	}
 
-	m, ok := cfg.(map[string]any)
-	if !ok {
-		m = make(map[string]any)
+	if svg, _ := m["logo_svg"].(string); svg != "" {
+		p.resolvedBrandLogoSVG = svg
+		return m
 	}
-	if m["logo_svg"] != nil || m["logo_url"] != nil {
+	if m["logo_url"] != nil {
 		return m
 	}
 
 	// Fetch SVG content for inline rendering; fall back to URL on failure.
 	if svg, err := fetchLogoSVG(portalLogo); err == nil {
 		m["logo_svg"] = svg
+		p.resolvedBrandLogoSVG = svg
 	} else {
 		slog.Debug("portal logo fetch failed, using URL", "url", portalLogo, "err", err)
 		m["logo_url"] = portalLogo
@@ -1706,6 +1726,39 @@ func (p *Platform) PortalS3Client() portal.S3Client {
 	return p.portalS3Client
 }
 
+// BrandLogoSVG returns the resolved brand logo SVG content (from portal.logo
+// or mcpapps platform-info config), or empty string if none is configured.
+func (p *Platform) BrandLogoSVG() string {
+	return p.resolvedBrandLogoSVG
+}
+
+// BrandURL returns the resolved brand URL from the mcpapps platform-info
+// config (brand_url), or empty string if not configured.
+func (p *Platform) BrandURL() string {
+	return p.resolvedBrandURL
+}
+
+// ResolveImplementorLogo fetches the implementor logo SVG from the URL
+// configured in portal.implementor.logo. The result is cached so subsequent
+// calls return the same value without another HTTP request. Returns empty
+// string if no logo URL is configured or the fetch fails.
+func (p *Platform) ResolveImplementorLogo() string {
+	logoURL := p.config.Portal.Implementor.Logo
+	if logoURL == "" {
+		return ""
+	}
+	if p.resolvedImplementorLogo != "" {
+		return p.resolvedImplementorLogo
+	}
+	svg, err := fetchLogoSVG(logoURL)
+	if err != nil {
+		slog.Debug("implementor logo fetch failed", "url", logoURL, "err", err)
+		return ""
+	}
+	p.resolvedImplementorLogo = svg
+	return svg
+}
+
 // BrowserSessionFlow returns the OIDC login flow, or nil if browser sessions are disabled.
 func (p *Platform) BrowserSessionFlow() *browsersession.Flow {
 	return p.browserSessionFlow

pkg/platform/platform_test.go

@@ -3870,6 +3870,101 @@ func TestFetchLogoSVG(t *testing.T) {
 	})
 }
 
+func TestBrandURL(t *testing.T) {
+	t.Run("returns empty when not set", func(t *testing.T) {
+		p := &Platform{config: &Config{}}
+		if got := p.BrandURL(); got != "" {
+			t.Errorf("BrandURL() = %q, want empty", got)
+		}
+	})
+
+	t.Run("returns cached value from injectPortalLogo", func(t *testing.T) {
+		p := &Platform{config: &Config{}}
+		cfg := map[string]any{"brand_url": "https://example.com"}
+		_ = p.injectPortalLogo(cfg)
+		if got := p.BrandURL(); got != "https://example.com" {
+			t.Errorf("BrandURL() = %q, want %q", got, "https://example.com")
+		}
+	})
+}
+
+func TestInjectPortalLogo_CachesBrandURL(t *testing.T) {
+	t.Run("caches brand_url from config", func(t *testing.T) {
+		p := &Platform{config: &Config{}}
+		cfg := map[string]any{"brand_url": "https://platform.io"}
+		_ = p.injectPortalLogo(cfg)
+		if p.resolvedBrandURL != "https://platform.io" {
+			t.Errorf("resolvedBrandURL = %q, want %q", p.resolvedBrandURL, "https://platform.io")
+		}
+	})
+
+	t.Run("caches brand_url even without portal logo", func(t *testing.T) {
+		p := &Platform{config: &Config{}} // no Portal.Logo
+		cfg := map[string]any{"brand_url": "https://noportallogo.io", "logo_svg": "<svg/>"}
+		_ = p.injectPortalLogo(cfg)
+		if p.resolvedBrandURL != "https://noportallogo.io" {
+			t.Errorf("resolvedBrandURL = %q, want %q", p.resolvedBrandURL, "https://noportallogo.io")
+		}
+		// Also verify logo_svg was cached even without portal.Logo
+		if p.resolvedBrandLogoSVG != "<svg/>" {
+			t.Errorf("resolvedBrandLogoSVG = %q, want %q", p.resolvedBrandLogoSVG, "<svg/>")
+		}
+	})
+
+	t.Run("does not set brand_url when absent", func(t *testing.T) {
+		p := &Platform{config: &Config{}}
+		cfg := map[string]any{"brand_name": "Test"}
+		_ = p.injectPortalLogo(cfg)
+		if p.resolvedBrandURL != "" {
+			t.Errorf("resolvedBrandURL = %q, want empty", p.resolvedBrandURL)
+		}
+	})
+}
+
+func TestResolveImplementorLogo(t *testing.T) {
+	svgContent := `<svg viewBox="0 0 32 32"><rect width="32" height="32"/></svg>`
+
+	t.Run("fetches and caches SVG", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			w.Header().Set("Content-Type", "image/svg+xml")
+			_, _ = w.Write([]byte(svgContent))
+		}))
+		defer srv.Close()
+
+		p := &Platform{config: &Config{
+			Portal: PortalConfig{Implementor: ImplementorConfig{Logo: srv.URL + "/impl.svg"}},
+		}}
+
+		got := p.ResolveImplementorLogo()
+		if got != svgContent {
+			t.Errorf("ResolveImplementorLogo() = %q, want %q", got, svgContent)
+		}
+
+		// Second call should return cached value (no HTTP request)
+		srv.Close()
+		got2 := p.ResolveImplementorLogo()
+		if got2 != svgContent {
+			t.Errorf("cached ResolveImplementorLogo() = %q, want %q", got2, svgContent)
+		}
+	})
+
+	t.Run("returns empty when logo URL is empty", func(t *testing.T) {
+		p := &Platform{config: &Config{}}
+		if got := p.ResolveImplementorLogo(); got != "" {
+			t.Errorf("ResolveImplementorLogo() = %q, want empty", got)
+		}
+	})
+
+	t.Run("returns empty on fetch failure", func(t *testing.T) {
+		p := &Platform{config: &Config{
+			Portal: PortalConfig{Implementor: ImplementorConfig{Logo: "http://127.0.0.1:1/unreachable.svg"}},
+		}}
+		if got := p.ResolveImplementorLogo(); got != "" {
+			t.Errorf("ResolveImplementorLogo() = %q, want empty on fetch failure", got)
+		}
+	})
+}
+
 func TestNew_WorkflowGatingDisabled(t *testing.T) {
 	cfg := &Config{
 		Server:   ServerConfig{Name: testServerName},

pkg/portal/handler.go

@@ -63,6 +63,15 @@ type Deps struct {
 	AuditMetrics    AuditMetrics
 	InsightStore    InsightReader
 	PersonaResolver PersonaResolver
+	// Platform brand (far right of public viewer header)
+	BrandName    string // display name (default: "MCP Data Platform")
+	BrandLogoSVG string // inline SVG for header logo (empty = default icon)
+	BrandURL     string // link URL (e.g., "https://plexara.io"); empty = no link
+
+	// Implementor brand (far left of public viewer header, optional)
+	ImplementorName    string // display name (e.g., "ACME Corp"); empty = hidden
+	ImplementorLogoSVG string // inline SVG; empty = hidden
+	ImplementorURL     string // link URL; empty = no link
 }
 
 // Handler provides portal REST API endpoints.