multisite-cms-mcp 1.1.1 → 1.2.0

package/dist/index.js

@@ -14,6 +14,8 @@ const get_tenant_schema_1 = require("./tools/get-tenant-schema");
 const list_projects_1 = require("./tools/list-projects");
 const create_site_1 = require("./tools/create-site");
 const deploy_package_1 = require("./tools/deploy-package");
+const get_field_types_1 = require("./tools/get-field-types");
+const sync_schema_1 = require("./tools/sync-schema");
 const server = new index_js_1.Server({
     name: 'multisite-cms',
     version: '1.0.0',
@@ -49,7 +51,7 @@ const TOOLS = [
     },
     {
         name: 'validate_template',
-        description: 'Validate an HTML template for correct CMS token usage. Checks for proper {{token}} syntax, correct field names, and proper use of triple braces for rich text.',
+        description: 'Validate an HTML template for correct CMS token usage. Checks for proper {{token}} syntax, correct field names, and proper use of triple braces for rich text. When authenticated with a projectId, also validates tokens against the actual project schema and reports missing fields.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -66,6 +68,10 @@ const TOOLS = [
                     type: 'string',
                     description: 'For custom collections, the collection slug',
                 },
+                projectId: {
+                    type: 'string',
+                    description: 'Optional: Project ID or name to validate tokens against actual schema. Requires authentication. If missing fields are found, provides instructions for creating them with sync_schema.',
+                },
             },
             required: ['html', 'templateType'],
         },
@@ -206,6 +212,89 @@ const TOOLS = [
             required: ['packagePath'],
         },
     },
+    {
+        name: 'get_field_types',
+        description: 'Get the list of available field types for creating new fields in collections. Use this to see what field types you can use with sync_schema. This is NOT the list of fields in your schema - use get_schema or get_tenant_schema for that. No authentication required.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'sync_schema',
+        description: 'Create collections and/or add fields to existing collections. Requires authentication. Skips duplicates automatically. All fields must have a type specified - use get_field_types to see available types. Use this after validate_template reports missing fields.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: {
+                    type: 'string',
+                    description: 'Project ID (UUID) or project name. Use list_projects to see available projects.',
+                },
+                collections: {
+                    type: 'array',
+                    description: 'New collections to create, each with optional fields',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            slug: { type: 'string', description: 'URL-friendly identifier (lowercase, no spaces)' },
+                            name: { type: 'string', description: 'Display name (plural)' },
+                            nameSingular: { type: 'string', description: 'Singular form of name' },
+                            description: { type: 'string', description: 'Optional description' },
+                            hasSlug: { type: 'boolean', description: 'Whether items have URL slugs (default: true)' },
+                            fields: {
+                                type: 'array',
+                                description: 'Fields to add to this collection',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        slug: { type: 'string', description: 'Field identifier' },
+                                        name: { type: 'string', description: 'Field display name' },
+                                        type: { type: 'string', description: 'Field type (REQUIRED) - use get_field_types to see options' },
+                                        description: { type: 'string', description: 'Optional field description' },
+                                        isRequired: { type: 'boolean', description: 'Whether field is required' },
+                                        options: { type: 'string', description: 'For select/multiSelect: comma-separated options' },
+                                        referenceCollection: { type: 'string', description: 'For relation type: slug of referenced collection' },
+                                    },
+                                    required: ['slug', 'name', 'type'],
+                                },
+                            },
+                        },
+                        required: ['slug', 'name', 'nameSingular'],
+                    },
+                },
+                fieldsToAdd: {
+                    type: 'array',
+                    description: 'Fields to add to existing collections (builtin or custom)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            collectionSlug: { type: 'string', description: 'Collection slug (e.g., "blogs", "team", or custom collection slug)' },
+                            isBuiltin: { type: 'boolean', description: 'true for blogs/authors/team/downloads, false for custom collections' },
+                            fields: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        slug: { type: 'string', description: 'Field identifier' },
+                                        name: { type: 'string', description: 'Field display name' },
+                                        type: { type: 'string', description: 'Field type (REQUIRED) - use get_field_types to see options' },
+                                        description: { type: 'string', description: 'Optional field description' },
+                                        isRequired: { type: 'boolean', description: 'Whether field is required' },
+                                        options: { type: 'string', description: 'For select/multiSelect: comma-separated options' },
+                                        referenceCollection: { type: 'string', description: 'For relation type: slug of referenced collection' },
+                                    },
+                                    required: ['slug', 'name', 'type'],
+                                },
+                            },
+                        },
+                        required: ['collectionSlug', 'isBuiltin', 'fields'],
+                    },
+                },
+            },
+            required: ['projectId'],
+        },
+    },
 ];
 // Handle list tools request
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
@@ -225,7 +314,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 result = await (0, validate_manifest_1.validateManifest)(params.manifest);
                 break;
             case 'validate_template':
-                result = await (0, validate_template_1.validateTemplate)(params.html, params.templateType, params.collectionSlug);
+                result = await (0, validate_template_1.validateTemplate)(params.html, params.templateType, params.collectionSlug, params.projectId);
                 break;
             case 'validate_package': {
                 let templateContents;
@@ -258,6 +347,16 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             case 'deploy_package':
                 result = await (0, deploy_package_1.deployPackage)(params.packagePath, params.projectId, params.projectName);
                 break;
+            case 'get_field_types':
+                result = await (0, get_field_types_1.getFieldTypes)();
+                break;
+            case 'sync_schema':
+                result = await (0, sync_schema_1.syncSchema)({
+                    projectId: params.projectId,
+                    collections: params.collections,
+                    fieldsToAdd: params.fieldsToAdd,
+                });
+                break;
             default:
                 return {
                     content: [{ type: 'text', text: `Unknown tool: ${name}` }],

package/dist/tools/get-field-types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Get Available Field Types Tool
+ *
+ * Returns the list of field types that can be used when CREATING new fields
+ * in collections. This is NOT the list of fields in your schema - use
+ * get_schema or get_tenant_schema for that.
+ *
+ * No authentication required.
+ */
+/**
+ * Field type definition
+ */
+export interface FieldType {
+    value: string;
+    label: string;
+    description: string;
+    requiresOptions?: boolean;
+    requiresReferenceCollection?: boolean;
+}
+/**
+ * Available field types for creating custom fields
+ * This matches the API's supported field types
+ */
+export declare const AVAILABLE_FIELD_TYPES: FieldType[];
+/**
+ * Returns the list of available field types for creating fields.
+ * No authentication required.
+ */
+export declare function getFieldTypes(): Promise<string>;
+//# sourceMappingURL=get-field-types.d.ts.map

package/dist/tools/get-field-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-field-types.d.ts","sourceRoot":"","sources":["../../src/tools/get-field-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,EAgE5C,CAAC;AAEF;;;GAGG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CA0CrD"}

package/dist/tools/get-field-types.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Get Available Field Types Tool
+ *
+ * Returns the list of field types that can be used when CREATING new fields
+ * in collections. This is NOT the list of fields in your schema - use
+ * get_schema or get_tenant_schema for that.
+ *
+ * No authentication required.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVAILABLE_FIELD_TYPES = void 0;
+exports.getFieldTypes = getFieldTypes;
+/**
+ * Available field types for creating custom fields
+ * This matches the API's supported field types
+ */
+exports.AVAILABLE_FIELD_TYPES = [
+    {
+        value: 'text',
+        label: 'Text',
+        description: 'Single line text field. Use for titles, names, short descriptions.'
+    },
+    {
+        value: 'richText',
+        label: 'Rich Text',
+        description: 'Multi-line formatted text (HTML). Use for body content, descriptions with formatting. Use {{{fieldName}}} in templates (triple braces for unescaped HTML).'
+    },
+    {
+        value: 'number',
+        label: 'Number',
+        description: 'Numeric value. Use for prices, quantities, order numbers.'
+    },
+    {
+        value: 'boolean',
+        label: 'Boolean',
+        description: 'True/False toggle. Use for featured flags, visibility toggles.'
+    },
+    {
+        value: 'date',
+        label: 'Date',
+        description: 'Date picker (date only). Use for publication dates, event dates.'
+    },
+    {
+        value: 'datetime',
+        label: 'Date & Time',
+        description: 'Date and time picker. Use when you need both date and time.'
+    },
+    {
+        value: 'image',
+        label: 'Image URL',
+        description: 'URL to an image. Use for photos, thumbnails, hero images.'
+    },
+    {
+        value: 'url',
+        label: 'URL',
+        description: 'Web link. Use for external links, social media URLs.'
+    },
+    {
+        value: 'email',
+        label: 'Email',
+        description: 'Email address field with validation.'
+    },
+    {
+        value: 'select',
+        label: 'Select',
+        description: 'Dropdown with predefined options. Requires "options" parameter with comma-separated values.',
+        requiresOptions: true,
+    },
+    {
+        value: 'multiSelect',
+        label: 'Multi-Select',
+        description: 'Multiple selections from options. Requires "options" parameter with comma-separated values.',
+        requiresOptions: true,
+    },
+    {
+        value: 'relation',
+        label: 'Relation',
+        description: 'Link to another collection item. Requires "referenceCollection" parameter with the collection slug. Only for custom collections.',
+        requiresReferenceCollection: true,
+    },
+];
+/**
+ * Returns the list of available field types for creating fields.
+ * No authentication required.
+ */
+async function getFieldTypes() {
+    const typeList = exports.AVAILABLE_FIELD_TYPES.map(ft => {
+        let entry = `- **${ft.value}** (${ft.label}): ${ft.description}`;
+        if (ft.requiresOptions) {
+            entry += '\n  - ⚠️ Requires `options` parameter (comma-separated values)';
+        }
+        if (ft.requiresReferenceCollection) {
+            entry += '\n  - ⚠️ Requires `referenceCollection` parameter (collection slug)';
+        }
+        return entry;
+    }).join('\n');
+    return `# Available Field Types
+
+These are the field types you can use when CREATING new fields with the \`sync_schema\` tool.
+
+**Note:** This is NOT the list of fields in your schema. Use \`get_schema\` for the generic schema or \`get_tenant_schema\` for a specific project's schema.
+
+## Field Types
+
+${typeList}
+
+## Usage Example
+
+When calling \`sync_schema\` to add fields, specify the \`type\` parameter:
+
+\`\`\`json
+{
+  "fieldsToAdd": [
+    {
+      "collectionSlug": "blogs",
+      "isBuiltin": true,
+      "fields": [
+        { "slug": "heroImage", "name": "Hero Image", "type": "image" },
+        { "slug": "featured", "name": "Featured", "type": "boolean" },
+        { "slug": "category", "name": "Category", "type": "select", "options": "Tech,Business,Lifestyle" }
+      ]
+    }
+  ]
+}
+\`\`\`
+`;
+}

package/dist/tools/sync-schema.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Sync Schema Tool
+ *
+ * Creates collections and/or fields in Fast Mode.
+ * Requires authentication. Will skip duplicates.
+ */
+interface FieldToCreate {
+    slug: string;
+    name: string;
+    type: string;
+    description?: string;
+    isRequired?: boolean;
+    options?: string;
+    referenceCollection?: string;
+}
+interface CollectionToCreate {
+    slug: string;
+    name: string;
+    nameSingular: string;
+    description?: string;
+    hasSlug?: boolean;
+    fields?: FieldToCreate[];
+}
+interface FieldsToAdd {
+    collectionSlug: string;
+    isBuiltin: boolean;
+    fields: FieldToCreate[];
+}
+interface SyncSchemaInput {
+    projectId: string;
+    collections?: CollectionToCreate[];
+    fieldsToAdd?: FieldsToAdd[];
+}
+/**
+ * Sync schema - create collections and/or fields
+ *
+ * @param input - The sync schema input with projectId, collections, and/or fieldsToAdd
+ */
+export declare function syncSchema(input: SyncSchemaInput): Promise<string>;
+export {};
+//# sourceMappingURL=sync-schema.d.ts.map

package/dist/tools/sync-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-schema.d.ts","sourceRoot":"","sources":["../../src/tools/sync-schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,UAAU,WAAW;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACnC,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;CAC7B;AAyKD;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CA8UxE"}

package/dist/tools/sync-schema.js

@@ -0,0 +1,409 @@
+"use strict";
+/**
+ * Sync Schema Tool
+ *
+ * Creates collections and/or fields in Fast Mode.
+ * Requires authentication. Will skip duplicates.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncSchema = syncSchema;
+const api_client_1 = require("../lib/api-client");
+const device_flow_1 = require("../lib/device-flow");
+const get_field_types_1 = require("./get-field-types");
+// ============ Constants ============
+const BUILTIN_COLLECTION_TYPES = ['blogs', 'authors', 'team', 'downloads'];
+const VALID_FIELD_TYPES = get_field_types_1.AVAILABLE_FIELD_TYPES.map(ft => ft.value);
+const AUTH_REQUIRED_MESSAGE = `# Authentication Required
+
+This tool requires authentication to create collections and fields.
+
+**To authenticate:**
+1. Set the FASTMODE_AUTH_TOKEN environment variable, OR
+2. Run this tool again and follow the browser-based login flow
+
+Use \`list_projects\` to verify your authentication status.
+`;
+// ============ Helper Functions ============
+/**
+ * Validate a field type against available types
+ */
+function validateFieldType(type) {
+    if (!type) {
+        return { valid: false, error: 'Field type is required' };
+    }
+    if (!VALID_FIELD_TYPES.includes(type)) {
+        return {
+            valid: false,
+            error: `Invalid field type "${type}". Valid types: ${VALID_FIELD_TYPES.join(', ')}`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate all fields in input
+ */
+function validateFields(fields) {
+    const errors = [];
+    for (const field of fields) {
+        if (!field.slug) {
+            errors.push(`Field missing slug`);
+            continue;
+        }
+        if (!field.name) {
+            errors.push(`Field "${field.slug}" missing name`);
+        }
+        if (!field.type) {
+            errors.push(`Field "${field.slug}" missing type. Use get_field_types to see available types.`);
+            continue;
+        }
+        const typeValidation = validateFieldType(field.type);
+        if (!typeValidation.valid) {
+            errors.push(`Field "${field.slug}": ${typeValidation.error}`);
+        }
+        // Check for required options/referenceCollection
+        if ((field.type === 'select' || field.type === 'multiSelect') && !field.options) {
+            errors.push(`Field "${field.slug}" (${field.type}) requires "options" parameter with comma-separated values`);
+        }
+        if (field.type === 'relation' && !field.referenceCollection) {
+            errors.push(`Field "${field.slug}" (relation) requires "referenceCollection" parameter`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Resolve project identifier to tenant ID
+ */
+async function resolveProjectId(projectIdentifier) {
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidPattern.test(projectIdentifier)) {
+        return { tenantId: projectIdentifier };
+    }
+    const response = await (0, api_client_1.apiRequest)('/api/tenants');
+    if ((0, api_client_1.isApiError)(response)) {
+        return { error: `Failed to look up project: ${response.error}` };
+    }
+    const match = response.data.find(p => p.name.toLowerCase() === projectIdentifier.toLowerCase());
+    if (match) {
+        return { tenantId: match.id };
+    }
+    const partialMatch = response.data.find(p => p.name.toLowerCase().includes(projectIdentifier.toLowerCase()));
+    if (partialMatch) {
+        return { tenantId: partialMatch.id };
+    }
+    return {
+        error: `Project "${projectIdentifier}" not found. Use list_projects to see available projects.`
+    };
+}
+/**
+ * Fetch existing schema for a project
+ */
+async function fetchExistingSchema(tenantId) {
+    // Fetch custom collections
+    const collectionsRes = await (0, api_client_1.apiRequest)('/api/collections', { tenantId });
+    if ((0, api_client_1.isApiError)(collectionsRes)) {
+        return { error: `Failed to fetch collections: ${collectionsRes.error}` };
+    }
+    // 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.map(f => ({ slug: f.slug, name: f.name, type: f.type }));
+        }
+    }
+    return {
+        collections: collectionsRes.data,
+        builtinFields,
+    };
+}
+// ============ Main Function ============
+/**
+ * Sync schema - create collections and/or fields
+ *
+ * @param input - The sync schema input with projectId, collections, and/or fieldsToAdd
+ */
+async function syncSchema(input) {
+    // Check authentication
+    if (await (0, api_client_1.needsAuthentication)()) {
+        const authResult = await (0, device_flow_1.ensureAuthenticated)();
+        if (!authResult.authenticated) {
+            return AUTH_REQUIRED_MESSAGE;
+        }
+    }
+    const { projectId, collections, fieldsToAdd } = input;
+    // Validate input
+    if (!projectId) {
+        return `# Error: Missing projectId
+
+Please provide a projectId. Use \`list_projects\` to see your available projects.
+`;
+    }
+    if ((!collections || collections.length === 0) && (!fieldsToAdd || fieldsToAdd.length === 0)) {
+        return `# Error: Nothing to sync
+
+Please provide either:
+- \`collections\`: Array of new collections to create
+- \`fieldsToAdd\`: Array of fields to add to existing collections
+
+Use \`get_field_types\` to see available field types.
+`;
+    }
+    // Validate all field types before making any API calls
+    const allValidationErrors = [];
+    if (collections) {
+        for (const col of collections) {
+            if (!col.slug)
+                allValidationErrors.push(`Collection missing slug`);
+            if (!col.name)
+                allValidationErrors.push(`Collection "${col.slug || 'unknown'}" missing name`);
+            if (!col.nameSingular)
+                allValidationErrors.push(`Collection "${col.slug || 'unknown'}" missing nameSingular`);
+            if (col.fields && col.fields.length > 0) {
+                const fieldValidation = validateFields(col.fields);
+                if (!fieldValidation.valid) {
+                    allValidationErrors.push(...fieldValidation.errors.map(e => `Collection "${col.slug}": ${e}`));
+                }
+            }
+        }
+    }
+    if (fieldsToAdd) {
+        for (const group of fieldsToAdd) {
+            if (!group.collectionSlug) {
+                allValidationErrors.push(`fieldsToAdd entry missing collectionSlug`);
+                continue;
+            }
+            if (group.isBuiltin && !BUILTIN_COLLECTION_TYPES.includes(group.collectionSlug)) {
+                allValidationErrors.push(`"${group.collectionSlug}" is not a valid builtin collection. Valid: ${BUILTIN_COLLECTION_TYPES.join(', ')}`);
+            }
+            if (!group.fields || group.fields.length === 0) {
+                allValidationErrors.push(`fieldsToAdd for "${group.collectionSlug}" has no fields`);
+                continue;
+            }
+            const fieldValidation = validateFields(group.fields);
+            if (!fieldValidation.valid) {
+                allValidationErrors.push(...fieldValidation.errors.map(e => `${group.collectionSlug}: ${e}`));
+            }
+        }
+    }
+    if (allValidationErrors.length > 0) {
+        return `# Validation Errors
+
+Please fix the following errors before syncing:
+
+${allValidationErrors.map(e => `- ${e}`).join('\n')}
+
+**Tip:** Use \`get_field_types\` to see available field types and their requirements.
+`;
+    }
+    // Resolve project ID
+    const resolved = await resolveProjectId(projectId);
+    if ('error' in resolved) {
+        return `# Project Not Found
+
+${resolved.error}
+`;
+    }
+    const { tenantId } = resolved;
+    // Fetch existing schema
+    const existingSchema = await fetchExistingSchema(tenantId);
+    if ('error' in existingSchema) {
+        // Check if auth error
+        if (existingSchema.error.includes('401') || existingSchema.error.includes('auth')) {
+            const authResult = await (0, device_flow_1.ensureAuthenticated)();
+            if (!authResult.authenticated) {
+                return AUTH_REQUIRED_MESSAGE;
+            }
+            // Retry
+            const retry = await fetchExistingSchema(tenantId);
+            if ('error' in retry) {
+                return `# Error\n\n${retry.error}`;
+            }
+            Object.assign(existingSchema, retry);
+        }
+        else {
+            return `# Error\n\n${existingSchema.error}`;
+        }
+    }
+    const { collections: existingCollections, builtinFields } = existingSchema;
+    // Track results
+    const results = [];
+    const created = { collections: 0, fields: 0 };
+    const skipped = { collections: 0, fields: 0 };
+    // Create new collections
+    if (collections && collections.length > 0) {
+        for (const col of collections) {
+            // Check if collection already exists
+            const existing = existingCollections.find(c => c.slug.toLowerCase() === col.slug.toLowerCase());
+            if (existing) {
+                results.push(`⏭️ Skipped collection "${col.slug}" (already exists)`);
+                skipped.collections++;
+                // But still try to add any new fields
+                if (col.fields && col.fields.length > 0) {
+                    for (const field of col.fields) {
+                        const fieldExists = existing.fields.some(f => f.slug.toLowerCase() === field.slug.toLowerCase());
+                        if (fieldExists) {
+                            results.push(`  ⏭️ Skipped field "${field.slug}" (already exists)`);
+                            skipped.fields++;
+                        }
+                        else {
+                            // Add field to existing collection
+                            const fieldRes = await (0, api_client_1.apiRequest)(`/api/collections/${existing.id}/fields`, {
+                                tenantId,
+                                method: 'POST',
+                                body: {
+                                    slug: field.slug,
+                                    name: field.name,
+                                    type: field.type,
+                                    description: field.description,
+                                    isRequired: field.isRequired,
+                                    options: field.options,
+                                    referenceCollection: field.referenceCollection,
+                                },
+                            });
+                            if ((0, api_client_1.isApiError)(fieldRes)) {
+                                results.push(`  ❌ Failed to add field "${field.slug}": ${fieldRes.error}`);
+                            }
+                            else {
+                                results.push(`  ✅ Added field "${field.slug}" (${field.type})`);
+                                created.fields++;
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            // Create new collection
+            const createRes = await (0, api_client_1.apiRequest)('/api/collections', {
+                tenantId,
+                method: 'POST',
+                body: {
+                    slug: col.slug,
+                    name: col.name,
+                    nameSingular: col.nameSingular,
+                    description: col.description,
+                    hasSlug: col.hasSlug ?? true,
+                },
+            });
+            if ((0, api_client_1.isApiError)(createRes)) {
+                results.push(`❌ Failed to create collection "${col.slug}": ${createRes.error}`);
+                continue;
+            }
+            results.push(`✅ Created collection "${col.name}" (${col.slug})`);
+            created.collections++;
+            // Add fields to the new collection
+            if (col.fields && col.fields.length > 0) {
+                const collectionId = createRes.data.id;
+                for (const field of col.fields) {
+                    const fieldRes = await (0, api_client_1.apiRequest)(`/api/collections/${collectionId}/fields`, {
+                        tenantId,
+                        method: 'POST',
+                        body: {
+                            slug: field.slug,
+                            name: field.name,
+                            type: field.type,
+                            description: field.description,
+                            isRequired: field.isRequired,
+                            options: field.options,
+                            referenceCollection: field.referenceCollection,
+                        },
+                    });
+                    if ((0, api_client_1.isApiError)(fieldRes)) {
+                        results.push(`  ❌ Failed to add field "${field.slug}": ${fieldRes.error}`);
+                    }
+                    else {
+                        results.push(`  ✅ Added field "${field.slug}" (${field.type})`);
+                        created.fields++;
+                    }
+                }
+            }
+        }
+    }
+    // Add fields to existing collections
+    if (fieldsToAdd && fieldsToAdd.length > 0) {
+        for (const group of fieldsToAdd) {
+            results.push(`\n📁 ${group.collectionSlug} (${group.isBuiltin ? 'builtin' : 'custom'}):`);
+            if (group.isBuiltin) {
+                // Add to builtin collection
+                const existingBuiltinFields = builtinFields[group.collectionSlug] || [];
+                for (const field of group.fields) {
+                    const fieldExists = existingBuiltinFields.some(f => f.slug.toLowerCase() === field.slug.toLowerCase());
+                    if (fieldExists) {
+                        results.push(`  ⏭️ Skipped field "${field.slug}" (already exists)`);
+                        skipped.fields++;
+                        continue;
+                    }
+                    const fieldRes = await (0, api_client_1.apiRequest)(`/api/cms/builtin-collections/${group.collectionSlug}/fields`, {
+                        tenantId,
+                        method: 'POST',
+                        body: {
+                            slug: field.slug,
+                            name: field.name,
+                            type: field.type,
+                            description: field.description,
+                            isRequired: field.isRequired,
+                            options: field.options,
+                        },
+                    });
+                    if ((0, api_client_1.isApiError)(fieldRes)) {
+                        results.push(`  ❌ Failed to add field "${field.slug}": ${fieldRes.error}`);
+                    }
+                    else {
+                        results.push(`  ✅ Added field "${field.slug}" (${field.type})`);
+                        created.fields++;
+                    }
+                }
+            }
+            else {
+                // Add to custom collection
+                const customCollection = existingCollections.find(c => c.slug.toLowerCase() === group.collectionSlug.toLowerCase());
+                if (!customCollection) {
+                    results.push(`  ❌ Collection "${group.collectionSlug}" not found. Create it first with the collections parameter.`);
+                    continue;
+                }
+                for (const field of group.fields) {
+                    const fieldExists = customCollection.fields.some(f => f.slug.toLowerCase() === field.slug.toLowerCase());
+                    if (fieldExists) {
+                        results.push(`  ⏭️ Skipped field "${field.slug}" (already exists)`);
+                        skipped.fields++;
+                        continue;
+                    }
+                    const fieldRes = await (0, api_client_1.apiRequest)(`/api/collections/${customCollection.id}/fields`, {
+                        tenantId,
+                        method: 'POST',
+                        body: {
+                            slug: field.slug,
+                            name: field.name,
+                            type: field.type,
+                            description: field.description,
+                            isRequired: field.isRequired,
+                            options: field.options,
+                            referenceCollection: field.referenceCollection,
+                        },
+                    });
+                    if ((0, api_client_1.isApiError)(fieldRes)) {
+                        results.push(`  ❌ Failed to add field "${field.slug}": ${fieldRes.error}`);
+                    }
+                    else {
+                        results.push(`  ✅ Added field "${field.slug}" (${field.type})`);
+                        created.fields++;
+                    }
+                }
+            }
+        }
+    }
+    // Summary
+    return `# Schema Sync Complete
+
+**Project ID:** \`${tenantId}\`
+
+## Summary
+- Collections created: ${created.collections}
+- Fields created: ${created.fields}
+- Collections skipped (already exist): ${skipped.collections}
+- Fields skipped (already exist): ${skipped.fields}
+
+## Details
+
+${results.join('\n')}
+`;
+}

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

@@ -1,7 +1,12 @@
 type TemplateType = 'blog_index' | 'blog_post' | 'team' | 'downloads' | 'authors_index' | 'author_detail' | '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 collectionSlug - For custom collections, the collection slug
+ * @param projectId - Optional: Project ID or name to validate against actual schema
  */
-export declare function validateTemplate(html: string, templateType: TemplateType, collectionSlug?: string): Promise<string>;
+export declare function validateTemplate(html: string, templateType: TemplateType, collectionSlug?: string, projectId?: string): Promise<string>;
 export {};
 //# sourceMappingURL=validate-template.d.ts.map

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":"AAAA,KAAK,YAAY,GAAG,YAAY,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,aAAa,CAAC;AA0E7J;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,YAAY,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CA+OjB"}
+{"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,CAwVjB"}

package/dist/tools/validate-template.js

@@ -1,6 +1,7 @@
 "use strict";
 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 },
@@ -62,10 +63,118 @@ const COMMON_MISTAKES = {
     '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'],
+};
+/**
+ * Resolve project identifier to tenant ID
+ */
+async function resolveProjectId(projectIdentifier) {
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidPattern.test(projectIdentifier)) {
+        return { tenantId: projectIdentifier };
+    }
+    const response = await (0, api_client_1.apiRequest)('/api/tenants');
+    if ((0, api_client_1.isApiError)(response)) {
+        return null;
+    }
+    const match = response.data.find(p => p.name.toLowerCase() === projectIdentifier.toLowerCase() ||
+        p.name.toLowerCase().includes(projectIdentifier.toLowerCase()));
+    return match ? { tenantId: match.id } : null;
+}
+/**
+ * Fetch tenant schema for validation
+ */
+async function fetchTenantSchema(tenantId) {
+    // Fetch custom collections
+    const collectionsRes = await (0, api_client_1.apiRequest)('/api/collections', { 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,
+    };
+}
+/**
+ * Extract field names used in template tokens
+ */
+function extractTokenFieldNames(html) {
+    const fields = new Set();
+    // Match {{fieldName}} and {{{fieldName}}}
+    const doubleTokens = html.match(/\{\{([^{}#/][^{}]*)\}\}/g) || [];
+    const tripleTokens = html.match(/\{\{\{([^{}]+)\}\}\}/g) || [];
+    for (const token of [...doubleTokens, ...tripleTokens]) {
+        const fieldName = token.replace(/\{|\}/g, '').trim();
+        // Skip special tokens
+        if (fieldName.startsWith('#') || fieldName.startsWith('/') ||
+            fieldName === 'else' || fieldName.startsWith('@') ||
+            fieldName.startsWith('this') || fieldName.startsWith('../')) {
+            continue;
+        }
+        // Get the base field name (before any dots)
+        const baseName = fieldName.split('.')[0];
+        if (baseName && baseName !== 'site') {
+            fields.add(baseName);
+        }
+    }
+    return Array.from(fields);
+}
+/**
+ * Check which fields are missing from schema
+ */
+function findMissingFields(usedFields, collectionType, isBuiltin, 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];
+        for (const field of usedFields) {
+            if (!allFields.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;
+        }
+    }
+    return missing;
+}
 /**
  * Validates an HTML template for correct CMS token usage
+ *
+ * @param html - The HTML template content
+ * @param templateType - The type of template
+ * @param collectionSlug - For custom collections, the collection slug
+ * @param projectId - Optional: Project ID or name to validate against actual schema
  */
-async function validateTemplate(html, templateType, collectionSlug) {
+async function validateTemplate(html, templateType, collectionSlug, projectId) {
     const errors = [];
     const warnings = [];
     const suggestions = [];
@@ -236,6 +345,100 @@ async function validateTemplate(html, templateType, collectionSlug) {
     if (eqBlocks.length !== eqCloses) {
         errors.push(`- Unbalanced {{#eq}}: ${eqBlocks.length} opens, ${eqCloses} closes`);
     }
+    // ============ Schema Validation (if authenticated with projectId) ============
+    let schemaValidation = '';
+    if (projectId && !(await (0, api_client_1.needsAuthentication)())) {
+        // Resolve project
+        const resolved = await resolveProjectId(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;
+                }
+                if (targetCollection && templateType !== 'static_page') {
+                    // Extract fields used in template
+                    const usedFields = extractTokenFieldNames(html);
+                    // Find missing fields
+                    const missingFields = findMissingFields(usedFields, targetCollection, isBuiltin, schema);
+                    if (missingFields.length > 0) {
+                        schemaValidation = `
+
+## ⚠️ Missing Fields in Schema
+
+The following fields are used in the template but don't exist in the "${targetCollection}" collection:
+
+${missingFields.map(f => `- \`${f}\``).join('\n')}
+
+**To create these fields, use the \`sync_schema\` tool:**
+
+\`\`\`json
+{
+  "projectId": "${resolved.tenantId}",
+  "fieldsToAdd": [
+    {
+      "collectionSlug": "${targetCollection}",
+      "isBuiltin": ${isBuiltin},
+      "fields": [
+${missingFields.map(f => `        { "slug": "${f}", "name": "${f.charAt(0).toUpperCase() + f.slice(1).replace(/([A-Z])/g, ' $1')}", "type": "YOUR_TYPE_HERE" }`).join(',\n')}
+      ]
+    }
+  ]
+}
+\`\`\`
+
+**Important:** Replace \`"type": "YOUR_TYPE_HERE"\` with the appropriate field type.
+Use \`get_field_types\` to see available field types.
+`;
+                    }
+                    else {
+                        schemaValidation = `
+
+## ✅ Schema Validation Passed
+
+All fields used in this template exist in the "${targetCollection}" collection.
+`;
+                    }
+                }
+            }
+        }
+    }
+    else if (projectId) {
+        // projectId provided but not authenticated
+        schemaValidation = `
+
+## ℹ️ 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.
+
+Without authentication, only syntax validation is performed.
+`;
+    }
     // Build result
     let output = '';
     if (errors.length === 0 && warnings.length === 0) {
@@ -279,5 +482,9 @@ Warnings:
 ${warnings.join('\n')}`;
         }
     }
+    // Add schema validation results if available
+    if (schemaValidation) {
+        output += schemaValidation;
+    }
     return output;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "multisite-cms-mcp",
-  "version": "1.1.1",
-  "description": "MCP server for Fast Mode CMS. Convert websites, validate packages, and deploy directly to Fast Mode. Includes authentication, project creation, and one-click deployment.",
+  "version": "1.2.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": {
     "multisite-cms-mcp": "./dist/index.js"