snow-flow 1.3.18 → 1.3.19

package/dist/cli.js

@@ -65,8 +65,16 @@ program
 // Helper function to deploy XML to ServiceNow
 async function deployXMLToServiceNow(xmlFile, options = {}) {
     const oauth = new snow_oauth_js_1.ServiceNowOAuth();
-    const isAuthenticated = await oauth.getStoredTokens() !== null;
-    if (!isAuthenticated) {
+    let tokens;
+    try {
+        tokens = await oauth.getStoredTokens();
+    }
+    catch (error) {
+        cliLogger.error('❌ Failed to get authentication tokens:', error);
+        cliLogger.error('Please run: snow-flow auth login');
+        return false;
+    }
+    if (!tokens || !tokens.accessToken) {
         cliLogger.error('❌ Not authenticated. Please run: snow-flow auth login');
         return false;
     }
@@ -166,11 +174,43 @@ async function deployXMLToServiceNow(xmlFile, options = {}) {
         return true;
     }
     catch (error) {
-        cliLogger.error('\n❌ Deployment failed:', error instanceof Error ? error.message : String(error));
+        cliLogger.error('\n❌ Deployment failed:');
+        // Detailed error handling for 400 errors
+        if (error.response?.status === 400) {
+            cliLogger.error(`   Status: ${error.response.status} Bad Request`);
+            if (error.response.data) {
+                cliLogger.error(`   Message: ${error.response.data.error?.message || error.response.data.message || 'Unknown error'}`);
+                if (error.response.data.error?.detail) {
+                    cliLogger.error(`   Detail: ${error.response.data.error.detail}`);
+                }
+                if (error.response.data.error?.fields) {
+                    cliLogger.error('   Missing or invalid fields:');
+                    Object.entries(error.response.data.error.fields).forEach(([field, msg]) => {
+                        cliLogger.error(`     - ${field}: ${msg}`);
+                    });
+                }
+            }
+        }
+        else if (error.response?.status === 401) {
+            cliLogger.error('   Status: 401 Unauthorized - Authentication failed');
+            cliLogger.error('   Your OAuth token may be expired. Please run: snow-flow auth login');
+        }
+        else if (error.response?.status === 403) {
+            cliLogger.error('   Status: 403 Forbidden - Insufficient permissions');
+            cliLogger.error('   You need admin or update_set_admin role to import update sets');
+        }
+        else if (error.response) {
+            cliLogger.error(`   Status: ${error.response.status}`);
+            cliLogger.error(`   Message: ${error.response.data?.error?.message || error.response.statusText}`);
+        }
+        else {
+            cliLogger.error(`   ${error instanceof Error ? error.message : String(error)}`);
+        }
         cliLogger.info('\n💡 Troubleshooting tips:');
         cliLogger.info('   1. Check your authentication: snow-flow auth status');
         cliLogger.info('   2. Verify XML file format is correct');
         cliLogger.info('   3. Ensure you have required permissions in ServiceNow');
+        cliLogger.info('   4. Check ServiceNow system logs for more details');
         return false;
     }
 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.3.18",
+  "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",