snow-flow 4.3.5 → 4.3.8

package/dist/cli.js

@@ -754,28 +754,36 @@ Memory.store("swarm_session_${sessionId}", JSON.stringify({
 }));
 \`\`\`
 
-### 2. Validate ServiceNow Connection
-**Execute these steps IN ORDER:**
+### 2. 🚨 MANDATORY: ServiceNow Auth & Update Set Setup
+**CRITICAL: These steps are REQUIRED for ALL development work:**
 
 \`\`\`javascript
-// Step 2.1: Test ServiceNow authentication
+// Step 2.1: MANDATORY - Test ServiceNow authentication
 const authCheck = await snow_auth_diagnostics();
 if (!authCheck.success) {
-  throw new Error("Authentication failed! Run: snow-flow auth login");
+  throw new Error("❌ CRITICAL: Authentication failed! Run: snow-flow auth login");
 }
 
-// Step 2.2: Create Update Set for tracking changes
+// Step 2.2: MANDATORY - Create Update Set for tracking ALL changes
 const updateSetName = "Snow-Flow: ${objective.substring(0, 50)}... - ${new Date().toISOString().split('T')[0]}";
 const updateSet = await snow_update_set_create({
   name: updateSetName,
-  description: "Automated creation for: ${objective}\\n\\nSession: ${sessionId}",
-  auto_switch: true
+  description: "Automated Snow-Flow development for: ${objective}\\n\\nSession: ${sessionId}\\nAll changes tracked automatically",
+  auto_switch: true  // 🚨 CRITICAL: Sets as current update set!
 });
 
-// Store Update Set info in memory
+// Store Update Set info in memory for all agents
 Memory.store("update_set_${sessionId}", JSON.stringify(updateSet));
+Memory.store("current_update_set", updateSet.sys_id);
 \`\`\`
 
+**WHY THIS IS CRITICAL:**
+- ✅ All ServiceNow changes are automatically tracked
+- ✅ Enables deployment to other instances later  
+- ✅ Provides rollback capabilities
+- ✅ Follows ServiceNow development best practices
+- ❌ **WITHOUT UPDATE SET: Changes are untracked and risky!**
+
 ### 3. Create Master Task List
 After completing setup steps, create task breakdown:
 \`\`\`javascript
@@ -816,12 +824,14 @@ TodoWrite([
 ### 4. Agent Spawning Strategy
 Based on the task analysis, spawn ${taskAnalysis.estimatedAgentCount} agents in smart batches:
 
-**Agent Spawn Order (Use Snow-Flow MCP Tools):**
+**Dynamic Agent Discovery & Spawning (Use Snow-Flow MCP Tools):**
 1. **Initialize Swarm**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
-2. **Primary Agent**: \`agent_spawn({ type: '${taskAnalysis.primaryAgent}', name: 'Primary${taskAnalysis.primaryAgent.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')}' })\`
-3. **Supporting Agents**: Use \`agent_spawn\` for each: ${taskAnalysis.supportingAgents.map(agent => `'${agent}'`).join(', ')}
+2. **Discover Agents Dynamically**: \`agent_discover({ task_analysis: ${JSON.stringify(taskAnalysis)}, required_capabilities: [], context: { max_agents: ${parseInt(options.maxAgents)}, include_new_types: true } })\`
+3. **Spawn Discovered Agents**: Use \`agent_spawn({ type: 'agent_type_from_discovery', name: 'Agent Name', capabilities: ['discovered_capabilities'] })\` for each discovered agent
 4. **Coordination**: \`task_orchestrate({ task: '${objective}', strategy: 'adaptive' })\`
 
+**IMPORTANT**: Do NOT use hardcoded agent types like 'widget-creator', 'specialist' etc. Let \`agent_discover\` determine the optimal agent types for this specific task!
+
 ### 5. Memory Coordination Pattern
 All agents MUST use this simple memory coordination:
 
@@ -888,10 +898,11 @@ ${isAuthenticated ? '✅ Authentication detected - full deployment capabilities'
 
 Your agents MUST use these MCP tools IN THIS ORDER:
 
-🔍 **PRE-FLIGHT CHECKS** (Always do first!):
+🚨 **MANDATORY PRE-FLIGHT CHECKS** (ALWAYS do first!):
 1. \`snow_auth_diagnostics\` - Test authentication and permissions
-2. If auth fails, the tool provides specific instructions
-3. Continue with appropriate strategy based on auth status
+2. \`snow_update_set_create\` - Create and activate update set for tracking
+3. If auth fails, STOP and provide instructions to run 'snow-flow auth login'
+4. If update set fails, STOP - development work is not safe without tracking
 
 🎯 **Core Development Tools**:
 1. **Universal Query Tool**: \`snow_query_table\` - Works with ALL ServiceNow tables

package/dist/mcp/servicenow-knowledge-catalog-mcp.js

@@ -1315,49 +1315,50 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
          * Helper function to format action details for display
          */
     }
-    /**
-     * Helper function to format action details for display
-     */
-    formatActionDetails(action) {
-        const details = [];
-        if (action.mandatory !== undefined) {
-            details.push(`Mandatory: ${action.mandatory}`);
-        }
-        if (action.visible !== undefined) {
-            details.push(`Visible: ${action.visible}`);
-        }
-        if (action.readonly !== undefined) {
-            details.push(`Read-only: ${action.readonly}`);
-        }
-        if (action.value !== undefined && action.value !== '') {
-            details.push(`Value: "${action.value}"`);
-        }
-        return details.length > 0 ? details.join(', ') : 'No specific action';
+    catch(error) { n; this.logger.error('Failed to create catalog UI policy:', error); n; return { content: [{ type: 'text', text: `❌ Failed to create catalog UI policy: ${error.message || error}` }] }; n; }
+}
+n;
+n;
+formatActionDetails(action, any);
+string;
+{
+    const details = [];
+    if (action.mandatory !== undefined) {
+        details.push(`Mandatory: ${action.mandatory}`);
     }
-    /**
-     * Create Catalog Client Script
-     * Uses catalog_script_client table
-     */
-    async createCatalogClientScript(args) {
-        try {
-            this.logger.info('Creating catalog client script...');
-            const scriptData = {
-                cat_item: args.cat_item,
-                name: args.name,
-                script: args.script,
-                type: args.type,
-                applies_to: args.applies_to || 'item',
-                cat_variable: args.variable || '',
-                active: args.active !== false
-            };
-            const response = await this.client.createRecord('catalog_script_client', scriptData);
-            if (!response.success) {
-                throw new Error(`Failed to create catalog client script: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Catalog Client Script created successfully!
+    if (action.visible !== undefined) {
+        details.push(`Visible: ${action.visible}`);
+    }
+    if (action.readonly !== undefined) {
+        details.push(`Read-only: ${action.readonly}`);
+    }
+    if (action.value !== undefined && action.value !== '') {
+        details.push(`Value: "${action.value}"`);
+    }
+    return details.length > 0 ? details.join(', ') : 'No specific action';
+}
+async;
+createCatalogClientScript(args, any);
+{
+    try {
+        this.logger.info('Creating catalog client script...');
+        const scriptData = {
+            cat_item: args.cat_item,
+            name: args.name,
+            script: args.script,
+            type: args.type,
+            applies_to: args.applies_to || 'item',
+            cat_variable: args.variable || '',
+            active: args.active !== false
+        };
+        const response = await this.client.createRecord('catalog_script_client', scriptData);
+        if (!response.success) {
+            throw new Error(`Failed to create catalog client script: ${response.error}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Catalog Client Script created successfully!
 
 📜 **${args.name}**
 🆔 sys_id: ${response.data.sys_id}
@@ -1367,118 +1368,115 @@ ${args.variable ? `📝 Variable: ${args.variable}` : ''}
 🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
 
 ✨ Client script added to catalog item!`
+                }]
+        };
+    }
+    catch (error) {
+        this.logger.error('Failed to create catalog client script:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create catalog client script: ${error}`);
+    }
+}
+async;
+searchCatalog(args, any);
+{
+    try {
+        this.logger.info('Searching service catalog...');
+        let query = args.query ? `nameLIKE${args.query}^ORshort_descriptionLIKE${args.query}` : '';
+        if (args.category) {
+            query += query ? '^' : '';
+            query += `category=${args.category}`;
+        }
+        if (args.catalog) {
+            query += query ? '^' : '';
+            query += `sc_catalogs=${args.catalog}`;
+        }
+        if (args.active_only) {
+            query += query ? '^' : '';
+            query += 'active=true';
+        }
+        const limit = args.limit || 20;
+        this.logger.trackAPICall('SEARCH', 'sc_cat_item', limit);
+        const response = await this.client.searchRecords('sc_cat_item', query, limit);
+        if (!response.success) {
+            throw new Error('Failed to search catalog');
+        }
+        const items = response.data.result;
+        if (!items.length) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ No catalog items found${args.query ? ` matching "${args.query}"` : ''}`
                     }]
             };
         }
-        catch (error) {
-            this.logger.error('Failed to create catalog client script:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create catalog client script: ${error}`);
-        }
-    }
-    /**
-     * Search Service Catalog
-     */
-    async searchCatalog(args) {
-        try {
-            this.logger.info('Searching service catalog...');
-            let query = args.query ? `nameLIKE${args.query}^ORshort_descriptionLIKE${args.query}` : '';
-            if (args.category) {
-                query += query ? '^' : '';
-                query += `category=${args.category}`;
-            }
-            if (args.catalog) {
-                query += query ? '^' : '';
-                query += `sc_catalogs=${args.catalog}`;
-            }
-            if (args.active_only) {
-                query += query ? '^' : '';
-                query += 'active=true';
-            }
-            const limit = args.limit || 20;
-            this.logger.trackAPICall('SEARCH', 'sc_cat_item', limit);
-            const response = await this.client.searchRecords('sc_cat_item', query, limit);
-            if (!response.success) {
-                throw new Error('Failed to search catalog');
-            }
-            const items = response.data.result;
-            if (!items.length) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `❌ No catalog items found${args.query ? ` matching "${args.query}"` : ''}`
-                        }]
-                };
-            }
-            const itemList = items.map((item) => {
-                return `🛍️ **${item.name}**
+        const itemList = items.map((item) => {
+            return `🛍️ **${item.name}**
 🆔 ${item.sys_id}
 📝 ${item.short_description}
 ${item.price && item.price !== '0' ? `💰 Price: $${item.price}` : ''}
 🔄 Active: ${item.active ? 'Yes' : 'No'}`;
-            }).join('\n\n');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Catalog Search Results${args.query ? ` for "${args.query}"` : ''}:
+        }).join('\n\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `🔍 Catalog Search Results${args.query ? ` for "${args.query}"` : ''}:
 
 ${itemList}
 
 ✨ Found ${items.length} catalog item(s)`
-                    }]
-            };
+                }]
+        };
+    }
+    catch (error) {
+        this.logger.error('Failed to search catalog:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to search catalog: ${error}`);
+    }
+}
+async;
+orderCatalogItem(args, any);
+{
+    try {
+        this.logger.info('Ordering catalog item...');
+        // Create service catalog request
+        const requestData = {
+            requested_for: args.requested_for,
+            opened_by: args.requested_for,
+            special_instructions: args.special_instructions || ''
+        };
+        const requestResponse = await this.client.createRecord('sc_request', requestData);
+        if (!requestResponse.success) {
+            throw new Error(`Failed to create request: ${requestResponse.error}`);
         }
-        catch (error) {
-            this.logger.error('Failed to search catalog:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to search catalog: ${error}`);
+        const requestId = requestResponse.data.sys_id;
+        // Create requested item (RITM)
+        const ritmData = {
+            request: requestId,
+            cat_item: args.cat_item,
+            requested_for: args.requested_for,
+            quantity: args.quantity || 1,
+            delivery_address: args.delivery_address || ''
+        };
+        const ritmResponse = await this.client.createRecord('sc_req_item', ritmData);
+        if (!ritmResponse.success) {
+            throw new Error(`Failed to create requested item: ${ritmResponse.error}`);
         }
-    }
-    /**
-     * Order Catalog Item
-     * Creates sc_request and sc_req_item records
-     */
-    async orderCatalogItem(args) {
-        try {
-            this.logger.info('Ordering catalog item...');
-            // Create service catalog request
-            const requestData = {
-                requested_for: args.requested_for,
-                opened_by: args.requested_for,
-                special_instructions: args.special_instructions || ''
-            };
-            const requestResponse = await this.client.createRecord('sc_request', requestData);
-            if (!requestResponse.success) {
-                throw new Error(`Failed to create request: ${requestResponse.error}`);
-            }
-            const requestId = requestResponse.data.sys_id;
-            // Create requested item (RITM)
-            const ritmData = {
-                request: requestId,
-                cat_item: args.cat_item,
-                requested_for: args.requested_for,
-                quantity: args.quantity || 1,
-                delivery_address: args.delivery_address || ''
-            };
-            const ritmResponse = await this.client.createRecord('sc_req_item', ritmData);
-            if (!ritmResponse.success) {
-                throw new Error(`Failed to create requested item: ${ritmResponse.error}`);
-            }
-            const ritmId = ritmResponse.data.sys_id;
-            const ritmNumber = ritmResponse.data.number;
-            // Set variable values if provided
-            if (args.variables) {
-                for (const [varName, varValue] of Object.entries(args.variables)) {
-                    const varData = {
-                        request_item: ritmId,
-                        name: varName,
-                        value: varValue
-                    };
-                    await this.client.createRecord('sc_item_option_mtom', varData);
-                }
+        const ritmId = ritmResponse.data.sys_id;
+        const ritmNumber = ritmResponse.data.number;
+        // Set variable values if provided
+        if (args.variables) {
+            for (const [varName, varValue] of Object.entries(args.variables)) {
+                const varData = {
+                    request_item: ritmId,
+                    name: varName,
+                    value: varValue
+                };
+                await this.client.createRecord('sc_item_option_mtom', varData);
             }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Catalog Item ordered successfully!
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Catalog Item ordered successfully!
 
 🛍️ **Order Placed**
 🆔 Request: ${requestId}
@@ -1489,52 +1487,51 @@ ${args.delivery_address ? `📍 Delivery: ${args.delivery_address}` : ''}
 ${args.special_instructions ? `📝 Instructions: ${args.special_instructions}` : ''}
 
 ✨ Order submitted for fulfillment!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to order catalog item:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to order catalog item: ${error}`);
-        }
+                }]
+        };
     }
-    /**
-     * Get Catalog Item Details
-     */
-    async getCatalogItemDetails(args) {
-        try {
-            this.logger.info('Getting catalog item details...', { sys_id: args.sys_id });
-            // 🔍 DEBUGGING: Try different methods to find the item
-            this.logger.info('🔍 Step 1: Trying getRecord method...');
-            let itemResponse = await this.client.getRecord('sc_cat_item', args.sys_id);
-            if (!itemResponse.success) {
-                this.logger.warn('❌ getRecord failed, trying searchRecords as fallback...');
-                this.logger.warn('getRecord error:', itemResponse.error);
-                // Fallback: try searchRecords method
-                itemResponse = await this.client.searchRecords('sc_cat_item', `sys_id=${args.sys_id}`, 1);
-                if (!itemResponse.success || itemResponse.data.result.length === 0) {
-                    this.logger.error('❌ Both getRecord and searchRecords failed');
-                    this.logger.error('searchRecords error:', itemResponse.error);
-                    // Final fallback: try to query with different parameters
-                    const queryResponse = await this.client.queryTable('sc_cat_item', `sys_id=${args.sys_id}`, 1);
-                    if (queryResponse.success && queryResponse.data.result.length > 0) {
-                        this.logger.info('✅ Found item using queryTable fallback');
-                        itemResponse = { success: true, data: queryResponse.data.result[0] };
-                    }
-                    else {
-                        this.logger.error('❌ All methods failed to find catalog item');
-                        throw new Error(`Catalog item not found with sys_id: ${args.sys_id}. Tried getRecord, searchRecords, and queryTable.`);
-                    }
+    catch (error) {
+        this.logger.error('Failed to order catalog item:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to order catalog item: ${error}`);
+    }
+}
+async;
+getCatalogItemDetails(args, any);
+{
+    try {
+        this.logger.info('Getting catalog item details...', { sys_id: args.sys_id });
+        // 🔍 DEBUGGING: Try different methods to find the item
+        this.logger.info('🔍 Step 1: Trying getRecord method...');
+        let itemResponse = await this.client.getRecord('sc_cat_item', args.sys_id);
+        if (!itemResponse.success) {
+            this.logger.warn('❌ getRecord failed, trying searchRecords as fallback...');
+            this.logger.warn('getRecord error:', itemResponse.error);
+            // Fallback: try searchRecords method
+            itemResponse = await this.client.searchRecords('sc_cat_item', `sys_id=${args.sys_id}`, 1);
+            if (!itemResponse.success || itemResponse.data.result.length === 0) {
+                this.logger.error('❌ Both getRecord and searchRecords failed');
+                this.logger.error('searchRecords error:', itemResponse.error);
+                // Final fallback: try to query with different parameters
+                const queryResponse = await this.client.queryTable('sc_cat_item', `sys_id=${args.sys_id}`, 1);
+                if (queryResponse.success && queryResponse.data.result.length > 0) {
+                    this.logger.info('✅ Found item using queryTable fallback');
+                    itemResponse = { success: true, data: queryResponse.data.result[0] };
                 }
                 else {
-                    this.logger.info('✅ Found item using searchRecords fallback');
-                    itemResponse = { success: true, data: itemResponse.data.result[0] };
+                    this.logger.error('❌ All methods failed to find catalog item');
+                    throw new Error(`Catalog item not found with sys_id: ${args.sys_id}. Tried getRecord, searchRecords, and queryTable.`);
                 }
             }
             else {
-                this.logger.info('✅ Found item using getRecord');
+                this.logger.info('✅ Found item using searchRecords fallback');
+                itemResponse = { success: true, data: itemResponse.data.result[0] };
             }
-            const item = itemResponse.data;
-            let details = `🛍️ **${item.name}**
+        }
+        else {
+            this.logger.info('✅ Found item using getRecord');
+        }
+        const item = itemResponse.data;
+        let details = `🛍️ **${item.name}**
 🆔 sys_id: ${item.sys_id}
 📝 ${item.short_description}
 📄 ${item.description || 'No detailed description'}
@@ -1542,82 +1539,82 @@ ${item.price && item.price !== '0' ? `💰 Price: $${item.price}` : ''}
 ${item.recurring_price && item.recurring_price !== '0' ? `🔄 Recurring: $${item.recurring_price}` : ''}
 📦 Delivery: ${item.delivery_time || '3 business days'}
 🔄 Active: ${item.active ? 'Yes' : 'No'}`;
-            // Get variables if requested
-            if (args.include_variables) {
-                const varResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${args.sys_id}`, 50);
-                if (varResponse.success && varResponse.data.result.length) {
-                    const variables = varResponse.data.result.map((v) => `  - ${v.question_text} (${v.type})${v.mandatory ? ' *Required' : ''}`).join('\n');
-                    details += `\n\n📋 **Variables:**\n${variables}`;
-                }
+        // Get variables if requested
+        if (args.include_variables) {
+            const varResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${args.sys_id}`, 50);
+            if (varResponse.success && varResponse.data.result.length) {
+                const variables = varResponse.data.result.map((v) => `  - ${v.question_text} (${v.type})${v.mandatory ? ' *Required' : ''}`).join('\n');
+                details += `\n\n📋 **Variables:**\n${variables}`;
             }
-            return {
-                content: [{
-                        type: 'text',
-                        text: details + '\n\n✨ Catalog item details retrieved!'
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get catalog item details:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get catalog item details: ${error}`);
         }
+        return {
+            content: [{
+                    type: 'text',
+                    text: details + '\n\n✨ Catalog item details retrieved!'
+                }]
+        };
     }
-    /**
-     * Discover Service Catalogs
-     */
-    async discoverCatalogs(args) {
-        try {
-            this.logger.info('Discovering service catalogs...');
-            let query = '';
-            if (args.active_only) {
-                query = 'active=true';
-            }
-            const catalogResponse = await this.client.searchRecords('sc_catalog', query, 50);
-            if (!catalogResponse.success) {
-                throw new Error('Failed to discover catalogs');
+    catch (error) {
+        this.logger.error('Failed to get catalog item details:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get catalog item details: ${error}`);
+    }
+}
+async;
+discoverCatalogs(args, any);
+{
+    try {
+        this.logger.info('Discovering service catalogs...');
+        let query = '';
+        if (args.active_only) {
+            query = 'active=true';
+        }
+        const catalogResponse = await this.client.searchRecords('sc_catalog', query, 50);
+        if (!catalogResponse.success) {
+            throw new Error('Failed to discover catalogs');
+        }
+        const catalogs = catalogResponse.data.result;
+        // Get categories if requested
+        const catalogsWithDetails = await Promise.all(catalogs.map(async (catalog) => {
+            if (args.include_categories) {
+                const catResponse = await this.client.searchRecords('sc_category', `sc_catalog=${catalog.sys_id}`, 20);
+                const categories = catResponse.success ? catResponse.data.result : [];
+                return { ...catalog, categories };
             }
-            const catalogs = catalogResponse.data.result;
-            // Get categories if requested
-            const catalogsWithDetails = await Promise.all(catalogs.map(async (catalog) => {
-                if (args.include_categories) {
-                    const catResponse = await this.client.searchRecords('sc_category', `sc_catalog=${catalog.sys_id}`, 20);
-                    const categories = catResponse.success ? catResponse.data.result : [];
-                    return { ...catalog, categories };
-                }
-                return catalog;
-            }));
-            const catalogText = catalogsWithDetails.map((catalog) => {
-                let text = `🛍️ **${catalog.title}** ${catalog.active ? '✅' : '❌'}
+            return catalog;
+        }));
+        const catalogText = catalogsWithDetails.map((catalog) => {
+            let text = `🛍️ **${catalog.title}** ${catalog.active ? '✅' : '❌'}
 🆔 ${catalog.sys_id}
 📝 ${catalog.description || 'No description'}`;
-                if (catalog.categories) {
-                    const categoryList = catalog.categories.map((cat) => `  - ${cat.title}`).join('\n');
-                    text += `\n📂 Categories:\n${categoryList || '  No categories'}`;
-                }
-                return text;
-            }).join('\n\n');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Discovered Service Catalogs:
+            if (catalog.categories) {
+                const categoryList = catalog.categories.map((cat) => `  - ${cat.title}`).join('\n');
+                text += `\n📂 Categories:\n${categoryList || '  No categories'}`;
+            }
+            return text;
+        }).join('\n\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `🔍 Discovered Service Catalogs:
 
 ${catalogText}
 
 ✨ Found ${catalogs.length} catalog(s)`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover catalogs:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover catalogs: ${error}`);
-        }
+                }]
+        };
     }
-    async run() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Knowledge & Catalog MCP Server running on stdio');
+    catch (error) {
+        this.logger.error('Failed to discover catalogs:', error);
+        throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover catalogs: ${error}`);
     }
 }
+async;
+run();
+{
+    const transport = new stdio_js_1.StdioServerTransport();
+    await this.server.connect(transport);
+    this.logger.info('ServiceNow Knowledge & Catalog MCP Server running on stdio');
+}
 const server = new ServiceNowKnowledgeCatalogMCP();
 server.run().catch(console.error);
 //# sourceMappingURL=servicenow-knowledge-catalog-mcp.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.3.5",
+  "version": "4.3.8",
   "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 200+ ServiceNow tools for comprehensive platform development.",
   "main": "dist/index.js",
   "type": "commonjs",