snow-flow 1.4.49 → 2.0.0

package/src/utils/theme-manager.ts

@@ -0,0 +1,295 @@
+/**
+ * Service Portal Theme Manager
+ * Handles automatic dependency injection into Service Portal themes
+ */
+
+import { DependencyInfo, DependencyDetector } from './dependency-detector';
+import { logger } from './logger';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export interface ThemeUpdateOptions {
+  autoPermissions?: boolean;
+  skipPrompt?: boolean;
+  useMinified?: boolean;
+  themeId?: string;
+  themeName?: string;
+}
+
+export interface ThemeInfo {
+  sys_id: string;
+  name: string;
+  css_variables?: string;
+  footer?: string;
+  header?: string;
+  js_includes?: string;
+}
+
+export class ServicePortalThemeManager {
+  /**
+   * Update Service Portal theme with dependencies
+   */
+  static async updateThemeWithDependencies(
+    dependencies: DependencyInfo[],
+    mcpTools: any,
+    options: ThemeUpdateOptions = {}
+  ): Promise<{success: boolean; message: string}> {
+    try {
+      // Step 1: Find the Service Portal theme
+      logger.info('🔍 Finding Service Portal theme...');
+      const theme = await this.findTheme(mcpTools, options);
+      
+      if (!theme) {
+        return {
+          success: false,
+          message: '❌ No Service Portal theme found. Please specify a theme name or ID.'
+        };
+      }
+
+      logger.info(`📋 Found theme: ${theme.name} (${theme.sys_id})`);
+
+      // Step 2: Check which dependencies are missing
+      const currentHeader = theme.header || '';
+      const missingDeps = DependencyDetector.getMissingDependencies(
+        dependencies, 
+        currentHeader
+      );
+
+      if (missingDeps.length === 0) {
+        logger.info('✅ All dependencies are already installed in the theme');
+        return {
+          success: true,
+          message: 'All required dependencies are already present in the theme'
+        };
+      }
+
+      // Step 3: Prompt user for confirmation (unless auto-permissions or skip prompt)
+      if (!options.autoPermissions && !options.skipPrompt) {
+        const shouldInstall = await this.promptForDependencies(missingDeps, theme.name);
+        if (!shouldInstall) {
+          return {
+            success: false,
+            message: 'User cancelled dependency installation'
+          };
+        }
+      } else if (options.autoPermissions) {
+        logger.info('🤖 Auto-permissions enabled - installing dependencies automatically');
+      }
+
+      // Step 4: Generate script tags
+      const scriptTags = DependencyDetector.generateScriptTags(
+        missingDeps, 
+        options.useMinified !== false
+      );
+
+      // Step 5: Update theme header
+      const updatedHeader = this.injectDependencies(currentHeader, scriptTags);
+
+      // Step 6: Save updated theme
+      logger.info('💾 Updating Service Portal theme...');
+      const updateResult = await this.updateTheme(
+        mcpTools,
+        theme.sys_id,
+        { header: updatedHeader }
+      );
+
+      if (updateResult.success) {
+        const depNames = missingDeps.map(d => d.name).join(', ');
+        logger.info(chalk.green(`✅ Successfully added dependencies: ${depNames}`));
+        return {
+          success: true,
+          message: `Successfully added ${missingDeps.length} dependencies to theme "${theme.name}"`
+        };
+      } else {
+        return {
+          success: false,
+          message: updateResult.message || 'Failed to update theme'
+        };
+      }
+
+    } catch (error: any) {
+      logger.error('❌ Error updating theme:', error);
+      return {
+        success: false,
+        message: `Error updating theme: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Find Service Portal theme
+   */
+  private static async findTheme(
+    mcpTools: any, 
+    options: ThemeUpdateOptions
+  ): Promise<ThemeInfo | null> {
+    try {
+      // If theme ID is provided, use direct lookup
+      if (options.themeId) {
+        const result = await mcpTools.snow_get_by_sysid({
+          sys_id: options.themeId,
+          table: 'sp_theme'
+        });
+        return result.record || null;
+      }
+
+      // Search by name or find default theme
+      const searchQuery = options.themeName 
+        ? `name=${options.themeName}` 
+        : 'active=true^ORDERBYname';
+
+      const result = await mcpTools.snow_find_artifact({
+        query: searchQuery,
+        type: 'any',
+        table: 'sp_theme'
+      });
+
+      if (result.artifacts && result.artifacts.length > 0) {
+        // Return first active theme or first theme found
+        return result.artifacts[0];
+      }
+
+      // Try to find any theme
+      const anyThemeResult = await mcpTools.snow_comprehensive_search({
+        query: 'Service Portal theme'
+      });
+
+      if (anyThemeResult.results && anyThemeResult.results.length > 0) {
+        const themeResult = anyThemeResult.results.find((r: any) => 
+          r.sys_class_name === 'sp_theme'
+        );
+        return themeResult || null;
+      }
+
+      return null;
+    } catch (error) {
+      logger.error('Error finding theme:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Prompt user for dependency installation
+   */
+  private static async promptForDependencies(
+    dependencies: DependencyInfo[],
+    themeName: string
+  ): Promise<boolean> {
+    console.log('\n' + chalk.yellow('📦 Missing Dependencies Detected:'));
+    
+    dependencies.forEach(dep => {
+      console.log(chalk.cyan(`  • ${dep.name} (${dep.version || 'latest'})`));
+      console.log(chalk.gray(`    ${dep.description}`));
+    });
+
+    console.log('\n' + chalk.yellow(`These dependencies need to be added to the "${themeName}" theme.`));
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Would you like to automatically install these dependencies?',
+        default: true
+      }
+    ]);
+
+    return confirm;
+  }
+
+  /**
+   * Inject dependencies into theme header
+   */
+  private static injectDependencies(currentHeader: string, scriptTags: string): string {
+    // Check if header already has a dependency section
+    const dependencyMarker = '<!-- Snow-Flow Dependencies -->';
+    const endMarker = '<!-- End Snow-Flow Dependencies -->';
+
+    // Create dependency section
+    const dependencySection = `
+${dependencyMarker}
+${scriptTags}
+${endMarker}`;
+
+    // If markers exist, replace the section
+    if (currentHeader.includes(dependencyMarker)) {
+      const regex = new RegExp(
+        `${dependencyMarker}[\\s\\S]*?${endMarker}`,
+        'g'
+      );
+      return currentHeader.replace(regex, dependencySection);
+    }
+
+    // Otherwise, add before closing </head> or at the end
+    if (currentHeader.includes('</head>')) {
+      return currentHeader.replace('</head>', `${dependencySection}\n</head>`);
+    }
+
+    // Just append if no head tag
+    return currentHeader + '\n' + dependencySection;
+  }
+
+  /**
+   * Update theme in ServiceNow
+   */
+  private static async updateTheme(
+    mcpTools: any,
+    themeId: string,
+    updates: Partial<ThemeInfo>
+  ): Promise<{success: boolean; message?: string}> {
+    try {
+      // Use snow_edit_by_sysid to update the theme
+      const result = await mcpTools.snow_edit_by_sysid({
+        sys_id: themeId,
+        table: 'sp_theme',
+        field: 'header',
+        value: updates.header
+      });
+
+      return { success: true };
+    } catch (error: any) {
+      return { 
+        success: false, 
+        message: error.message || 'Failed to update theme' 
+      };
+    }
+  }
+
+  /**
+   * Check if widget requires dependencies and handle installation
+   */
+  static async handleWidgetDependencies(
+    widgetConfig: any,
+    mcpTools: any,
+    options: ThemeUpdateOptions = {}
+  ): Promise<{
+    dependencies: DependencyInfo[];
+    installed: boolean;
+    message: string;
+  }> {
+    // Detect dependencies in widget
+    const dependencies = DependencyDetector.analyzeWidget(widgetConfig);
+
+    if (dependencies.length === 0) {
+      return {
+        dependencies: [],
+        installed: true,
+        message: 'No external dependencies detected'
+      };
+    }
+
+    logger.info(`🔍 Detected ${dependencies.length} dependencies in widget`);
+
+    // Update theme with dependencies
+    const result = await this.updateThemeWithDependencies(
+      dependencies,
+      mcpTools,
+      options
+    );
+
+    return {
+      dependencies,
+      installed: result.success,
+      message: result.message
+    };
+  }
+}

package/src/utils/unified-auth-store.ts

@@ -0,0 +1,222 @@
+/**
+ * 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.
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+export interface AuthTokens {
+  instance: string;
+  clientId: string;
+  clientSecret: string;
+  accessToken?: string;
+  refreshToken?: string;
+  expiresAt?: string;
+}
+
+export class UnifiedAuthStore {
+  private static instance: UnifiedAuthStore;
+  private tokenPath: string;
+  private memoryStore: AuthTokens | null = null;
+
+  constructor() {
+    // Use consistent path across all contexts
+    const configDir = process.env.SNOW_FLOW_HOME || join(os.homedir(), '.snow-flow');
+    this.tokenPath = 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(): UnifiedAuthStore {
+    if (!UnifiedAuthStore.instance) {
+      UnifiedAuthStore.instance = new UnifiedAuthStore();
+    }
+    return UnifiedAuthStore.instance;
+  }
+
+  /**
+   * Get tokens from file or memory
+   */
+  async getTokens(): Promise<AuthTokens | null> {
+    try {
+      // First check memory store (fastest)
+      if (this.memoryStore) {
+        return this.memoryStore;
+      }
+
+      // Then check file system
+      const data = await fs.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: AuthTokens): Promise<void> {
+    try {
+      const configDir = join(os.homedir(), '.snow-flow');
+      await fs.mkdir(configDir, { recursive: true });
+      
+      await fs.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)
+   */
+  private getTokensFromEnv(): AuthTokens | null {
+    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(): Promise<boolean> {
+    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(): Promise<void> {
+    try {
+      await fs.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(): Promise<string | null> {
+    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(): Promise<Record<string, string> | null> {
+    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(): Promise<void> {
+    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;
+      }
+    }
+  }
+}
+
+// Export singleton instance
+export const unifiedAuthStore = UnifiedAuthStore.getInstance();