snow-flow 1.3.17 → 1.3.19

package/dist/mcp/servicenow-xml-flow-mcp.js

@@ -41,6 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceNowXMLFlowMCP = void 0;
 const base_mcp_server_1 = require("./base-mcp-server");
 const improved_flow_xml_generator_1 = __importStar(require("../utils/improved-flow-xml-generator"));
+const xml_first_flow_generator_1 = require("../utils/xml-first-flow-generator"); // Keep for backward compatibility
 const natural_language_mapper_1 = require("../api/natural-language-mapper");
 const servicenow_id_generator_js_1 = require("../utils/servicenow-id-generator.js");
 const fs = __importStar(require("fs"));
@@ -118,7 +119,7 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
         // Generate flow XML from natural language
         this.registerTool({
             name: 'snow_xml_flow_from_instruction',
-            description: 'Generate flow Update Set XML from natural language instruction',
+            description: '⚠️ DEPRECATED - Use snow_create_flow instead. This tool is kept for backwards compatibility only.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -130,6 +131,11 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
                         type: 'boolean',
                         default: true,
                         description: 'Save XML to file'
+                    },
+                    auto_deploy: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Automatically deploy XML to ServiceNow after generation (RECOMMENDED)'
                     }
                 },
                 required: ['instruction']
@@ -219,7 +225,7 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
      */
     async generateFlowFromInstruction(args) {
         try {
-            const { instruction } = args;
+            const { instruction, auto_deploy = true } = args;
             // Parse natural language to flow components
             const flowRequirements = await this.nlMapper.parseFlowRequirements(instruction);
             // Convert to IMPROVED flow definition
@@ -235,21 +241,128 @@ class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
                 tags: ['auto-generated'],
                 activities: this.convertToImprovedActivities(flowRequirements)
             };
-            // Use IMPROVED generator
-            const result = (0, improved_flow_xml_generator_1.generateImprovedFlowXML)(flowDef);
+            // Use PRODUCTION-READY generator with proper Update Set structure
+            const result = (0, xml_first_flow_generator_1.generateProductionFlowXML)(flowDef);
+            let deploymentResult = null;
+            // 🚀 AUTO-DEPLOYMENT: Deploy immediately if requested
+            if (auto_deploy) {
+                try {
+                    this.logger.info('🚀 AUTO-DEPLOYING XML to ServiceNow...');
+                    // Check authentication
+                    const isAuth = await this.oauth.isAuthenticated();
+                    if (!isAuth) {
+                        throw new Error('Not authenticated with ServiceNow. Please run: snow-flow auth login');
+                    }
+                    // Initialize ServiceNow client
+                    const client = new ServiceNowClient();
+                    // Read the XML file
+                    const fs = require('fs').promises;
+                    const xmlContent = await fs.readFile(result.filePath, 'utf-8');
+                    // Import XML as remote update set
+                    const importResponse = await client.makeRequest({
+                        method: 'POST',
+                        url: '/api/now/table/sys_remote_update_set',
+                        headers: {
+                            'Content-Type': 'application/xml',
+                            'Accept': 'application/json'
+                        },
+                        data: xmlContent
+                    });
+                    if (!importResponse.result || !importResponse.result.sys_id) {
+                        throw new Error('Failed to import XML update set');
+                    }
+                    const remoteUpdateSetId = importResponse.result.sys_id;
+                    this.logger.info(`✅ XML imported successfully (sys_id: ${remoteUpdateSetId})`);
+                    // Load the update set
+                    await client.makeRequest({
+                        method: 'PUT',
+                        url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
+                        data: {
+                            state: 'loaded'
+                        }
+                    });
+                    // Find the loaded update set
+                    const loadedResponse = await client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_update_set',
+                        params: {
+                            sysparm_query: `remote_sys_id=${remoteUpdateSetId}`,
+                            sysparm_limit: 1
+                        }
+                    });
+                    if (!loadedResponse.result || loadedResponse.result.length === 0) {
+                        throw new Error('Failed to find loaded update set');
+                    }
+                    const updateSetId = loadedResponse.result[0].sys_id;
+                    const updateSetName = loadedResponse.result[0].name;
+                    // Preview the update set
+                    await client.makeRequest({
+                        method: 'POST',
+                        url: `/api/now/table/sys_update_set/${updateSetId}/preview`
+                    });
+                    // Check for preview problems
+                    const previewProblems = await client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_update_preview_problem',
+                        params: {
+                            sysparm_query: `update_set=${updateSetId}`,
+                            sysparm_limit: 100
+                        }
+                    });
+                    if (previewProblems.result && previewProblems.result.length > 0) {
+                        const problemsList = previewProblems.result.map((p) => `- ${p.type}: ${p.description}`).join('\n');
+                        throw new Error(`Preview found problems:\n${problemsList}\n\nPlease review and resolve in ServiceNow UI`);
+                    }
+                    // Commit the update set
+                    await client.makeRequest({
+                        method: 'POST',
+                        url: `/api/now/table/sys_update_set/${updateSetId}/commit`
+                    });
+                    deploymentResult = {
+                        success: true,
+                        message: '✅ XML automatically deployed to ServiceNow!',
+                        update_set_id: updateSetId,
+                        update_set_name: updateSetName,
+                        steps_completed: [
+                            '✅ XML imported as remote update set',
+                            '✅ Update set loaded successfully',
+                            '✅ Preview completed with no problems',
+                            '✅ Update set committed successfully'
+                        ]
+                    };
+                    this.logger.info('✅ Auto-deployment successful', deploymentResult);
+                }
+                catch (deployError) {
+                    this.logger.warn('⚠️ Auto-deployment failed, providing manual instructions', deployError);
+                    deploymentResult = {
+                        success: false,
+                        error: deployError instanceof Error ? deployError.message : String(deployError),
+                        manual_command: `snow-flow deploy-xml ${result.filePath}`,
+                        troubleshooting: [
+                            '1. Check ServiceNow authentication: snow-flow auth status',
+                            '2. Verify admin permissions in ServiceNow',
+                            '3. Review XML file for format issues',
+                            '4. Try manual deployment command above'
+                        ]
+                    };
+                }
+            }
             return {
                 success: true,
                 xml: args.save_to_file === false ? result.xml : undefined,
                 file_path: result.filePath,
                 flow_definition: flowDef,
-                message: `✅ Generated IMPROVED flow XML from instruction: ${instruction}`,
+                deployment: deploymentResult,
+                message: `✅ Generated IMPROVED flow XML from instruction: ${instruction}${deploymentResult?.success ? ' + DEPLOYED!' : ''}`,
                 improvements: [
                     '✅ Production-ready Flow Designer format',
                     '✅ Complete XML structure with all required fields',
                     '✅ Base64+gzip encoded action values',
-                    '✅ Proper v2 table usage'
+                    '✅ Proper v2 table usage',
+                    ...(deploymentResult?.success ? ['✅ Automatically deployed to ServiceNow!'] : [])
                 ],
-                import_instructions: result.instructions
+                import_instructions: deploymentResult?.success ? 'Flow is already deployed and ready to use!' : result.instructions,
+                auto_deploy_command: deploymentResult?.manual_command || `snow-flow deploy-xml ${result.filePath}`
             };
         }
         catch (error) {

package/dist/types/index.js

@@ -17,4 +17,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Re-export coordination framework types
 __exportStar(require("./snow-flow.types"), exports);
-__exportStar(require("../coordination/types"), exports);

package/dist/utils/mcp-server-manager.js

@@ -12,6 +12,7 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const events_1 = require("events");
 const os_1 = __importDefault(require("os"));
+const unified_auth_store_js_1 = require("./unified-auth-store.js");
 class MCPServerManager extends events_1.EventEmitter {
     constructor(configPath) {
         super();
@@ -172,15 +173,33 @@ class MCPServerManager extends events_1.EventEmitter {
             }
             // Check if script exists
             await fs_1.promises.access(scriptPath);
-            // Start the process
+            // Bridge OAuth tokens to MCP servers
+            await unified_auth_store_js_1.unifiedAuthStore.bridgeToMCP();
+            // Get current tokens for the MCP server
+            const tokens = await unified_auth_store_js_1.unifiedAuthStore.getTokens();
+            const authEnv = {};
+            if (tokens) {
+                authEnv.SNOW_OAUTH_TOKENS = JSON.stringify(tokens);
+                authEnv.SNOW_INSTANCE = tokens.instance;
+                authEnv.SNOW_CLIENT_ID = tokens.clientId;
+                authEnv.SNOW_CLIENT_SECRET = tokens.clientSecret;
+                if (tokens.accessToken) {
+                    authEnv.SNOW_ACCESS_TOKEN = tokens.accessToken;
+                }
+                if (tokens.refreshToken) {
+                    authEnv.SNOW_REFRESH_TOKEN = tokens.refreshToken;
+                }
+                if (tokens.expiresAt) {
+                    authEnv.SNOW_TOKEN_EXPIRES_AT = tokens.expiresAt;
+                }
+            }
+            // Start the process with OAuth tokens
             const childProcess = (0, child_process_1.spawn)('node', [scriptPath], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 detached: true,
                 env: {
                     ...process.env,
-                    SNOW_INSTANCE: process.env.SNOW_INSTANCE,
-                    SNOW_CLIENT_ID: process.env.SNOW_CLIENT_ID,
-                    SNOW_CLIENT_SECRET: process.env.SNOW_CLIENT_SECRET
+                    ...authEnv
                 }
             });
             // Set up logging

package/dist/utils/servicenow-client.js

@@ -15,6 +15,7 @@ const action_type_cache_1 = require("./action-type-cache");
 const snow_flow_config_js_1 = require("../config/snow-flow-config.js");
 const widget_template_generator_js_1 = require("./widget-template-generator.js");
 const logger_1 = require("./logger");
+const unified_auth_store_js_1 = require("./unified-auth-store.js");
 const flow_structure_builder_1 = require("./flow-structure-builder");
 class ServiceNowClient {
     constructor() {
@@ -115,7 +116,22 @@ class ServiceNowClient {
      */
     async ensureAuthenticated() {
         if (!this.credentials) {
-            this.credentials = await this.oauth.loadCredentials();
+            // Try unified auth store first (most reliable)
+            const tokens = await unified_auth_store_js_1.unifiedAuthStore.getTokens();
+            if (tokens) {
+                this.credentials = {
+                    instance: tokens.instance,
+                    clientId: tokens.clientId,
+                    clientSecret: tokens.clientSecret,
+                    accessToken: tokens.accessToken,
+                    refreshToken: tokens.refreshToken,
+                    expiresAt: tokens.expiresAt
+                };
+            }
+            else {
+                // Fallback to OAuth loadCredentials
+                this.credentials = await this.oauth.loadCredentials();
+            }
         }
         if (!this.credentials) {
             console.error('❌ No ServiceNow credentials found');

package/dist/utils/snow-oauth.js

@@ -18,6 +18,7 @@ const axios_1 = __importDefault(require("axios"));
 const net_1 = __importDefault(require("net"));
 const crypto_1 = __importDefault(require("crypto"));
 const snow_flow_config_js_1 = require("../config/snow-flow-config.js");
+const unified_auth_store_js_1 = require("./unified-auth-store.js");
 class ServiceNowOAuth {
     constructor() {
         // Store tokens in user's home directory
@@ -348,15 +349,16 @@ class ServiceNowOAuth {
      */
     async saveTokens(tokenData) {
         try {
-            const configDir = process.env.SNOW_FLOW_HOME || (0, path_1.join)(os_1.default.homedir(), '.snow-flow');
-            await fs_1.promises.mkdir(configDir, { recursive: true });
             const expiresAt = new Date();
             expiresAt.setSeconds(expiresAt.getSeconds() + tokenData.expiresIn);
             const authData = {
                 ...tokenData,
                 expiresAt: expiresAt.toISOString()
             };
-            await fs_1.promises.writeFile(this.tokenPath, JSON.stringify(authData, null, 2), 'utf8');
+            // Use unified auth store
+            await unified_auth_store_js_1.unifiedAuthStore.saveTokens(authData);
+            // Bridge to MCP servers immediately
+            await unified_auth_store_js_1.unifiedAuthStore.bridgeToMCP();
         }
         catch (error) {
             console.error('Failed to save tokens:', error);
@@ -368,8 +370,7 @@ class ServiceNowOAuth {
      */
     async loadTokens() {
         try {
-            const data = await fs_1.promises.readFile(this.tokenPath, 'utf8');
-            return JSON.parse(data);
+            return await unified_auth_store_js_1.unifiedAuthStore.getTokens();
         }
         catch (error) {
             return null;
@@ -495,6 +496,12 @@ class ServiceNowOAuth {
             console.log('No active session to logout from');
         }
     }
+    /**
+     * Get stored OAuth tokens for use in other contexts (MCP servers)
+     */
+    async getStoredTokens() {
+        return await this.loadTokens();
+    }
     /**
      * Load credentials (including tokens) with .env fallback
      */

package/dist/utils/unified-auth-store.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Unified Authentication Store for ServiceNow
+ *
+ * Provides shared token storage accessible from both CLI and MCP contexts.
+ * Solves the token isolation problem between different execution contexts.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedAuthStore = exports.UnifiedAuthStore = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = __importDefault(require("os"));
+const dotenv_1 = __importDefault(require("dotenv"));
+// Load environment variables
+dotenv_1.default.config();
+class UnifiedAuthStore {
+    constructor() {
+        this.memoryStore = null;
+        // Use consistent path across all contexts
+        const configDir = process.env.SNOW_FLOW_HOME || (0, path_1.join)(os_1.default.homedir(), '.snow-flow');
+        this.tokenPath = (0, path_1.join)(configDir, 'auth.json');
+        // Also check environment for shared tokens (from MCP bridge)
+        if (process.env.SNOW_OAUTH_TOKENS) {
+            try {
+                this.memoryStore = JSON.parse(process.env.SNOW_OAUTH_TOKENS);
+            }
+            catch (e) {
+                console.error('Failed to parse SNOW_OAUTH_TOKENS from environment');
+            }
+        }
+    }
+    static getInstance() {
+        if (!UnifiedAuthStore.instance) {
+            UnifiedAuthStore.instance = new UnifiedAuthStore();
+        }
+        return UnifiedAuthStore.instance;
+    }
+    /**
+     * Get tokens from file or memory
+     */
+    async getTokens() {
+        try {
+            // First check memory store (fastest)
+            if (this.memoryStore) {
+                return this.memoryStore;
+            }
+            // Then check file system
+            const data = await fs_1.promises.readFile(this.tokenPath, 'utf8');
+            const tokens = JSON.parse(data);
+            // Cache in memory for performance
+            this.memoryStore = tokens;
+            return tokens;
+        }
+        catch (error) {
+            // Fallback to environment variables
+            return this.getTokensFromEnv();
+        }
+    }
+    /**
+     * Save tokens to file and memory
+     */
+    async saveTokens(tokens) {
+        try {
+            const configDir = (0, path_1.join)(os_1.default.homedir(), '.snow-flow');
+            await fs_1.promises.mkdir(configDir, { recursive: true });
+            await fs_1.promises.writeFile(this.tokenPath, JSON.stringify(tokens, null, 2));
+            // Update memory store
+            this.memoryStore = tokens;
+            // Update environment for child processes
+            process.env.SNOW_OAUTH_TOKENS = JSON.stringify(tokens);
+        }
+        catch (error) {
+            console.error('Failed to save tokens:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get tokens from environment variables (fallback)
+     */
+    getTokensFromEnv() {
+        const instance = process.env.SNOW_INSTANCE;
+        const clientId = process.env.SNOW_CLIENT_ID;
+        const clientSecret = process.env.SNOW_CLIENT_SECRET;
+        if (!instance || !clientId || !clientSecret) {
+            return null;
+        }
+        return {
+            instance: instance.replace(/\/$/, ''),
+            clientId,
+            clientSecret,
+            accessToken: process.env.SNOW_ACCESS_TOKEN,
+            refreshToken: process.env.SNOW_REFRESH_TOKEN,
+            expiresAt: process.env.SNOW_TOKEN_EXPIRES_AT
+        };
+    }
+    /**
+     * Check if tokens are valid and not expired
+     */
+    async isAuthenticated() {
+        try {
+            const tokens = await this.getTokens();
+            if (!tokens || !tokens.accessToken) {
+                return false;
+            }
+            // Check expiration
+            if (tokens.expiresAt) {
+                const expiresAt = new Date(tokens.expiresAt);
+                const now = new Date();
+                return now < expiresAt;
+            }
+            // If no expiration, assume valid
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Clear all stored tokens
+     */
+    async clearTokens() {
+        try {
+            await fs_1.promises.unlink(this.tokenPath);
+        }
+        catch (error) {
+            // Ignore if file doesn't exist
+        }
+        // Clear memory and environment
+        this.memoryStore = null;
+        delete process.env.SNOW_OAUTH_TOKENS;
+        delete process.env.SNOW_ACCESS_TOKEN;
+        delete process.env.SNOW_REFRESH_TOKEN;
+        delete process.env.SNOW_TOKEN_EXPIRES_AT;
+    }
+    /**
+     * Get ServiceNow instance URL
+     */
+    async getInstanceUrl() {
+        const tokens = await this.getTokens();
+        if (!tokens) {
+            return null;
+        }
+        let instance = tokens.instance;
+        if (!instance.startsWith('http')) {
+            instance = `https://${instance}`;
+        }
+        if (!instance.endsWith('.service-now.com')) {
+            instance = `${instance}.service-now.com`;
+        }
+        return instance;
+    }
+    /**
+     * Get headers for API requests
+     */
+    async getAuthHeaders() {
+        const tokens = await this.getTokens();
+        if (!tokens || !tokens.accessToken) {
+            return null;
+        }
+        return {
+            'Authorization': `Bearer ${tokens.accessToken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        };
+    }
+    /**
+     * Bridge tokens to MCP servers via environment
+     */
+    async bridgeToMCP() {
+        const tokens = await this.getTokens();
+        if (tokens) {
+            process.env.SNOW_OAUTH_TOKENS = JSON.stringify(tokens);
+            process.env.SNOW_INSTANCE = tokens.instance;
+            process.env.SNOW_CLIENT_ID = tokens.clientId;
+            process.env.SNOW_CLIENT_SECRET = tokens.clientSecret;
+            if (tokens.accessToken) {
+                process.env.SNOW_ACCESS_TOKEN = tokens.accessToken;
+            }
+            if (tokens.refreshToken) {
+                process.env.SNOW_REFRESH_TOKEN = tokens.refreshToken;
+            }
+            if (tokens.expiresAt) {
+                process.env.SNOW_TOKEN_EXPIRES_AT = tokens.expiresAt;
+            }
+        }
+    }
+}
+exports.UnifiedAuthStore = UnifiedAuthStore;
+// Export singleton instance
+exports.unifiedAuthStore = UnifiedAuthStore.getInstance();

package/dist/utils/xml-first-flow-generator.js

@@ -425,47 +425,38 @@ class XMLFirstFlowGenerator {
 }
 exports.XMLFirstFlowGenerator = XMLFirstFlowGenerator;
 /**
- * Generate PRODUCTION-READY flow XML (NO placeholders!)
+ * Generate PRODUCTION-READY flow XML with BOTH formats
  */
 function generateProductionFlowXML(flowDef) {
     const generator = new XMLFirstFlowGenerator(flowDef.name.replace(/[^a-zA-Z0-9]+/g, '_') + '_Import');
+    // Generate Update Set XML (better for automatic deployment)
     const xml = generator.generateFlowUpdateSetXML(flowDef);
     const filePath = generator.saveToFile(xml, flowDef.name.toLowerCase().replace(/[^a-z0-9]+/g, '_') + '_flow.xml');
     const instructions = `
-=== ServiceNow Flow Import Instructions ===
+=== ServiceNow Flow Deployment Options ===
 
-1. Log into your ServiceNow instance as an admin user
+🚀 OPTION 1: Automatic Deployment (RECOMMENDED)
+   Use the snow-flow deploy-xml command for complete automation:
+   
+   snow-flow deploy-xml ${filePath}
+   
+   This automatically:
+   ✅ Imports the Update Set
+   ✅ Previews for conflicts 
+   ✅ Commits if clean
+   ✅ Reports any issues
 
-2. Navigate to:
-   System Update Sets > Retrieved Update Sets
+🔧 OPTION 2: Manual Import (if automatic fails)
+   
+   1. Log into ServiceNow as admin
+   2. Navigate to: System Update Sets > Local Update Sets
+   3. Click "Import Update Set from XML"
+   4. Choose file: ${filePath}
+   5. Click "Upload" and follow prompts
+   6. Preview and commit the Update Set
+   7. Find your flow in Flow Designer
 
-3. Click the "Import Update Set from XML" link at the bottom of the list
-   (NOT the "Import from XML" in the context menu!)
-
-4. Choose file: ${filePath}
-
-5. Click "Upload"
-
-6. Find your imported Update Set in the list
-
-7. Click on the Update Set name to open it
-
-8. Click "Preview Update Set"
-   - Review any errors or warnings
-   - Resolve any missing dependencies
-
-9. Once preview is clean, click "Commit Update Set"
-
-10. Navigate to Flow Designer:
-    - All > Flow Designer > Designer
-    - Your flow "${flowDef.name}" should appear in the list
-
-11. Open the flow to verify all components are present
-
-TROUBLESHOOTING:
-- If flow appears empty: Check that all sys_update_xml records were imported
-- If import fails: Verify you're using "Import Update Set from XML" link
-- For dependency errors: Import required plugins/applications first
+The flow "${flowDef.name}" will appear in Flow Designer > Designer
 `.trim();
     return { xml, filePath, instructions };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.3.17",
+  "version": "1.3.19",
   "description": "ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development inspired by claude-flow. Transform complex workflows into elegant one-command orchestration.",
   "main": "dist/index.js",
   "type": "commonjs",