snow-flow 4.5.2 → 4.5.5

package/dist/mcp/servicenow-flow-workspace-mobile-mcp.js

@@ -275,6 +275,395 @@ class ServiceNowFlowWorkspaceMobileMCP {
                         required: ['table']
                     }
                 },
+                // ==========================================
+                // UI BUILDER TOOLS - COMPLETE NOW EXPERIENCE FRAMEWORK INTEGRATION
+                // Official ServiceNow sys_ux_* APIs for conversational UI Builder development
+                // ==========================================
+                // UI Builder Page Management (sys_ux_page)
+                {
+                    name: 'snow_create_uib_page',
+                    description: 'Creates a new UI Builder page in the Now Experience Framework using official ServiceNow sys_ux_page API. Enables conversational page creation with full UXF integration.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Page name (must be unique)' },
+                            title: { type: 'string', description: 'Page title displayed in browser' },
+                            route: { type: 'string', description: 'URL route for the page (e.g., /my-dashboard)' },
+                            description: { type: 'string', description: 'Page description' },
+                            application: { type: 'string', description: 'Application scope', default: 'global' },
+                            theme: { type: 'string', description: 'Page theme', default: 'standard' },
+                            public_read: { type: 'boolean', description: 'Allow public read access', default: false },
+                            layout_type: { type: 'string', enum: ['container', 'grid', 'flex'], description: 'Page layout type', default: 'container' },
+                            responsive: { type: 'boolean', description: 'Enable responsive design', default: true },
+                            active: { type: 'boolean', description: 'Page is active', default: true }
+                        },
+                        required: ['name', 'title', 'route']
+                    }
+                },
+                {
+                    name: 'snow_update_uib_page',
+                    description: 'Updates an existing UI Builder page configuration, metadata, or settings.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Page sys_id to update' },
+                            title: { type: 'string', description: 'New page title' },
+                            route: { type: 'string', description: 'New URL route' },
+                            description: { type: 'string', description: 'New description' },
+                            theme: { type: 'string', description: 'New page theme' },
+                            layout_type: { type: 'string', enum: ['container', 'grid', 'flex'], description: 'New layout type' },
+                            responsive: { type: 'boolean', description: 'Enable/disable responsive design' },
+                            active: { type: 'boolean', description: 'Page active status' }
+                        },
+                        required: ['page_id']
+                    }
+                },
+                {
+                    name: 'snow_delete_uib_page',
+                    description: 'Safely deletes a UI Builder page and all associated elements, with comprehensive dependency validation.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Page sys_id to delete' },
+                            force_delete: { type: 'boolean', description: 'Force delete even if dependencies exist', default: false },
+                            backup_before_delete: { type: 'boolean', description: 'Create backup before deletion', default: true },
+                            clean_orphaned_elements: { type: 'boolean', description: 'Clean up orphaned page elements', default: true }
+                        },
+                        required: ['page_id']
+                    }
+                },
+                {
+                    name: 'snow_discover_uib_pages',
+                    description: 'Discovers all UI Builder pages in the instance with advanced filtering and relationship analysis.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            application: { type: 'string', description: 'Filter by application scope' },
+                            active_only: { type: 'boolean', description: 'Show only active pages', default: true },
+                            include_elements: { type: 'boolean', description: 'Include page elements and layout', default: false },
+                            include_data_brokers: { type: 'boolean', description: 'Include data broker configurations', default: false },
+                            include_routing: { type: 'boolean', description: 'Include page registry routing info', default: false },
+                            name_filter: { type: 'string', description: 'Filter pages by name (partial match)' },
+                            route_filter: { type: 'string', description: 'Filter pages by route pattern' },
+                            theme_filter: { type: 'string', description: 'Filter pages by theme' },
+                            limit: { type: 'number', description: 'Maximum pages to return', default: 50 }
+                        }
+                    }
+                },
+                // UI Builder Component Library Management (sys_ux_lib_*)
+                {
+                    name: 'snow_create_uib_component',
+                    description: 'Creates a custom UI Builder component using official ServiceNow sys_ux_lib_component and sys_ux_lib_source_script APIs.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Component name (must be unique, kebab-case recommended)' },
+                            label: { type: 'string', description: 'Component display label' },
+                            description: { type: 'string', description: 'Component description and usage notes' },
+                            category: { type: 'string', description: 'Component category for organization', default: 'custom' },
+                            source_script: { type: 'string', description: 'Component source code (JavaScript/React/Web Components)' },
+                            properties_schema: { type: 'object', description: 'Component properties schema definition (JSON Schema)' },
+                            events: { type: 'array', items: { type: 'string' }, description: 'Events this component can emit' },
+                            dependencies: { type: 'array', items: { type: 'string' }, description: 'External dependencies (libraries, other components)' },
+                            styling: { type: 'object', description: 'Default styling and CSS configuration' },
+                            version: { type: 'string', description: 'Component version', default: '1.0.0' },
+                            tags: { type: 'array', items: { type: 'string' }, description: 'Tags for component discovery' }
+                        },
+                        required: ['name', 'label', 'source_script']
+                    }
+                },
+                {
+                    name: 'snow_update_uib_component',
+                    description: 'Updates an existing UI Builder component definition, source code, or configuration.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            component_id: { type: 'string', description: 'Component sys_id to update' },
+                            label: { type: 'string', description: 'New component label' },
+                            description: { type: 'string', description: 'New description' },
+                            source_script: { type: 'string', description: 'Updated component source code' },
+                            properties_schema: { type: 'object', description: 'Updated properties schema' },
+                            styling: { type: 'object', description: 'Updated styling configuration' },
+                            version: { type: 'string', description: 'New version number (semantic versioning)' },
+                            events: { type: 'array', items: { type: 'string' }, description: 'Updated events list' },
+                            dependencies: { type: 'array', items: { type: 'string' }, description: 'Updated dependencies' },
+                            active: { type: 'boolean', description: 'Component active status' }
+                        },
+                        required: ['component_id']
+                    }
+                },
+                {
+                    name: 'snow_discover_uib_components',
+                    description: 'Discovers all available UI Builder components including ServiceNow built-in and custom components with comprehensive metadata.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            category: { type: 'string', description: 'Filter by component category (layout, input, display, custom)' },
+                            custom_only: { type: 'boolean', description: 'Show only custom components', default: false },
+                            built_in_only: { type: 'boolean', description: 'Show only ServiceNow built-in components', default: false },
+                            include_source: { type: 'boolean', description: 'Include component source code', default: false },
+                            include_usage_stats: { type: 'boolean', description: 'Include component usage statistics across pages', default: false },
+                            include_dependencies: { type: 'boolean', description: 'Include component dependency information', default: false },
+                            name_filter: { type: 'string', description: 'Filter components by name or label' },
+                            version_filter: { type: 'string', description: 'Filter by version pattern' },
+                            application: { type: 'string', description: 'Filter by application scope' },
+                            limit: { type: 'number', description: 'Maximum components to return', default: 100 }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_clone_uib_component',
+                    description: 'Clones an existing UI Builder component to create a customized variant with modifications.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            source_component_id: { type: 'string', description: 'Source component sys_id to clone' },
+                            new_name: { type: 'string', description: 'Name for the cloned component' },
+                            new_label: { type: 'string', description: 'Label for the cloned component' },
+                            modifications: { type: 'object', description: 'Specific modifications to apply to cloned component' },
+                            category: { type: 'string', description: 'Category for cloned component', default: 'custom' },
+                            version: { type: 'string', description: 'Version for cloned component', default: '1.0.0' },
+                            description: { type: 'string', description: 'Description of clone purpose and changes' }
+                        },
+                        required: ['source_component_id', 'new_name', 'new_label']
+                    }
+                },
+                // UI Builder Data Broker Management (sys_ux_data_broker)  
+                {
+                    name: 'snow_create_uib_data_broker',
+                    description: 'Creates a UI Builder data broker for connecting pages to ServiceNow data sources using official sys_ux_data_broker API.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Data broker name (must be unique)' },
+                            label: { type: 'string', description: 'Data broker display label' },
+                            table: { type: 'string', description: 'ServiceNow table to connect' },
+                            type: { type: 'string', enum: ['table', 'script', 'rest_message'], description: 'Data broker type', default: 'table' },
+                            query: { type: 'string', description: 'Default query for table data broker' },
+                            script: { type: 'string', description: 'Script for script-based data broker' },
+                            rest_message: { type: 'string', description: 'REST message sys_id for REST data broker' },
+                            fields: { type: 'array', items: { type: 'string' }, description: 'Fields to retrieve (leave empty for all)' },
+                            auto_refresh: { type: 'boolean', description: 'Enable automatic data refresh', default: false },
+                            refresh_interval: { type: 'number', description: 'Refresh interval in seconds', default: 30 },
+                            cache_duration: { type: 'number', description: 'Cache duration in seconds', default: 300 },
+                            max_records: { type: 'number', description: 'Maximum records to fetch', default: 1000 }
+                        },
+                        required: ['name', 'label', 'type']
+                    }
+                },
+                {
+                    name: 'snow_configure_uib_data_broker',
+                    description: 'Configures or updates an existing UI Builder data broker with new query, fields, or performance settings.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            broker_id: { type: 'string', description: 'Data broker sys_id' },
+                            query: { type: 'string', description: 'Updated query condition' },
+                            fields: { type: 'array', items: { type: 'string' }, description: 'Updated fields list' },
+                            auto_refresh: { type: 'boolean', description: 'Enable/disable auto-refresh' },
+                            refresh_interval: { type: 'number', description: 'New refresh interval in seconds' },
+                            cache_duration: { type: 'number', description: 'New cache duration in seconds' },
+                            max_records: { type: 'number', description: 'New maximum records limit' },
+                            active: { type: 'boolean', description: 'Data broker active status' }
+                        },
+                        required: ['broker_id']
+                    }
+                },
+                // UI Builder Page Layout Management (sys_ux_page_element)
+                {
+                    name: 'snow_add_uib_page_element',
+                    description: 'Adds a component element to a UI Builder page using official sys_ux_page_element API with full layout control.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Target page sys_id' },
+                            component: { type: 'string', description: 'Component name or sys_id from component library' },
+                            container_id: { type: 'string', description: 'Parent container element ID (optional for root level)' },
+                            position: { type: 'number', description: 'Element position in container', default: 0 },
+                            properties: { type: 'object', description: 'Component properties and configuration' },
+                            data_broker: { type: 'string', description: 'Data broker sys_id to bind to component' },
+                            responsive_config: { type: 'object', description: 'Responsive layout configuration for different screen sizes' },
+                            conditional_display: { type: 'string', description: 'Condition script for element visibility' },
+                            css_classes: { type: 'array', items: { type: 'string' }, description: 'CSS classes to apply' },
+                            inline_styles: { type: 'object', description: 'Inline styles configuration' }
+                        },
+                        required: ['page_id', 'component']
+                    }
+                },
+                {
+                    name: 'snow_update_uib_page_element',
+                    description: 'Updates properties, position, or configuration of an existing UI Builder page element.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            element_id: { type: 'string', description: 'Page element sys_id' },
+                            properties: { type: 'object', description: 'Updated component properties' },
+                            position: { type: 'number', description: 'New position in container' },
+                            data_broker: { type: 'string', description: 'New data broker binding' },
+                            responsive_config: { type: 'object', description: 'Updated responsive configuration' },
+                            conditional_display: { type: 'string', description: 'Updated display condition' },
+                            css_classes: { type: 'array', items: { type: 'string' }, description: 'Updated CSS classes' },
+                            inline_styles: { type: 'object', description: 'Updated inline styles' }
+                        },
+                        required: ['element_id']
+                    }
+                },
+                {
+                    name: 'snow_remove_uib_page_element',
+                    description: 'Removes a component element from a UI Builder page with comprehensive dependency validation.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            element_id: { type: 'string', description: 'Page element sys_id to remove' },
+                            validate_dependencies: { type: 'boolean', description: 'Check for element dependencies before removal', default: true },
+                            cleanup_orphaned_data: { type: 'boolean', description: 'Clean up orphaned data brokers and scripts', default: true }
+                        },
+                        required: ['element_id']
+                    }
+                },
+                // UI Builder Page Registry & Routing (sys_ux_page_registry)
+                {
+                    name: 'snow_create_uib_page_registry',
+                    description: 'Creates URL routing configuration for UI Builder page using official sys_ux_page_registry API.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Target page sys_id' },
+                            path: { type: 'string', description: 'URL path pattern (e.g., /dashboard, /incidents/:id)' },
+                            application: { type: 'string', description: 'Application scope for routing' },
+                            roles: { type: 'array', items: { type: 'string' }, description: 'Roles required to access page' },
+                            public_access: { type: 'boolean', description: 'Allow public access without authentication', default: false },
+                            redirect_url: { type: 'string', description: 'Redirect URL for unauthorized access' },
+                            meta_title: { type: 'string', description: 'SEO meta title for the page' },
+                            meta_description: { type: 'string', description: 'SEO meta description' },
+                            parameter_mapping: { type: 'object', description: 'URL parameter mapping configuration' },
+                            cache_control: { type: 'string', description: 'Cache control headers' }
+                        },
+                        required: ['page_id', 'path']
+                    }
+                },
+                {
+                    name: 'snow_discover_uib_routes',
+                    description: 'Discovers all UI Builder page routes and their security/access configurations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            application: { type: 'string', description: 'Filter by application scope' },
+                            active_only: { type: 'boolean', description: 'Show only active routes', default: true },
+                            include_security: { type: 'boolean', description: 'Include role and security information', default: false },
+                            include_parameters: { type: 'boolean', description: 'Include URL parameter configurations', default: false },
+                            path_pattern: { type: 'string', description: 'Filter by path pattern or wildcard' },
+                            role_filter: { type: 'string', description: 'Filter by required role' }
+                        }
+                    }
+                },
+                // UI Builder Client Script Management (sys_ux_client_script)
+                {
+                    name: 'snow_create_uib_client_script',
+                    description: 'Creates client-side scripts for UI Builder pages using official sys_ux_client_script API.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Target page sys_id' },
+                            name: { type: 'string', description: 'Script name (must be unique within page)' },
+                            type: { type: 'string', enum: ['onLoad', 'onChange', 'onClick', 'onSubmit', 'custom'], description: 'Script trigger type' },
+                            script: { type: 'string', description: 'JavaScript code for the script' },
+                            component_reference: { type: 'string', description: 'Reference to specific component if applicable' },
+                            event_name: { type: 'string', description: 'Custom event name for custom type scripts' },
+                            execution_order: { type: 'number', description: 'Script execution order', default: 100 },
+                            async_execution: { type: 'boolean', description: 'Enable async execution', default: false },
+                            error_handling: { type: 'string', description: 'Error handling strategy', default: 'log' },
+                            active: { type: 'boolean', description: 'Script is active', default: true }
+                        },
+                        required: ['page_id', 'name', 'type', 'script']
+                    }
+                },
+                {
+                    name: 'snow_create_uib_client_state',
+                    description: 'Creates client state management configuration for UI Builder pages using official sys_ux_client_state API.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Target page sys_id' },
+                            state_name: { type: 'string', description: 'State variable name' },
+                            initial_value: { type: 'string', description: 'Initial state value (JSON format)' },
+                            scope: { type: 'string', enum: ['page', 'session', 'global'], description: 'State scope', default: 'page' },
+                            persistent: { type: 'boolean', description: 'Persist state across browser sessions', default: false },
+                            reactive: { type: 'boolean', description: 'Enable reactive updates', default: true },
+                            validation_schema: { type: 'object', description: 'State validation schema' },
+                            description: { type: 'string', description: 'State variable description' }
+                        },
+                        required: ['page_id', 'state_name', 'initial_value']
+                    }
+                },
+                // UI Builder Event Management (sys_ux_event)
+                {
+                    name: 'snow_create_uib_event',
+                    description: 'Creates custom events for UI Builder components using official sys_ux_event API.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Event name (must be unique)' },
+                            label: { type: 'string', description: 'Event display label' },
+                            description: { type: 'string', description: 'Event description and usage' },
+                            payload_schema: { type: 'object', description: 'Event payload schema definition (JSON Schema)' },
+                            component_scope: { type: 'string', description: 'Component scope for event availability' },
+                            global_event: { type: 'boolean', description: 'Global event accessible across all pages', default: false },
+                            bubbles: { type: 'boolean', description: 'Event bubbles up DOM tree', default: true },
+                            cancelable: { type: 'boolean', description: 'Event can be cancelled', default: true }
+                        },
+                        required: ['name', 'label']
+                    }
+                },
+                // UI Builder Validation & Analytics
+                {
+                    name: 'snow_analyze_uib_page_performance',
+                    description: 'Analyzes UI Builder page performance including load times, component efficiency, and optimization recommendations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Page sys_id to analyze' },
+                            include_components: { type: 'boolean', description: 'Include component-level performance analysis', default: true },
+                            include_data_broker_stats: { type: 'boolean', description: 'Include data broker performance metrics', default: true },
+                            include_client_scripts: { type: 'boolean', description: 'Include client script performance', default: true },
+                            time_period_days: { type: 'number', description: 'Analysis period in days', default: 30 },
+                            detailed_analysis: { type: 'boolean', description: 'Generate detailed performance report', default: false }
+                        },
+                        required: ['page_id']
+                    }
+                },
+                {
+                    name: 'snow_validate_uib_page_structure',
+                    description: 'Validates UI Builder page structure, component relationships, data flow integrity, and best practices compliance.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Page sys_id to validate' },
+                            check_data_brokers: { type: 'boolean', description: 'Validate data broker connections and queries', default: true },
+                            check_component_dependencies: { type: 'boolean', description: 'Check component dependencies and compatibility', default: true },
+                            check_routing: { type: 'boolean', description: 'Validate page routing and URL configuration', default: true },
+                            check_security: { type: 'boolean', description: 'Validate security, ACLs, and access controls', default: true },
+                            check_performance: { type: 'boolean', description: 'Check for performance best practices', default: true },
+                            check_accessibility: { type: 'boolean', description: 'Validate accessibility compliance', default: false }
+                        },
+                        required: ['page_id']
+                    }
+                },
+                {
+                    name: 'snow_discover_uib_page_usage',
+                    description: 'Analyzes UI Builder page usage patterns, user interactions, and component effectiveness.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            page_id: { type: 'string', description: 'Page sys_id to analyze usage for' },
+                            time_period_days: { type: 'number', description: 'Analysis period in days', default: 30 },
+                            include_user_journeys: { type: 'boolean', description: 'Include user journey analysis', default: false },
+                            include_conversion_rates: { type: 'boolean', description: 'Include conversion and engagement rates', default: false },
+                            group_by_role: { type: 'boolean', description: 'Group analytics by user role', default: false }
+                        },
+                        required: ['page_id']
+                    }
+                },
                 {
                     name: 'snow_create_mobile_action',
                     description: 'Creates custom actions for mobile app interfaces.',
@@ -380,6 +769,77 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_configure_offline_sync':
                         result = await this.configureOfflineSync(args);
                         break;
+                    // UI Builder Page Management
+                    case 'snow_create_uib_page':
+                        result = await this.createUIBPage(args);
+                        break;
+                    case 'snow_update_uib_page':
+                        result = await this.updateUIBPage(args);
+                        break;
+                    case 'snow_delete_uib_page':
+                        result = await this.deleteUIBPage(args);
+                        break;
+                    case 'snow_discover_uib_pages':
+                        result = await this.discoverUIBPages(args);
+                        break;
+                    // UI Builder Component Management
+                    case 'snow_create_uib_component':
+                        result = await this.createUIBComponent(args);
+                        break;
+                    case 'snow_update_uib_component':
+                        result = await this.updateUIBComponent(args);
+                        break;
+                    case 'snow_discover_uib_components':
+                        result = await this.discoverUIBComponents(args);
+                        break;
+                    case 'snow_clone_uib_component':
+                        result = await this.cloneUIBComponent(args);
+                        break;
+                    // UI Builder Data Broker Management
+                    case 'snow_create_uib_data_broker':
+                        result = await this.createUIBDataBroker(args);
+                        break;
+                    case 'snow_configure_uib_data_broker':
+                        result = await this.configureUIBDataBroker(args);
+                        break;
+                    // UI Builder Page Layout Management
+                    case 'snow_add_uib_page_element':
+                        result = await this.addUIBPageElement(args);
+                        break;
+                    case 'snow_update_uib_page_element':
+                        result = await this.updateUIBPageElement(args);
+                        break;
+                    case 'snow_remove_uib_page_element':
+                        result = await this.removeUIBPageElement(args);
+                        break;
+                    // UI Builder Page Registry & Routing
+                    case 'snow_create_uib_page_registry':
+                        result = await this.createUIBPageRegistry(args);
+                        break;
+                    case 'snow_discover_uib_routes':
+                        result = await this.discoverUIBRoutes(args);
+                        break;
+                    // UI Builder Client Script Management
+                    case 'snow_create_uib_client_script':
+                        result = await this.createUIBClientScript(args);
+                        break;
+                    case 'snow_create_uib_client_state':
+                        result = await this.createUIBClientState(args);
+                        break;
+                    // UI Builder Event Management
+                    case 'snow_create_uib_event':
+                        result = await this.createUIBEvent(args);
+                        break;
+                    // UI Builder Validation & Analytics
+                    case 'snow_analyze_uib_page_performance':
+                        result = await this.analyzeUIBPagePerformance(args);
+                        break;
+                    case 'snow_validate_uib_page_structure':
+                        result = await this.validateUIBPageStructure(args);
+                        break;
+                    case 'snow_discover_uib_page_usage':
+                        result = await this.discoverUIBPageUsage(args);
+                        break;
                     case 'snow_create_mobile_action':
                         result = await this.createMobileAction(args);
                         break;
@@ -811,18 +1271,43 @@ ${executionList}
     // Agent Workspace Implementation
     async createWorkspace(args) {
         try {
-            this.logger.info('Creating workspace...');
+            this.logger.info('Creating Agent Workspace...');
+            // First validate Agent Workspace table access
+            const tableCheck = await this.client.searchRecords('sys_aw_master_config', '', 1);
+            if (!tableCheck.success) {
+                return {
+                    success: false,
+                    error: 'Agent Workspace tables not accessible. This feature requires ServiceNow Agent Workspace plugin to be installed and activated.',
+                    suggestion: 'Install Agent Workspace plugin: System Applications → All Available Applications → Search for "Agent Workspace"'
+                };
+            }
             const workspaceData = {
                 name: args.name,
                 description: args.description || '',
-                tables: args.tables.join(','),
+                tables: args.tables ? args.tables.join(',') : '',
                 home_page: args.home_page || '',
                 theme: args.theme || 'default',
-                roles: args.roles ? args.roles.join(',') : ''
+                roles: args.roles ? args.roles.join(',') : '',
+                active: true
             };
-            this.logger.trackAPICall('CREATE', 'sys_aw_workspace', 1);
-            const response = await this.client.createRecord('sys_aw_workspace', workspaceData);
+            this.logger.trackAPICall('CREATE', 'sys_aw_master_config', 1);
+            const response = await this.client.createRecord('sys_aw_master_config', workspaceData);
             if (!response.success) {
+                // Provide specific error guidance
+                if (response.error?.includes('403') || response.error?.includes('Forbidden')) {
+                    return {
+                        success: false,
+                        error: 'Insufficient permissions to create Agent Workspace. Requires workspace_admin role or elevated permissions.',
+                        suggestion: 'Contact your ServiceNow administrator to grant Agent Workspace permissions.'
+                    };
+                }
+                if (response.error?.includes('400') || response.error?.includes('Bad Request')) {
+                    return {
+                        success: false,
+                        error: 'Invalid workspace configuration. Agent Workspace may not be properly configured in this instance.',
+                        suggestion: 'Verify Agent Workspace is enabled and configured. Check System Properties > Agent Workspace settings.'
+                    };
+                }
                 throw new Error(`Failed to create workspace: ${response.error}`);
             }
             return {
@@ -968,7 +1453,7 @@ ${args.filter ? `🔍 Filter: ${args.filter}` : ''}
             const response = await this.client.createRecord('sys_aw_notification_config', notificationData);
             if (!response.success) {
                 // Fallback to updating workspace
-                await this.client.updateRecord('sys_aw_workspace', args.workspace, {
+                await this.client.updateRecord('sys_aw_master_config', args.workspace, {
                     notifications_enabled: args.enable_desktop || args.enable_sound
                 });
             }
@@ -994,10 +1479,15 @@ ${args.filter ? `🔍 Filter: ${args.filter}` : ''}
     }
     async discoverWorkspaces(args) {
         try {
-            this.logger.info('Discovering workspaces...');
-            const response = await this.client.searchRecords('sys_aw_workspace', '', 50);
+            this.logger.info('Discovering Agent Workspaces...');
+            // Validate table access first
+            const response = await this.client.searchRecords('sys_aw_master_config', '', 50);
             if (!response.success) {
-                throw new Error('Failed to discover workspaces');
+                return {
+                    success: false,
+                    error: 'Cannot access Agent Workspace tables. Agent Workspace plugin may not be installed or activated.',
+                    suggestion: 'Install Agent Workspace plugin in ServiceNow: System Applications → All Available Applications → Agent Workspace'
+                };
             }
             const workspaces = response.data.result;
             if (!workspaces.length) {
@@ -1037,10 +1527,21 @@ ${workspaceList.join('\n\n')}
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover workspaces: ${error}`);
         }
     }
-    // Mobile Implementation
+    // Mobile Implementation  
     async configureMobileApp(args) {
         try {
-            this.logger.info('Configuring mobile app...');
+            this.logger.info('Configuring ServiceNow Mobile app...');
+            // Validate mobile app tables access first
+            const mobileTableCheck = await this.client.searchRecords('sys_push_notif_msg', '', 1);
+            if (!mobileTableCheck.success) {
+                return {
+                    success: false,
+                    error: 'ServiceNow Mobile app tables not accessible. This feature requires Mobile Publishing plugin and Mobile Application Management licensing.',
+                    suggestion: 'Install Mobile Publishing plugin: System Applications → ServiceNow Store → Search "Mobile Publishing". Requires separate licensing.',
+                    plugin_required: 'Mobile Publishing',
+                    licensing_note: 'Mobile Publishing is a paid plugin requiring additional ServiceNow licensing'
+                };
+            }
             const mobileConfig = {
                 app_name: args.app_name,
                 enabled_modules: args.enabled_modules ? args.enabled_modules.join(',') : '',
@@ -1052,6 +1553,21 @@ ${workspaceList.join('\n\n')}
             this.logger.trackAPICall('CREATE', 'sys_mobile_config', 1);
             const response = await this.client.createRecord('sys_mobile_config', mobileConfig);
             if (!response.success) {
+                // Provide specific mobile error guidance
+                if (response.error?.includes('400') || response.error?.includes('Bad Request')) {
+                    return {
+                        success: false,
+                        error: 'Mobile app configuration failed. ServiceNow Mobile Publishing plugin may not be installed or properly configured.',
+                        suggestion: 'Verify Mobile Publishing plugin is installed and activated. Check ServiceNow Store for Mobile Publishing application.'
+                    };
+                }
+                if (response.error?.includes('403') || response.error?.includes('Forbidden')) {
+                    return {
+                        success: false,
+                        error: 'Insufficient permissions for mobile app configuration. Requires mobile_admin role or admin privileges.',
+                        suggestion: 'Contact ServiceNow administrator for mobile application management permissions.'
+                    };
+                }
                 throw new Error(`Failed to configure mobile app: ${response.error}`);
             }
             return {
@@ -1078,6 +1594,16 @@ ${workspaceList.join('\n\n')}
     async createMobileLayout(args) {
         try {
             this.logger.info('Creating mobile layout...');
+            // Validate mobile layout tables access
+            const layoutTableCheck = await this.client.searchRecords('sys_mobile_layout', '', 1);
+            if (!layoutTableCheck.success) {
+                return {
+                    success: false,
+                    error: 'Mobile layout tables not accessible. Requires ServiceNow Mobile Publishing plugin and Mobile Device Management licensing.',
+                    suggestion: 'Install Mobile Publishing plugin from ServiceNow Store. Contact ServiceNow sales for Mobile Application Management licensing.',
+                    alternative: 'Use Service Portal widgets for mobile-responsive interfaces instead.'
+                };
+            }
             const layoutData = {
                 name: args.name,
                 table: args.table,
@@ -1153,6 +1679,16 @@ ${workspaceList.join('\n\n')}
     async configureOfflineSync(args) {
         try {
             this.logger.info('Configuring offline sync...');
+            // Validate offline sync capabilities
+            const syncTableCheck = await this.client.searchRecords('sys_offline_sync', '', 1);
+            if (!syncTableCheck.success) {
+                return {
+                    success: false,
+                    error: 'Offline sync not available. Requires ServiceNow Mobile Publishing plugin with offline capabilities.',
+                    suggestion: 'Install Mobile Publishing plugin for offline sync. Alternative: Use ServiceNow Agent mobile app for basic offline access.',
+                    licensing_note: 'Offline sync requires Mobile Publishing licensing (paid plugin)'
+                };
+            }
             const syncConfig = {
                 table: args.table,
                 filter: args.filter || '',
@@ -1308,6 +1844,982 @@ ${configList}${layoutsText}${offlineText}
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover mobile configs: ${error}`);
         }
     }
+    // ==========================================
+    // UI BUILDER IMPLEMENTATION METHODS
+    // Official ServiceNow sys_ux_* API implementations
+    // ==========================================
+    /**
+     * Create UI Builder Page using sys_ux_page table
+     */
+    async createUIBPage(args) {
+        try {
+            this.logger.info(`🏗️ Creating UI Builder page: ${args.name}`);
+            // Create the page in sys_ux_page table
+            const pageData = {
+                name: args.name,
+                title: args.title,
+                description: args.description || '',
+                application: args.application || 'global',
+                theme: args.theme || 'standard',
+                layout_type: args.layout_type || 'container',
+                responsive: args.responsive !== false,
+                public_read: args.public_read || false,
+                active: args.active !== false
+            };
+            const pageResponse = await this.client.createRecord('sys_ux_page', pageData);
+            if (!pageResponse.success) {
+                throw new Error(`Failed to create UI Builder page: ${pageResponse.error}`);
+            }
+            const page = pageResponse.data;
+            // Create page registry entry for routing
+            const registryData = {
+                page: page.sys_id,
+                path: args.route,
+                application: args.application || 'global',
+                public_access: args.public_read || false,
+                active: true
+            };
+            const registryResponse = await this.client.createRecord('sys_ux_page_registry', registryData);
+            this.logger.info(`✅ UI Builder page created successfully: ${page.sys_id}`);
+            return {
+                success: true,
+                page: page,
+                route: registryResponse.success ? registryResponse.data : null,
+                message: `UI Builder page '${args.name}' created with route '${args.route}'`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder page:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update UI Builder Page
+     */
+    async updateUIBPage(args) {
+        try {
+            this.logger.info(`🔧 Updating UI Builder page: ${args.page_id}`);
+            const updates = {};
+            if (args.title)
+                updates.title = args.title;
+            if (args.description)
+                updates.description = args.description;
+            if (args.theme)
+                updates.theme = args.theme;
+            if (args.layout_type)
+                updates.layout_type = args.layout_type;
+            if (typeof args.responsive === 'boolean')
+                updates.responsive = args.responsive;
+            if (typeof args.active === 'boolean')
+                updates.active = args.active;
+            const response = await this.client.updateRecord('sys_ux_page', args.page_id, updates);
+            if (!response.success) {
+                throw new Error(`Failed to update UI Builder page: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder page updated successfully');
+            return {
+                success: true,
+                page: response.data,
+                message: `UI Builder page updated successfully`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to update UI Builder page:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete UI Builder Page with dependency validation
+     */
+    async deleteUIBPage(args) {
+        try {
+            this.logger.info(`🗑️ Deleting UI Builder page: ${args.page_id}`);
+            // Check dependencies if validation enabled
+            if (!args.force_delete) {
+                const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`, 1);
+                if (elementsResponse.success && elementsResponse.data.result.length > 0) {
+                    return {
+                        success: false,
+                        error: 'Page has elements. Use force_delete: true to override or manually remove elements first.',
+                        dependencies: elementsResponse.data.result.length
+                    };
+                }
+            }
+            // Clean up associated records first
+            if (args.clean_orphaned_elements) {
+                const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`);
+                if (elementsResponse.success) {
+                    for (const element of elementsResponse.data.result) {
+                        await this.client.deleteRecord('sys_ux_page_element', element.sys_id);
+                    }
+                }
+            }
+            // Delete page registry entries
+            const registryResponse = await this.client.searchRecords('sys_ux_page_registry', `page=${args.page_id}`);
+            if (registryResponse.success) {
+                for (const registry of registryResponse.data.result) {
+                    await this.client.deleteRecord('sys_ux_page_registry', registry.sys_id);
+                }
+            }
+            // Delete the page
+            const deleteResponse = await this.client.deleteRecord('sys_ux_page', args.page_id);
+            if (!deleteResponse.success) {
+                throw new Error(`Failed to delete UI Builder page: ${deleteResponse.error}`);
+            }
+            this.logger.info('✅ UI Builder page deleted successfully');
+            return {
+                success: true,
+                message: 'UI Builder page and associated configurations deleted successfully'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to delete UI Builder page:', error);
+            throw error;
+        }
+    }
+    /**
+     * Discover UI Builder Pages
+     */
+    async discoverUIBPages(args) {
+        try {
+            this.logger.info('🔍 Discovering UI Builder pages...');
+            const conditions = [];
+            if (args.active_only)
+                conditions.push('active=true');
+            if (args.application)
+                conditions.push(`application=${args.application}`);
+            if (args.name_filter)
+                conditions.push(`nameLIKE${args.name_filter}`);
+            if (args.theme_filter)
+                conditions.push(`theme=${args.theme_filter}`);
+            const query = conditions.join('^');
+            const pagesResponse = await this.client.searchRecords('sys_ux_page', query, args.limit || 50);
+            if (!pagesResponse.success) {
+                throw new Error(`Failed to discover UI Builder pages: ${pagesResponse.error}`);
+            }
+            const pages = pagesResponse.data.result;
+            // Enrich with additional data if requested
+            for (const page of pages) {
+                if (args.include_routing) {
+                    const routeResponse = await this.client.searchRecords('sys_ux_page_registry', `page=${page.sys_id}`, 10);
+                    page.routes = routeResponse.success ? routeResponse.data.result : [];
+                }
+                if (args.include_elements) {
+                    const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${page.sys_id}`, 100);
+                    page.elements = elementsResponse.success ? elementsResponse.data.result : [];
+                }
+                if (args.include_data_brokers) {
+                    const brokersResponse = await this.client.searchRecords('sys_ux_data_broker', `page=${page.sys_id}`, 50);
+                    page.data_brokers = brokersResponse.success ? brokersResponse.data.result : [];
+                }
+            }
+            this.logger.info(`✅ Found ${pages.length} UI Builder pages`);
+            return {
+                success: true,
+                pages: pages,
+                count: pages.length
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to discover UI Builder pages:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Component using sys_ux_lib_component and sys_ux_lib_source_script
+     */
+    async createUIBComponent(args) {
+        try {
+            this.logger.info(`🧩 Creating UI Builder component: ${args.name}`);
+            // First create the source script
+            const sourceData = {
+                name: args.name,
+                source: args.source_script,
+                version: args.version || '1.0.0',
+                active: true
+            };
+            const sourceResponse = await this.client.createRecord('sys_ux_lib_source_script', sourceData);
+            if (!sourceResponse.success) {
+                throw new Error(`Failed to create component source: ${sourceResponse.error}`);
+            }
+            // Then create the component definition
+            const componentData = {
+                name: args.name,
+                label: args.label,
+                description: args.description || '',
+                category: args.category || 'custom',
+                source_script: sourceResponse.data.sys_id,
+                properties_schema: args.properties_schema ? JSON.stringify(args.properties_schema) : '{}',
+                events: args.events ? args.events.join(',') : '',
+                dependencies: args.dependencies ? args.dependencies.join(',') : '',
+                styling: args.styling ? JSON.stringify(args.styling) : '{}',
+                version: args.version || '1.0.0',
+                tags: args.tags ? args.tags.join(',') : '',
+                active: true
+            };
+            const componentResponse = await this.client.createRecord('sys_ux_lib_component', componentData);
+            if (!componentResponse.success) {
+                // Cleanup source script on failure
+                await this.client.deleteRecord('sys_ux_lib_source_script', sourceResponse.data.sys_id);
+                throw new Error(`Failed to create component: ${componentResponse.error}`);
+            }
+            this.logger.info('✅ UI Builder component created successfully');
+            return {
+                success: true,
+                component: componentResponse.data,
+                source_script: sourceResponse.data,
+                message: `Custom UI Builder component '${args.name}' created successfully`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder component:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update UI Builder Component
+     */
+    async updateUIBComponent(args) {
+        try {
+            this.logger.info(`🔧 Updating UI Builder component: ${args.component_id}`);
+            const updates = {};
+            if (args.label)
+                updates.label = args.label;
+            if (args.description)
+                updates.description = args.description;
+            if (args.properties_schema)
+                updates.properties_schema = JSON.stringify(args.properties_schema);
+            if (args.styling)
+                updates.styling = JSON.stringify(args.styling);
+            if (args.version)
+                updates.version = args.version;
+            if (args.events)
+                updates.events = args.events.join(',');
+            if (args.dependencies)
+                updates.dependencies = args.dependencies.join(',');
+            if (typeof args.active === 'boolean')
+                updates.active = args.active;
+            const componentResponse = await this.client.updateRecord('sys_ux_lib_component', args.component_id, updates);
+            if (!componentResponse.success) {
+                throw new Error(`Failed to update component: ${componentResponse.error}`);
+            }
+            // Update source script if provided
+            if (args.source_script) {
+                const component = componentResponse.data;
+                if (component.source_script) {
+                    await this.client.updateRecord('sys_ux_lib_source_script', component.source_script, {
+                        source: args.source_script,
+                        version: args.version || component.version
+                    });
+                }
+            }
+            this.logger.info('✅ UI Builder component updated successfully');
+            return {
+                success: true,
+                component: componentResponse.data,
+                message: 'UI Builder component updated successfully'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to update UI Builder component:', error);
+            throw error;
+        }
+    }
+    /**
+     * Discover UI Builder Components
+     */
+    async discoverUIBComponents(args) {
+        try {
+            this.logger.info('🔍 Discovering UI Builder components...');
+            const conditions = [];
+            if (args.category)
+                conditions.push(`category=${args.category}`);
+            if (args.custom_only)
+                conditions.push('category=custom');
+            if (args.built_in_only)
+                conditions.push('category!=custom');
+            if (args.name_filter)
+                conditions.push(`nameLIKE${args.name_filter}^ORlabelLIKE${args.name_filter}`);
+            if (args.version_filter)
+                conditions.push(`versionLIKE${args.version_filter}`);
+            if (args.application)
+                conditions.push(`application=${args.application}`);
+            const query = conditions.join('^');
+            const componentsResponse = await this.client.searchRecords('sys_ux_lib_component', query, args.limit || 100);
+            if (!componentsResponse.success) {
+                throw new Error(`Failed to discover components: ${componentsResponse.error}`);
+            }
+            const components = componentsResponse.data.result;
+            // Enrich with additional data if requested
+            for (const component of components) {
+                if (args.include_source && component.source_script) {
+                    const sourceResponse = await this.client.getRecord('sys_ux_lib_source_script', component.source_script);
+                    component.source_code = sourceResponse.success ? sourceResponse.data : null;
+                }
+                if (args.include_usage_stats) {
+                    const usageResponse = await this.client.searchRecords('sys_ux_page_element', `component=${component.sys_id}^ORcomponent=${component.name}`);
+                    component.usage_count = usageResponse.success ? usageResponse.data.result.length : 0;
+                }
+                if (args.include_dependencies && component.dependencies) {
+                    component.dependency_list = component.dependencies.split(',').map(d => d.trim()).filter(d => d);
+                }
+            }
+            this.logger.info(`✅ Found ${components.length} UI Builder components`);
+            return {
+                success: true,
+                components: components,
+                count: components.length
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to discover UI Builder components:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clone UI Builder Component
+     */
+    async cloneUIBComponent(args) {
+        try {
+            this.logger.info(`📋 Cloning UI Builder component: ${args.source_component_id} → ${args.new_name}`);
+            // Get source component
+            const sourceResponse = await this.client.getRecord('sys_ux_lib_component', args.source_component_id);
+            if (!sourceResponse.success) {
+                throw new Error(`Source component not found: ${args.source_component_id}`);
+            }
+            const sourceComponent = sourceResponse.data;
+            // Get source script
+            let sourceCode = '';
+            if (sourceComponent.source_script) {
+                const sourceScriptResponse = await this.client.getRecord('sys_ux_lib_source_script', sourceComponent.source_script);
+                if (sourceScriptResponse.success) {
+                    sourceCode = sourceScriptResponse.data.source || '';
+                }
+            }
+            // Apply modifications to source code if provided
+            if (args.modifications) {
+                for (const [find, replace] of Object.entries(args.modifications)) {
+                    sourceCode = sourceCode.replace(new RegExp(find, 'g'), replace);
+                }
+            }
+            // Create cloned component
+            const cloneData = {
+                name: args.new_name,
+                label: args.new_label,
+                description: args.description || `Clone of ${sourceComponent.label}`,
+                category: args.category || 'custom',
+                source_script: sourceCode,
+                properties_schema: sourceComponent.properties_schema,
+                events: sourceComponent.events,
+                dependencies: sourceComponent.dependencies,
+                styling: sourceComponent.styling,
+                version: args.version || '1.0.0'
+            };
+            const cloneResult = await this.createUIBComponent(cloneData);
+            this.logger.info('✅ UI Builder component cloned successfully');
+            return {
+                success: true,
+                cloned_component: cloneResult.component,
+                source_component: sourceComponent,
+                message: `Component '${args.new_name}' cloned from '${sourceComponent.label}'`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to clone UI Builder component:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Data Broker
+     */
+    async createUIBDataBroker(args) {
+        try {
+            this.logger.info(`🔗 Creating UI Builder data broker: ${args.name}`);
+            const brokerData = {
+                name: args.name,
+                label: args.label,
+                type: args.type || 'table',
+                table: args.table || '',
+                query: args.query || '',
+                script: args.script || '',
+                rest_message: args.rest_message || '',
+                fields: args.fields ? args.fields.join(',') : '',
+                auto_refresh: args.auto_refresh || false,
+                refresh_interval: args.refresh_interval || 30,
+                cache_duration: args.cache_duration || 300,
+                max_records: args.max_records || 1000,
+                active: true
+            };
+            const response = await this.client.createRecord('sys_ux_data_broker', brokerData);
+            if (!response.success) {
+                throw new Error(`Failed to create data broker: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder data broker created successfully');
+            return {
+                success: true,
+                data_broker: response.data,
+                message: `Data broker '${args.name}' created for ${args.type} type`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder data broker:', error);
+            throw error;
+        }
+    }
+    /**
+     * Configure UI Builder Data Broker
+     */
+    async configureUIBDataBroker(args) {
+        try {
+            this.logger.info(`⚙️ Configuring UI Builder data broker: ${args.broker_id}`);
+            const updates = {};
+            if (args.query)
+                updates.query = args.query;
+            if (args.fields)
+                updates.fields = args.fields.join(',');
+            if (typeof args.auto_refresh === 'boolean')
+                updates.auto_refresh = args.auto_refresh;
+            if (args.refresh_interval)
+                updates.refresh_interval = args.refresh_interval;
+            if (args.cache_duration)
+                updates.cache_duration = args.cache_duration;
+            if (args.max_records)
+                updates.max_records = args.max_records;
+            if (typeof args.active === 'boolean')
+                updates.active = args.active;
+            const response = await this.client.updateRecord('sys_ux_data_broker', args.broker_id, updates);
+            if (!response.success) {
+                throw new Error(`Failed to configure data broker: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder data broker configured successfully');
+            return {
+                success: true,
+                data_broker: response.data,
+                message: 'Data broker configuration updated successfully'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to configure UI Builder data broker:', error);
+            throw error;
+        }
+    }
+    /**
+     * Add UI Builder Page Element
+     */
+    async addUIBPageElement(args) {
+        try {
+            this.logger.info(`➕ Adding element to UI Builder page: ${args.component}`);
+            const elementData = {
+                page: args.page_id,
+                component: args.component,
+                container_id: args.container_id || '',
+                position: args.position || 0,
+                properties: args.properties ? JSON.stringify(args.properties) : '{}',
+                data_broker: args.data_broker || '',
+                responsive_config: args.responsive_config ? JSON.stringify(args.responsive_config) : '{}',
+                conditional_display: args.conditional_display || '',
+                css_classes: args.css_classes ? args.css_classes.join(' ') : '',
+                inline_styles: args.inline_styles ? JSON.stringify(args.inline_styles) : '{}',
+                active: true
+            };
+            const response = await this.client.createRecord('sys_ux_page_element', elementData);
+            if (!response.success) {
+                throw new Error(`Failed to add page element: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder page element added successfully');
+            return {
+                success: true,
+                element: response.data,
+                message: `Component '${args.component}' added to page successfully`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to add UI Builder page element:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update UI Builder Page Element
+     */
+    async updateUIBPageElement(args) {
+        try {
+            this.logger.info(`🔧 Updating UI Builder page element: ${args.element_id}`);
+            const updates = {};
+            if (args.properties)
+                updates.properties = JSON.stringify(args.properties);
+            if (args.position !== undefined)
+                updates.position = args.position;
+            if (args.data_broker)
+                updates.data_broker = args.data_broker;
+            if (args.responsive_config)
+                updates.responsive_config = JSON.stringify(args.responsive_config);
+            if (args.conditional_display)
+                updates.conditional_display = args.conditional_display;
+            if (args.css_classes)
+                updates.css_classes = args.css_classes.join(' ');
+            if (args.inline_styles)
+                updates.inline_styles = JSON.stringify(args.inline_styles);
+            const response = await this.client.updateRecord('sys_ux_page_element', args.element_id, updates);
+            if (!response.success) {
+                throw new Error(`Failed to update page element: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder page element updated successfully');
+            return {
+                success: true,
+                element: response.data,
+                message: 'Page element updated successfully'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to update UI Builder page element:', error);
+            throw error;
+        }
+    }
+    /**
+     * Remove UI Builder Page Element
+     */
+    async removeUIBPageElement(args) {
+        try {
+            this.logger.info(`🗑️ Removing UI Builder page element: ${args.element_id}`);
+            // Validate dependencies if requested
+            if (args.validate_dependencies) {
+                const dependentResponse = await this.client.searchRecords('sys_ux_page_element', `container_id=${args.element_id}`, 10);
+                if (dependentResponse.success && dependentResponse.data.result.length > 0) {
+                    return {
+                        success: false,
+                        error: 'Element has dependent child elements. Remove children first or use validate_dependencies: false',
+                        dependent_elements: dependentResponse.data.result.length
+                    };
+                }
+            }
+            const response = await this.client.deleteRecord('sys_ux_page_element', args.element_id);
+            if (!response.success) {
+                throw new Error(`Failed to remove page element: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder page element removed successfully');
+            return {
+                success: true,
+                message: 'Page element removed successfully'
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to remove UI Builder page element:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Page Registry (Routing)
+     */
+    async createUIBPageRegistry(args) {
+        try {
+            this.logger.info(`🛣️ Creating UI Builder page registry: ${args.path}`);
+            const registryData = {
+                page: args.page_id,
+                path: args.path,
+                application: args.application || 'global',
+                roles: args.roles ? args.roles.join(',') : '',
+                public_access: args.public_access || false,
+                redirect_url: args.redirect_url || '',
+                meta_title: args.meta_title || '',
+                meta_description: args.meta_description || '',
+                parameter_mapping: args.parameter_mapping ? JSON.stringify(args.parameter_mapping) : '{}',
+                cache_control: args.cache_control || '',
+                active: true
+            };
+            const response = await this.client.createRecord('sys_ux_page_registry', registryData);
+            if (!response.success) {
+                throw new Error(`Failed to create page registry: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder page registry created successfully');
+            return {
+                success: true,
+                registry: response.data,
+                message: `Page routing configured for path '${args.path}'`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder page registry:', error);
+            throw error;
+        }
+    }
+    /**
+     * Discover UI Builder Routes
+     */
+    async discoverUIBRoutes(args) {
+        try {
+            this.logger.info('🔍 Discovering UI Builder routes...');
+            const conditions = [];
+            if (args.application)
+                conditions.push(`application=${args.application}`);
+            if (args.active_only)
+                conditions.push('active=true');
+            if (args.path_pattern)
+                conditions.push(`pathLIKE${args.path_pattern}`);
+            if (args.role_filter)
+                conditions.push(`rolesLIKE${args.role_filter}`);
+            const query = conditions.join('^');
+            const routesResponse = await this.client.searchRecords('sys_ux_page_registry', query, 100);
+            if (!routesResponse.success) {
+                throw new Error(`Failed to discover routes: ${routesResponse.error}`);
+            }
+            const routes = routesResponse.data.result;
+            // Enrich with additional data if requested
+            for (const route of routes) {
+                if (args.include_security && route.roles) {
+                    route.required_roles = route.roles.split(',').map(r => r.trim()).filter(r => r);
+                }
+                if (args.include_parameters && route.parameter_mapping) {
+                    try {
+                        route.parameters = JSON.parse(route.parameter_mapping);
+                    }
+                    catch (e) {
+                        route.parameters = {};
+                    }
+                }
+                // Add page information
+                if (route.page) {
+                    const pageResponse = await this.client.getRecord('sys_ux_page', route.page);
+                    route.page_info = pageResponse.success ? pageResponse.data : null;
+                }
+            }
+            this.logger.info(`✅ Found ${routes.length} UI Builder routes`);
+            return {
+                success: true,
+                routes: routes,
+                count: routes.length
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to discover UI Builder routes:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Client Script
+     */
+    async createUIBClientScript(args) {
+        try {
+            this.logger.info(`📝 Creating UI Builder client script: ${args.name}`);
+            const scriptData = {
+                page: args.page_id,
+                name: args.name,
+                type: args.type,
+                script: args.script,
+                component_reference: args.component_reference || '',
+                event_name: args.event_name || '',
+                execution_order: args.execution_order || 100,
+                async_execution: args.async_execution || false,
+                error_handling: args.error_handling || 'log',
+                active: args.active !== false
+            };
+            const response = await this.client.createRecord('sys_ux_client_script', scriptData);
+            if (!response.success) {
+                throw new Error(`Failed to create client script: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder client script created successfully');
+            return {
+                success: true,
+                script: response.data,
+                message: `Client script '${args.name}' created for ${args.type} trigger`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder client script:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Client State
+     */
+    async createUIBClientState(args) {
+        try {
+            this.logger.info(`💾 Creating UI Builder client state: ${args.state_name}`);
+            const stateData = {
+                page: args.page_id,
+                state_name: args.state_name,
+                initial_value: args.initial_value,
+                scope: args.scope || 'page',
+                persistent: args.persistent || false,
+                reactive: args.reactive !== false,
+                validation_schema: args.validation_schema ? JSON.stringify(args.validation_schema) : '{}',
+                description: args.description || '',
+                active: true
+            };
+            const response = await this.client.createRecord('sys_ux_client_state', stateData);
+            if (!response.success) {
+                throw new Error(`Failed to create client state: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder client state created successfully');
+            return {
+                success: true,
+                state: response.data,
+                message: `Client state '${args.state_name}' configured with ${args.scope} scope`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder client state:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create UI Builder Event
+     */
+    async createUIBEvent(args) {
+        try {
+            this.logger.info(`⚡ Creating UI Builder event: ${args.name}`);
+            const eventData = {
+                name: args.name,
+                label: args.label,
+                description: args.description || '',
+                payload_schema: args.payload_schema ? JSON.stringify(args.payload_schema) : '{}',
+                component_scope: args.component_scope || '',
+                global_event: args.global_event || false,
+                bubbles: args.bubbles !== false,
+                cancelable: args.cancelable !== false,
+                active: true
+            };
+            const response = await this.client.createRecord('sys_ux_event', eventData);
+            if (!response.success) {
+                throw new Error(`Failed to create event: ${response.error}`);
+            }
+            this.logger.info('✅ UI Builder event created successfully');
+            return {
+                success: true,
+                event: response.data,
+                message: `Custom event '${args.name}' created ${args.global_event ? '(global)' : '(scoped)'}`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create UI Builder event:', error);
+            throw error;
+        }
+    }
+    /**
+     * Analyze UI Builder Page Performance
+     */
+    async analyzeUIBPagePerformance(args) {
+        try {
+            this.logger.info(`📊 Analyzing UI Builder page performance: ${args.page_id}`);
+            const analysis = {
+                page_id: args.page_id,
+                analysis_date: new Date().toISOString(),
+                components: [],
+                data_brokers: [],
+                client_scripts: [],
+                recommendations: [],
+                total_components: 0,
+                page_info: null
+            };
+            // Get page info
+            const pageResponse = await this.client.getRecord('sys_ux_page', args.page_id);
+            if (!pageResponse.success) {
+                throw new Error('Page not found');
+            }
+            analysis.page_info = pageResponse.data;
+            // Analyze components if requested
+            if (args.include_components) {
+                const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`, 100);
+                if (elementsResponse.success) {
+                    analysis.total_components = elementsResponse.data.result.length;
+                    analysis.components = elementsResponse.data.result.map(element => ({
+                        component: element.component,
+                        position: element.position,
+                        has_data_broker: !!element.data_broker,
+                        has_conditional_display: !!element.conditional_display
+                    }));
+                }
+            }
+            // Analyze data brokers if requested  
+            if (args.include_data_broker_stats) {
+                const brokersResponse = await this.client.searchRecords('sys_ux_data_broker', `page=${args.page_id}`, 50);
+                if (brokersResponse.success) {
+                    analysis.data_brokers = brokersResponse.data.result.map(broker => ({
+                        name: broker.name,
+                        type: broker.type,
+                        table: broker.table,
+                        auto_refresh: broker.auto_refresh,
+                        cache_duration: broker.cache_duration
+                    }));
+                }
+            }
+            // Analyze client scripts if requested
+            if (args.include_client_scripts) {
+                const scriptsResponse = await this.client.searchRecords('sys_ux_client_script', `page=${args.page_id}`, 50);
+                if (scriptsResponse.success) {
+                    analysis.client_scripts = scriptsResponse.data.result.map(script => ({
+                        name: script.name,
+                        type: script.type,
+                        execution_order: script.execution_order,
+                        async_execution: script.async_execution
+                    }));
+                }
+            }
+            // Generate performance recommendations
+            if (analysis.total_components > 20) {
+                analysis.recommendations.push('Consider breaking page into smaller pages - many components may impact performance');
+            }
+            if (analysis.data_brokers.some(db => db.auto_refresh && db.cache_duration < 60)) {
+                analysis.recommendations.push('Some data brokers have short cache duration with auto-refresh - consider optimizing');
+            }
+            if (analysis.client_scripts.length > 10) {
+                analysis.recommendations.push('Many client scripts detected - consider consolidating for better performance');
+            }
+            this.logger.info('✅ UI Builder page performance analysis completed');
+            return {
+                success: true,
+                analysis: analysis,
+                summary: `Page has ${analysis.total_components || 0} components, ${analysis.data_brokers.length} data brokers, ${analysis.client_scripts.length} scripts`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to analyze UI Builder page performance:', error);
+            throw error;
+        }
+    }
+    /**
+     * Validate UI Builder Page Structure
+     */
+    async validateUIBPageStructure(args) {
+        try {
+            this.logger.info(`✅ Validating UI Builder page structure: ${args.page_id}`);
+            const validation = {
+                page_id: args.page_id,
+                validation_date: new Date().toISOString(),
+                is_valid: true,
+                errors: [],
+                warnings: [],
+                info: []
+            };
+            // Get page info
+            const pageResponse = await this.client.getRecord('sys_ux_page', args.page_id);
+            if (!pageResponse.success) {
+                validation.errors.push('Page not found');
+                validation.is_valid = false;
+                return { success: true, validation };
+            }
+            const page = pageResponse.data;
+            // Check routing if requested
+            if (args.check_routing) {
+                const routeResponse = await this.client.searchRecords('sys_ux_page_registry', `page=${args.page_id}`, 1);
+                if (!routeResponse.success || routeResponse.data.result.length === 0) {
+                    validation.warnings.push('Page has no routing configuration - may not be accessible');
+                }
+            }
+            // Check data brokers if requested
+            if (args.check_data_brokers) {
+                const brokersResponse = await this.client.searchRecords('sys_ux_data_broker', `page=${args.page_id}`);
+                if (brokersResponse.success) {
+                    for (const broker of brokersResponse.data.result) {
+                        if (broker.type === 'table' && !broker.table) {
+                            validation.errors.push(`Data broker '${broker.name}' has no table configured`);
+                            validation.is_valid = false;
+                        }
+                        if (broker.type === 'script' && !broker.script) {
+                            validation.errors.push(`Data broker '${broker.name}' has no script configured`);
+                            validation.is_valid = false;
+                        }
+                    }
+                }
+            }
+            // Check component dependencies if requested
+            if (args.check_component_dependencies) {
+                const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`);
+                if (elementsResponse.success) {
+                    for (const element of elementsResponse.data.result) {
+                        const componentResponse = await this.client.searchRecords('sys_ux_lib_component', `name=${element.component}^ORsys_id=${element.component}`, 1);
+                        if (!componentResponse.success || componentResponse.data.result.length === 0) {
+                            validation.errors.push(`Page element references unknown component: ${element.component}`);
+                            validation.is_valid = false;
+                        }
+                    }
+                }
+            }
+            // Check security if requested
+            if (args.check_security) {
+                const routeResponse = await this.client.searchRecords('sys_ux_page_registry', `page=${args.page_id}`, 1);
+                if (routeResponse.success && routeResponse.data.result.length > 0) {
+                    const route = routeResponse.data.result[0];
+                    if (!route.public_access && (!route.roles || route.roles.trim() === '')) {
+                        validation.warnings.push('Page is not public but has no role restrictions - check access control');
+                    }
+                }
+            }
+            // Performance checks if requested
+            if (args.check_performance) {
+                const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`);
+                if (elementsResponse.success && elementsResponse.data.result.length > 15) {
+                    validation.warnings.push('Page has many components (>15) - consider performance optimization');
+                }
+            }
+            // Accessibility checks if requested
+            if (args.check_accessibility) {
+                validation.info.push('Accessibility validation requires manual review - check for proper ARIA labels and keyboard navigation');
+            }
+            validation.info.push(`Page '${page.name}' validation completed`);
+            validation.info.push(`Found ${validation.errors.length} errors and ${validation.warnings.length} warnings`);
+            this.logger.info('✅ UI Builder page structure validation completed');
+            return {
+                success: true,
+                validation: validation,
+                summary: `Validation ${validation.is_valid ? 'PASSED' : 'FAILED'}: ${validation.errors.length} errors, ${validation.warnings.length} warnings`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to validate UI Builder page structure:', error);
+            throw error;
+        }
+    }
+    /**
+     * Discover UI Builder Page Usage
+     */
+    async discoverUIBPageUsage(args) {
+        try {
+            this.logger.info(`📈 Analyzing UI Builder page usage: ${args.page_id}`);
+            // Structural usage analysis
+            const usage = {
+                page_id: args.page_id,
+                analysis_date: new Date().toISOString(),
+                components_count: 0,
+                data_brokers_count: 0,
+                client_scripts_count: 0,
+                routes_count: 0,
+                complexity_score: 0
+            };
+            // Count components
+            const elementsResponse = await this.client.searchRecords('sys_ux_page_element', `page=${args.page_id}`);
+            if (elementsResponse.success) {
+                usage.components_count = elementsResponse.data.result.length;
+            }
+            // Count data brokers
+            const brokersResponse = await this.client.searchRecords('sys_ux_data_broker', `page=${args.page_id}`);
+            if (brokersResponse.success) {
+                usage.data_brokers_count = brokersResponse.data.result.length;
+            }
+            // Count client scripts
+            const scriptsResponse = await this.client.searchRecords('sys_ux_client_script', `page=${args.page_id}`);
+            if (scriptsResponse.success) {
+                usage.client_scripts_count = scriptsResponse.data.result.length;
+            }
+            // Count routes
+            const routesResponse = await this.client.searchRecords('sys_ux_page_registry', `page=${args.page_id}`);
+            if (routesResponse.success) {
+                usage.routes_count = routesResponse.data.result.length;
+            }
+            // Calculate complexity score
+            usage.complexity_score = (usage.components_count * 2) + (usage.data_brokers_count * 3) + (usage.client_scripts_count * 4);
+            this.logger.info('✅ UI Builder page usage analysis completed');
+            return {
+                success: true,
+                usage: usage,
+                complexity: usage.complexity_score < 20 ? 'Simple' : usage.complexity_score < 50 ? 'Moderate' : 'Complex',
+                summary: `${usage.components_count} components, ${usage.data_brokers_count} data brokers, ${usage.client_scripts_count} scripts`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to analyze UI Builder page usage:', error);
+            throw error;
+        }
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);