multisite-cms-mcp 1.2.3 → 1.3.0

package/dist/tools/validate-package.js

@@ -14,36 +14,34 @@ async function validatePackage(fileList, manifestContent, templateContents) {
     const hasManifest = fileList.some(f => f === 'manifest.json' || f.endsWith('/manifest.json'));
     const hasPagesFolder = fileList.some(f => f.includes('pages/'));
     const hasPublicFolder = fileList.some(f => f.includes('public/'));
-    // Note: Templates folder is optional - only needed for CMS pages
-    // Check is performed but variable not stored since it's informational only
     if (!hasManifest) {
         errors.push('- Missing manifest.json at package root');
     }
     else {
-        validations.push('✓ manifest.json found');
+        validations.push('manifest.json found');
     }
     if (!hasPagesFolder) {
         warnings.push('- No pages/ folder found - static pages should be in pages/');
     }
     else {
-        validations.push('✓ pages/ folder found');
+        validations.push('pages/ folder found');
     }
     if (!hasPublicFolder) {
         warnings.push('- No public/ folder found - assets (CSS, JS, images) should be in public/');
     }
     else {
-        validations.push('✓ public/ folder found');
+        validations.push('public/ folder found');
     }
     // 2. Validate manifest
     const manifestResult = await (0, validate_manifest_1.validateManifest)(manifestContent);
-    if (manifestResult.startsWith('❌')) {
+    if (manifestResult.includes('INVALID')) {
         errors.push('- Manifest validation failed (see details below)');
     }
-    else if (manifestResult.startsWith('⚠️')) {
+    else if (manifestResult.includes('WARNINGS')) {
         warnings.push('- Manifest has warnings (see details below)');
     }
     else {
-        validations.push('✓ manifest.json is valid');
+        validations.push('manifest.json is valid');
     }
     // 3. Parse manifest for template checks
     let manifest = null;
@@ -65,19 +63,25 @@ async function validatePackage(fileList, manifestContent, templateContents) {
             }
         }
     }
-    // 5. Check CMS template files exist
+    // 5. Check CMS template files exist (detect custom collections from manifest)
     if (manifest?.cmsTemplates) {
-        const templateFields = ['blogIndex', 'blogPost', 'team', 'downloads', 'authorsIndex', 'authorDetail'];
-        for (const field of templateFields) {
-            const templateFile = manifest.cmsTemplates[field];
-            if (templateFile) {
-                const fileExists = fileList.some(f => f === templateFile || f.endsWith('/' + templateFile));
-                if (!fileExists) {
-                    errors.push(`- Template file not found: ${templateFile} (cmsTemplates.${field})`);
-                }
-                else {
-                    validations.push(`✓ ${field} template exists`);
-                }
+        const templates = manifest.cmsTemplates;
+        const checkedTemplates = new Set();
+        for (const [key, value] of Object.entries(templates)) {
+            // Skip path keys and non-string values
+            if (key.endsWith('Path') || typeof value !== 'string' || !value.endsWith('.html')) {
+                continue;
+            }
+            // Avoid duplicate checks
+            if (checkedTemplates.has(value))
+                continue;
+            checkedTemplates.add(value);
+            const fileExists = fileList.some(f => f === value || f.endsWith('/' + value));
+            if (!fileExists) {
+                errors.push(`- Template file not found: ${value} (cmsTemplates.${key})`);
+            }
+            else {
+                validations.push(`${key} template exists`);
             }
         }
     }
@@ -85,31 +89,32 @@ async function validatePackage(fileList, manifestContent, templateContents) {
     const templateValidations = [];
     if (templateContents) {
         for (const [path, content] of Object.entries(templateContents)) {
+            // Determine template type based on path
             let templateType = 'static_page';
-            if (path.includes('blog_index') || path.includes('insights_index') || path.includes('news_index')) {
-                templateType = 'blog_index';
+            // Check if it's an index template
+            if (path.includes('_index') || path.includes('-index')) {
+                templateType = 'custom_index';
             }
-            else if (path.includes('blog_post') || path.includes('insights_detail') || path.includes('news_detail')) {
-                templateType = 'blog_post';
+            // Check if it's a detail template
+            else if (path.includes('_detail') || path.includes('-detail') || path.includes('_post') || path.includes('-post')) {
+                templateType = 'custom_detail';
             }
-            else if (path.includes('team')) {
-                templateType = 'team';
-            }
-            else if (path.includes('download')) {
-                templateType = 'downloads';
-            }
-            else if (path.includes('author') && path.includes('index')) {
-                templateType = 'authors_index';
-            }
-            else if (path.includes('author') && path.includes('detail')) {
-                templateType = 'author_detail';
+            // Check if it's in templates/ folder (likely a CMS template)
+            else if (path.includes('templates/')) {
+                // If it has collection-like patterns
+                if (content.includes('{{#each')) {
+                    templateType = 'custom_index';
+                }
+                else if (content.includes('{{name}}') || content.includes('{{slug}}')) {
+                    templateType = 'custom_detail';
+                }
             }
             const result = await (0, validate_template_1.validateTemplate)(content, templateType);
-            if (result.startsWith('❌')) {
+            if (result.includes('ERRORS')) {
                 errors.push(`- Template ${path} has errors`);
                 templateValidations.push(`\n### ${path}\n${result}`);
             }
-            else if (result.startsWith('⚠️')) {
+            else if (result.includes('WARNINGS')) {
                 warnings.push(`- Template ${path} has warnings`);
                 templateValidations.push(`\n### ${path}\n${result}`);
             }
@@ -141,9 +146,9 @@ async function validatePackage(fileList, manifestContent, templateContents) {
     // Build result
     let output = '';
     if (errors.length === 0) {
-        output = `✅ PACKAGE STRUCTURE VALID
+        output = `PACKAGE STRUCTURE VALID
 
-${validations.join('\n')}
+${validations.map(v => `- ${v}`).join('\n')}
 
 Summary:
 - ${htmlFiles.length} HTML file(s)
@@ -158,13 +163,13 @@ ${warnings.join('\n')}`;
         }
     }
     else {
-        output = `❌ PACKAGE HAS ERRORS
+        output = `PACKAGE HAS ERRORS
 
 Errors (must fix):
 ${errors.join('\n')}
 
 What passed:
-${validations.join('\n')}`;
+${validations.map(v => `- ${v}`).join('\n')}`;
         if (warnings.length > 0) {
             output += `
 

package/dist/tools/validate-template.d.ts

@@ -1,9 +1,9 @@
-type TemplateType = 'blog_index' | 'blog_post' | 'team' | 'downloads' | 'authors_index' | 'author_detail' | 'custom_index' | 'custom_detail' | 'static_page';
+type TemplateType = 'custom_index' | 'custom_detail' | 'static_page';
 /**
  * Validates an HTML template for correct CMS token usage
  *
  * @param html - The HTML template content
- * @param templateType - The type of template
+ * @param templateType - The type of template (custom_index, custom_detail, static_page)
  * @param collectionSlug - For custom collections, the collection slug
  * @param projectId - Optional: Project ID or name to validate against actual schema
  */

package/dist/tools/validate-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-template.d.ts","sourceRoot":"","sources":["../../src/tools/validate-template.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,aAAa,CAAC;AA6O7J;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CA4ZjB"}
+{"version":3,"file":"validate-template.d.ts","sourceRoot":"","sources":["../../src/tools/validate-template.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG,cAAc,GAAG,eAAe,GAAG,aAAa,CAAC;AAmJrE;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAoXjB"}

package/dist/tools/validate-template.js

@@ -2,73 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTemplate = validateTemplate;
 const api_client_1 = require("../lib/api-client");
-const BLOG_FIELDS = [
-    { name: 'name', isRichText: false, isRequired: true },
-    { name: 'slug', isRichText: false, isRequired: true },
-    { name: 'mainImage', isRichText: false },
-    { name: 'thumbnailImage', isRichText: false },
-    { name: 'postSummary', isRichText: false },
-    { name: 'postBody', isRichText: true },
-    { name: 'featured', isRichText: false },
-    { name: 'publishedAt', isRichText: false },
-    { name: 'url', isRichText: false },
-];
-const AUTHOR_FIELDS = [
-    { name: 'name', isRichText: false, isRequired: true },
-    { name: 'slug', isRichText: false, isRequired: true },
-    { name: 'bio', isRichText: true },
-    { name: 'picture', isRichText: false },
-    { name: 'email', isRichText: false },
-    { name: 'twitterProfileLink', isRichText: false },
-    { name: 'linkedinProfileLink', isRichText: false },
-    { name: 'url', isRichText: false },
-];
-const TEAM_FIELDS = [
-    { name: 'name', isRichText: false, isRequired: true },
-    { name: 'slug', isRichText: false },
-    { name: 'role', isRichText: false },
-    { name: 'bio', isRichText: true },
-    { name: 'photo', isRichText: false },
-    { name: 'email', isRichText: false },
-    { name: 'order', isRichText: false },
-];
-const DOWNLOAD_FIELDS = [
-    { name: 'title', isRichText: false, isRequired: true },
-    { name: 'slug', isRichText: false },
-    { name: 'description', isRichText: false },
-    { name: 'fileUrl', isRichText: false },
-    { name: 'category', isRichText: false },
-    { name: 'order', isRichText: false },
-];
-// Common wrong field names and their corrections
-const COMMON_MISTAKES = {
-    'title': 'name (for blog posts) or title (for downloads)',
-    'body': 'postBody',
-    'content': 'postBody',
-    'excerpt': 'postSummary',
-    'summary': 'postSummary',
-    'image': 'mainImage or thumbnailImage',
-    'coverImage': 'mainImage',
-    'coverImageUrl': 'mainImage',
-    'heroImage': 'mainImage',
-    'thumbnail': 'thumbnailImage',
-    'date': 'publishedAt',
-    'createdAt': 'publishedAt',
-    'author_name': 'author.name',
-    'authorName': 'author.name',
-    'link': 'url',
-    'href': 'url',
-    'headshot': 'photo (for team) or picture (for authors)',
-    'headshotUrl': 'photo (for team) or picture (for authors)',
-    'position': 'role',
-    'jobTitle': 'role',
-};
-// Built-in collection standard fields (not including custom fields)
-const BUILTIN_STANDARD_FIELDS = {
-    blogs: ['name', 'slug', 'mainImage', 'thumbnailImage', 'postSummary', 'postBody', 'featured', 'publishedAt', 'author', 'url'],
-    authors: ['name', 'slug', 'bio', 'picture', 'email', 'twitterProfileLink', 'linkedinProfileLink', 'url'],
-    team: ['name', 'slug', 'role', 'bio', 'photo', 'email', 'order'],
-    downloads: ['title', 'slug', 'description', 'fileUrl', 'category', 'order'],
+// Common wrong field names and suggestions (generic)
+const COMMON_SUGGESTIONS = {
+    'body': 'Consider using a descriptive name like "content" or "description"',
+    'content': 'Good field name - make sure it exists in your collection',
+    'image': 'Consider using a descriptive name like "heroImage", "thumbnail", etc.',
+    'link': 'Use "url" as the field name for links',
+    'href': 'Use "url" as the field name for links',
+    'date': 'Use "publishedAt" (auto-tracked) or define a custom date field',
 };
 /**
  * Resolve project identifier to tenant ID
@@ -95,17 +36,8 @@ async function fetchTenantSchema(tenantId) {
     if ((0, api_client_1.isApiError)(collectionsRes)) {
         return null;
     }
-    // Fetch builtin collection fields
-    const builtinRes = await (0, api_client_1.apiRequest)('/api/cms/builtin-collections', { tenantId });
-    const builtinFields = {};
-    if (!(0, api_client_1.isApiError)(builtinRes)) {
-        for (const bc of builtinRes.data) {
-            builtinFields[bc.type] = bc.fields;
-        }
-    }
     return {
         collections: collectionsRes.data,
-        builtinFields,
     };
 }
 /**
@@ -135,42 +67,41 @@ function extractTokenFieldNames(html) {
 /**
  * Check which fields are missing from schema
  */
-function findMissingFields(usedFields, collectionType, isBuiltin, schema) {
+function findMissingFields(usedFields, collectionType, schema) {
     const missing = [];
-    if (isBuiltin) {
-        // Check against builtin standard fields + custom fields
-        const standardFields = BUILTIN_STANDARD_FIELDS[collectionType] || [];
-        const customFields = schema.builtinFields[collectionType]?.map(f => f.slug) || [];
-        const allFields = [...standardFields, ...customFields];
+    // Check against custom collection fields
+    const collection = schema.collections.find(c => c.slug === collectionType);
+    if (collection) {
+        // Built-in fields available on all items
+        const builtInFields = ['name', 'slug', 'url', 'publishedAt', 'createdAt', 'updatedAt'];
+        const collectionFields = [...builtInFields, ...collection.fields.map(f => f.slug)];
         for (const field of usedFields) {
-            if (!allFields.includes(field)) {
+            if (!collectionFields.includes(field)) {
                 missing.push(field);
             }
         }
     }
     else {
-        // Check against custom collection fields
-        const collection = schema.collections.find(c => c.slug === collectionType);
-        if (collection) {
-            const collectionFields = ['name', 'slug', 'publishedAt', ...collection.fields.map(f => f.slug)];
-            for (const field of usedFields) {
-                if (!collectionFields.includes(field)) {
-                    missing.push(field);
-                }
-            }
-        }
-        else {
-            // Collection doesn't exist - all fields are "missing"
-            return usedFields;
-        }
+        // Collection doesn't exist - all fields except built-ins are "missing"
+        const builtInFields = ['name', 'slug', 'url', 'publishedAt', 'createdAt', 'updatedAt'];
+        return usedFields.filter(f => !builtInFields.includes(f));
     }
     return missing;
 }
+/**
+ * Get richText fields from collection
+ */
+function getRichTextFields(collectionSlug, schema) {
+    const collection = schema.collections.find(c => c.slug === collectionSlug);
+    if (!collection)
+        return [];
+    return collection.fields.filter(f => f.type === 'richText').map(f => f.slug);
+}
 /**
  * Validates an HTML template for correct CMS token usage
  *
  * @param html - The HTML template content
- * @param templateType - The type of template
+ * @param templateType - The type of template (custom_index, custom_detail, static_page)
  * @param collectionSlug - For custom collections, the collection slug
  * @param projectId - Optional: Project ID or name to validate against actual schema
  */
@@ -178,36 +109,7 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
     const errors = [];
     const warnings = [];
     const suggestions = [];
-    // Get expected fields based on template type
-    let expectedFields = [];
-    let collectionName = '';
-    switch (templateType) {
-        case 'blog_index':
-        case 'blog_post':
-            expectedFields = BLOG_FIELDS;
-            collectionName = 'blogs';
-            break;
-        case 'authors_index':
-        case 'author_detail':
-            expectedFields = AUTHOR_FIELDS;
-            collectionName = 'authors';
-            break;
-        case 'team':
-            expectedFields = TEAM_FIELDS;
-            collectionName = 'team';
-            break;
-        case 'downloads':
-            expectedFields = DOWNLOAD_FIELDS;
-            collectionName = 'downloads';
-            break;
-        case 'custom_index':
-        case 'custom_detail':
-            collectionName = collectionSlug || 'collection';
-            break;
-        case 'static_page':
-            // Static pages just use data-edit-key
-            break;
-    }
+    let richTextFields = [];
     // Extract all tokens from the HTML
     const doubleTokens = html.match(/\{\{([^{}#/]+)\}\}/g) || [];
     const tripleTokens = html.match(/\{\{\{([^{}]+)\}\}\}/g) || [];
@@ -219,38 +121,21 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
     if (tokensWithSpaces.length > 0 || tokensWithSpaces2.length > 0) {
         warnings.push('- Some tokens have spaces inside braces (e.g., {{ name }} instead of {{name}}). While supported, {{name}} without spaces is preferred.');
     }
-    // Check for common mistakes
+    // Check for common suggestions
     for (const token of doubleTokens) {
         const fieldName = token.replace(/\{\{|\}\}/g, '').trim();
         // Skip control structures
         if (fieldName.startsWith('#') || fieldName.startsWith('/') || fieldName === 'else' || fieldName.startsWith('@')) {
             continue;
         }
-        // Check against common mistakes
+        // Check against common suggestions
         const baseName = fieldName.split('.')[0];
-        if (COMMON_MISTAKES[baseName]) {
-            errors.push(`- Wrong token: {{${fieldName}}} → Use ${COMMON_MISTAKES[baseName]}`);
+        if (COMMON_SUGGESTIONS[baseName]) {
+            suggestions.push(`- Token {{${baseName}}}: ${COMMON_SUGGESTIONS[baseName]}`);
         }
     }
-    // Check richText fields are using triple braces
-    for (const field of expectedFields) {
-        if (field.isRichText) {
-            const doublePattern = new RegExp(`\\{\\{${field.name}\\}\\}`, 'g');
-            const triplePattern = new RegExp(`\\{\\{\\{${field.name}\\}\\}\\}`, 'g');
-            const hasDouble = doublePattern.test(html);
-            const hasTriple = triplePattern.test(html);
-            if (hasDouble && !hasTriple) {
-                errors.push(`- {{${field.name}}} must use triple braces {{{${field.name}}}} because it contains HTML`);
-            }
-        }
-    }
-    // Check for nested author fields in double braces (should be fine)
-    const authorBioDouble = /\{\{author\.bio\}\}/g.test(html);
-    if (authorBioDouble) {
-        errors.push('- {{author.bio}} must use triple braces {{{author.bio}}} because it contains HTML');
-    }
     // Check loop syntax for index templates
-    if (templateType.endsWith('_index') || templateType === 'team' || templateType === 'downloads') {
+    if (templateType === 'custom_index') {
         if (eachLoops.length === 0) {
             warnings.push(`- No {{#each}} loop found - index templates usually need a loop to display items`);
         }
@@ -260,8 +145,8 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
                 const match = loop.match(/\{\{#each\s+(\w+)/);
                 if (match) {
                     const usedCollection = match[1];
-                    if (collectionName && usedCollection !== collectionName) {
-                        warnings.push(`- Loop uses '${usedCollection}' but expected '${collectionName}'`);
+                    if (collectionSlug && usedCollection !== collectionSlug) {
+                        warnings.push(`- Loop uses '${usedCollection}' but expected '${collectionSlug}'`);
                     }
                 }
             }
@@ -302,6 +187,23 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
     if (wrongAssetPaths.length > 5) {
         warnings.push(`- ...and ${wrongAssetPaths.length - 5} more asset paths that may need /public/ prefix`);
     }
+    // Check YouTube iframes for required attributes
+    const allIframes = html.match(/<iframe[^>]*>/gi) || [];
+    for (const iframe of allIframes) {
+        const isYouTubeEmbed = /youtube\.com|youtu\.be/i.test(iframe);
+        const hasTemplateSrc = /src=["'][^"']*\{\{[^}]+\}\}[^"']*["']/i.test(iframe);
+        if (isYouTubeEmbed || hasTemplateSrc) {
+            if (!/referrerpolicy/i.test(iframe)) {
+                errors.push(`- YouTube iframe missing referrerpolicy attribute. Add: referrerpolicy="strict-origin-when-cross-origin" (without this, YouTube will show Error 153)`);
+            }
+            if (!/allowfullscreen/i.test(iframe)) {
+                warnings.push(`- iframe missing allowfullscreen attribute - fullscreen button won't work`);
+            }
+            if (!/title=/i.test(iframe)) {
+                suggestions.push(`- Consider adding a title attribute to iframe for accessibility`);
+            }
+        }
+    }
     // Validate site tokens
     const siteTokens = html.match(/\{\{site\.(\w+)\}\}/g) || [];
     for (const token of siteTokens) {
@@ -320,7 +222,6 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
     // Validate parent context references (../)
     const parentRefs = html.match(/\{\{\.\.\/([\w.]+)\}\}/g) || [];
     if (parentRefs.length > 0) {
-        // Check if they're used inside a loop
         if (eachLoops.length === 0) {
             warnings.push(`- Found ${parentRefs.length} parent reference(s) like {{../name}} but no {{#each}} loop - these only work inside loops`);
         }
@@ -332,7 +233,6 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
     const eqHelpers = html.match(/\{\{#if\s+\(eq\s+[^)]+\)\s*\}\}/g) || [];
     if (eqHelpers.length > 0) {
         suggestions.push(`- Found ${eqHelpers.length} equality comparison(s) like {{#if (eq field1 field2)}} - compares two values`);
-        // Check if closing {{/if}} exists for each
         for (const helper of eqHelpers) {
             if (!html.includes('{{/if}}')) {
                 errors.push(`- Missing {{/if}} to close: ${helper}`);
@@ -353,49 +253,35 @@ async function validateTemplate(html, templateType, collectionSlug, projectId) {
         if (resolved) {
             const schema = await fetchTenantSchema(resolved.tenantId);
             if (schema) {
-                // Determine which collection we're validating
-                let targetCollection = collectionSlug || '';
-                let isBuiltin = false;
-                switch (templateType) {
-                    case 'blog_index':
-                    case 'blog_post':
-                        targetCollection = 'blogs';
-                        isBuiltin = true;
-                        break;
-                    case 'authors_index':
-                    case 'author_detail':
-                        targetCollection = 'authors';
-                        isBuiltin = true;
-                        break;
-                    case 'team':
-                        targetCollection = 'team';
-                        isBuiltin = true;
-                        break;
-                    case 'downloads':
-                        targetCollection = 'downloads';
-                        isBuiltin = true;
-                        break;
-                    case 'custom_index':
-                    case 'custom_detail':
-                        isBuiltin = false;
-                        break;
-                }
+                const targetCollection = collectionSlug || '';
                 if (targetCollection && templateType !== 'static_page') {
+                    // Get richText fields for triple brace validation
+                    richTextFields = getRichTextFields(targetCollection, schema);
+                    // Check richText fields are using triple braces
+                    for (const fieldSlug of richTextFields) {
+                        const doublePattern = new RegExp(`\\{\\{${fieldSlug}\\}\\}`, 'g');
+                        const triplePattern = new RegExp(`\\{\\{\\{${fieldSlug}\\}\\}\\}`, 'g');
+                        const hasDouble = doublePattern.test(html);
+                        const hasTriple = triplePattern.test(html);
+                        if (hasDouble && !hasTriple) {
+                            errors.push(`- {{${fieldSlug}}} must use triple braces {{{${fieldSlug}}}} because it contains HTML (richText field)`);
+                        }
+                    }
                     // Extract fields used in template
                     const usedFields = extractTokenFieldNames(html);
-                    // Check if custom collection exists
-                    const collectionExists = isBuiltin || schema.collections.some(c => c.slug === targetCollection);
-                    if (!isBuiltin && !collectionExists) {
+                    // Check if collection exists
+                    const collectionExists = schema.collections.some(c => c.slug === targetCollection);
+                    if (!collectionExists) {
                         // Collection doesn't exist - need to create it
                         schemaValidation = `
 
-## 🚨 ACTION REQUIRED: Collection Does Not Exist
+## ACTION REQUIRED: Collection Does Not Exist
 
 The collection "${targetCollection}" does **not exist** in this project.
 
 ---
 
-### ⚡ YOU MUST CREATE THIS COLLECTION
+### YOU MUST CREATE THIS COLLECTION
 
 Use the \`sync_schema\` tool to create the collection and its fields before deploying.
 
@@ -412,7 +298,7 @@ Use the \`sync_schema\` tool to create the collection and its fields before depl
       "name": "${targetCollection.charAt(0).toUpperCase() + targetCollection.slice(1)}",
       "nameSingular": "${targetCollection.endsWith('s') ? targetCollection.slice(0, -1).charAt(0).toUpperCase() + targetCollection.slice(0, -1).slice(1) : targetCollection.charAt(0).toUpperCase() + targetCollection.slice(1)}",
       "fields": [
-${usedFields.filter(f => !['name', 'slug', 'publishedAt'].includes(f)).map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpperCase() + f.slice(1).replace(/([A-Z])/g, ' $1').trim()}", "type": "YOUR_TYPE" }`).join(',\n')}
+${usedFields.filter(f => !['name', 'slug', 'url', 'publishedAt', 'createdAt', 'updatedAt'].includes(f)).map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpperCase() + f.slice(1).replace(/([A-Z])/g, ' $1').trim()}", "type": "YOUR_TYPE" }`).join(',\n')}
       ]
     }
   ]
@@ -428,17 +314,18 @@ ${usedFields.filter(f => !['name', 'slug', 'publishedAt'].includes(f)).map(f =>
 - \`date\` - Date picker
 - \`number\` - Numeric values
 - \`select\` - Dropdown (requires \`options\` parameter)
+- \`relation\` - Link to another collection (requires \`referenceCollection\` parameter)
 
 **DO NOT SKIP THIS STEP** - Templates will not render without the collection.
 `;
                     }
                     else {
                         // Find missing fields
-                        const missingFields = findMissingFields(usedFields, targetCollection, isBuiltin, schema);
+                        const missingFields = findMissingFields(usedFields, targetCollection, schema);
                         if (missingFields.length > 0) {
                             schemaValidation = `
 
-## 🚨 ACTION REQUIRED: Missing Fields
+## ACTION REQUIRED: Missing Fields
 
 The following fields are used in the template but **do not exist** in the "${targetCollection}" collection:
 
@@ -446,7 +333,7 @@ ${missingFields.map(f => `- \`${f}\``).join('\n')}
 
 ---
 
-### ⚡ YOU MUST CREATE THESE FIELDS
+### YOU MUST CREATE THESE FIELDS
 
 Use the \`sync_schema\` tool to create the missing fields before deploying. This is required for your template to work correctly.
 
@@ -460,7 +347,7 @@ Use the \`sync_schema\` tool to create the missing fields before deploying. This
   "fieldsToAdd": [
     {
       "collectionSlug": "${targetCollection}",
-      "isBuiltin": ${isBuiltin},
+      "isBuiltin": false,
       "fields": [
 ${missingFields.map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpperCase() + f.slice(1).replace(/([A-Z])/g, ' $1').trim()}", "type": "YOUR_TYPE" }`).join(',\n')}
       ]
@@ -478,6 +365,7 @@ ${missingFields.map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpp
 - \`date\` - Date picker
 - \`number\` - Numeric values
 - \`select\` - Dropdown (requires \`options\` parameter)
+- \`relation\` - Link to another collection (requires \`referenceCollection\` parameter)
 
 **DO NOT SKIP THIS STEP** - Templates will not render correctly without these fields.
 `;
@@ -485,7 +373,7 @@ ${missingFields.map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpp
                         else {
                             schemaValidation = `
 
-## ✅ Schema Validation Passed
+## Schema Validation Passed
 
 All fields used in this template exist in the "${targetCollection}" collection.
 `;
@@ -499,7 +387,7 @@ All fields used in this template exist in the "${targetCollection}" collection.
         // projectId provided but not authenticated
         schemaValidation = `
 
-## ℹ️ Schema Validation Skipped
+## Schema Validation Skipped
 
 A projectId was provided but you're not authenticated. 
 To validate against your project's schema, authenticate first using the device flow or FASTMODE_AUTH_TOKEN.
@@ -510,7 +398,7 @@ Without authentication, only syntax validation is performed.
     // Build result
     let output = '';
     if (errors.length === 0 && warnings.length === 0) {
-        output = `✅ TEMPLATE VALID
+        output = `TEMPLATE VALID
 
 The ${templateType} template structure looks correct.
 
@@ -527,7 +415,7 @@ ${suggestions.join('\n')}`;
         }
     }
     else if (errors.length === 0) {
-        output = `⚠️ TEMPLATE VALID WITH WARNINGS
+        output = `TEMPLATE VALID WITH WARNINGS
 
 Warnings:
 ${warnings.join('\n')}`;
@@ -539,7 +427,7 @@ ${suggestions.join('\n')}`;
         }
     }
     else {
-        output = `❌ TEMPLATE HAS ERRORS
+        output = `TEMPLATE HAS ERRORS
 
 Errors (must fix):
 ${errors.join('\n')}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multisite-cms-mcp",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "MCP server for Fast Mode CMS. Convert websites, validate packages, and deploy directly to Fast Mode. Includes authentication, project creation, schema sync, and one-click deployment.",
   "main": "dist/index.js",
   "bin": {