@bernierllc/chat-suite 1.0.0

package/src/services/MessageOrchestrator.ts

@@ -0,0 +1,271 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import type {
+  Provider,
+  ProviderType,
+  ProviderMessage,
+  ProviderMessageResult,
+  OrchestratedMessage,
+  BroadcastConfig,
+  SuiteResult
+} from '../types';
+import { MessagePriority, MessageStatus } from '../types';
+import { MessageBridge } from '../utils/message-bridge';
+import { ChatSuiteError, ChatSuiteErrorType, retryOperation } from '../utils/error-handling';
+
+/**
+ * Orchestrates messages across all providers
+ */
+export class MessageOrchestrator {
+  private messageBridge?: MessageBridge;
+  private messages: Map<string, OrchestratedMessage> = new Map();
+
+  /**
+   * Set message bridge for cross-platform sync
+   */
+  public setMessageBridge(bridge: MessageBridge): void {
+    this.messageBridge = bridge;
+  }
+
+  /**
+   * Send a message through a specific provider
+   */
+  public async sendMessage(
+    provider: Provider,
+    message: ProviderMessage
+  ): Promise<SuiteResult<ProviderMessageResult>> {
+    try {
+      if (!provider.isInitialized()) {
+        return {
+          success: false,
+          error: `Provider ${provider.type} is not initialized`
+        };
+      }
+
+      const result = await retryOperation(
+        () => provider.sendMessage(message),
+        3,
+        1000
+      );
+
+      return { success: true, data: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to send message'
+      };
+    }
+  }
+
+  /**
+   * Broadcast a message to multiple platforms
+   */
+  public async broadcastMessage(
+    providers: Map<ProviderType, Provider>,
+    config: BroadcastConfig
+  ): Promise<SuiteResult<ProviderMessageResult[]>> {
+    try {
+      const results: ProviderMessageResult[] = [];
+      const targetProviders = config.platforms
+        .map(type => providers.get(type))
+        .filter((p): p is Provider => p !== undefined);
+
+      if (targetProviders.length === 0) {
+        return {
+          success: false,
+          error: 'No valid providers found for broadcast'
+        };
+      }
+
+      // Create orchestrated message
+      const orchestratedMessage: OrchestratedMessage = {
+        id: this.generateMessageId(),
+        content: config.content,
+        priority: config.priority || MessagePriority.NORMAL,
+        status: MessageStatus.SENDING,
+        targetProviders: config.platforms,
+        metadata: config.metadata,
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      this.messages.set(orchestratedMessage.id, orchestratedMessage);
+
+      // Send to all providers
+      for (const provider of targetProviders) {
+        const providerMessage: ProviderMessage = {
+          content: config.content,
+          channelId: config.channels?.[0],
+          metadata: config.metadata
+        };
+
+        const result = await this.sendMessage(provider, providerMessage);
+        if (result.success && result.data) {
+          results.push(result.data);
+        }
+      }
+
+      // Update orchestrated message status
+      orchestratedMessage.status = results.length > 0 ? MessageStatus.SENT : MessageStatus.FAILED;
+      orchestratedMessage.updatedAt = new Date();
+
+      return { success: true, data: results };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to broadcast message'
+      };
+    }
+  }
+
+  /**
+   * Bridge a message from one provider to another
+   */
+  public async bridgeMessage(
+    sourceProvider: Provider,
+    targetProvider: Provider,
+    message: ProviderMessage
+  ): Promise<SuiteResult<ProviderMessageResult>> {
+    try {
+      if (!this.messageBridge) {
+        throw new ChatSuiteError(
+          ChatSuiteErrorType.CONFIGURATION_ERROR,
+          'Message bridge not configured'
+        );
+      }
+
+      if (!this.messageBridge.shouldBridge(sourceProvider.type, targetProvider.type)) {
+        return {
+          success: false,
+          error: `Bridging from ${sourceProvider.type} to ${targetProvider.type} is not enabled`
+        };
+      }
+
+      // Transform message for target provider
+      const transformedMessage = this.messageBridge.transformMessage(
+        message,
+        sourceProvider.type,
+        targetProvider.type
+      );
+
+      // Send to target provider
+      const result = await this.sendMessage(targetProvider, transformedMessage);
+
+      if (result.success && result.data) {
+        // Record the bridge
+        this.messageBridge.recordBridgedMessage({
+          originalMessageId: result.data.messageId || 'unknown',
+          sourceProvider: sourceProvider.type,
+          targetProvider: targetProvider.type,
+          targetMessageId: result.data.messageId,
+          timestamp: new Date()
+        });
+      }
+
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to bridge message'
+      };
+    }
+  }
+
+  /**
+   * Get an orchestrated message by ID
+   */
+  public getMessage(messageId: string): OrchestratedMessage | undefined {
+    return this.messages.get(messageId);
+  }
+
+  /**
+   * Get all messages
+   */
+  public getAllMessages(): OrchestratedMessage[] {
+    return Array.from(this.messages.values());
+  }
+
+  /**
+   * Get messages by status
+   */
+  public getMessagesByStatus(status: MessageStatus): OrchestratedMessage[] {
+    return Array.from(this.messages.values()).filter(m => m.status === status);
+  }
+
+  /**
+   * Update message status
+   */
+  public updateMessageStatus(messageId: string, status: MessageStatus): boolean {
+    const message = this.messages.get(messageId);
+    if (!message) {
+      return false;
+    }
+
+    message.status = status;
+    message.updatedAt = new Date();
+    return true;
+  }
+
+  /**
+   * Clear all messages
+   */
+  public clearMessages(): void {
+    this.messages.clear();
+  }
+
+  /**
+   * Get message count
+   */
+  public getMessageCount(): number {
+    return this.messages.size;
+  }
+
+  /**
+   * Get statistics
+   */
+  public getStats(): {
+    total: number;
+    byStatus: Record<MessageStatus, number>;
+    byPriority: Record<MessagePriority, number>;
+  } {
+    const byStatus: Record<MessageStatus, number> = {
+      [MessageStatus.PENDING]: 0,
+      [MessageStatus.ROUTING]: 0,
+      [MessageStatus.SENDING]: 0,
+      [MessageStatus.SENT]: 0,
+      [MessageStatus.FAILED]: 0,
+      [MessageStatus.RETRYING]: 0
+    };
+
+    const byPriority: Record<MessagePriority, number> = {
+      [MessagePriority.LOW]: 0,
+      [MessagePriority.NORMAL]: 0,
+      [MessagePriority.HIGH]: 0,
+      [MessagePriority.URGENT]: 0
+    };
+
+    this.messages.forEach(message => {
+      byStatus[message.status]++;
+      byPriority[message.priority]++;
+    });
+
+    return {
+      total: this.messages.size,
+      byStatus,
+      byPriority
+    };
+  }
+
+  /**
+   * Generate a unique message ID
+   */
+  private generateMessageId(): string {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+}

package/src/services/ProviderManager.ts

@@ -0,0 +1,247 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import type { Provider, ProviderType, SuiteResult } from '../types';
+import { ChatSuiteError, ChatSuiteErrorType } from '../utils/error-handling';
+
+/**
+ * Provider registration information
+ */
+export interface ProviderRegistration {
+  provider: Provider;
+  priority: number;
+  enabled: boolean;
+}
+
+/**
+ * Manages all chat providers
+ */
+export class ProviderManager {
+  private providers: Map<ProviderType, ProviderRegistration> = new Map();
+  private initializedProviders: Set<ProviderType> = new Set();
+
+  /**
+   * Register a provider
+   */
+  public registerProvider(registration: ProviderRegistration): SuiteResult<void> {
+    try {
+      if (this.providers.has(registration.provider.type)) {
+        return {
+          success: false,
+          error: `Provider ${registration.provider.type} is already registered`
+        };
+      }
+
+      this.providers.set(registration.provider.type, registration);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to register provider'
+      };
+    }
+  }
+
+  /**
+   * Initialize a provider
+   */
+  public async initializeProvider(providerType: ProviderType): Promise<SuiteResult<void>> {
+    try {
+      const registration = this.providers.get(providerType);
+      if (!registration) {
+        return {
+          success: false,
+          error: `Provider ${providerType} not registered`
+        };
+      }
+
+      if (!registration.enabled) {
+        return {
+          success: false,
+          error: `Provider ${providerType} is not enabled`
+        };
+      }
+
+      await registration.provider.initialize();
+      this.initializedProviders.add(providerType);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to initialize provider'
+      };
+    }
+  }
+
+  /**
+   * Initialize all enabled providers
+   */
+  public async initializeAll(): Promise<{
+    successful: ProviderType[];
+    failed: Array<{ type: ProviderType; error: string }>;
+  }> {
+    const successful: ProviderType[] = [];
+    const failed: Array<{ type: ProviderType; error: string }> = [];
+
+    for (const [type, registration] of this.providers) {
+      if (!registration.enabled) {
+        continue;
+      }
+
+      const result = await this.initializeProvider(type);
+      if (result.success) {
+        successful.push(type);
+      } else {
+        failed.push({ type, error: result.error || 'Unknown error' });
+      }
+    }
+
+    return { successful, failed };
+  }
+
+  /**
+   * Get a provider by type
+   */
+  public getProvider(providerType: ProviderType): Provider | undefined {
+    return this.providers.get(providerType)?.provider;
+  }
+
+  /**
+   * Check if a provider is initialized
+   */
+  public isInitialized(providerType: ProviderType): boolean {
+    return this.initializedProviders.has(providerType);
+  }
+
+  /**
+   * Get all enabled providers sorted by priority
+   */
+  public getEnabledProviders(): Provider[] {
+    const enabled = Array.from(this.providers.values())
+      .filter(reg => reg.enabled)
+      .sort((a, b) => a.priority - b.priority);
+
+    return enabled.map(reg => reg.provider);
+  }
+
+  /**
+   * Get all initialized providers
+   */
+  public getInitializedProviders(): Provider[] {
+    return Array.from(this.initializedProviders)
+      .map(type => this.providers.get(type)?.provider)
+      .filter((p): p is Provider => p !== undefined);
+  }
+
+  /**
+   * Get provider by priority (1 = highest)
+   */
+  public getProviderByPriority(priority: number): Provider | undefined {
+    const registration = Array.from(this.providers.values())
+      .find(reg => reg.priority === priority && reg.enabled);
+
+    return registration?.provider;
+  }
+
+  /**
+   * Get highest priority provider
+   */
+  public getPrimaryProvider(): Provider | undefined {
+    const enabled = Array.from(this.providers.values())
+      .filter(reg => reg.enabled)
+      .sort((a, b) => a.priority - b.priority);
+
+    return enabled[0]?.provider;
+  }
+
+  /**
+   * Shutdown a provider
+   */
+  public async shutdownProvider(providerType: ProviderType): Promise<SuiteResult<void>> {
+    try {
+      const provider = this.providers.get(providerType)?.provider;
+      if (!provider) {
+        return {
+          success: false,
+          error: `Provider ${providerType} not found`
+        };
+      }
+
+      if (!this.initializedProviders.has(providerType)) {
+        return { success: true }; // Already shutdown
+      }
+
+      await provider.shutdown();
+      this.initializedProviders.delete(providerType);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to shutdown provider'
+      };
+    }
+  }
+
+  /**
+   * Shutdown all providers
+   */
+  public async shutdownAll(): Promise<void> {
+    const shutdownPromises = Array.from(this.initializedProviders).map(type =>
+      this.shutdownProvider(type)
+    );
+
+    await Promise.all(shutdownPromises);
+  }
+
+  /**
+   * Unregister a provider
+   */
+  public unregisterProvider(providerType: ProviderType): SuiteResult<void> {
+    if (this.initializedProviders.has(providerType)) {
+      throw new ChatSuiteError(
+        ChatSuiteErrorType.PROVIDER_ERROR,
+        `Cannot unregister initialized provider ${providerType}. Shutdown first.`
+      );
+    }
+
+    const deleted = this.providers.delete(providerType);
+    if (!deleted) {
+      return {
+        success: false,
+        error: `Provider ${providerType} not registered`
+      };
+    }
+
+    return { success: true };
+  }
+
+  /**
+   * Get provider count
+   */
+  public getProviderCount(): {
+    total: number;
+    enabled: number;
+    initialized: number;
+  } {
+    const enabled = Array.from(this.providers.values()).filter(r => r.enabled).length;
+
+    return {
+      total: this.providers.size,
+      enabled,
+      initialized: this.initializedProviders.size
+    };
+  }
+
+  /**
+   * Clear all providers
+   */
+  public clear(): void {
+    this.providers.clear();
+    this.initializedProviders.clear();
+  }
+}

package/src/services/UserManager.ts

@@ -0,0 +1,176 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import type { ProviderType } from '../types';
+import { UserMapper, UserIdentity, createUnifiedId } from '../utils/user-mapping';
+import type { SuiteResult } from '../types';
+
+/**
+ * User registration data
+ */
+export interface UserRegistration {
+  provider: ProviderType;
+  platformUserId: string;
+  displayName?: string;
+  email?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Manages users across all chat providers
+ */
+export class UserManager {
+  private mapper: UserMapper;
+
+  constructor() {
+    this.mapper = new UserMapper();
+  }
+
+  /**
+   * Register a new user or update existing user
+   */
+  public registerUser(registration: UserRegistration): SuiteResult<UserIdentity> {
+    try {
+      // Check if user already exists
+      const existingId = this.mapper.getUnifiedId(
+        registration.provider,
+        registration.platformUserId
+      );
+
+      if (existingId) {
+        // Update existing user
+        const identity = this.mapper.getIdentity(existingId);
+        if (identity) {
+          if (registration.displayName) {
+            identity.displayName = registration.displayName;
+          }
+          if (registration.email) {
+            identity.email = registration.email;
+          }
+          if (registration.metadata) {
+            identity.metadata = { ...identity.metadata, ...registration.metadata };
+          }
+          this.mapper.mapUser(identity);
+          return { success: true, data: identity };
+        }
+      }
+
+      // Create new user
+      const platformIds = new Map<ProviderType, string>();
+      platformIds.set(registration.provider, registration.platformUserId);
+
+      const newIdentity: UserIdentity = {
+        unifiedId: createUnifiedId(),
+        platformIds,
+        displayName: registration.displayName,
+        email: registration.email,
+        metadata: registration.metadata
+      };
+
+      this.mapper.mapUser(newIdentity);
+      return { success: true, data: newIdentity };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to register user'
+      };
+    }
+  }
+
+  /**
+   * Link a platform account to an existing user
+   */
+  public linkPlatform(
+    unifiedId: string,
+    provider: ProviderType,
+    platformUserId: string
+  ): SuiteResult<UserIdentity> {
+    try {
+      const success = this.mapper.addPlatformId(unifiedId, provider, platformUserId);
+      if (!success) {
+        return { success: false, error: 'User not found' };
+      }
+
+      const identity = this.mapper.getIdentity(unifiedId);
+      return { success: true, data: identity };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to link platform'
+      };
+    }
+  }
+
+  /**
+   * Get unified user ID from platform-specific ID
+   */
+  public getUnifiedId(provider: ProviderType, platformUserId: string): string | undefined {
+    return this.mapper.getUnifiedId(provider, platformUserId);
+  }
+
+  /**
+   * Get platform-specific user ID
+   */
+  public getPlatformId(unifiedId: string, provider: ProviderType): string | undefined {
+    return this.mapper.getPlatformId(unifiedId, provider);
+  }
+
+  /**
+   * Get complete user identity
+   */
+  public getUser(unifiedId: string): SuiteResult<UserIdentity> {
+    const identity = this.mapper.getIdentity(unifiedId);
+    if (!identity) {
+      return { success: false, error: 'User not found' };
+    }
+    return { success: true, data: identity };
+  }
+
+  /**
+   * Get all users
+   */
+  public getAllUsers(): UserIdentity[] {
+    return this.mapper.getAllUsers();
+  }
+
+  /**
+   * Remove a user
+   */
+  public removeUser(unifiedId: string): SuiteResult<void> {
+    const success = this.mapper.removeUser(unifiedId);
+    if (!success) {
+      return { success: false, error: 'User not found' };
+    }
+    return { success: true };
+  }
+
+  /**
+   * Get user count
+   */
+  public getUserCount(): number {
+    return this.mapper.size();
+  }
+
+  /**
+   * Search users by display name or email
+   */
+  public searchUsers(query: string): UserIdentity[] {
+    const lowerQuery = query.toLowerCase();
+    return this.mapper.getAllUsers().filter(user =>
+      user.displayName?.toLowerCase().includes(lowerQuery) ||
+      user.email?.toLowerCase().includes(lowerQuery)
+    );
+  }
+
+  /**
+   * Clear all users
+   */
+  public clear(): void {
+    this.mapper.clear();
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,13 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+export * from './ConfigManager';
+export * from './UserManager';
+export * from './HealthMonitor';
+export * from './ProviderManager';
+export * from './MessageOrchestrator';

package/src/types/index.ts

@@ -0,0 +1,11 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+export * from './provider-types';
+export * from './message-types';
+export * from './suite-types';