snow-flow 1.4.49 → 2.0.0

package/src/utils/mcp-tool-registry.ts

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+/**
+ * MCP Tool Registry Mapper
+ * 
+ * Solves Issue #2: Tool Registry Mapping Failures
+ * Provides robust tool name resolution between different MCP providers
+ */
+
+import { Logger } from './logger.js';
+
+export interface ToolMapping {
+  canonicalName: string;
+  aliases: string[];
+  provider: string;
+  actualTool: string;
+  description?: string;
+}
+
+export class MCPToolRegistry {
+  private toolMappings: Map<string, ToolMapping> = new Map();
+  private logger: Logger;
+  
+  constructor() {
+    this.logger = new Logger('MCPToolRegistry');
+    this.initializeDefaultMappings();
+  }
+
+  /**
+   * Initialize default tool mappings
+   */
+  private initializeDefaultMappings(): void {
+    // ServiceNow table schema discovery - common confusion point
+    this.registerTool({
+      canonicalName: 'table_schema_discovery',
+      aliases: [
+        'mcp__servicenow-operations__snow_table_schema_discovery',
+        'snow_table_schema_discovery',
+        'table_schema',
+        'schema_discovery'
+      ],
+      provider: 'servicenow-platform-development',
+      actualTool: 'mcp__servicenow-platform-development__snow_table_schema_discovery',
+      description: 'Comprehensive table schema discovery'
+    });
+
+    // Flow deployment tools
+    this.registerTool({
+      canonicalName: 'deploy_flow',
+      aliases: [
+        'mcp__servicenow-deployment__snow_deploy_flow',
+        'snow_deploy_flow',
+        'deploy_flow',
+        'flow_deploy'
+      ],
+      provider: 'servicenow-deployment',
+      actualTool: 'mcp__servicenow-deployment__snow_deploy',
+      description: 'Deploy flows to ServiceNow'
+    });
+
+    // Widget deployment
+    this.registerTool({
+      canonicalName: 'deploy_widget',
+      aliases: [
+        'mcp__servicenow-deployment__snow_deploy_widget',
+        'snow_deploy_widget',
+        'deploy_widget',
+        'widget_deploy'
+      ],
+      provider: 'servicenow-deployment',
+      actualTool: 'mcp__servicenow-deployment__snow_deploy',
+      description: 'Deploy widgets to ServiceNow'
+    });
+
+
+    // Update Set management
+    this.registerTool({
+      canonicalName: 'update_set_create',
+      aliases: [
+        'mcp__servicenow-update-set__snow_update_set_create',
+        'snow_update_set_create',
+        'create_update_set',
+        'update_set_new'
+      ],
+      provider: 'servicenow-update-set',
+      actualTool: 'mcp__servicenow-update-set__snow_update_set_create',
+      description: 'Create Update Sets'
+    });
+
+    // Authentication diagnostics
+    this.registerTool({
+      canonicalName: 'auth_diagnostics',
+      aliases: [
+        'mcp__servicenow-deployment__snow_auth_diagnostics',
+        'snow_auth_diagnostics',
+        'auth_check',
+        'permission_check'
+      ],
+      provider: 'servicenow-deployment',
+      actualTool: 'mcp__servicenow-deployment__snow_auth_diagnostics',
+      description: 'Authentication and permission diagnostics'
+    });
+
+    // Catalog item management
+    this.registerTool({
+      canonicalName: 'catalog_item_manager',
+      aliases: [
+        'mcp__servicenow-operations__snow_catalog_item_manager',
+        'snow_catalog_item_manager',
+        'catalog_manager',
+        'manage_catalog'
+      ],
+      provider: 'servicenow-operations',
+      actualTool: 'mcp__servicenow-operations__snow_catalog_item_manager',
+      description: 'Manage service catalog items'
+    });
+
+    // Platform development tools
+    this.registerTool({
+      canonicalName: 'discover_table_fields',
+      aliases: [
+        'mcp__servicenow-platform-development__snow_discover_table_fields',
+        'snow_discover_table_fields',
+        'discover_fields',
+        'table_fields'
+      ],
+      provider: 'servicenow-platform-development',
+      actualTool: 'mcp__servicenow-platform-development__snow_discover_table_fields',
+      description: 'Discover table fields'
+    });
+
+    // Add more mappings as needed...
+  }
+
+  /**
+   * Register a tool mapping
+   */
+  registerTool(mapping: ToolMapping): void {
+    // Register by canonical name
+    this.toolMappings.set(mapping.canonicalName, mapping);
+    
+    // Register by actual tool name
+    this.toolMappings.set(mapping.actualTool, mapping);
+    
+    // Register by all aliases
+    mapping.aliases.forEach(alias => {
+      this.toolMappings.set(alias.toLowerCase(), mapping);
+    });
+    
+    this.logger.debug(`Registered tool: ${mapping.canonicalName} with ${mapping.aliases.length} aliases`);
+  }
+
+  /**
+   * Resolve a tool name to its actual MCP tool
+   */
+  resolveTool(toolName: string): string | null {
+    // Try exact match first
+    let mapping = this.toolMappings.get(toolName);
+    
+    // Try lowercase match
+    if (!mapping) {
+      mapping = this.toolMappings.get(toolName.toLowerCase());
+    }
+    
+    // Try partial matches
+    if (!mapping) {
+      const searchKey = toolName.toLowerCase();
+      for (const [key, value] of this.toolMappings.entries()) {
+        if (key.includes(searchKey) || searchKey.includes(key)) {
+          mapping = value;
+          break;
+        }
+      }
+    }
+    
+    if (mapping) {
+      this.logger.debug(`Resolved '${toolName}' to '${mapping.actualTool}'`);
+      return mapping.actualTool;
+    }
+    
+    this.logger.warn(`Could not resolve tool: ${toolName}`);
+    return null;
+  }
+
+  /**
+   * Get all tools for a provider
+   */
+  getProviderTools(provider: string): ToolMapping[] {
+    const tools: ToolMapping[] = [];
+    const seen = new Set<string>();
+    
+    for (const mapping of this.toolMappings.values()) {
+      if (mapping.provider === provider && !seen.has(mapping.canonicalName)) {
+        tools.push(mapping);
+        seen.add(mapping.canonicalName);
+      }
+    }
+    
+    return tools;
+  }
+
+  /**
+   * Search tools by keyword
+   */
+  searchTools(keyword: string): ToolMapping[] {
+    const results: ToolMapping[] = [];
+    const seen = new Set<string>();
+    const searchKey = keyword.toLowerCase();
+    
+    for (const mapping of this.toolMappings.values()) {
+      if (seen.has(mapping.canonicalName)) continue;
+      
+      if (
+        mapping.canonicalName.includes(searchKey) ||
+        mapping.description?.toLowerCase().includes(searchKey) ||
+        mapping.aliases.some(alias => alias.toLowerCase().includes(searchKey))
+      ) {
+        results.push(mapping);
+        seen.add(mapping.canonicalName);
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Check if a tool exists
+   */
+  toolExists(toolName: string): boolean {
+    return this.resolveTool(toolName) !== null;
+  }
+
+  /**
+   * Get tool info
+   */
+  getToolInfo(toolName: string): ToolMapping | null {
+    const resolved = this.resolveTool(toolName);
+    if (!resolved) return null;
+    
+    return this.toolMappings.get(resolved) || null;
+  }
+
+  /**
+   * Export all mappings for documentation
+   */
+  exportMappings(): Record<string, ToolMapping> {
+    const exports: Record<string, ToolMapping> = {};
+    const seen = new Set<string>();
+    
+    for (const mapping of this.toolMappings.values()) {
+      if (!seen.has(mapping.canonicalName)) {
+        exports[mapping.canonicalName] = mapping;
+        seen.add(mapping.canonicalName);
+      }
+    }
+    
+    return exports;
+  }
+}
+
+// Singleton instance
+let registryInstance: MCPToolRegistry | null = null;
+
+/**
+ * Get or create registry instance
+ */
+export function getToolRegistry(): MCPToolRegistry {
+  if (!registryInstance) {
+    registryInstance = new MCPToolRegistry();
+  }
+  return registryInstance;
+}
+
+/**
+ * Helper function to resolve tool names
+ */
+export function resolveToolName(toolName: string): string {
+  const registry = getToolRegistry();
+  return registry.resolveTool(toolName) || toolName;
+}
+
+/**
+ * Helper to check if tool exists
+ */
+export function isValidTool(toolName: string): boolean {
+  const registry = getToolRegistry();
+  return registry.toolExists(toolName);
+}
+
+/**
+ * Helper to get tool suggestions
+ */
+export function suggestTools(partial: string): ToolMapping[] {
+  const registry = getToolRegistry();
+  return registry.searchTools(partial);
+}
+
+// Export types and default instance
+export default MCPToolRegistry;

package/src/utils/migrate-snow-flow.ts

@@ -0,0 +1,98 @@
+/**
+ * Migration utility to move from .snow-flow to .snow-flow directories
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from './logger.js';
+
+export class ClaudeFlowMigration {
+  private logger: Logger;
+
+  constructor() {
+    this.logger = new Logger('Migration');
+  }
+
+  /**
+   * Check if migration is needed
+   */
+  async checkMigrationNeeded(): Promise<boolean> {
+    const oldDir = path.join(process.cwd(), '.snow-flow');
+    const newDir = path.join(process.cwd(), '.snow-flow');
+    
+    return fs.existsSync(oldDir) && !fs.existsSync(newDir);
+  }
+
+  /**
+   * Perform migration from .snow-flow to .snow-flow
+   */
+  async migrate(): Promise<void> {
+    const oldDir = path.join(process.cwd(), '.snow-flow');
+    const newDir = path.join(process.cwd(), '.snow-flow');
+    
+    if (!fs.existsSync(oldDir)) {
+      this.logger.debug('No .snow-flow directory found, skipping migration');
+      return;
+    }
+
+    if (fs.existsSync(newDir)) {
+      this.logger.warn('.snow-flow directory already exists, skipping migration');
+      return;
+    }
+
+    this.logger.info('🔄 Migrating from .snow-flow to .snow-flow...');
+
+    try {
+      // Create new directory structure
+      await this.copyDirectory(oldDir, newDir);
+      
+      this.logger.info('✅ Migration completed successfully!');
+      this.logger.info('💡 Old .snow-flow directory preserved for safety');
+      this.logger.info('🔍 You can manually delete .snow-flow after verifying everything works');
+    } catch (error) {
+      this.logger.error('❌ Migration failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Recursively copy directory
+   */
+  private async copyDirectory(src: string, dest: string): Promise<void> {
+    // Create destination directory
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    // Read source directory
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively copy subdirectory
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        // Copy file
+        fs.copyFileSync(srcPath, destPath);
+        this.logger.debug(`Copied: ${entry.name}`);
+      }
+    }
+  }
+
+  /**
+   * Clean up old .snow-flow directory (only after user confirmation)
+   */
+  async cleanup(): Promise<void> {
+    const oldDir = path.join(process.cwd(), '.snow-flow');
+    
+    if (fs.existsSync(oldDir)) {
+      this.logger.warn('⚠️  Removing old .snow-flow directory...');
+      fs.rmSync(oldDir, { recursive: true, force: true });
+      this.logger.info('✅ Cleanup completed');
+    }
+  }
+}
+
+export const migrationUtil = new ClaudeFlowMigration();

package/src/utils/oauth-html-templates.ts

@@ -0,0 +1,188 @@
+/**
+ * OAuth HTML Templates with Snow-Flow branding
+ */
+
+const baseStyles = `
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0;
+      padding: 20px;
+    }
+    .container {
+      background: white;
+      border-radius: 12px;
+      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
+      padding: 40px;
+      text-align: center;
+      max-width: 500px;
+      width: 100%;
+    }
+    .logo {
+      margin-bottom: 30px;
+    }
+    .logo-ascii {
+      font-family: 'Courier New', monospace;
+      white-space: pre;
+      line-height: 1.2;
+      color: #4A90E2;
+      font-size: 14px;
+      margin-bottom: 20px;
+    }
+    h1 {
+      color: #2E5C8A;
+      margin-bottom: 20px;
+      font-size: 28px;
+    }
+    p {
+      color: #666;
+      line-height: 1.6;
+      margin-bottom: 15px;
+    }
+    .success { color: #52c41a; }
+    .error { color: #f5222d; }
+    .brand {
+      color: #4A90E2;
+      font-weight: bold;
+    }
+    .snowflake {
+      display: inline-block;
+      animation: fall 3s ease-in-out infinite;
+    }
+    @keyframes fall {
+      0% { transform: translateY(0) rotate(0deg); }
+      100% { transform: translateY(20px) rotate(360deg); }
+    }
+  </style>
+`;
+
+const logoASCII = `
+      /\\        <span class="snowflake">❄</span>
+     /  \\      <span class="snowflake" style="animation-delay: 0.5s">❄</span>
+    /    \\    <span class="snowflake" style="animation-delay: 1s">❄</span>
+   /      \\  <span class="snowflake" style="animation-delay: 1.5s">❄</span>
+  /________\\
+     ||||
+`;
+
+export const OAuthTemplates = {
+  success: `
+    <html>
+      <head>
+        <title>Snow-Flow - Authentication Successful</title>
+        ${baseStyles}
+      </head>
+      <body>
+        <div class="container">
+          <div class="logo">
+            <div class="logo-ascii">${logoASCII}</div>
+            <h2 class="brand">Snow-Flow</h2>
+          </div>
+          <h1><span class="success">✅</span> Authentication Successful!</h1>
+          <p>You are now connected to ServiceNow!</p>
+          <p>You can close this window and return to the terminal.</p>
+          <p style="margin-top: 30px; font-size: 14px; color: #999;">
+            Snow-Flow: ServiceNow Multi-Agent Development Framework
+          </p>
+        </div>
+      </body>
+    </html>
+  `,
+
+  error: (error: string) => `
+    <html>
+      <head>
+        <title>Snow-Flow - Authentication Error</title>
+        ${baseStyles}
+      </head>
+      <body>
+        <div class="container">
+          <div class="logo">
+            <div class="logo-ascii">${logoASCII}</div>
+            <h2 class="brand">Snow-Flow</h2>
+          </div>
+          <h1><span class="error">❌</span> OAuth Error</h1>
+          <p>Error: ${error}</p>
+          <p>Please close this window and try again.</p>
+          <p style="margin-top: 30px; font-size: 14px; color: #999;">
+            Need help? Check the Snow-Flow documentation.
+          </p>
+        </div>
+      </body>
+    </html>
+  `,
+
+  securityError: `
+    <html>
+      <head>
+        <title>Snow-Flow - Security Error</title>
+        ${baseStyles}
+      </head>
+      <body>
+        <div class="container">
+          <div class="logo">
+            <div class="logo-ascii">${logoASCII}</div>
+            <h2 class="brand">Snow-Flow</h2>
+          </div>
+          <h1><span class="error">❌</span> Security Error</h1>
+          <p>Invalid state parameter - possible CSRF attack detected.</p>
+          <p>Please close this window and start the authentication process again.</p>
+          <p style="margin-top: 30px; font-size: 14px; color: #999;">
+            Your security is our priority.
+          </p>
+        </div>
+      </body>
+    </html>
+  `,
+
+  missingCode: `
+    <html>
+      <head>
+        <title>Snow-Flow - Missing Authorization Code</title>
+        ${baseStyles}
+      </head>
+      <body>
+        <div class="container">
+          <div class="logo">
+            <div class="logo-ascii">${logoASCII}</div>
+            <h2 class="brand">Snow-Flow</h2>
+          </div>
+          <h1><span class="error">❌</span> Missing Authorization Code</h1>
+          <p>No authorization code was received from ServiceNow.</p>
+          <p>Please close this window and try again.</p>
+          <p style="margin-top: 30px; font-size: 14px; color: #999;">
+            Make sure you approve the authorization request in ServiceNow.
+          </p>
+        </div>
+      </body>
+    </html>
+  `,
+
+  tokenExchangeFailed: (error: string) => `
+    <html>
+      <head>
+        <title>Snow-Flow - Token Exchange Failed</title>
+        ${baseStyles}
+      </head>
+      <body>
+        <div class="container">
+          <div class="logo">
+            <div class="logo-ascii">${logoASCII}</div>
+            <h2 class="brand">Snow-Flow</h2>
+          </div>
+          <h1><span class="error">❌</span> Token Exchange Failed</h1>
+          <p>Error: ${error}</p>
+          <p>Please close this window and check your OAuth configuration.</p>
+          <p style="margin-top: 30px; font-size: 14px; color: #999;">
+            Ensure your Client ID and Client Secret are correct.
+          </p>
+        </div>
+      </body>
+    </html>
+  `
+};