sonance-brand-mcp 1.2.5 → 1.3.1

package/dist/index.js

@@ -306,6 +306,76 @@ function getAssetPath(assetType) {
         }
     }
 }
+// ============================================
+// LOGO PATH RESOLUTION
+// ============================================
+/**
+ * Resolve a logo path to an absolute file path
+ * Handles both bundled and dev mode, with path sanitization
+ */
+function resolveLogoPath(logoPath) {
+    // Sanitize path to prevent directory traversal
+    const sanitized = logoPath
+        .replace(/^\/+/, '') // Remove leading slashes
+        .replace(/\.{2,}/g, '') // Remove .. sequences
+        .replace(/\/+/g, '/'); // Normalize multiple slashes
+    // Remove "logos/" prefix if present (manifest has /logos/xxx format)
+    const normalizedPath = sanitized.replace(/^logos\//, '');
+    if (IS_BUNDLED) {
+        // In bundled mode, logos are in dist/assets/logos/
+        const logosDir = path.join(BUNDLED_ASSETS, "logos");
+        return path.join(logosDir, normalizedPath);
+    }
+    else {
+        // In dev mode, logos are in public/logos/
+        const logosDir = path.join(DEV_PROJECT_ROOT, "public/logos");
+        return path.join(logosDir, normalizedPath);
+    }
+}
+/**
+ * Get MIME type for image file based on extension
+ */
+function getImageMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.png': return 'image/png';
+        case '.jpg':
+        case '.jpeg': return 'image/jpeg';
+        case '.svg': return 'image/svg+xml';
+        case '.gif': return 'image/gif';
+        case '.webp': return 'image/webp';
+        default: return 'application/octet-stream';
+    }
+}
+/**
+ * Embed a logo as base64 image content for MCP responses
+ * Returns an MCP-compatible image content block or null if logo not found
+ */
+async function embedLogo(logoPath) {
+    try {
+        const resolvedPath = resolveLogoPath(logoPath);
+        if (!resolvedPath)
+            return null;
+        // Check if file exists
+        if (!fs.existsSync(resolvedPath)) {
+            console.error(`Logo not found: ${resolvedPath}`);
+            return null;
+        }
+        // Read file as base64
+        const fileBuffer = fs.readFileSync(resolvedPath);
+        const base64Data = fileBuffer.toString('base64');
+        const mimeType = getImageMimeType(resolvedPath);
+        return {
+            type: "image",
+            data: base64Data,
+            mimeType,
+        };
+    }
+    catch (error) {
+        console.error(`Error embedding logo: ${error}`);
+        return null;
+    }
+}
 /**
  * Detect output type from user's request/prompt
  */
@@ -545,6 +615,50 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
     catch (e) {
         // Components directory might not exist
     }
+    // Add logo resources
+    try {
+        let logoList;
+        if (IS_BUNDLED) {
+            const manifestPath = getAssetPath("logos");
+            logoList = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        }
+        else {
+            // Scan directory in development
+            const logosDir = getAssetPath("logos");
+            function listLogoFiles(dir, prefix = "") {
+                let results = [];
+                if (!fs.existsSync(dir))
+                    return results;
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        results = [...results, ...listLogoFiles(path.join(dir, entry.name), `${prefix}${entry.name}/`)];
+                    }
+                    else if (/\.(png|svg|jpg|jpeg)$/i.test(entry.name)) {
+                        results.push(`/logos/${prefix}${entry.name}`);
+                    }
+                }
+                return results;
+            }
+            logoList = listLogoFiles(logosDir);
+        }
+        for (const logoPath of logoList) {
+            // Convert /logos/sonance/file.png to sonance/file.png for URI
+            const uriPath = logoPath.replace(/^\/logos\//, '');
+            const fileName = path.basename(logoPath, path.extname(logoPath));
+            const folder = path.dirname(uriPath);
+            const mimeType = getImageMimeType(logoPath);
+            resources.push({
+                uri: `sonance://logo/${uriPath}`,
+                name: `${fileName} Logo`,
+                description: `${folder !== '.' ? folder + ' - ' : ''}Brand logo image file`,
+                mimeType: mimeType,
+            });
+        }
+    }
+    catch (e) {
+        // Logo resources might not be available
+    }
     return { resources };
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
@@ -572,6 +686,24 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             };
         }
     }
+    // Handle logo resources
+    if (uri.startsWith("sonance://logo/")) {
+        const logoPath = uri.replace("sonance://logo/", "");
+        const resolvedPath = resolveLogoPath(logoPath);
+        if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+            throw new Error(`Logo not found: ${logoPath}`);
+        }
+        const imageBuffer = fs.readFileSync(resolvedPath);
+        const base64Data = imageBuffer.toString('base64');
+        const mimeType = getImageMimeType(resolvedPath);
+        return {
+            contents: [{
+                    uri,
+                    mimeType,
+                    blob: base64Data, // Use blob for binary resources
+                }],
+        };
+    }
     throw new Error(`Resource not found: ${uri}`);
 });
 // ============================================
@@ -639,6 +771,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: [],
                 },
             },
+            {
+                name: "get_logo",
+                description: "Returns a brand logo image as base64-encoded data that AI can view and analyze. Use list_logos first to see available logos, then use this tool to retrieve the actual image.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        logo_path: {
+                            type: "string",
+                            description: "The path to the logo from list_logos output (e.g., '/logos/sonance/Sonance_Logo_2C_Dark_RGB.png' or 'sonance/Sonance_Logo_2C_Dark_RGB.png')",
+                        },
+                    },
+                    required: ["logo_path"],
+                },
+            },
             {
                 name: "get_full_library",
                 description: "RECOMMENDED FOR APP REDESIGNS & FULL APPLICATIONS: Returns the complete component library including brand guidelines, CSS theme, utilities, and all component source code. USE THIS TOOL when the user asks to: redesign an application, rebrand an app, build a full application, update an entire codebase to use Sonance/IPORT/Blaze brand, or any multi-file/multi-component project. This is the go-to tool for comprehensive brand implementation across an entire project.",
@@ -650,7 +796,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "design_component",
-                description: "Returns brand-specific design tokens, colors, implementation rules, and logo assets for designing a component. Smart defaults: Sonance/Light/Default logo lockup if not specified. Auto-detects output type (ui/doc/marketing/tech) if not specified.",
+                description: "Returns brand-specific design tokens, colors, implementation rules, and AUTO-EMBEDS the correct logo image(s) for designing a component. For UI outputs, embeds both light and dark theme logos. Smart defaults: Sonance+James+IPORT lockup as default logo. Auto-detects output type (ui/doc/marketing/tech).",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -666,8 +812,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         },
                         logo_preference: {
                             type: "string",
-                            enum: ["default", "sonance", "iport", "blaze"],
-                            description: "Which logo to use. 'default' = Sonance+James+IPORT lockup. Or specify 'sonance', 'iport', or 'blaze' for individual brand logos. Defaults to 'default' if not specified.",
+                            enum: ["default", "sonance", "iport", "blaze", "james"],
+                            description: "Which logo to use. 'default' = Sonance+James+IPORT lockup. Or specify 'sonance', 'iport', 'blaze', or 'james' for individual brand logos. Defaults to 'default' if not specified.",
                         },
                         output_type: {
                             type: "string",
@@ -755,7 +901,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "rebrand_document",
-                description: "Returns universal rebranding instructions for converting ANY existing document to a specific brand (Sonance, IPORT, or Blaze). Works with any document format - provides color replacements, font substitutions, and logo placement rules that apply regardless of document structure.",
+                description: "Returns universal rebranding instructions for converting ANY existing document to a specific brand (Sonance, IPORT, or Blaze) and AUTO-EMBEDS both light and dark logo variants for immediate use. Provides color replacements, font substitutions, and logo placement rules. Default: Sonance+James+IPORT lockup for Sonance brand.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -941,6 +1087,66 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
         }
+        case "get_logo": {
+            const logoPath = args.logo_path;
+            if (!logoPath) {
+                return {
+                    content: [{ type: "text", text: "Error: logo_path is required. Use list_logos to see available logos." }],
+                    isError: true,
+                };
+            }
+            try {
+                const resolvedPath = resolveLogoPath(logoPath);
+                if (!resolvedPath) {
+                    return {
+                        content: [{ type: "text", text: `Error: Invalid logo path: ${logoPath}` }],
+                        isError: true,
+                    };
+                }
+                if (!fs.existsSync(resolvedPath)) {
+                    // Try to help user find the right logo
+                    let suggestion = '\n\nUse list_logos to see available logos.';
+                    if (IS_BUNDLED) {
+                        try {
+                            const manifestPath = getAssetPath("logos");
+                            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+                            suggestion = `\n\nAvailable logos include:\n${manifest.slice(0, 5).map((p) => `  - ${p}`).join('\n')}\n  ... and ${manifest.length - 5} more. Use list_logos to see all.`;
+                        }
+                        catch {
+                            // Keep default suggestion
+                        }
+                    }
+                    return {
+                        content: [{ type: "text", text: `Error: Logo not found: ${logoPath}${suggestion}` }],
+                        isError: true,
+                    };
+                }
+                // Read and encode the image
+                const imageBuffer = fs.readFileSync(resolvedPath);
+                const base64Data = imageBuffer.toString('base64');
+                const mimeType = getImageMimeType(resolvedPath);
+                const fileName = path.basename(resolvedPath);
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: base64Data,
+                            mimeType: mimeType,
+                        },
+                        {
+                            type: "text",
+                            text: `**Logo:** ${fileName}\n**Path:** ${logoPath}\n**Size:** ${imageBuffer.length} bytes\n**Format:** ${mimeType}`,
+                        },
+                    ],
+                };
+            }
+            catch (e) {
+                return {
+                    content: [{ type: "text", text: `Error reading logo: ${e}` }],
+                    isError: true,
+                };
+            }
+        }
         case "get_full_library": {
             try {
                 let fullLibrary = "# Sonance Component Library\n\n";
@@ -1044,11 +1250,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     light: "/logos/blaze/BlazeBySonance_Logo_Lockup_3C_Dark_RGB_05162025.png",
                     dark: "/logos/blaze/BlazeBySonance_Logo_Lockup_2C_Light_RGB_05162025.png",
                 },
+                james: {
+                    light: "/logos/james/James_Logo_Black_RGB.png",
+                    dark: "/logos/james/James_Logo_Reverse_RGB.png",
+                },
             };
             const logoPath = logoMap[logoPreference]?.[theme] || logoMap.default[theme];
             const logoPreferenceLabel = logoPreference === "default"
                 ? "Sonance + James + IPORT Lockup"
-                : `${logoPreference.charAt(0).toUpperCase() + logoPreference.slice(1)} Only`;
+                : logoPreference === "james"
+                    ? "James Only"
+                    : `${logoPreference.charAt(0).toUpperCase() + logoPreference.slice(1)} Only`;
             // Brand-specific design tokens
             const brandTokens = {
                 sonance: {
@@ -1524,8 +1736,35 @@ ${outputTypeGuidance[detectedOutputType]}
 
 Now design the **${component_description}** following these tokens and principles.`;
             }
+            // Embed logos in response
+            const contentBlocks = [];
+            if (isDualThemeMode) {
+                // Dual-theme mode: embed both light and dark theme logos
+                const lightLogoPath = logoMap[logoPreference]?.light || logoMap.default.light;
+                const darkLogoPath = logoMap[logoPreference]?.dark || logoMap.default.dark;
+                const lightLogo = await embedLogo(lightLogoPath);
+                const darkLogo = await embedLogo(darkLogoPath);
+                if (lightLogo) {
+                    contentBlocks.push({ type: "text", text: `## Logo for Light Backgrounds\n**Path:** \`${lightLogoPath}\`` });
+                    contentBlocks.push(lightLogo);
+                }
+                if (darkLogo) {
+                    contentBlocks.push({ type: "text", text: `## Logo for Dark Backgrounds\n**Path:** \`${darkLogoPath}\`` });
+                    contentBlocks.push(darkLogo);
+                }
+            }
+            else {
+                // Single-theme mode: embed the appropriate logo
+                const embeddedLogo = await embedLogo(logoPath);
+                if (embeddedLogo) {
+                    contentBlocks.push({ type: "text", text: `## Brand Logo (${theme === "light" ? "for Light Backgrounds" : "for Dark Backgrounds"})\n**Path:** \`${logoPath}\`` });
+                    contentBlocks.push(embeddedLogo);
+                }
+            }
+            // Add the main response text
+            contentBlocks.push({ type: "text", text: response });
             return {
-                content: [{ type: "text", text: response }],
+                content: contentBlocks,
             };
         }
         case "evaluate_design": {
@@ -2668,8 +2907,40 @@ ${rebrandArgs.source_format === "word" ? `
 
 **Remember:** The goal is to make the document unmistakably ${palette.name} while preserving its original structure and content.
 `;
+            // Embed logos for rebrand_document
+            // Use the Sonance+James+IPORT lockup as default for Sonance brand
+            const rebrandLogoMap = {
+                sonance: {
+                    light: "/logos/sonance-james-iport/Sonance_James_IPORT_Lockup_Dark.png",
+                    dark: "/logos/sonance-james-iport/Sonance_James_IPORT_Lockup_Light.png",
+                },
+                iport: {
+                    light: "/logos/iport/IPORT_Sonance_LockUp_2C_Dark_RGB.png",
+                    dark: "/logos/iport/IPORT_Sonance_LockUp_2C_Light_RGB.png",
+                },
+                blaze: {
+                    light: "/logos/blaze/BlazeBySonance_Logo_Lockup_3C_Dark_RGB_05162025.png",
+                    dark: "/logos/blaze/BlazeBySonance_Logo_Lockup_2C_Light_RGB_05162025.png",
+                },
+            };
+            const rebrandContentBlocks = [];
+            // For documents, provide both light and dark logo variants
+            const lightLogoPath = rebrandLogoMap[targetBrand].light;
+            const darkLogoPath = rebrandLogoMap[targetBrand].dark;
+            const lightLogo = await embedLogo(lightLogoPath);
+            const darkLogo = await embedLogo(darkLogoPath);
+            if (lightLogo) {
+                rebrandContentBlocks.push({ type: "text", text: `## Logo for Light Backgrounds\n**Use on white/light document backgrounds**\n**Path:** \`${lightLogoPath}\`` });
+                rebrandContentBlocks.push(lightLogo);
+            }
+            if (darkLogo) {
+                rebrandContentBlocks.push({ type: "text", text: `## Logo for Dark Backgrounds\n**Use on dark/colored document backgrounds**\n**Path:** \`${darkLogoPath}\`` });
+                rebrandContentBlocks.push(darkLogo);
+            }
+            // Add the main guide text
+            rebrandContentBlocks.push({ type: "text", text: rebrandGuide });
             return {
-                content: [{ type: "text", text: rebrandGuide }],
+                content: rebrandContentBlocks,
             };
         }
         default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonance-brand-mcp",
-  "version": "1.2.5",
+  "version": "1.3.1",
   "description": "MCP Server for Sonance Brand Guidelines and Component Library - gives Claude instant access to brand colors, typography, and UI components.",
   "main": "dist/index.js",
   "type": "module",