@futdevpro/nts-dynamo 1.14.7 → 1.14.9

package/src/_modules/bot/_modules/teams-bot/_models/teb-platform.types.ts

@@ -0,0 +1,9 @@
+import { DyNTS_Bot_Message } from '../../../_models/bot-message.interface';
+import { DyNTS_Bot_Channel } from '../../../_models/bot-channel.interface';
+import { DyNTS_Bot_User } from '../../../_models/bot-user.interface';
+
+// Teams Bot Platform-Specific Types
+// TODO: Replace 'any' with actual Teams SDK types when implementing
+export type DyNTS_TeB_Message = DyNTS_Bot_Message<any>;
+export type DyNTS_TeB_Channel = DyNTS_Bot_Channel<any>;
+export type DyNTS_TeB_User = DyNTS_Bot_User<any>;

package/src/_modules/bot/_modules/teams-bot/_services/teb-provider.service.ts

@@ -0,0 +1,152 @@
+import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../../../_models/bot-provider.interface';
+import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
+import { DyNTS_Bot_Provider_Type } from '../../../_enums/bot-provider.enum';
+import { DyNTS_TeB_Message, DyNTS_TeB_Channel, DyNTS_TeB_User } from '../_models/teb-platform.types';
+
+export class DyNTS_TeB_Provider implements DyNTS_Bot_Provider<
+  DyNTS_TeB_Channel,
+  DyNTS_TeB_Message,
+  DyNTS_TeB_User
+> {
+  private isInitialized: boolean = false;
+  private config: DyNTS_Bot_Provider_Config;
+  
+  // Event handlers
+  private messageHandlers: Array<(message: DyNTS_TeB_Message, issuer: string) => void> = [];
+  private readyHandlers: Array<() => void> = [];
+  private errorHandlers: Array<(error: Error) => void> = [];
+
+  async initialize(config: DyNTS_Bot_Provider_Config): Promise<void> {
+    this.config = config;
+    
+    if (config.provider !== DyNTS_Bot_Provider_Type.teams) {
+      throw new Error(`Invalid provider type: ${config.provider}. Expected 'teams'`);
+    }
+
+    if (!config.teams) {
+      throw new Error('Teams configuration is required');
+    }
+
+    this.isInitialized = true;
+    // TODO: Initialize Teams client
+  }
+
+  async login(token: string): Promise<void> {
+    if (!this.isInitialized) {
+      throw new Error('Provider not initialized. Call initialize() first.');
+    }
+    // TODO: Implement Teams login
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Channel operations
+  async getChannelByName(name: string): Promise<DyNTS_TeB_Channel> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_TeB_Message[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async clearChannel(channelId: string): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Message operations
+  async sendMessage(channelId: string, content: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async replyToMessage(messageId: string, channelId: string, content: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendTyping(channelId: string): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchMessages(channelId: string, limit: number): Promise<DyNTS_TeB_Message[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchAllMessagesWithPaging(channelId: string, maxFetch?: number): Promise<DyNTS_TeB_Message[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async deleteMessage(messageId: string, channelId: string): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_TeB_User> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  getUserMention(userId: string): string {
+    return `<@${userId}>`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_TeB_User[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_TeB_Message> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_TeB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Event binding
+  onMessage(handler: (message: DyNTS_TeB_Message, issuer: string) => void): void {
+    this.messageHandlers.push(handler);
+  }
+
+  onReady(handler: () => void): void {
+    this.readyHandlers.push(handler);
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandlers.push(handler);
+  }
+
+  // Metadata
+  getBotId(): string {
+    return 'teams-bot-stub';
+  }
+
+  getBotDisplayName(): string {
+    return 'Teams Bot (Stub)';
+  }
+
+  getProviderName(): string {
+    return 'teams';
+  }
+
+  isReady(): boolean {
+    return this.isInitialized;
+  }
+}

package/src/_modules/bot/_modules/teams-bot/index.ts

@@ -0,0 +1,14 @@
+//
+// Teams Bot Provider
+//
+// This module provides Teams-specific implementation of the Bot provider interface
+//
+
+// TYPES
+export * from './_models/teb-platform.types';
+
+// SERVICES
+export * from './_services/teb-provider.service';
+
+// COLLECTIONS
+export * from './_collections/teb-operations.util';

package/src/_modules/bot/_services/bot-commands.control-service.ts

@@ -0,0 +1,126 @@
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { DyNTS_Bot_User } from '../_models/bot-user.interface';
+import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
+import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../_models/bot-provider.interface';
+
+export abstract class DyNTS_Bot_Commands_ControlService<
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+> extends DyNTS_SingletonService {
+
+  static getInstance<T_PlatformMessage extends DyNTS_Bot_Message<any>>(): DyNTS_Bot_Commands_ControlService<T_PlatformMessage> {
+    return DyNTS_Bot_Commands_ControlService.getSingletonInstance();
+  }
+
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+  protected readonly mainBot_CS: DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider> = 
+    this.getMainBotControlService();
+
+  get provider(): T_PlatformProvider {
+    return this.mainBot_CS?.provider;
+  }
+
+  protected constructor() {
+    super();
+
+    if (!this.provider) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'constructor', 
+          new Error(
+            'Bot provider not yet initialized, ' +
+            'should only be called after DyNTS_Bot_Main_ControlService.start'
+          ), 
+          'system-init'
+        ),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-C00`,
+      })
+    }
+  }
+
+  async handleCommand(message: T_PlatformMessage, issuer: string): Promise<void> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Provider_Config;
+      let haveCommandOperator = false;
+      let msg = message.content.replace(
+        `<@${this.mainBot_CS.botClientId}>`, ''
+      ).trim();
+
+      if (!botSettings?.commandSettings?.commandOperator) {
+        haveCommandOperator = true;
+      } else if (
+        msg.startsWith(botSettings.commandSettings.commandOperator)
+      ) {
+        haveCommandOperator = true;
+        msg = msg.replace(botSettings.commandSettings.commandOperator, '');
+      }
+
+      if (!haveCommandOperator) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'handleCommand', 
+            new Error('No command operator found in the message'), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC1`,
+        })
+      }
+
+      const commandExists = botSettings?.commandSettings?.commands?.find(
+        (command) => msg.startsWith(command.command)
+      );
+
+      if (!commandExists) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'handleCommand', 
+            new Error(`Command not found: "${msg.split(' ')[0]}"`), 
+            issuer
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC2`,
+        })
+      }
+
+      if (commandExists.permissionNeeded) {
+        const permissionNeeded = await commandExists.permissionNeeded(message);
+
+        if (!permissionNeeded) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings(
+              'handleCommand', 
+              new Error('Permission needed'), 
+              issuer
+            ),
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC3`,
+          })
+        }
+      }
+
+      await commandExists.commandHandler(message);
+    } catch (error) {
+      this.provider.replyToMessage(
+        message.id,
+        message.channelId,
+        `Error occurred while handling the command:\n` +
+        DyFM_Error.getAnyMessage(error)
+      )
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC0`,
+      })
+    }
+  }
+}

package/src/_modules/bot/_services/bot-io.control-service.ts

@@ -0,0 +1,325 @@
+import { DyFM_Error, DyFM_Log, hour, week } from '@futdevpro/fsm-dynamo'
+import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service'
+import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service'
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service'
+import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service'
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const'
+import { DyNTS_Bot_Message } from '../_models/bot-message.interface'
+import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface'
+import { DyNTS_Bot_User } from '../_models/bot-user.interface'
+import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface'
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface'
+import { DyNTS_Msg_Integration_ControlService } from '../../messaging/_services/msg-integration.control-service'
+
+export abstract class DyNTS_Bot_IO_ControlService<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+> extends DyNTS_SingletonService {
+
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+  protected abstract mainBot_CS: DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+
+  get provider(): T_PlatformProvider {
+    return this.mainBot_CS?.provider;
+  }
+  
+  get botClientId(): string {
+    return this.mainBot_CS.botClientId;
+  }
+  
+  get botDisplayName(): string {
+    return this.mainBot_CS.botDisplayName;
+  }
+
+  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
+  protected commands_CS: DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
+
+  dontSendErrorReply?: boolean;
+
+  async start(issuer: string): Promise<void> {
+    try {
+      this.mainBot_CS = this.getMainBotControlService();
+      this.commands_CS = this.getCommandsControlService();
+
+      if (!this.provider) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'constructor', 
+            new Error(
+              'Bot provider not yet initialized, ' +
+              'should only be called after DyNTS_Bot_Main_ControlService.start'
+            ), 
+            'system-init'
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-C000`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-S000`,
+      })
+    }
+  }
+
+  async handleNewMessage(message: T_PlatformMessage, issuer: string): Promise<void> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (botSettings?.debugLevel >= 1) {
+        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}):\n${message.content}`)
+      }
+
+      const isForYou = await this.getMessageIsForBotToHandle(message, issuer);
+
+      if (!isForYou) {
+        return;
+      }
+
+      const isHandledAsCommand = await this.handleIfCommand(message, issuer);
+
+      if (isHandledAsCommand) {
+        return;
+      }
+
+      await this.handleMessage(message, issuer);
+      
+      // Sync message to messaging system if enabled
+      try {
+        if (DyNTS_global_settings.messaging_settings?.integration?.syncBotMessages) {
+          const messagingIntegration = DyNTS_Msg_Integration_ControlService.getInstance();
+          
+          // Find or create conversation for this channel
+          const conversation = await messagingIntegration.findOrCreateBotConversation(
+            message.channelId,
+            this.provider.getProviderName(),
+            issuer
+          );
+          
+          // Sync the message
+          await messagingIntegration.syncBotMessage(
+            message,
+            conversation._id!,
+            issuer
+          );
+        }
+      } catch (syncError) {
+        // Log sync error but don't break bot functionality
+        DyFM_Log.error('Failed to sync bot message to messaging system', syncError);
+      }
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error handleNewMessage:', error);
+
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (!this.dontSendErrorReply && botSettings?.debugLevel >= 1) {
+        await this.provider.replyToMessage(
+          message.id,
+          message.channelId,
+          `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] Error occurred while handling the message:\n` +
+          DyFM_Error.getAnyMessage(error)
+        ).catch(error => {
+          DyFM_Error.logSimple('❌❌ Error sending message to report channel:', error);
+        });
+      }
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleNewMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-H0`,
+      })
+    }
+  }
+
+  abstract handleMessage(message: T_PlatformMessage, issuer: string): Promise<T_PlatformMessage>;
+
+  async getMessageIsForBotToHandle(
+    message: T_PlatformMessage, 
+    issuer: string, 
+    dontRemovePing?: boolean
+  ): Promise<boolean> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      
+      if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+        DyFM_Log.H_error(
+          '🚫❌ Bot not initialized yet. END wont respond to message:', message.content,
+          new Error('Bot not initialized yet').stack
+        )
+
+        await this.start(issuer);
+
+        if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+          DyFM_Log.H_error(
+            '🚫❌❌ can not start bot. END wont respond to message:', message.content,
+            new Error('can not start bot').stack
+          )
+        }
+
+        return false;
+      }
+
+      const isReplyForYou = message.replyToMessageId && message.replyToMessageId; // Simplified check
+      const isPinged = message.content.includes(this.botClientId) || 
+        message.content.includes(`@${this.botDisplayName}`) ||
+        isReplyForYou;
+      const isOwnMessage = message.authorId === this.botClientId || 
+        message.authorDisplayName === this.botDisplayName;
+      const haveSkipFlags = botSettings?.messageSettings?.skipFlags?.some(
+        flag => message.content.includes(flag)
+      ) || false;
+      const channelName = message.channelName;
+      const isDMChannel = message.channelName?.startsWith('DM-'); // Simplified DM detection
+      const isInDefaultChannel = botSettings?.channelSettings?.defaultChannels?.includes(
+        channelName
+      ) || (isDMChannel && botSettings?.channelSettings?.dmIsAllowed);
+      const isAllowedChannel = botSettings?.channelSettings?.allowedChannels?.includes(
+        channelName
+      ) || (isDMChannel && botSettings?.channelSettings?.dmIsAllowed);
+
+      if (!isAllowedChannel) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed channel. END')
+        }
+
+        if (!isOwnMessage && isPinged) {
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            `[SYSTEM|REFUSE|CHANNEL] I'm sorry, but I'm not allowed to answer you in this channel!`
+          )
+        }
+
+        return false;
+      }
+      
+      if (isOwnMessage) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖 will not answer; own message')
+        }
+
+        return false;
+      }
+
+      if (haveSkipFlags) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🏳️  not for me; this message have some skip flags:', 
+            botSettings?.messageSettings?.skipFlags?.filter(
+              flag => message.content.includes(flag)
+            ),
+            message.content
+          )
+        }
+
+        return false;
+      }
+
+      if (
+        message.isBot && 
+        !botSettings?.allowBotsInteractEachOther
+      ) {
+        if (isPinged && botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫🤖❌ not for me; this message is from a bot')
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            '[SYSTEM|REFUSE|BOT] You should not ping me!'
+          )
+        }
+
+        return false;
+      }
+
+      if (!isPinged && !isInDefaultChannel) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫 not for me; not pinged, and not my message, and not in default channel')
+        }
+
+        return false;
+      }
+
+      const isAllowedUser = botSettings?.allowedUsers === 'all' || 
+        botSettings?.allowedUsers?.includes(message.authorId) ||
+        botSettings?.allowedUsers?.includes(message.authorName) ||
+        botSettings?.allowedUsers?.includes(message.authorDisplayName);
+
+      if (!isAllowedUser) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not allowed user. END', message.authorName, message.authorDisplayName)
+          this.provider.replyToMessage(
+            message.id,
+            message.channelId,
+            `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
+          )
+        }
+
+        return false;
+      }
+
+      if (!message.channelName) {
+        if (botSettings?.debugLevel >= 2) {
+          DyFM_Log.warn('🚫❌ not text based channel. END')
+        }
+
+        return false;
+      }
+      
+      return true;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getMessageIsForBotToHandle', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-MCS-G0`,
+      })
+    }
+  }
+
+  async handleIfCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+    try {
+      const isCommand = await this.isCommand(message, issuer);
+
+      if (isCommand) {
+        await this.commands_CS.handleCommand(message, issuer);
+      }
+
+      return Boolean(isCommand);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleIfCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-HIC0`,
+      })
+    }
+  }
+
+  async isCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+    try {
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      let haveCommandOperator = false;
+
+      if (!botSettings?.commandSettings?.commandOperator) {
+        haveCommandOperator = true;
+      } else if (
+        message.content.trim().startsWith(botSettings.commandSettings.commandOperator)
+      ) {
+        haveCommandOperator = true;
+      }
+
+      if (!haveCommandOperator) {
+        return false;
+      }
+
+      const commandExists = botSettings?.commandSettings?.commands?.find(
+        (command) => message.content.trim().startsWith(
+          `${botSettings.commandSettings.commandOperator}${command.command}`
+        )
+      );
+
+      return Boolean(commandExists);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('isCommand', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-IC0`,
+      })
+    }
+  }
+}