snow-flow 2.0.2 → 2.0.4

package/src/mcp/servicenow-platform-development-mcp-refactored.ts

@@ -1,611 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-platform-development MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-
-interface DynamicTableInfo {
-  name: string;
-  label: string;
-  fields: Array<{
-    name: string;
-    type: string;
-    label: string;
-    mandatory: boolean;
-    display: boolean;
-  }>;
-}
-
-export class ServiceNowPlatformDevelopmentMCP extends BaseMCPServer {
-  private tableCache: Map<string, DynamicTableInfo> = new Map();
-
-  constructor() {
-    super({
-      name: 'servicenow-platform-development',
-      version: '2.0.0',
-      description: 'Handles core platform development artifacts with full dynamic discovery'
-    });
-  }
-
-  protected setupTools(): void {
-    // Tools are defined in getTools() method
-  }
-
-  protected getTools(): Tool[] {
-    return [
-      {
-        name: 'snow_create_ui_page',
-        description: 'Create UI Pages dynamically with full field discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'UI Page name' },
-            title: { type: 'string', description: 'Page title' },
-            html: { type: 'string', description: 'HTML content' },
-            processingScript: { type: 'string', description: 'Server-side processing script' },
-            clientScript: { type: 'string', description: 'Client-side script' },
-            css: { type: 'string', description: 'CSS styles' },
-            category: { type: 'string', description: 'Page category' }
-          },
-          required: ['name', 'title', 'html']
-        }
-      },
-      {
-        name: 'snow_create_script_include',
-        description: 'Create Script Includes with dynamic table discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'Script Include name' },
-            script: { type: 'string', description: 'JavaScript code' },
-            description: { type: 'string', description: 'Description of functionality' },
-            clientCallable: { type: 'boolean', description: 'Can be called from client' },
-            apiName: { type: 'string', description: 'API name for external calls' }
-          },
-          required: ['name', 'script']
-        }
-      },
-      {
-        name: 'snow_create_business_rule',
-        description: 'Create Business Rules with dynamic table and field discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'Business Rule name' },
-            tableName: { type: 'string', description: 'Target table name or sys_id' },
-            script: { type: 'string', description: 'JavaScript code' },
-            when: { type: 'string', description: 'When to execute: before, after, async, display' },
-            condition: { type: 'string', description: 'Condition script' },
-            description: { type: 'string', description: 'Rule description' }
-          },
-          required: ['name', 'tableName', 'script', 'when']
-        }
-      },
-      {
-        name: 'snow_create_client_script',
-        description: 'Create Client Scripts with dynamic form discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'Client Script name' },
-            tableName: { type: 'string', description: 'Target table name or sys_id' },
-            script: { type: 'string', description: 'JavaScript code' },
-            type: { type: 'string', description: 'Script type: onLoad, onChange, onSubmit, onCellEdit' },
-            fieldName: { type: 'string', description: 'Field name for onChange scripts' },
-            condition: { type: 'string', description: 'Condition script' },
-            description: { type: 'string', description: 'Script description' }
-          },
-          required: ['name', 'tableName', 'script', 'type']
-        }
-      },
-      {
-        name: 'snow_create_ui_policy',
-        description: 'Create UI Policies with dynamic field discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'UI Policy name' },
-            tableName: { type: 'string', description: 'Target table name or sys_id' },
-            condition: { type: 'string', description: 'Condition script' },
-            description: { type: 'string', description: 'Policy description' },
-            runScripts: { type: 'boolean', description: 'Run scripts when policy applies' },
-            reverseWhenFalse: { type: 'boolean', description: 'Reverse actions when condition is false' }
-          },
-          required: ['name', 'tableName', 'condition']
-        }
-      },
-      {
-        name: 'snow_create_ui_action',
-        description: 'Create UI Actions with dynamic form discovery - NO hardcoded values',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'UI Action name' },
-            tableName: { type: 'string', description: 'Target table name or sys_id' },
-            script: { type: 'string', description: 'JavaScript code' },
-            condition: { type: 'string', description: 'Condition script' },
-            actionName: { type: 'string', description: 'Action name for forms' },
-            formButton: { type: 'boolean', description: 'Show as form button' },
-            listButton: { type: 'boolean', description: 'Show as list button' },
-            description: { type: 'string', description: 'Action description' }
-          },
-          required: ['name', 'tableName', 'script']
-        }
-      },
-      {
-        name: 'snow_discover_platform_tables',
-        description: 'Discover all available platform development tables dynamically',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            category: { type: 'string', description: 'Filter by category: ui, script, policy, action, all' }
-          }
-        }
-      },
-      {
-        name: 'snow_discover_table_fields',
-        description: 'Discover all fields for a specific table dynamically',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            tableName: { type: 'string', description: 'Table name to discover fields for' }
-          },
-          required: ['tableName']
-        }
-      },
-      {
-        name: 'snow_table_schema_discovery',
-        description: 'Comprehensive table schema discovery - structure, relationships, indexes, constraints',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            tableName: { type: 'string', description: 'Table name to analyze' },
-            includeRelated: { type: 'boolean', description: 'Include related table information' },
-            includeIndexes: { type: 'boolean', description: 'Include index information' },
-            includeExtensions: { type: 'boolean', description: 'Include table extensions/hierarchy' },
-            maxDepth: { type: 'number', description: 'Max depth for relationship discovery (default: 2)' }
-          },
-          required: ['tableName']
-        }
-      }
-    ];
-  }
-
-  protected async executeTool(name: string, args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-
-    switch (name) {
-      case 'snow_create_ui_page':
-        return await this.handleSnowCreateUiPage(args);
-      case 'snow_create_script_include':
-        return await this.handleSnowCreateScriptInclude(args);
-      case 'snow_create_business_rule':
-        return await this.handleSnowCreateBusinessRule(args);
-      case 'snow_create_client_script':
-        return await this.handleSnowCreateClientScript(args);
-      case 'snow_create_ui_policy':
-        return await this.handleSnowCreateUiPolicy(args);
-      case 'snow_create_ui_action':
-        return await this.handleSnowCreateUiAction(args);
-      case 'snow_discover_platform_tables':
-        return await this.handleSnowDiscoverPlatformTables(args);
-      case 'snow_discover_table_fields':
-        return await this.handleSnowDiscoverTableFields(args);
-      case 'snow_table_schema_discovery':
-        return await this.handleSnowTableSchemaDiscovery(args);
-      default:
-        return {
-          success: false,
-          error: `Unknown tool: ${name}`
-        };
-    }
-  }
-
-  // Tool handlers
-  private async handleSnowCreateUiPage(args: any): Promise<ToolResult> {
-    try {
-      const pageData = {
-        name: args.name,
-        title: args.title,
-        html: args.html,
-        processing_script: args.processingScript,
-        client_script: args.clientScript,
-        css: args.css,
-        category: args.category || 'general',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_ui_page', pageData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create UI page',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create UI page',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowCreateScriptInclude(args: any): Promise<ToolResult> {
-    try {
-      const scriptData = {
-        name: args.name,
-        script: args.script,
-        description: args.description,
-        client_callable: args.clientCallable || false,
-        api_name: args.apiName || args.name,
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_script_include', scriptData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create script include',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create script include',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowCreateBusinessRule(args: any): Promise<ToolResult> {
-    try {
-      // Resolve table name
-      const tableInfo = await this.getTableInfo(args.tableName);
-      if (!tableInfo) {
-        throw new Error(`Table not found: ${args.tableName}`);
-      }
-
-      const ruleData = {
-        name: args.name,
-        collection: tableInfo.name,
-        script: args.script,
-        when: args.when,
-        condition: args.condition || '',
-        description: args.description || '',
-        active: true,
-        order: 100
-      };
-
-      const result = await this.client.createRecord('sys_script', ruleData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create business rule',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create business rule',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowCreateClientScript(args: any): Promise<ToolResult> {
-    try {
-      // Resolve table name
-      const tableInfo = await this.getTableInfo(args.tableName);
-      if (!tableInfo) {
-        throw new Error(`Table not found: ${args.tableName}`);
-      }
-
-      const scriptData = {
-        name: args.name,
-        table: tableInfo.name,
-        script: args.script,
-        type: args.type,
-        field: args.fieldName || '',
-        condition: args.condition || '',
-        description: args.description || '',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_script_client', scriptData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create client script',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create client script',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowCreateUiPolicy(args: any): Promise<ToolResult> {
-    try {
-      // Resolve table name
-      const tableInfo = await this.getTableInfo(args.tableName);
-      if (!tableInfo) {
-        throw new Error(`Table not found: ${args.tableName}`);
-      }
-
-      const policyData = {
-        name: args.name,
-        table: tableInfo.name,
-        conditions: args.condition,
-        short_description: args.description || '',
-        run_scripts: args.runScripts || false,
-        reverse_if_false: args.reverseWhenFalse || false,
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_ui_policy', policyData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create UI policy',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create UI policy',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowCreateUiAction(args: any): Promise<ToolResult> {
-    try {
-      // Resolve table name
-      const tableInfo = await this.getTableInfo(args.tableName);
-      if (!tableInfo) {
-        throw new Error(`Table not found: ${args.tableName}`);
-      }
-
-      const actionData = {
-        name: args.name,
-        table: tableInfo.name,
-        script: args.script,
-        condition: args.condition || '',
-        action_name: args.actionName || args.name,
-        form_button: args.formButton !== false,
-        list_button: args.listButton || false,
-        comments: args.description || '',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_ui_action', actionData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create UI action',
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create UI action',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowDiscoverPlatformTables(args: any): Promise<ToolResult> {
-    try {
-      this.logger.info('Discovering platform development tables...');
-      
-      // Define table categories
-      const tableQueries = [
-        { category: 'ui', query: 'nameSTARTSWITHsys_ui^ORnameSTARTSWITHsp_' },
-        { category: 'script', query: 'nameSTARTSWITHsys_script^ORnameSTARTSWITHsys_processor' },
-        { category: 'policy', query: 'nameSTARTSWITHsys_ui_policy^ORnameSTARTSWITHsys_ui_action' },
-        { category: 'security', query: 'nameSTARTSWITHsys_security^ORnameSTARTSWITHsys_user' },
-        { category: 'system', query: 'nameSTARTSWITHsys_dictionary^ORnameSTARTSWITHsys_choice' }
-      ];
-
-      const category = args?.category || 'all';
-      const discoveredTables: Array<{category: string, tables: any[]}> = [];
-
-      for (const tableQuery of tableQueries) {
-        if (category === 'all' || category === tableQuery.category) {
-          const tablesResponse = await this.client.searchRecords(
-            'sys_db_object',
-            tableQuery.query,
-            50
-          );
-
-          if (tablesResponse.success && tablesResponse.data) {
-            discoveredTables.push({
-              category: tableQuery.category,
-              tables: tablesResponse.data.result.map((table: any) => ({
-                name: table.name,
-                label: table.label,
-                super_class: table.super_class,
-                is_extendable: table.is_extendable,
-                sys_id: table.sys_id
-              }))
-            });
-          }
-        }
-      }
-
-      return {
-        success: true,
-        result: { discoveredTables },
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to discover platform tables',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowDiscoverTableFields(args: any): Promise<ToolResult> {
-    try {
-      const tableName = args.tableName;
-      this.logger.info(`Discovering fields for table: ${tableName}`);
-
-      // Resolve table name
-      const tableInfo = await this.getTableInfo(tableName);
-      if (!tableInfo) {
-        throw new Error(`Table not found: ${tableName}`);
-      }
-
-      // Get all fields for this table
-      const fieldsResponse = await this.client.searchRecords(
-        'sys_dictionary',
-        `nameSTARTSWITH${tableInfo.name}^element!=NULL`,
-        100
-      );
-
-      if (!fieldsResponse.success || !fieldsResponse.data) {
-        throw new Error(`Failed to get fields for table: ${tableName}`);
-      }
-
-      const fields = fieldsResponse.data.result.map((field: any) => ({
-        name: field.element,
-        type: field.internal_type,
-        label: field.column_label,
-        mandatory: field.mandatory === 'true',
-        display: field.display === 'true',
-        max_length: field.max_length,
-        reference: field.reference,
-        choice: field.choice
-      }));
-
-      // Cache the table info
-      this.tableCache.set(tableName, {
-        name: tableInfo.name,
-        label: tableInfo.label,
-        fields: fields
-      });
-
-      return {
-        success: true,
-        result: { table: tableInfo, fields },
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to discover table fields',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  private async handleSnowTableSchemaDiscovery(args: any): Promise<ToolResult> {
-    try {
-      this.logger.info(`Discovering schema for table: ${args.tableName}`);
-
-      // Get basic table info and fields
-      const fieldsResult = await this.handleSnowDiscoverTableFields({ tableName: args.tableName });
-      if (!fieldsResult.success) {
-        return fieldsResult;
-      }
-
-      const schema: any = {
-        table: fieldsResult.result?.table,
-        fields: fieldsResult.result?.fields
-      };
-
-      // Add relationships if requested
-      if (args.includeRelated) {
-        // This would involve querying reference fields and foreign keys
-        schema.relationships = [];
-      }
-
-      // Add indexes if requested
-      if (args.includeIndexes) {
-        // This would involve querying sys_db_index
-        schema.indexes = [];
-      }
-
-      // Add extensions if requested
-      if (args.includeExtensions) {
-        // This would involve querying parent/child tables
-        schema.extensions = [];
-      }
-
-      return {
-        success: true,
-        result: schema,
-        executionTime: Date.now() - Date.now()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to discover table schema',
-        executionTime: Date.now() - Date.now()
-      };
-    }
-  }
-
-  // Helper methods
-  private async getTableInfo(tableName: string): Promise<{name: string, label: string, sys_id: string} | null> {
-    try {
-      // Try direct lookup first
-      const tableResponse = await this.client.searchRecords(
-        'sys_db_object',
-        `name=${tableName}`,
-        1
-      );
-
-      if (tableResponse.success && tableResponse.data?.result?.length > 0) {
-        const table = tableResponse.data.result[0];
-        return {
-          name: table.name,
-          label: table.label,
-          sys_id: table.sys_id
-        };
-      }
-
-      // Try by sys_id
-      const tableByIdResponse = await this.client.searchRecords(
-        'sys_db_object',
-        `sys_id=${tableName}`,
-        1
-      );
-
-      if (tableByIdResponse.success && tableByIdResponse.data?.result?.length > 0) {
-        const table = tableByIdResponse.data.result[0];
-        return {
-          name: table.name,
-          label: table.label,
-          sys_id: table.sys_id
-        };
-      }
-
-      return null;
-    } catch (error) {
-      this.logger.error('Failed to get table info:', error);
-      return null;
-    }
-  }
-}
-
-// Create and run the server
-if (require.main === module) {
-  const server = new ServiceNowPlatformDevelopmentMCP();
-  server.start().catch(console.error);
-}