diff --git a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Connector.py b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Connector.py
index a3526b13..0d969130 100644
--- a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Connector.py
+++ b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Connector.py
@@ -10,6 +10,7 @@ import keyboard # Keyboard functions
 import time
 import random # random integers
 from win32api import GetSystemMetrics # Get Screen rect
+import pyautogui # for hotkey operations
 # System variables for recovery scenario
 gRecoveryWindowRDPRetryCountInt = 3 # Retry iteration count is RDP window is not responsible
 gRecoveryWindowRDPRetryIntervalSecInt = 3 # Retry interval for reconnect
@@ -34,7 +35,7 @@ gRecoveryCMDResponsibleRetryIntervalSecInt = 3 # Retry interval for retry
     }
 }
 """
-def Session(inRDPSessionConfiguration):
+def Session(inRDPSessionConfiguration, inScreenSize550x350Bool = False):
     #RDPConnector.SessionConnect(mConfiguration)
     #RDPConnector.LoginPassSet("111.222.222.111","ww","dd")
     (lRDPFile, lSessionHex) = SessionConfigurationCreate(inRDPSessionConfiguration)
@@ -43,7 +44,7 @@ def Session(inRDPSessionConfiguration):
     #Set login/password
     SessionLoginPasswordSet(inRDPSessionConfiguration["Host"],inRDPSessionConfiguration["Login"],inRDPSessionConfiguration["Password"])
     #Start session
-    SessionRDPStart(lRDPFile)
+    SessionRDPStart(lRDPFile, inScreenSize550x350Bool= inScreenSize550x350Bool)
     #Remove temp file
     time.sleep(4) #Delete file after some delay - one way to delete and run the RDP before because RDP is not read file in one moment
     os.remove(lRDPFile) # delete the temp rdp
@@ -89,7 +90,7 @@ def SessionConfigurationCreate(inConfiguration):
     #Return .rdp full path
     return (lRDPCurrentFileFullPath, (lRDPCurrentFileFullPath.split("\\")[-1])[0:-4])
 #RDPSessionStart
-def SessionRDPStart(inRDPFilePath):
+def SessionRDPStart(inRDPFilePath, inScreenSize550x350Bool = False):
     #Disable certificate warning
     lCMDString = 'reg add "HKEY_CURRENT_USER\\Software\\Microsoft\\Terminal Server Client" /v "AuthenticationLevelOverride" /t "REG_DWORD" /d 0 /f'
     os.system(lCMDString)
@@ -147,24 +148,27 @@ def SessionRDPStart(inRDPFilePath):
     # Raise exception if RDP is not active
     if len(lWaitResult) == 0:
         raise ConnectorExceptions.SessionWindowNotExistError("Error when initialize the RDP session - No RDP windows has appreared!")
-    # Wait for init
-    time.sleep(3)
-    SessionScreenSize_X_Y_W_H(inSessionHex = lRDPFileName, inXInt = 10, inYInt = 10, inWInt = 550, inHInt = 350) #Prepare little window
+    time.sleep(3) # Wait for init
+    if inScreenSize550x350Bool: SessionScreenSize_X_Y_W_H(inSessionHex = lRDPFileName, inXInt = 10, inYInt = 10, inWInt = 550, inHInt = 350) #Prepare little window
     return None
 
 #Set fullscreen for app
-def SessionScreenFull(inSessionHex, inGSettings = None):
+def SessionScreenFull(inSessionHex, inLogger = None, inRDPConfigurationItem = None):
     ########################################
     lWindowRDPRetryIterator = 0 # Retry iterator if RDP window is not active
-    lRDPConfigurationItem = None
-    lL = None
-    if inGSettings: # Get the values from gSettings
-        lRDPConfigurationItem = inGSettings["RobotRDPActive"]["RDPList"][inSessionHex] # Get the RDP configuration item
-        lL = inGSettings["Logger"] # Get the logger instance
+    lRDPConfigurationItem = inRDPConfigurationItem # Get the RDP configuration item
+    lL = inLogger # Get the logger instance
+    lRDPWindow = None # Init the variable
     while lWindowRDPRetryIterator<gRecoveryWindowRDPRetryCountInt: # Loop iteration to connect to RDP
         try: # Try to get RDP window
             lRDPWindow = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHex}.*", "backend": "win32"}])
             lWindowRDPRetryIterator = gRecoveryWindowRDPRetryCountInt # Set last iterator to turn off the loop
+            # RDP window has been detected - go to set focus and maximize
+            lRDPWindow.set_focus()
+            lRDPWindow.maximize()
+            if not SessionIsFullScreen(inSessionHex):
+                lRDPWindow.type_keys("^%{BREAK}")
+                time.sleep(0.5)
         except Exception as e: # RDP window is not exist - try to reconnect
             if lL: lL.warning(f"RDP::SessionScreenFull: RDP window is not exist - try sleep {gRecoveryWindowRDPRetryIntervalSecInt}[s.] and then to reconnect. SessionHex: {inSessionHex}. Current retry iterator is {lWindowRDPRetryIterator}")
             if lRDPConfigurationItem:
@@ -172,6 +176,8 @@ def SessionScreenFull(inSessionHex, inGSettings = None):
                 # Try to reconnect the RDP
                 SessionClose(inSessionHexStr=inSessionHex) # Close the
                 Session(lRDPConfigurationItem) # Create RDP session
+                inSessionHex = lRDPConfigurationItem["SessionHex"] # Get new session hex after reconnect
+                SystemRDPWarningClickOk()  # Click all warning messages
                 lWindowRDPRetryIterator = lWindowRDPRetryIterator + 1 # increase the iterator
                 if lWindowRDPRetryIterator >= gRecoveryWindowRDPRetryCountInt:  # Raise the error if retry count is over
                     if lL: lL.warning(f"RDP::SessionScreenFull: Retry count is over. Raise the error. SessionHex: {inSessionHex}.")  # Log the info
@@ -179,13 +185,6 @@ def SessionScreenFull(inSessionHex, inGSettings = None):
             else:
                 if lL: lL.warning(f"RDP::SessionScreenFull: Has no RDP configuration item - don't reconnect. Raise the error. SessionHex: {inSessionHex}") # Log the info
                 raise ConnectorExceptions.SessionWindowNotExistError() # raise the error
-    # RDP window has been detected - go to set focus and maximize
-    lRDPWindow.set_focus()
-    lRDPWindow.maximize()
-    #time.sleep(0.5)
-    if not SessionIsFullScreen(inSessionHex):
-        lRDPWindow.type_keys("^%{BREAK}")
-        time.sleep(0.5)
     return None
 
 # Set the screen size
@@ -233,16 +232,14 @@ def SessionClose(inSessionHexStr):
 #   "IsResponsibleBool": True|False # Flag is RDP is responsible - works only when inModeStr = CROSSCHECK
 # }
 # example Connector.SessionCMDRun("4d1e48f3ff6c45cc810ea25d8adbeb50","start notepad", "RUN")
-def SessionCMDRun(inSessionHex,inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inGSettings = None):
-    lL = None # Init the logger
-    if inGSettings: # If gSettings is exist
-        lL = inGSettings["Logger"] # get the logger
+def SessionCMDRun(inSessionHex,inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inLogger=None, inRDPConfigurationItem=None):
+    lL = inLogger # Init the logger
     # Init the result dict
     lResult = {"OutStr": None,"IsResponsibleBool":True}
-    SessionScreenFull(inSessionHex, inGSettings = inGSettings) # Enter full screen mode with recovery scenario
+    SessionScreenFull(inSessionHex, inLogger=lL, inRDPConfigurationItem=inRDPConfigurationItem) # Enter full screen mode with recovery scenario
     time.sleep(2)
     # Run CMD operations
-    lResult = SystemCMDRun(inCMDCommandStr = inCMDCommandStr, inModeStr = inModeStr, inClipboardTimeoutSec = inClipboardTimeoutSec, inLogger=lL)
+    lResult = SystemCMDRun(inSessionHexStr = inRDPConfigurationItem["SessionHex"], inCMDCommandStr = inCMDCommandStr, inModeStr = inModeStr, inClipboardTimeoutSec = inClipboardTimeoutSec, inLogger=lL)
     # Exit fullscreen mode
     SessionScreenSize_X_Y_W_H(inSessionHex=inSessionHex, inXInt=10, inYInt=10, inWInt=550,
                               inHInt=350)  # Prepare little window
@@ -294,7 +291,12 @@ def SessionIsMinimizedScreen(inSessionHexStr):
 #   "IsResponsibleBool": True|False # Flag is RDP is responsible - works only when inModeStr = CROSSCHECK
 # }
 # example Connector.SessionCMDRun("4d1e48f3ff6c45cc810ea25d8adbeb50","start notepad", "RUN")
-def SystemCMDRun(inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inLogger = None):
+def SystemCMDRun(inSessionHexStr, inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboardTimeoutSec = 5, inLogger = None):
+    lRDPWindow = None # Init the UI object
+    try:
+        lRDPWindow = UIDesktop.UIOSelector_Get_UIO([{"title_re": f"{inSessionHexStr}.*", "backend": "win32"}])
+    except Exception as e:
+        raise ConnectorExceptions.SessionWindowNotExistError() # Raise error of gui window
     lL = inLogger # Alias for logger
     lResult = {"OutStr": None,"IsResponsibleBool":True} # Init the result dict
     lClipboardTextOld = str(random.randrange(999,9999999))  # Set random text to clipboard (for check purposes that clipboard text has been changed)
@@ -307,18 +309,19 @@ def SystemCMDRun(inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboard
         while lRecoveryWindowRUNRetryIteratorInt<gRecoveryWindowRUNRetryCountInt: # loop for retry
             lCMDPostFixStr = "" # Case default "RUN"
             if inModeStr == "CROSSCHECK":
-                lCMDPostFixStr = f"| echo {lCrosscheckKeyStr} | clip"
+                lCMDPostFixStr = f"& (echo {lCrosscheckKeyStr} | clip)"
             elif inModeStr == "LISTEN":
                 lCMDPostFixStr = f"| clip"
             keyboard.press_and_release('win+r')
             time.sleep(1) # Wait for RUN window will appear
-            keyboard.press_and_release("ctrl+a") # Select all
+            lRDPWindow.type_keys("^(a)") # Select all
             keyboard.press_and_release("backspace")  # Delete selected all
-            lInputStr = f"cmd /c {inCMDCommandStr} {lCMDPostFixStr}" # Generate the output string for RUN window
+            time.sleep(0.5)  # Wait for RUN window will appear ctrl+a+backspace is async - so we need some timeout...
+            lInputStr = f"cmd /c ({inCMDCommandStr}) {lCMDPostFixStr}" # Generate the output string for RUN window
             keyboard.write(lInputStr) # Write new text
-            keyboard.press_and_release("ctrl+a")  # Select all
-            keyboard.press_and_release("ctrl+c")  # COPY in clipboard to check
-            #time.sleep(2 + 2 * lRecoveryWindowRUNRetryIteratorInt) # Wait when data will be copied UPD - no need - wait is below
+            time.sleep(0.5)
+            lRDPWindow.type_keys("^(a)") # Select all
+            lRDPWindow.type_keys("^(c)") # Copy data
             # Check the clipboard
             lClipboardWaitTimeStartSec = time.time()
             lClipboardStr = Clipboard.TextGet() # Get text from clipboard
@@ -370,8 +373,8 @@ def SystemCMDRun(inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK", inClipboard
         # # # # # # # # # # # # # # # # # # # # # # # # # # # #
     return lResult # return the result
 # Check if current RDP is responsible
-def SystemRDPIsResponsible():
-    return SystemCMDRun(inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK")["IsResponsibleBool"]
+def SystemRDPIsResponsible(inSessionHexStr):
+    return SystemCMDRun(inSessionHexStr = inSessionHexStr, inCMDCommandStr = "echo 1", inModeStr="CROSSCHECK")["IsResponsibleBool"]
 # Click OK on error messages
 def SystemRDPWarningClickOk():
     # Try to click OK Error window in RUS version
diff --git a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Processor.py b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Processor.py
index 0f204ef1..3b670128 100644
--- a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Processor.py
+++ b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/Processor.py
@@ -30,10 +30,9 @@ def RDPSessionConnect(inRDPSessionKeyStr, inHostStr, inPortStr, inLoginStr, inPa
         "SessionIsWindowResponsibleBool": False,  # Flag if RDP window is responsible (recieve commands). Check every nn seconds. If window is Responsible - window is Exist too , example False
         "SessionIsIgnoredBool": False  # Flag to ignore RDP window False - dont ignore, True - ignore, example False
     }
-    # Add item in RDPList
-    gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr] = lRDPConfigurationItem
-    # Create the RDP session
-    Connector.Session(lRDPConfigurationItem)
+    gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr] = lRDPConfigurationItem # Add item in RDPList
+    Connector.Session(lRDPConfigurationItem) # Create the RDP session
+    Connector.SystemRDPWarningClickOk()  # Click all warning messages
     return True
 
 # Disconnect the RDP session
@@ -43,6 +42,7 @@ def RDPSessionDisconnect(inRDPSessionKeyStr):
     if lSessionHex:
         gSettings["RobotRDPActive"]["RDPList"].pop(inRDPSessionKeyStr,None)
         Connector.SessionClose(inSessionHexStr=lSessionHex)
+        Connector.SystemRDPWarningClickOk()  # Click all warning messages
     return True
 
 # RDP Session reconnect
@@ -64,18 +64,19 @@ def RDPSessionLogoff(inRDPSessionKeyStr):
     # Calculate the session Hex
     lSessionHex = gSettings["RobotRDPActive"]["RDPList"].get(inRDPSessionKeyStr,{}).get("SessionHex", None)
     if lSessionHex:
-        gSettings["RobotRDPActive"]["RDPList"].pop(inRDPSessionKeyStr,None)
         # Run CMD
-        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="RUN", inGSettings = gSettings)
+        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="CROSSCHECK", inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
+        gSettings["RobotRDPActive"]["RDPList"].pop(inRDPSessionKeyStr,None) # Remove item from RDPList
     return lResult
 
 # Check RDP Session responsibility TODO NEED DEV + TEST
 def RDPSessionResponsibilityCheck(inRDPSessionKeyStr):
     global gSettings
     inGlobalDict = gSettings
-    lSessionHex = inGlobalDict["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr]["SessionHex"]
+    lRDPConfigurationItem = inGlobalDict["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr] # Get the alias
     # set the fullscreen
-    Connector.SessionScreenFull(inSessionHex=lSessionHex, inGSettings = gSettings)
+    # ATTENTION!!! Session hex can be updated!!!
+    Connector.SessionScreenFull(inSessionHex=lRDPConfigurationItem["SessionHex"], inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
     time.sleep(1)
     # Check RDP responsibility
     lDoCheckResponsibilityBool = True
@@ -87,7 +88,7 @@ def RDPSessionResponsibilityCheck(inRDPSessionKeyStr):
             pass
             #raise ConnectorExceptions.SessionWindowNotResponsibleError("Error when initialize the RDP session - RDP window is not responding!")
         # Check responding
-        lDoCheckResponsibilityBool = not Connector.SystemRDPIsResponsible()
+        lDoCheckResponsibilityBool = not Connector.SystemRDPIsResponsible(inSessionHexStr = lRDPConfigurationItem["SessionHex"])
         # Wait if is not responding
         if lDoCheckResponsibilityBool:
             time.sleep(3)
@@ -105,7 +106,7 @@ def RDPSessionProcessStartIfNotRunning(inRDPSessionKeyStr, inProcessNameWEXEStr,
     lSessionHex = inGlobalDict["RobotRDPActive"]["RDPList"].get(inRDPSessionKeyStr,{}).get("SessionHex", None)
     # Run CMD
     if lSessionHex:
-        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="RUN", inGSettings = gSettings)
+        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="CROSSCHECK", inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
     return lResult
 # Create CMD str to stop process
 def RDPSessionProcessStop(inRDPSessionKeyStr, inProcessNameWEXEStr, inFlagForceCloseBool):
@@ -119,7 +120,7 @@ def RDPSessionProcessStop(inRDPSessionKeyStr, inProcessNameWEXEStr, inFlagForceC
     lSessionHex = inGlobalDict["RobotRDPActive"]["RDPList"].get(inRDPSessionKeyStr,{}).get("SessionHex", None)
     # Run CMD
     if lSessionHex:
-        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="RUN", inGSettings = gSettings)
+        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="CROSSCHECK", inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
     return lResult
 # Send file from Host to Session RDP using shared drive in RDP
 def RDPSessionFileStoredSend(inRDPSessionKeyStr, inHostFilePathStr, inRDPFilePathStr):
@@ -132,7 +133,7 @@ def RDPSessionFileStoredSend(inRDPSessionKeyStr, inHostFilePathStr, inRDPFilePat
     #lSessionHex = inGlobalDict["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr]["SessionHex"]
     # Run CMD
     if lSessionHex:
-        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="LISTEN", inClipboardTimeoutSec = 120, inGSettings = gSettings)
+        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="LISTEN", inClipboardTimeoutSec = 120, inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
     return lResult
 # Recieve file from Session RDP to Host using shared drive in RDP
 def RDPSessionFileStoredRecieve(inRDPSessionKeyStr, inRDPFilePathStr, inHostFilePathStr):
@@ -144,5 +145,5 @@ def RDPSessionFileStoredRecieve(inRDPSessionKeyStr, inRDPFilePathStr, inHostFile
     lSessionHex = inGlobalDict["RobotRDPActive"]["RDPList"].get(inRDPSessionKeyStr,{}).get("SessionHex", None)
     # Run CMD
     if lSessionHex:
-        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="LISTEN", inClipboardTimeoutSec = 120, inGSettings = gSettings)
+        Connector.SessionCMDRun(inSessionHex=lSessionHex, inCMDCommandStr=lCMDStr, inModeStr="LISTEN", inClipboardTimeoutSec = 120, inLogger=gSettings["Logger"], inRDPConfigurationItem=gSettings["RobotRDPActive"]["RDPList"][inRDPSessionKeyStr])
     return lResult
\ No newline at end of file
diff --git a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py
index 5f463a23..8f8c3029 100644
--- a/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py
+++ b/Sources/pyOpenRPA/Orchestrator/RobotRDPActive/RobotRDPActive.py
@@ -46,7 +46,7 @@ def RobotRDPActive(inGSettings):
                     # Check if RDP window is not ignored
                     if not lRDPConfigurationDict["SessionIsIgnoredBool"]:
                         try:
-                            Connector.Session(lRDPConfigurationDict)
+                            Connector.Session(lRDPConfigurationDict, inScreenSize550x350Bool = True)
                             lRDPConfigurationDict["SessionIsWindowExistBool"] = True  # Flag that session is started
                             if lL: lL.info(f"SessionHex: {str(lRDPConfigurationDict['SessionHex'])}:: Session has been initialized!")  #Logging
                         # catch ConnectorExceptions.SessionWindowNotExistError
@@ -90,7 +90,7 @@ def RobotRDPActive(inGSettings):
                                                               inWInt=550,
                                                               inHInt=350)  # Prepare little window
                             # Set full screen for new window
-                            Connector.SessionScreenFull(inSessionHex=lRDPConfigurationDict["SessionHex"], inGSettings = inGSettings)
+                            Connector.SessionScreenFull(inSessionHex=lRDPConfigurationDict["SessionHex"], inLogger= inGSettings["Logger"], inRDPConfigurationItem=inGlobalDict["RDPList"][lRDPSessionKeyStrItem])
                 else:
                     # Check all RDP window and minimize it
                     for lRDPSessionKeyStrItem in inGlobalDict["RDPList"]:
@@ -108,12 +108,13 @@ def RobotRDPActive(inGSettings):
                 for lActivityItem in lActivityListOld:
                     lSubmoduleFunctionName = lActivityItem["DefNameStr"]
                     if lSubmoduleFunctionName in dir(Processor):
+                        lActivityItemResult = None # init the variable
                         try: # try to run function from Processor.py
                             lActivityItemResult = getattr(Processor, lSubmoduleFunctionName)(
                                 *lActivityItem["ArgList"], **lActivityItem["ArgDict"])
                         except Exception as e:
                             if lL: lL.exception(f"RDP::main: Exception when run def in processor.py - activity will be ignored. Activity item: {lActivityItem}")  #Logging
-                            lActivityItemResultType = True # True - clear from repeat list
+                            lActivityItemResult = True # True - clear from repeat list
                         lActivityItemResultType = type(lActivityItemResult)
                         # Check if Result is bool
                         if lActivityItemResultType is bool: