snow-flow 3.3.5 → 3.3.7

package/dist/dynamic-version.js

@@ -36,7 +36,7 @@ function getDynamicVersion() {
         console.warn('Warning: Could not read version from package.json:', error);
     }
     // Fallback to hardcoded version
-    return '3.3.5';
+    return '3.3.7';
 }
 // Export a constant that uses the dynamic version
 exports.VERSION = getDynamicVersion();

package/dist/mcp/servicenow-deployment-mcp.js

@@ -1316,7 +1316,12 @@ ${is403Error ? '\n⚠️  **Possible False Negative**: Widget may have been crea
             const { updateSetId, updateSetName } = await this.ensureUpdateSet('Portal Page', args.page_id);
             // Validate portal page structure
             if (!args.page_id || !args.title) {
-                throw new Error('Portal page must have page_id and title');
+                this.logger.error('Portal page validation failed', {
+                    args,
+                    hasPageId: !!args.page_id,
+                    hasTitle: !!args.title
+                });
+                throw new Error(`Portal page must have page_id and title. Received: page_id=${args.page_id}, title=${args.title}`);
             }
             // Find widget sys_id if widget name is provided
             let widgetSysId = args.widget_sys_id;
@@ -1337,18 +1342,22 @@ ${is403Error ? '\n⚠️  **Possible False Negative**: Widget may have been crea
                 }
             }
             // Determine portal sys_id
-            let portalSysId = '';
-            try {
-                // Default to Employee Service Portal if available, otherwise standard Service Portal
-                const portalQuery = args.portal === 'esc' ? 'url_suffix=esc' : 'url_suffix=sp';
-                const portalResult = await this.client.searchRecords('sp_portal', portalQuery, 1);
-                if (portalResult.success && portalResult.data?.length > 0) {
-                    portalSysId = portalResult.data[0].sys_id;
-                    this.logger.info('Found portal', { portal: args.portal, sys_id: portalSysId });
+            let portalSysId = args.sp_portal || '';
+            // If sp_portal is already a sys_id (32 char hex), use it directly
+            if (!/^[a-f0-9]{32}$/.test(portalSysId)) {
+                // Not a sys_id, try to look it up
+                try {
+                    // Default to Employee Service Portal if available, otherwise standard Service Portal
+                    const portalQuery = args.portal === 'esc' ? 'url_suffix=esc' : 'url_suffix=sp';
+                    const portalResult = await this.client.searchRecords('sp_portal', portalQuery, 1);
+                    if (portalResult.success && portalResult.data?.result?.length > 0) {
+                        portalSysId = portalResult.data.result[0].sys_id;
+                        this.logger.info('Found portal', { portal: args.portal, sys_id: portalSysId });
+                    }
+                }
+                catch (error) {
+                    this.logger.warn('Failed to lookup portal, using provided value', { portal: args.portal, error });
                 }
-            }
-            catch (error) {
-                this.logger.warn('Failed to lookup portal, using default', { portal: args.portal, error });
             }
             // Create portal page
             let pageResult;
@@ -1381,8 +1390,35 @@ ${is403Error ? '\n⚠️  **Possible False Negative**: Widget may have been crea
             const credentials = await this.oauth.loadCredentials();
             // Create widget instances on the page if widget is provided
             const widgetInstances = [];
-            if (widgetSysId && args.widgets && args.widgets.length > 0) {
-                for (const widgetConfig of args.widgets) {
+            // Support both widgets array and single widget
+            const widgetsToCreate = args.widgets || [];
+            // If no widgets array but a single widget is specified, create one widget
+            if (widgetsToCreate.length === 0 && widgetSysId) {
+                widgetsToCreate.push({
+                    widget: args.widget_name || widgetSysId,
+                    width: 12,
+                    row: 1,
+                    column: 1,
+                    title: args.widget_title || args.title || '',
+                    options: args.widget_options || {}
+                });
+            }
+            if (widgetsToCreate.length > 0) {
+                for (const widgetConfig of widgetsToCreate) {
+                    // Determine widget sys_id for this widget
+                    let currentWidgetSysId = widgetSysId; // Default to the main widget
+                    // If widget config specifies a different widget, look it up
+                    if (widgetConfig.widget && widgetConfig.widget !== args.widget_name) {
+                        try {
+                            const widgetLookup = await this.client.searchRecords('sp_widget', `sys_id=${widgetConfig.widget}^ORname=${widgetConfig.widget}`, 1);
+                            if (widgetLookup.success && widgetLookup.data?.result?.length > 0) {
+                                currentWidgetSysId = widgetLookup.data.result[0].sys_id;
+                            }
+                        }
+                        catch (lookupError) {
+                            this.logger.warn('Could not find widget, using default', { widget: widgetConfig.widget });
+                        }
+                    }
                     try {
                         // Create container
                         const containerResult = await this.client.createRecord('sp_container', {
@@ -1417,10 +1453,10 @@ ${is403Error ? '\n⚠️  **Possible False Negative**: Widget may have been crea
                                     // Create widget instance
                                     const instanceResult = await this.client.createRecord('sp_instance', {
                                         sp_column: columnResult.data.sys_id,
-                                        sp_widget: widgetSysId,
+                                        sp_widget: currentWidgetSysId, // Use the current widget sys_id, not the main one
                                         order: widgetConfig.order || 100,
                                         title: widgetConfig.title || '',
-                                        options: JSON.stringify(widgetConfig.options || {}),
+                                        options: JSON.stringify(widgetConfig.options || widgetConfig.widget_parameters || {}),
                                         class_name: widgetConfig.instance_class || '',
                                         color: widgetConfig.color || 'default',
                                         active: true,
@@ -7260,7 +7296,23 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
             case 'widget':
                 return await this.deployWidget(scopedConfig);
             case 'portal_page':
-                return await this.deployPortalPage(scopedConfig);
+                // Map config fields to expected parameter names for portal_page
+                const portalPageArgs = {
+                    page_id: scopedConfig.id || scopedConfig.page_id,
+                    title: scopedConfig.title,
+                    widget_name: scopedConfig.widget_name,
+                    widget_sys_id: scopedConfig.widget_sys_id,
+                    description: scopedConfig.summary || scopedConfig.description,
+                    page_css: scopedConfig.css,
+                    portal: scopedConfig.portal || scopedConfig.sp_portal || 'sp',
+                    public: scopedConfig.public !== undefined ? scopedConfig.public : true,
+                    requires_authentication: scopedConfig.requires_authentication,
+                    draft: scopedConfig.draft || false,
+                    // Map containers to widgets format
+                    widgets: this.mapContainersToWidgets(scopedConfig.containers),
+                    ...scopedConfig // Include any other fields
+                };
+                return await this.deployPortalPage(portalPageArgs);
             case 'application':
                 return await this.deployApplication(scopedConfig);
             case 'xml_update_set':
@@ -8851,6 +8903,36 @@ c.$onInit = function() {
         await this.server.connect(transport);
         this.logger.info('ServiceNow Deployment MCP Server started');
     }
+    /**
+     * Map container structure to widget structure for portal page deployment
+     */
+    mapContainersToWidgets(containers) {
+        if (!containers || !Array.isArray(containers)) {
+            return [];
+        }
+        const widgets = [];
+        for (const container of containers) {
+            if (container.widget_instance) {
+                widgets.push({
+                    widget: container.widget_instance.widget,
+                    width: container.width || 12,
+                    row: container.row || 1,
+                    column: container.column || 1,
+                    title: container.widget_instance.title || '',
+                    options: container.widget_instance.widget_parameters || {},
+                    container_title: container.title || '',
+                    class_name: container.class_name || '',
+                    background_color: container.background_color || '',
+                    background_image: container.background_image || '',
+                    background_style: container.background_style || 'default',
+                    instance_class: container.widget_instance.class_name || '',
+                    color: container.widget_instance.color || 'default',
+                    order: container.widget_instance.order || 100
+                });
+            }
+        }
+        return widgets;
+    }
     /**
      * Escape XML special characters
      */

package/dist/mcp/servicenow-operations-mcp.js

@@ -868,7 +868,12 @@ class ServiceNowOperationsMCP {
             logger_js_1.logger.info(`⚠️ No specific context detected - using conservative limit. Consider specifying limit for your use case!`);
             return 500; // Conservative default
         };
-        const { table, query, include_content = false, fields, include_display_values = false, group_by, order_by } = args;
+        const { table, query = '', include_content = false, fields, include_display_values = false, group_by, order_by, offset = 0 // ✅ NEW: Support pagination!
+         } = args;
+        // Validate table name
+        if (!table) {
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Table name is required');
+        }
         // Apply intelligent limit strategy
         const limit = determineSmartLimit(args.limit, table, query, include_content || !!fields, fields);
         // For analytics, we want NO limit at all
@@ -880,19 +885,22 @@ class ServiceNowOperationsMCP {
         if (isMLTrainingContext && limit < 1000) {
             logger_js_1.logger.warn(`⚠️  ML Training detected with low limit (${limit}). Consider setting limit=5000+ for better training data!`);
         }
-        logger_js_1.logger.info(`Universal query on table '${table}' with: ${query} (limit: ${limit === undefined ? 'UNLIMITED' : limit}, include_content: ${include_content})`);
+        logger_js_1.logger.info(`Universal query on table '${table}' with: ${query} (limit: ${limit === undefined ? 'UNLIMITED' : limit}, offset: ${offset}, include_content: ${include_content})`);
         try {
             // Convert natural language to ServiceNow query if needed
-            const processedQuery = this.processNaturalLanguageQuery(query, table);
-            // Build the query with order_by if specified
+            const processedQuery = this.processNaturalLanguageQuery(query || '', table);
+            // Build the query with CORRECT order_by syntax
             let finalQuery = processedQuery;
             if (order_by) {
+                // ✅ FIX: Use correct ServiceNow ordering syntax
                 const orderDirection = order_by.startsWith('-') ? 'DESC' : '';
                 const orderField = order_by.replace(/^-/, '');
-                finalQuery += `^ORDERBY${orderDirection}${orderField}`;
+                finalQuery += `^ORDERBY${orderDirection ? orderDirection : ''}${orderField}`;
             }
-            // Query the table
-            const records = await this.client.searchRecords(table, finalQuery, effectiveLimit);
+            // ✅ NEW: Use searchRecordsWithOffset when offset is provided
+            const records = offset > 0
+                ? await this.client.searchRecordsWithOffset(table, finalQuery, effectiveLimit, offset)
+                : await this.client.searchRecords(table, finalQuery, effectiveLimit);
             let result = {
                 table: table,
                 total_results: records.success ? records.data.result.length : 0,
@@ -908,33 +916,62 @@ class ServiceNowOperationsMCP {
                 result.grouped_counts = grouped;
                 result.unique_values = Object.keys(grouped).length;
             }
-            // 🎯 SMART CONTENT DECISION: Only include full data if explicitly requested
-            if (include_content || (fields && fields.length > 0)) {
+            // ✅ IMPROVED: Clear content decision logic
+            const shouldIncludeContent = include_content === true || (fields && fields.length > 0);
+            if (shouldIncludeContent) {
                 // Include full record data when specifically requested
                 result.records = records.success ? records.data.result : [];
-                // If specific fields requested, filter them
-                if (fields && fields.length > 0 && records.success) {
+                // If specific fields requested, filter and validate them
+                if (fields && fields.length > 0 && records.success && records.data.result.length > 0) {
+                    // ✅ NEW: Validate fields exist
+                    const sampleRecord = records.data.result[0];
+                    const validFields = fields.filter((field) => {
+                        const exists = sampleRecord.hasOwnProperty(field) ||
+                            sampleRecord.hasOwnProperty(`${field}_display_value`);
+                        if (!exists) {
+                            logger_js_1.logger.warn(`⚠️ Field '${field}' not found in table '${table}'`);
+                        }
+                        return exists;
+                    });
+                    if (validFields.length === 0 && fields.length > 0) {
+                        // All requested fields are invalid
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `None of the requested fields exist in table '${table}'. Available fields: ${Object.keys(sampleRecord).slice(0, 10).join(', ')}...`);
+                    }
                     result.records = records.data.result.map((record) => {
                         const filtered = {};
                         // Always include sys_id and number/name if available
                         if (record.sys_id)
                             filtered.sys_id = record.sys_id;
-                        if (record.number)
+                        if (record.number && !validFields.includes('number'))
                             filtered.number = record.number;
-                        if (record.name && !fields.includes('name'))
+                        if (record.name && !validFields.includes('name'))
                             filtered.name = record.name;
                         // Add requested fields
-                        fields.forEach((field) => {
+                        validFields.forEach((field) => {
                             if (record[field] !== undefined) {
                                 filtered[field] = record[field];
-                                // Add display value if requested and available
-                                if (include_display_values && record[`${field}_display_value`]) {
-                                    filtered[`${field}_display`] = record[`${field}_display_value`];
+                                // ✅ FIX: Properly handle display values
+                                if (include_display_values) {
+                                    // Check for standard display value pattern
+                                    const displayField = `dv_${field}`; // Some tables use dv_ prefix
+                                    const displayFieldAlt = `${field}_display_value`; // Others use _display_value suffix
+                                    if (record[displayField]) {
+                                        filtered[`${field}_display`] = record[displayField];
+                                    }
+                                    else if (record[displayFieldAlt]) {
+                                        filtered[`${field}_display`] = record[displayFieldAlt];
+                                    }
                                 }
                             }
                         });
                         return filtered;
                     });
+                    // Add metadata about fields
+                    result.fields_info = {
+                        requested: fields,
+                        valid: validFields,
+                        invalid: fields.filter((f) => !validFields.includes(f))
+                    };
                 }
             }
             else {
@@ -955,18 +992,40 @@ class ServiceNowOperationsMCP {
                     };
                 }
             }
+            // ✅ NEW: Add pagination info when offset is used
+            if (offset > 0) {
+                result.pagination = {
+                    offset: offset,
+                    limit: effectiveLimit,
+                    has_more: records.success && records.data.result.length === effectiveLimit,
+                    next_offset: offset + effectiveLimit
+                };
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `Found ${records.success ? records.data.result.length : 0} ${table} records matching query: "${query}"\n\n${JSON.stringify(result, null, 2)}`
+                        text: `Found ${records.success ? records.data.result.length : 0} ${table} records${offset > 0 ? ` (offset: ${offset})` : ''} matching query: "${query || 'all'}"\n\n${JSON.stringify(result, null, 2)}`
                     }
                 ]
             };
         }
         catch (error) {
+            // ✅ IMPROVED: Better error messages
             logger_js_1.logger.error(`Error querying ${table}:`, error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to query ${table}: ${error}`);
+            if (error.code === 'ECONNREFUSED') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Cannot connect to ServiceNow. Please check your instance URL and network connection.`);
+            }
+            if (error.response?.status === 401) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Authentication failed. Please run: snow-flow auth login`);
+            }
+            if (error.response?.status === 404) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Table '${table}' not found. Please check the table name.`);
+            }
+            if (error.response?.status === 400) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Invalid query syntax: ${query}. Check ServiceNow encoded query format.`);
+            }
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to query ${table}: ${error.message || error}`);
         }
     }
     detectCommonFields(table, records) {

package/dist/mcp/servicenow-platform-development-mcp.js

@@ -256,44 +256,84 @@ class ServiceNowPlatformDevelopmentMCP {
      */
     async discoverTableFields(args) {
         try {
-            const tableName = args.tableName;
+            const tableName = args.tableName || args.table_name; // Support both parameter names
+            if (!tableName) {
+                throw new Error('Table name is required (use tableName or table_name parameter)');
+            }
             this.logger.info(`Discovering fields for table: ${tableName}`);
             // First, resolve table name to sys_id if needed
             const tableInfo = await this.getTableInfo(tableName);
             if (!tableInfo) {
                 throw new Error(`Table not found: ${tableName}`);
             }
-            // Get all fields for this table
-            const fieldsResponse = await this.client.searchRecords('sys_dictionary', `nameSTARTSWITH${tableInfo.name}^element!=NULL`, 100);
+            // Get all fields for this table with CORRECT query syntax
+            // ✅ FIX: Use proper ServiceNow query for dictionary
+            const fieldsResponse = await this.client.searchRecords('sys_dictionary', `name=${tableInfo.name}^element!=NULL^ORname=${tableInfo.name}^elementISNOTEMPTY`, 500 // Increased limit for tables with many fields
+            );
             if (!fieldsResponse.success || !fieldsResponse.data) {
                 throw new Error(`Failed to get fields for table: ${tableName}`);
             }
-            const fields = fieldsResponse.data.result.map((field) => ({
+            // ✅ IMPROVED: Better field mapping with validation
+            const fields = fieldsResponse.data.result
+                .filter((field) => field.element && field.element !== 'null' && field.element !== 'NULL')
+                .map((field) => ({
                 name: field.element,
-                type: field.internal_type,
-                label: field.column_label,
-                mandatory: field.mandatory === 'true',
-                display: field.display === 'true',
-                max_length: field.max_length,
-                reference: field.reference,
-                choice: field.choice
-            }));
+                type: field.internal_type || field.data_type || 'string',
+                label: field.column_label || field.element,
+                mandatory: field.mandatory === 'true' || field.mandatory === true,
+                display: field.display === 'true' || field.display === true,
+                max_length: parseInt(field.max_length) || null,
+                reference: field.reference || null,
+                choice: field.choice || null,
+                default_value: field.default_value || null,
+                read_only: field.read_only === 'true' || field.read_only === true
+            }))
+                .sort((a, b) => {
+                // Sort: sys_id first, then mandatory fields, then alphabetically
+                if (a.name === 'sys_id')
+                    return -1;
+                if (b.name === 'sys_id')
+                    return 1;
+                if (a.mandatory && !b.mandatory)
+                    return -1;
+                if (!a.mandatory && b.mandatory)
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
             // Cache the table info
             this.tableCache.set(tableName, {
                 name: tableInfo.name,
                 label: tableInfo.label,
                 fields: fields
             });
+            // ✅ NEW: Group fields by category for better readability
+            const mandatoryFields = fields.filter((f) => f.mandatory);
+            const referenceFields = fields.filter((f) => f.reference);
+            const regularFields = fields.filter((f) => !f.mandatory && !f.reference);
             return {
                 content: [{
                         type: 'text',
-                        text: `📋 Fields for ${tableInfo.label} (${tableInfo.name}):\n\n${fields.map((field) => `- **${field.name}** (${field.label})\n  Type: ${field.type}${field.mandatory ? ' *Required*' : ''}${field.reference ? ` -> ${field.reference}` : ''}`).join('\n')}\n\n🔍 Total fields: ${fields.length}\n✨ All fields discovered dynamically from ServiceNow schema!`
+                        text: `📋 Fields for ${tableInfo.label} (${tableInfo.name}):\n\n` +
+                            (mandatoryFields.length > 0 ? `**Required Fields:**\n${mandatoryFields.map((field) => `- **${field.name}** (${field.label})\n  Type: ${field.type}${field.max_length ? ` [max: ${field.max_length}]` : ''}${field.default_value ? ` = '${field.default_value}'` : ''}`).join('\n')}\n\n` : '') +
+                            (referenceFields.length > 0 ? `**Reference Fields:**\n${referenceFields.map((field) => `- **${field.name}** (${field.label})\n  → ${field.reference}${field.mandatory ? ' *Required*' : ''}`).join('\n')}\n\n` : '') +
+                            (regularFields.length > 0 ? `**Other Fields:**\n${regularFields.slice(0, 20).map((field) => `- ${field.name} (${field.type}${field.read_only ? ', read-only' : ''})`).join('\n')}${regularFields.length > 20 ? `\n  ... and ${regularFields.length - 20} more fields` : ''}\n\n` : '') +
+                            `🔍 Total: ${fields.length} fields (${mandatoryFields.length} required, ${referenceFields.length} references)\n` +
+                            `✨ All fields discovered dynamically from ServiceNow!\n\n` +
+                            `💡 Tip: Use these field names in snow_query_table with fields parameter`
                     }]
             };
         }
         catch (error) {
             this.logger.error('Failed to discover table fields:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover fields: ${error}`);
+            // ✅ IMPROVED: Better error messages
+            if (error.message?.includes('Table not found')) {
+                const tableName = args.tableName || args.table_name;
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Table '${tableName}' does not exist in ServiceNow. Please check the table name.`);
+            }
+            if (error.response?.status === 401) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Authentication required. Please run: snow-flow auth login`);
+            }
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover fields for ${args.tableName || args.table_name}: ${error.message || error}`);
         }
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.3.5",
-  "description": "Snow-Flow v3.3.5: CRITICAL ML FIX - Machine Learning MCP now fully functional with TensorFlow.js! Fixed pagination, ServiceNow API integration, data parsing, and training workflow. Real progress tracking, intelligent error messages, and automatic fallback when PA/PI not available. Train incident classifiers, predict change risks, forecast volumes, and detect anomalies - all working with real ServiceNow data. Enhanced MCP servers with real-time progress indicators and comprehensive operation logging. 180+ MCP tools across 17 specialized servers.",
+  "version": "3.3.7",
+  "description": "Snow-Flow v3.3.7: PORTAL PAGE FIX - Fixed portal_page deployment field mapping! Now correctly maps id->page_id, handles sp_portal sys_id, and converts containers to widgets format. Fixed widget instance creation with proper sys_id handling. Portal pages with AI chatbots and complex widgets now deploy successfully. Improved validation messages and support for both single widgets and widget arrays. 180+ MCP tools across 17 specialized servers.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {