snow-flow 4.5.53 → 4.6.0

package/.mcp.json

@@ -0,0 +1,220 @@
+{
+  "mcpServers": {
+    "servicenow-deployment": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-deployment-mcp.js"
+      ],
+      "description": "Widget and artifact deployment with COHERENCE VALIDATION - ensures HTML template, client script, server script work together perfectly. Tools: snow_deploy, snow_update, snow_validate_deployment, snow_rollback_deployment, snow_deployment_status, snow_export_artifact, snow_import_artifact, snow_preview_widget, snow_widget_test, snow_create_solution_package",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}",
+        "SNOW_DEPLOYMENT_TIMEOUT": "${SNOW_DEPLOYMENT_TIMEOUT}",
+        "MCP_DEPLOYMENT_TIMEOUT": "${MCP_DEPLOYMENT_TIMEOUT}"
+      }
+    },
+    "servicenow-operations": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-operations-mcp.js"
+      ],
+      "description": "Core ServiceNow operations - universal table query (snow_query_table), CRUD operations, incident/request/problem management, CMDB search, user/group management, catalog items, knowledge search, field discovery (snow_discover_table_fields), get by sys_id",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-automation": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-automation-mcp.js"
+      ],
+      "description": "Script execution with output capture (snow_execute_script_with_output), scheduled jobs, event rules, notifications, SLA definitions, workflow activities, script history, REST testing, system logs (snow_get_logs), execution tracing, background scripts with autoConfirm option",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-platform-development": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-platform-development-mcp.js"
+      ],
+      "description": "Platform development - create UI pages, script includes, business rules, client scripts, UI policies/actions, ACLs, dictionary entries, catalog items, workflows, transform maps",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-integration": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-integration-mcp.js"
+      ],
+      "description": "Integration management - REST messages, SOAP messages, transform maps, import sets, web services, email configuration, OAuth providers, endpoint discovery, integration testing",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-system-properties": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-system-properties-mcp.js"
+      ],
+      "description": "System property management - get/set/list/delete properties (snow_property_get, snow_property_set), bulk operations, import/export JSON, validate values, search by pattern, categories, audit history",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-update-set": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-update-set-mcp.js"
+      ],
+      "description": "Update set management - create/switch/complete update sets, preview changes, export/import XML, ensure active update set, add artifacts to sets, batch operations",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-development-assistant": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-development-assistant-mcp.js"
+      ],
+      "description": "Development assistance - code generation, best practices, pattern recommendations, code review, performance optimization, ES5 conversion, documentation generation, requirement analysis (snow_find_artifact, snow_edit_artifact, snow_analyze_artifact)",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-security-compliance": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-security-compliance-mcp.js"
+      ],
+      "description": "Security and compliance - security policies, compliance rules (SOX/GDPR/HIPAA), audit trails, access control review, vulnerability scanning, risk assessment, encryption settings",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-reporting-analytics": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-reporting-analytics-mcp.js"
+      ],
+      "description": "Reporting and analytics - create reports/dashboards/KPIs, data visualization, performance analytics, scheduled reports, data quality analysis, metrics collection, trend analysis",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-machine-learning": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-machine-learning-mcp.js"
+      ],
+      "description": "Machine learning - train/classify incidents (snow_train_classifier), change risk prediction, anomaly detection, forecast incidents, sentiment analysis, process optimization, hybrid recommendations with TensorFlow.js",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-knowledge-catalog": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-knowledge-catalog-mcp.js"
+      ],
+      "description": "Knowledge and catalog management - CORRECTED v3.6.10 with proper catalog UI policy creation (2-table system: policy with embedded conditions string, separate actions table). Create/search/update knowledge articles, catalog items, variables, UI policies with conditions as query string and actions array",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-change-virtualagent-pa": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-change-virtualagent-pa-mcp.js"
+      ],
+      "description": "Change management, Virtual Agent, and Performance Analytics - create/manage change requests, CAB meetings, VA topics/blocks, conversations, PA indicators/widgets/breakdowns, thresholds, data collection",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-flow-workspace-mobile": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-flow-workspace-mobile-mcp.js"
+      ],
+      "description": "Flow Designer, Workspace, and Mobile - create flows/actions/subflows/triggers, test flows, workspaces/tabs/lists, contextual panels, mobile app config, layouts, push notifications, offline sync",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-cmdb-event-hr-csm-devops": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-cmdb-event-hr-csm-devops-mcp.js"
+      ],
+      "description": "CMDB, Event Management, HR, CSM, and DevOps - create CIs/relationships, discovery, impact analysis, events/alerts, HR cases/onboarding, customer cases/accounts, DevOps pipelines/deployments",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-advanced-features": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/advanced/servicenow-advanced-features-mcp.js"
+      ],
+      "description": "Advanced features - batch API operations (80% reduction), table relationships analysis, query optimization, field usage analysis, code pattern detection, process discovery, workflow analysis, documentation generation",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "servicenow-local-development": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/servicenow-local-development-mcp.js"
+      ],
+      "description": "UNIVERSAL ARTIFACT DETECTION v3.6.6 - finds ANY ServiceNow record by sys_id using sys_metadata! Pull any artifact (even custom tables) to local files with Claude Code native tools. Supports all tables, generic artifact creation for unknown types, smart chunking, ES5 validation, coherence checking. Tools: snow_pull_artifact, snow_push_artifact, snow_validate_artifact_coherence",
+      "env": {
+        "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+        "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+        "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+      }
+    },
+    "snow-flow": {
+      "command": "node",
+      "args": [
+        "/Users/nielsvanderwerf/.nvm/versions/node/v20.15.0/lib/node_modules/snow-flow/dist/mcp/snow-flow-mcp.js"
+      ],
+      "description": "Snow-Flow orchestration - swarm init/status, agent spawn/discover, task orchestrate/categorize, neural train/patterns (TensorFlow.js), memory store/search (timeout-protected), performance reports, token usage tracking",
+      "env": {
+        "SNOW_FLOW_ENV": "${SNOW_FLOW_ENV}"
+      }
+    }
+  }
+}

package/dist/cli.js

@@ -1727,6 +1727,7 @@ program
 📋 Available Commands:
   swarm <objective>     Execute multi-agent orchestration
   spawn <type>          Spawn specific agent types
+  export                Export MCP configuration to Claude Desktop
   status                Show system status
   monitor               Real-time monitoring dashboard
   memory <action>       Memory operations
@@ -3327,6 +3328,64 @@ program
     }
 });
 // ===================================================
+// 📤 CLAUDE DESKTOP EXPORT COMMAND
+// ===================================================
+program
+    .command('export')
+    .description('📤 Export Snow-Flow MCP configuration to Claude Desktop with automatic credential injection')
+    .option('--output <path>', 'Custom output path for Claude Desktop config')
+    .option('--backup', 'Backup existing Claude Desktop config before overwriting', true)
+    .option('--merge', 'Merge with existing Claude Desktop config instead of overwriting')
+    .option('--dry-run', 'Preview the export without writing files')
+    .action(async (options) => {
+    console.log(`\n📤 Snow-Flow Claude Desktop Export v${version_js_1.VERSION}`);
+    console.log('🎯 Exporting all 22 MCP servers with 245+ tools to Claude Desktop...\n');
+    try {
+        const { exportToClaudeDesktop } = await Promise.resolve().then(() => __importStar(require('./utils/claude-desktop-exporter.js')));
+        const result = await exportToClaudeDesktop({
+            outputPath: options.output,
+            backup: options.backup,
+            merge: options.merge,
+            dryRun: options.dryRun
+        });
+        if (result.success) {
+            console.log('✅ Claude Desktop export completed successfully!\n');
+            if (result.configPath) {
+                console.log(`📝 Configuration written to: ${result.configPath}`);
+            }
+            if (result.backupPath) {
+                console.log(`💾 Backup created at: ${result.backupPath}`);
+            }
+            if (result.merged) {
+                console.log(`🔗 Merged with existing configuration (${result.existingServers} existing servers preserved)`);
+            }
+            console.log(`🔑 Credentials automatically injected from .env file`);
+            console.log(`🌍 Instance: ${result.credentials.instance}`);
+            console.log(`🔐 Authentication: OAuth configured`);
+            console.log('\n🚀 Next steps:');
+            console.log('1. Restart Claude Desktop to load the new MCP servers');
+            console.log('2. Open Claude Desktop chat');
+            console.log('3. Try: "Create UX workspace for IT support using snow_create_complete_workspace"');
+            console.log('\n💡 All 245+ Snow-Flow tools are now available in Claude Desktop!');
+        }
+        else {
+            console.error('\n❌ Export failed:', result.error);
+            if (result.missingCredentials) {
+                console.error('\n🔑 Missing credentials in .env file:');
+                result.missingCredentials.forEach(cred => {
+                    console.error(`   • ${cred}`);
+                });
+                console.error('\nRun: snow-flow auth login');
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('\n💥 Export error:', error.message);
+        process.exit(1);
+    }
+});
+// ===================================================
 // 🔄 BACKWARD COMPATIBILITY ENHANCEMENTS
 // ===================================================
 /**

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

@@ -140,10 +140,10 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     }
                 },
                 // 🏗️ COMPLETE UX WORKSPACE CREATION (6-Step Workflow)
-                // STEP 1: Experience Record (sys_ux_experience)
+                // STEP 1: Experience Record (sys_ux_experience) - REQUIRES NOW EXPERIENCE FRAMEWORK
                 {
                     name: 'snow_create_ux_experience',
-                    description: 'STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace. This is the first step in the 6-step workspace creation process.',
+                    description: 'STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace. ⚠️ REQUIRES: Now Experience Framework (UXF) enabled. ALTERNATIVE: Use traditional form/list configurations if UXF unavailable.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -357,10 +357,10 @@ class ServiceNowFlowWorkspaceMobileMCP {
                 // 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)
+                // UI Builder Page Management (sys_ux_page) - REQUIRES UI BUILDER PLUGIN
                 {
                     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.',
+                    description: 'Creates a new UI Builder page in the Now Experience Framework using official ServiceNow sys_ux_page API. ⚠️ REQUIRES: UI Builder plugin + ui_builder_admin role. ALTERNATIVE: Use Service Portal pages if plugin unavailable.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -815,33 +815,33 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_import_flow_from_xml':
                         result = await this.importFlowFromXml(args);
                         break;
-                    // 🏗️ UX WORKSPACE CREATION (6-Step Workflow)
+                    // 🏗️ UX WORKSPACE CREATION (SAFE EXECUTION)
                     case 'snow_create_ux_experience':
-                        result = await this.snow_create_ux_experience(args);
+                        result = await this.safeToolExecution('snow_create_ux_experience', () => this.snow_create_ux_experience(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_app_config':
-                        result = await this.snow_create_ux_app_config(args);
+                        result = await this.safeToolExecution('snow_create_ux_app_config', () => this.snow_create_ux_app_config(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_page_macroponent':
-                        result = await this.snow_create_ux_page_macroponent(args);
+                        result = await this.safeToolExecution('snow_create_ux_page_macroponent', () => this.snow_create_ux_page_macroponent(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_page_registry':
-                        result = await this.snow_create_ux_page_registry(args);
+                        result = await this.safeToolExecution('snow_create_ux_page_registry', () => this.snow_create_ux_page_registry(args), 'now_experience_framework');
                         break;
                     case 'snow_create_ux_app_route':
-                        result = await this.snow_create_ux_app_route(args);
+                        result = await this.safeToolExecution('snow_create_ux_app_route', () => this.snow_create_ux_app_route(args), 'now_experience_framework');
                         break;
                     case 'snow_update_ux_app_config_landing_page':
-                        result = await this.snow_update_ux_app_config_landing_page(args);
+                        result = await this.safeToolExecution('snow_update_ux_app_config_landing_page', () => this.snow_update_ux_app_config_landing_page(args), 'now_experience_framework');
                         break;
                     case 'snow_create_complete_workspace':
-                        result = await this.snow_create_complete_workspace(args);
+                        result = await this.safeToolExecution('snow_create_complete_workspace', () => this.snow_create_complete_workspace(args), 'now_experience_framework');
                         break;
                     case 'snow_create_configurable_agent_workspace':
-                        result = await this.snow_create_configurable_agent_workspace(args);
+                        result = await this.safeToolExecution('snow_create_configurable_agent_workspace', () => this.snow_create_configurable_agent_workspace(args), 'agent_workspace');
                         break;
                     case 'snow_discover_all_workspaces':
-                        result = await this.discoverAllWorkspaces(args);
+                        result = await this.safeToolExecution('snow_discover_all_workspaces', () => this.discoverAllWorkspaces(args), 'now_experience_framework');
                         break;
                     case 'snow_validate_workspace_configuration':
                         result = await this.validateWorkspaceConfiguration(args);
@@ -859,31 +859,31 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_configure_offline_sync':
                         result = await this.configureOfflineSync(args);
                         break;
-                    // UI Builder Page Management
+                    // UI Builder Page Management (SAFE EXECUTION)
                     case 'snow_create_uib_page':
-                        result = await this.createUIBPage(args);
+                        result = await this.safeToolExecution('snow_create_uib_page', () => this.createUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_update_uib_page':
-                        result = await this.updateUIBPage(args);
+                        result = await this.safeToolExecution('snow_update_uib_page', () => this.updateUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_delete_uib_page':
-                        result = await this.deleteUIBPage(args);
+                        result = await this.safeToolExecution('snow_delete_uib_page', () => this.deleteUIBPage(args), 'ui_builder');
                         break;
                     case 'snow_discover_uib_pages':
-                        result = await this.discoverUIBPages(args);
+                        result = await this.safeToolExecution('snow_discover_uib_pages', () => this.discoverUIBPages(args), 'ui_builder');
                         break;
-                    // UI Builder Component Management
+                    // UI Builder Component Management (SAFE EXECUTION)
                     case 'snow_create_uib_component':
-                        result = await this.createUIBComponent(args);
+                        result = await this.safeToolExecution('snow_create_uib_component', () => this.createUIBComponent(args), 'ui_builder');
                         break;
                     case 'snow_update_uib_component':
-                        result = await this.updateUIBComponent(args);
+                        result = await this.safeToolExecution('snow_update_uib_component', () => this.updateUIBComponent(args), 'ui_builder');
                         break;
                     case 'snow_discover_uib_components':
-                        result = await this.discoverUIBComponents(args);
+                        result = await this.safeToolExecution('snow_discover_uib_components', () => this.discoverUIBComponents(args), 'ui_builder');
                         break;
                     case 'snow_clone_uib_component':
-                        result = await this.cloneUIBComponent(args);
+                        result = await this.safeToolExecution('snow_clone_uib_component', () => this.cloneUIBComponent(args), 'ui_builder');
                         break;
                     // UI Builder Data Broker Management
                     case 'snow_create_uib_data_broker':
@@ -1809,10 +1809,12 @@ ${configList}${layoutsText}${offlineText}
         }
     }
     /**
-     * Discover UI Builder Pages
+     * Discover UI Builder Pages - ENHANCED with mandatory feedback
      */
     async discoverUIBPages(args) {
         try {
+            // MANDATORY: Always log start of operation
+            this.logger.info(`🔍 Starting UI Builder pages discovery...`);
             this.logger.info('🔍 Discovering UI Builder pages...');
             const conditions = [];
             if (args.active_only)
@@ -1853,7 +1855,19 @@ ${configList}${layoutsText}${offlineText}
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder pages:', error);
-            throw error;
+            // NEVER throw - always return error object for MCP
+            return {
+                success: false,
+                error: `UI Builder pages discovery failed: ${error}`,
+                suggestion: 'UI Builder plugin not installed or insufficient permissions (need ui_builder_admin role)',
+                plugin_required: 'UI Builder',
+                table_attempted: 'sys_ux_page',
+                operation_type: 'DISCOVERY',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error)
+                }
+            };
         }
     }
     /**
@@ -1869,9 +1883,27 @@ ${configList}${layoutsText}${offlineText}
                 version: args.version || '1.0.0',
                 active: true
             };
+            // PRE-CHECK: Verify UI Builder is available
+            const uiBuilderCheck = await this.client.searchRecords('sys_ux_lib_source_script', '', 1);
+            if (!uiBuilderCheck.success) {
+                return {
+                    success: false,
+                    error: 'UI Builder plugin not available - sys_ux_lib_source_script table not accessible',
+                    suggestion: 'Install UI Builder plugin from ServiceNow Store. Requires ui_builder_admin role.',
+                    plugin_required: 'UI Builder',
+                    table_tested: 'sys_ux_lib_source_script',
+                    alternative: 'Use Service Portal widgets instead of UI Builder components'
+                };
+            }
             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}`);
+                return {
+                    success: false,
+                    error: `Failed to create component source: ${sourceResponse.error}`,
+                    suggestion: 'Check UI Builder permissions and source script syntax',
+                    operation_attempted: 'CREATE sys_ux_lib_source_script',
+                    source_data_attempted: sourceData
+                };
             }
             // Then create the component definition
             const componentData = {
@@ -1891,8 +1923,18 @@ ${configList}${layoutsText}${offlineText}
             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}`);
+                const sourceId = sourceResponse.data?.sys_id || sourceResponse.data?.result?.sys_id;
+                if (sourceId) {
+                    await this.client.deleteRecord('sys_ux_lib_source_script', sourceId);
+                }
+                return {
+                    success: false,
+                    error: `Failed to create UI Builder component: ${componentResponse.error}`,
+                    suggestion: 'Check UI Builder permissions, component definition syntax, and plugin availability',
+                    operation_attempted: 'CREATE sys_ux_lib_component',
+                    component_data_attempted: componentData,
+                    cleanup_performed: !!sourceId
+                };
             }
             this.logger.info('✅ UI Builder component created successfully');
             return {
@@ -1957,10 +1999,12 @@ ${configList}${layoutsText}${offlineText}
         }
     }
     /**
-     * Discover UI Builder Components
+     * Discover UI Builder Components - ENHANCED with mandatory feedback
      */
     async discoverUIBComponents(args) {
         try {
+            // MANDATORY: Always log start of operation
+            this.logger.info(`🔍 Starting UI Builder components discovery...`);
             this.logger.info('🔍 Discovering UI Builder components...');
             const conditions = [];
             if (args.category)
@@ -2004,7 +2048,19 @@ ${configList}${layoutsText}${offlineText}
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder components:', error);
-            throw error;
+            // NEVER throw - always return error object for MCP
+            return {
+                success: false,
+                error: `UI Builder components discovery failed: ${error}`,
+                suggestion: 'UI Builder plugin not installed or insufficient permissions (need ui_builder_admin role)',
+                plugin_required: 'UI Builder',
+                table_attempted: 'sys_ux_lib_component',
+                operation_type: 'DISCOVERY',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error)
+                }
+            };
         }
     }
     /**
@@ -3425,6 +3481,113 @@ ${configList}${layoutsText}${offlineText}
     /**
      * Validate workspace configuration (fix from user feedback)
      */
+    /**
+     * COMPREHENSIVE PLUGIN DETECTION SYSTEM
+     * Checks all required plugins before tool execution
+     */
+    async checkPluginAvailabilityForTool(toolType) {
+        try {
+            switch (toolType) {
+                case 'ui_builder':
+                    const uiBuilderCheck = await this.client.searchRecords('sys_ux_page', '', 1);
+                    if (!uiBuilderCheck.success) {
+                        return {
+                            available: false,
+                            error: 'UI Builder plugin not installed or not accessible',
+                            suggestion: 'Install UI Builder plugin from ServiceNow Store. Requires ui_builder_admin + ui_builder_user roles.',
+                            alternative: 'Use Service Portal widgets for custom UI development instead'
+                        };
+                    }
+                    break;
+                case 'now_experience_framework':
+                    const uxfCheck = await this.client.searchRecords('sys_ux_experience', '', 1);
+                    if (!uxfCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Now Experience Framework (UXF) not available',
+                            suggestion: 'Enable Now Experience Framework in ServiceNow instance. May require additional licensing.',
+                            alternative: 'Use traditional ServiceNow interface development instead'
+                        };
+                    }
+                    break;
+                case 'agent_workspace':
+                    const agentWorkspaceCheck = await this.client.searchRecords('sys_ux_screen_type', '', 1);
+                    if (!agentWorkspaceCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Agent Workspace plugin not installed',
+                            suggestion: 'Install Agent Workspace plugin from ServiceNow Store. Requires workspace_admin role.',
+                            alternative: 'Use traditional forms and lists for agent interfaces'
+                        };
+                    }
+                    break;
+                case 'mobile_publishing':
+                    const mobileCheck = await this.client.searchRecords('sys_push_notif_msg', '', 1);
+                    if (!mobileCheck.success) {
+                        return {
+                            available: false,
+                            error: 'Mobile Publishing plugin not available',
+                            suggestion: 'Install Mobile Publishing plugin from ServiceNow Store. Requires additional licensing and mobile_admin role.',
+                            alternative: 'Use responsive Service Portal pages for mobile interfaces'
+                        };
+                    }
+                    break;
+            }
+            return { available: true };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: `Plugin check failed: ${error}`,
+                suggestion: 'Check ServiceNow connectivity and basic table access permissions'
+            };
+        }
+    }
+    /**
+     * SAFE TOOL EXECUTION WRAPPER
+     * Ensures all tools return proper feedback instead of throwing
+     */
+    async safeToolExecution(toolName, operation, pluginType) {
+        try {
+            this.logger.info(`🛠️ Executing tool: ${toolName}`);
+            // Step 1: Check plugin availability
+            const pluginCheck = await this.checkPluginAvailabilityForTool(pluginType);
+            if (!pluginCheck.available) {
+                this.logger.warn(`⚠️ Plugin check failed for ${toolName}`);
+                return {
+                    success: false,
+                    tool_name: toolName,
+                    plugin_type: pluginType,
+                    ...pluginCheck
+                };
+            }
+            // Step 2: Execute operation
+            const result = await operation();
+            this.logger.info(`✅ Tool ${toolName} executed successfully`);
+            return {
+                ...result,
+                tool_name: toolName,
+                plugin_verified: true,
+                execution_timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            this.logger.error(`❌ Tool ${toolName} failed with exception:`, error);
+            // NEVER throw - always return error object
+            return {
+                success: false,
+                tool_name: toolName,
+                error: `Tool execution failed: ${error}`,
+                suggestion: 'Check ServiceNow connectivity, permissions, and plugin installation',
+                execution_type: 'EXCEPTION_CAUGHT',
+                debug_info: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                    error_message: String(error),
+                    stack_trace: error instanceof Error ? error.stack : undefined
+                }
+            };
+        }
+    }
     validateWorkspaceConfig(config) {
         const errors = [];
         // Check required fields

package/dist/utils/claude-desktop-exporter.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Claude Desktop Exporter - Export Snow-Flow MCP configuration to Claude Desktop
+ * Handles automatic credential injection, backup, and merge operations
+ */
+interface ExportOptions {
+    outputPath?: string;
+    backup?: boolean;
+    merge?: boolean;
+    dryRun?: boolean;
+}
+interface ExportResult {
+    success: boolean;
+    error?: string;
+    configPath?: string;
+    backupPath?: string;
+    merged?: boolean;
+    existingServers?: number;
+    credentials?: {
+        instance: string;
+        clientId: string;
+        clientSecret: string;
+    };
+    missingCredentials?: string[];
+}
+/**
+ * Export Snow-Flow MCP configuration to Claude Desktop
+ */
+export declare function exportToClaudeDesktop(options: ExportOptions): Promise<ExportResult>;
+export {};
+//# sourceMappingURL=claude-desktop-exporter.d.ts.map

package/dist/utils/claude-desktop-exporter.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Claude Desktop Exporter - Export Snow-Flow MCP configuration to Claude Desktop
+ * Handles automatic credential injection, backup, and merge operations
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportToClaudeDesktop = exportToClaudeDesktop;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Export Snow-Flow MCP configuration to Claude Desktop
+ */
+async function exportToClaudeDesktop(options) {
+    try {
+        console.log('🔍 Detecting Claude Desktop configuration location...');
+        // Step 1: Detect Claude Desktop config location
+        const claudeConfigPath = await detectClaudeDesktopConfigPath();
+        const outputPath = options.outputPath || claudeConfigPath;
+        if (!outputPath) {
+            return {
+                success: false,
+                error: 'Could not detect Claude Desktop configuration location. Specify --output <path> manually.'
+            };
+        }
+        console.log(`📂 Claude Desktop config: ${outputPath}`);
+        // Step 2: Load .env credentials
+        console.log('🔐 Loading credentials from .env file...');
+        const credentials = await loadCredentialsFromEnv();
+        if (credentials.missingCredentials && credentials.missingCredentials.length > 0) {
+            return {
+                success: false,
+                error: 'Missing required credentials in .env file',
+                missingCredentials: credentials.missingCredentials
+            };
+        }
+        console.log(`✅ Credentials loaded for instance: ${credentials.instance}`);
+        // Step 3: Load Snow-Flow MCP template
+        console.log('📋 Loading Snow-Flow MCP template...');
+        const mcpTemplate = await loadSnowFlowMCPTemplate();
+        // Step 4: Inject credentials into template
+        console.log('💉 Injecting credentials into MCP configuration...');
+        const mcpConfig = injectCredentials(mcpTemplate, credentials);
+        // Step 5: Handle existing config (backup/merge)
+        let existingConfig = null;
+        let backupPath = null;
+        if (fs_1.default.existsSync(outputPath)) {
+            console.log('📁 Existing Claude Desktop config found');
+            if (options.backup) {
+                backupPath = await createBackup(outputPath);
+                console.log(`🗃️ Backup created: ${backupPath}`);
+            }
+            if (options.merge) {
+                console.log('🔗 Merging configurations...');
+                existingConfig = JSON.parse(fs_1.default.readFileSync(outputPath, 'utf8'));
+            }
+        }
+        // Step 6: Generate final config
+        const finalConfig = options.merge && existingConfig ?
+            mergeConfigurations(existingConfig, mcpConfig) : mcpConfig;
+        // Step 7: Write config (or dry run)
+        if (options.dryRun) {
+            console.log('🔬 DRY RUN - Preview of configuration:');
+            console.log(JSON.stringify(finalConfig, null, 2));
+        }
+        else {
+            // Ensure directory exists
+            const configDir = path_1.default.dirname(outputPath);
+            if (!fs_1.default.existsSync(configDir)) {
+                fs_1.default.mkdirSync(configDir, { recursive: true });
+                console.log(`📁 Created directory: ${configDir}`);
+            }
+            fs_1.default.writeFileSync(outputPath, JSON.stringify(finalConfig, null, 2));
+            console.log(`✅ Configuration written to: ${outputPath}`);
+        }
+        return {
+            success: true,
+            configPath: outputPath,
+            backupPath: backupPath,
+            merged: !!options.merge,
+            existingServers: existingConfig ? Object.keys(existingConfig.mcpServers || {}).length : 0,
+            credentials: {
+                instance: credentials.instance,
+                clientId: credentials.clientId ? '[CONFIGURED]' : '[MISSING]',
+                clientSecret: credentials.clientSecret ? '[CONFIGURED]' : '[MISSING]'
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Export failed: ${error}`
+        };
+    }
+}
+/**
+ * Detect Claude Desktop configuration path for different platforms
+ */
+async function detectClaudeDesktopConfigPath() {
+    const platform = os_1.default.platform();
+    switch (platform) {
+        case 'darwin': // macOS
+            return path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        case 'win32': // Windows
+            return path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+        case 'linux': // Linux
+            return path_1.default.join(os_1.default.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+        default:
+            return null;
+    }
+}
+/**
+ * Load credentials from .env file
+ */
+async function loadCredentialsFromEnv() {
+    const envPath = path_1.default.join(process.cwd(), '.env');
+    const missingCredentials = [];
+    if (!fs_1.default.existsSync(envPath)) {
+        return {
+            missingCredentials: ['SNOW_INSTANCE', 'SNOW_CLIENT_ID', 'SNOW_CLIENT_SECRET']
+        };
+    }
+    const envContent = fs_1.default.readFileSync(envPath, 'utf8');
+    const envVars = {};
+    // Parse .env file
+    envContent.split('\n').forEach(line => {
+        const [key, ...valueParts] = line.split('=');
+        if (key && valueParts.length > 0) {
+            envVars[key.trim()] = valueParts.join('=').trim().replace(/^["']|["']$/g, '');
+        }
+    });
+    // Check required credentials
+    const requiredCreds = ['SNOW_INSTANCE', 'SNOW_CLIENT_ID', 'SNOW_CLIENT_SECRET'];
+    requiredCreds.forEach(cred => {
+        if (!envVars[cred]) {
+            missingCredentials.push(cred);
+        }
+    });
+    return {
+        instance: envVars.SNOW_INSTANCE,
+        clientId: envVars.SNOW_CLIENT_ID,
+        clientSecret: envVars.SNOW_CLIENT_SECRET,
+        missingCredentials: missingCredentials.length > 0 ? missingCredentials : null
+    };
+}
+/**
+ * Load Snow-Flow MCP template
+ */
+async function loadSnowFlowMCPTemplate() {
+    // Try to load from current project
+    let templatePath = path_1.default.join(process.cwd(), '.mcp.json.template');
+    if (!fs_1.default.existsSync(templatePath)) {
+        // Try to load from Snow-Flow installation (global npm package)
+        const globalSnowFlowPath = path_1.default.join(os_1.default.homedir(), '.nvm', 'versions', 'node', process.version, 'lib', 'node_modules', 'snow-flow');
+        templatePath = path_1.default.join(globalSnowFlowPath, '.mcp.json.template');
+    }
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new Error('Snow-Flow MCP template not found. Run "snow-flow init" first.');
+    }
+    const templateContent = fs_1.default.readFileSync(templatePath, 'utf8');
+    return JSON.parse(templateContent);
+}
+/**
+ * Inject credentials into MCP configuration
+ */
+function injectCredentials(mcpTemplate, credentials) {
+    const configJson = JSON.stringify(mcpTemplate, null, 2)
+        .replace(/\{\{SNOW_INSTANCE\}\}/g, credentials.instance)
+        .replace(/\{\{SNOW_CLIENT_ID\}\}/g, credentials.clientId)
+        .replace(/\{\{SNOW_CLIENT_SECRET\}\}/g, credentials.clientSecret)
+        .replace(/\{\{PROJECT_ROOT\}\}/g, path_1.default.join(os_1.default.homedir(), '.nvm', 'versions', 'node', process.version, 'lib', 'node_modules', 'snow-flow'))
+        .replace(/\{\{SNOW_DEPLOYMENT_TIMEOUT\}\}/g, '300000')
+        .replace(/\{\{MCP_DEPLOYMENT_TIMEOUT\}\}/g, '30000');
+    return JSON.parse(configJson);
+}
+/**
+ * Create backup of existing Claude Desktop config
+ */
+async function createBackup(configPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = configPath.replace('.json', `_backup_${timestamp}.json`);
+    fs_1.default.copyFileSync(configPath, backupPath);
+    return backupPath;
+}
+/**
+ * Merge Snow-Flow config with existing Claude Desktop config
+ */
+function mergeConfigurations(existing, snowFlow) {
+    const merged = {
+        ...existing,
+        mcpServers: {
+            ...existing.mcpServers,
+            ...snowFlow.servers // Snow-Flow uses 'servers' key, Claude Desktop uses 'mcpServers'
+        }
+    };
+    return merged;
+}
+//# sourceMappingURL=claude-desktop-exporter.js.map

package/memory/agents/README.md

@@ -0,0 +1,3 @@
+# Agent Memory
+
+This directory contains persistent memory for ServiceNow agents.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.5.53",
+  "version": "4.6.0",
   "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 245+ ServiceNow tools including complete UX + Agent Workspace creation with official APIs.",
   "main": "dist/index.js",
   "type": "commonjs",

package/servicenow/README.md

@@ -0,0 +1,3 @@
+# ServiceNow Artifacts
+
+This directory contains generated ServiceNow development artifacts.