pms-domain-service-0.1.6.0: src/PMS/Domain/Service/DS/State/Run/ToolsCall.hs

{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}

module PMS.Domain.Service.DS.State.Run.ToolsCall where


import System.IO
import Control.Monad.IO.Class
import Control.Monad.Trans.Class
import Control.Monad.Logger
import Control.Lens
import Control.Monad.Reader
import qualified Control.Concurrent.STM as STM
import System.Exit
import qualified Data.Text as T

import qualified PMS.Domain.Model.DM.Type as DM
import qualified PMS.Domain.Model.DM.Constant as DM

import PMS.Domain.Service.DM.Type


-- |
--
instance IStateActivity RunStateData ToolsCallEventData where
  action _ (ToolsCallEvent (ToolsCallEventData evDat)) = do
    $logDebugS DM._LOGTAG "Run ToolsCallEvent called."

    go evDat $ evDat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams

    return noStateTransition
    
    where
      go :: DM.McpToolsCallRequestData -> String -> AppContext ()
      go dat "pty-connect"       = ptyConnectCommand dat
      go dat "pty-terminate"     = ptyTerminateCommand dat
      go dat "pty-message"       = ptyMessageCommand dat
      go dat "pty-bash"          = ptyConnectCommand dat
      go dat "pty-ssh"           = ptyConnectCommand dat
      go dat "pty-telnet"        = ptyConnectCommand dat
      go dat "pty-cabal"         = ptyConnectCommand dat
      go dat "pty-stack"         = ptyConnectCommand dat
      go dat "pty-ghci"          = ptyConnectCommand dat
      go dat "proc-spawn"        = procRunCommand dat
      go dat "proc-cmd"          = procRunCommand dat
      go dat "proc-ps"           = procRunCommand dat
      go dat "proc-ssh"          = procRunCommand dat
      go dat "proc-telnet"       = procRunCommand dat
      -- go dat "proc-winpty"    = procRunCommand dat
      go dat "proc-plink"        = procRunCommand dat
      go dat "proc-terminate"    = procTerminateCommand dat
      go dat "proc-message"      = procMessageCommand dat
      go dat "proc-read"         = procReadCommand dat
      go dat "proc-write"        = procWriteCommand dat
      go dat "agent-proc-run"       = agentProcRunCommand dat
      go dat "agent-proc-read"      = agentProcReadCommand dat
      go dat "agent-proc-write"     = agentProcWriteCommand dat
      go dat "agent-proc-terminate" = agentProcTerminateCommand dat
      go dat "agent-socket-open"       = agentSocketOpenCommand dat
      go dat "agent-socket-close"      = agentSocketCloseCommand dat
      go dat "agent-socket-read"       = agentSocketReadCommand dat
      go dat "agent-socket-read-byte"  = agentSocketReadByteCommand dat
      go dat "agent-socket-write"      = agentSocketWriteCommand dat
      go dat "agent-socket-write-byte" = agentSocketWriteByteCommand dat
      go dat "agent-serial-open"       = agentSerialOpenCommand dat
      go dat "agent-serial-close"      = agentSerialCloseCommand dat
      go dat "agent-serial-read"       = agentSerialReadCommand dat
      go dat "agent-serial-read-byte"  = agentSerialReadByteCommand dat
      go dat "agent-serial-write"      = agentSerialWriteCommand dat
      go dat "agent-serial-write-byte" = agentSerialWriteByteCommand dat
      go dat "agent-server-listen"       = agentServerListenCommand dat
      go dat "agent-server-close"        = agentServerCloseCommand dat
      go dat "agent-server-status"       = agentServerStatusCommand dat
      go dat "agent-server-events"       = agentServerEventsCommand dat
      go dat "agent-server-read"         = agentServerReadCommand dat
      go dat "agent-server-write"        = agentServerWriteCommand dat
      go dat "agent-server-read-byte"    = agentServerReadByteCommand dat
      go dat "agent-server-write-byte"   = agentServerWriteByteCommand dat
      go dat "socket-open"       = socketOpenCommand dat
      go dat "socket-close"      = socketCloseCommand dat
      go dat "socket-read"       = socketReadCommand dat
      go dat "socket-write"      = socketWriteCommand dat
      go dat "socket-message"    = socketMessageCommand dat
      go dat "socket-telnet"     = socketTelnetCommand dat
      go dat "serial-open"       = serialOpenCommand dat
      go dat "serial-close"      = serialCloseCommand dat
      go dat "serial-read"       = serialReadCommand dat
      go dat "serial-write"      = serialWriteCommand dat
      go dat "serial-message"    = serialMessageCommand dat
      go dat "pms-list-dir"      = fileSystemListDirCommand dat
      go dat "pms-make-dir"      = fileSystemMakeDirCommand dat
      go dat "pms-read-file"     = fileSystemReadFileCommand dat
      go dat "pms-write-file"    = fileSystemWriteFileCommand dat
      go dat "pms-patch-file"    = fileSystemPatchFileCommand dat
      go dat "pms-file-info"     = fileSystemFileInfoCommand dat
      go dat "pms-grep-file"     = fileSystemGrepFileCommand dat
      go dat "pms-replace-file"  = fileSystemReplaceFileCommand dat
      go dat x = do
        $logDebugS DM._LOGTAG $ T.pack $ "handled cmdrun. " ++ show x ++ ": " ++ show dat
        cmdRunCommand dat


-- |
--
ptyConnectCommand :: DM.McpToolsCallRequestData -> AppContext ()
ptyConnectCommand dat = do
  resQ <- view DM.responseQueueDomainData <$> lift ask
  let cmdDat = DM.PtyConnectCommandData {
                DM._namePtyConnectCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsPtyConnectCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              , DM._callbackPtyConnectCommandData  = callback dat resQ
              }

  cmdQ <- view DM.commandQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.PtyConnectCommand cmdDat


-- |
--
ptyTerminateCommand :: DM.McpToolsCallRequestData -> AppContext ()
ptyTerminateCommand dat = do
  resQ <- view DM.responseQueueDomainData <$> lift ask
  let cmdDat = DM.PtyTerminateCommandData {
                DM._callbackPtyTerminateCommandData  = callback dat resQ
              }

  cmdQ <- view DM.commandQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.PtyTerminateCommand cmdDat


-- |
--
ptyMessageCommand :: DM.McpToolsCallRequestData -> AppContext ()
ptyMessageCommand dat = do
  resQ <- view DM.responseQueueDomainData <$> lift ask
  let cmdDat = DM.PtyMessageCommandData {
                DM._argumentsPtyMessageCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              , DM._callbackPtyMessageCommandData  = callback dat resQ
              }

  cmdQ <- view DM.commandQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.PtyMessageCommand cmdDat


-- |
--
callback :: DM.McpToolsCallRequestData -> STM.TQueue DM.McpResponse -> DM.ToolsCallCommandCallback ()
callback evDat resQ code outStr errStr = do
  hPutStrLn stderr $ "[INFO] PMS.Domain.Service.DS.State.Run.callback called."

  let jsonRpc = evDat^.DM.jsonrpcMcpToolsCallRequestData
      content = [ DM.McpToolsCallResponseResultContent "text" outStr
                , DM.McpToolsCallResponseResultContent "text" errStr
                ]
      result = DM.McpToolsCallResponseResult {
                  DM._contentMcpToolsCallResponseResult = content
                , DM._isErrorMcpToolsCallResponseResult = (ExitSuccess /= code)
                }
      resDat = DM.McpToolsCallResponseData jsonRpc result
      res = DM.McpToolsCallResponse resDat

  STM.atomically $ STM.writeTQueue resQ res

  hPutStrLn stderr $ "[INFO] PMS.Domain.Service.DS.State.Run.callback end."


-- |
--
procRunCommand :: DM.McpToolsCallRequestData -> AppContext ()
procRunCommand dat = do
  let cmdDat = DM.ProcRunCommandData {
                DM._jsonrpcProcRunCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameProcRunCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsProcRunCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.procspawnQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ProcRunCommand cmdDat


-- |
--
procTerminateCommand :: DM.McpToolsCallRequestData -> AppContext ()
procTerminateCommand dat = do
  let cmdDat = DM.ProcTerminateCommandData {
                DM._jsonrpcProcTerminateCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              }

  cmdQ <- view DM.procspawnQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ProcTerminateCommand cmdDat


-- |
--
procMessageCommand :: DM.McpToolsCallRequestData -> AppContext ()
procMessageCommand dat = do
  let cmdDat = DM.ProcMessageCommandData {
                DM._jsonrpcProcMessageCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsProcMessageCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.procspawnQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ProcMessageCommand cmdDat


-- |
--
procReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
procReadCommand dat = do
  let cmdDat = DM.ProcReadCommandData {
                DM._jsonrpcProcReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsProcReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.procspawnQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ProcReadCommand cmdDat


-- |
--
procWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
procWriteCommand dat = do
  let cmdDat = DM.ProcWriteCommandData {
                DM._jsonrpcProcWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsProcWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.procspawnQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ProcWriteCommand cmdDat


-- |
--
agentProcRunCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentProcRunCommand dat = do
  let cmdDat = DM.AgentProcessRunCommandData {
                DM._jsonrpcAgentProcessRunCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameAgentProcessRunCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsAgentProcessRunCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentProcessQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentProcessRunCommand cmdDat


-- |
--
agentProcTerminateCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentProcTerminateCommand dat = do
  let cmdDat = DM.AgentProcessTerminateCommandData {
                DM._jsonrpcAgentProcessTerminateCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
              }
  cmdQ <- view DM.agentProcessQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentProcessTerminateCommand cmdDat


-- |
--
agentProcReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentProcReadCommand dat = do
  let cmdDat = DM.AgentProcessReadCommandData {
                DM._jsonrpcAgentProcessReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentProcessReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentProcessQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentProcessReadCommand cmdDat


-- |
--
agentProcWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentProcWriteCommand dat = do
  let cmdDat = DM.AgentProcessWriteCommandData {
                DM._jsonrpcAgentProcessWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentProcessWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentProcessQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentProcessWriteCommand cmdDat


-- |
-- 
agentSocketOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketOpenCommand dat = do
  let cmdDat = DM.AgentSocketOpenCommandData {
                DM._jsonrpcAgentSocketOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameAgentSocketOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsAgentSocketOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketOpenCommand cmdDat


-- |
-- 
agentSocketCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketCloseCommand dat = do
  let cmdDat = DM.AgentSocketCloseCommandData {
                DM._jsonrpcAgentSocketCloseCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketCloseCommand cmdDat


-- |
-- 
agentSocketReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketReadCommand dat = do
  let cmdDat = DM.AgentSocketReadCommandData {
                DM._jsonrpcAgentSocketReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSocketReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketReadCommand cmdDat


-- |
-- 
agentSocketReadByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketReadByteCommand dat = do
  let cmdDat = DM.AgentSocketReadByteCommandData {
                DM._jsonrpcAgentSocketReadByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSocketReadByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketReadByteCommand cmdDat


-- |
-- 
agentSocketWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketWriteCommand dat = do
  let cmdDat = DM.AgentSocketWriteCommandData {
                DM._jsonrpcAgentSocketWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSocketWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketWriteCommand cmdDat


-- |
-- 
agentSocketWriteByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSocketWriteByteCommand dat = do
  let cmdDat = DM.AgentSocketWriteByteCommandData {
                DM._jsonrpcAgentSocketWriteByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSocketWriteByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSocketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSocketWriteByteCommand cmdDat


-- |
-- 
agentSerialOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialOpenCommand dat = do
  let cmdDat = DM.AgentSerialOpenCommandData {
                DM._jsonrpcAgentSerialOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameAgentSerialOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsAgentSerialOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialOpenCommand cmdDat


-- |
-- 
agentSerialCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialCloseCommand dat = do
  let cmdDat = DM.AgentSerialCloseCommandData {
                DM._jsonrpcAgentSerialCloseCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialCloseCommand cmdDat


-- |
-- 
agentSerialReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialReadCommand dat = do
  let cmdDat = DM.AgentSerialReadCommandData {
                DM._jsonrpcAgentSerialReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSerialReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialReadCommand cmdDat


-- |
-- 
agentSerialReadByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialReadByteCommand dat = do
  let cmdDat = DM.AgentSerialReadByteCommandData {
                DM._jsonrpcAgentSerialReadByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSerialReadByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialReadByteCommand cmdDat


-- |
-- 
agentSerialWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialWriteCommand dat = do
  let cmdDat = DM.AgentSerialWriteCommandData {
                DM._jsonrpcAgentSerialWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSerialWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialWriteCommand cmdDat


-- |
-- 
agentSerialWriteByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentSerialWriteByteCommand dat = do
  let cmdDat = DM.AgentSerialWriteByteCommandData {
                DM._jsonrpcAgentSerialWriteByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentSerialWriteByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentSerialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentSerialWriteByteCommand cmdDat


-- |
--
cmdRunCommand :: DM.McpToolsCallRequestData -> AppContext ()
cmdRunCommand dat = do
  let cmdDat = DM.DefaultCmdRunCommandData {
                DM._jsonrpcDefaultCmdRunCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameDefaultCmdRunCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsDefaultCmdRunCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.cmdRunQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.DefaultCmdRunCommand cmdDat


-- |
--
socketOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketOpenCommand dat = do
  let cmdDat = DM.SocketOpenCommandData {
                DM._jsonrpcSocketOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameSocketOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsSocketOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  $logDebugS DM._LOGTAG $ T.pack $ "socketOpenCommand" ++ show cmdDat

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketOpenCommand cmdDat


-- |
--
socketCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketCloseCommand dat = do
  let cmdDat = DM.SocketCloseCommandData {
                DM._jsonrpcSocketCloseCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              }

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketCloseCommand cmdDat


-- |
--
socketReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketReadCommand dat = do
  let cmdDat = DM.SocketReadCommandData {
                DM._jsonrpcSocketReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSocketReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketReadCommand cmdDat


-- |
--
socketWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketWriteCommand dat = do
  let cmdDat = DM.SocketWriteCommandData {
                DM._jsonrpcSocketWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSocketWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketWriteCommand cmdDat


-- |
--
socketMessageCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketMessageCommand dat = do
  let cmdDat = DM.SocketMessageCommandData {
                DM._jsonrpcSocketMessageCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSocketMessageCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketMessageCommand cmdDat


-- |
--
socketTelnetCommand :: DM.McpToolsCallRequestData -> AppContext ()
socketTelnetCommand dat = do
  let cmdDat = DM.SocketTelnetCommandData {
                DM._jsonrpcSocketTelnetCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameSocketTelnetCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsSocketTelnetCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.socketQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SocketTelnetCommand cmdDat

-- |
--
serialOpenCommand :: DM.McpToolsCallRequestData -> AppContext ()
serialOpenCommand dat = do
  let cmdDat = DM.SerialOpenCommandData {
                DM._jsonrpcSerialOpenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._nameSerialOpenCommandData      = dat^.DM.paramsMcpToolsCallRequestData^.DM.nameMcpToolsCallRequestDataParams
              , DM._argumentsSerialOpenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  $logDebugS DM._LOGTAG $ T.pack $ "serialOpenCommand" ++ show cmdDat

  cmdQ <- view DM.serialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SerialOpenCommand cmdDat


-- |
--
serialCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
serialCloseCommand dat = do
  let cmdDat = DM.SerialCloseCommandData {
                DM._jsonrpcSerialCloseCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              }

  cmdQ <- view DM.serialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SerialCloseCommand cmdDat


-- |
--
serialReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
serialReadCommand dat = do
  let cmdDat = DM.SerialReadCommandData {
                DM._jsonrpcSerialReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSerialReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.serialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SerialReadCommand cmdDat


-- |
--
serialWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
serialWriteCommand dat = do
  let cmdDat = DM.SerialWriteCommandData {
                DM._jsonrpcSerialWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSerialWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.serialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SerialWriteCommand cmdDat


-- |
--
serialMessageCommand :: DM.McpToolsCallRequestData -> AppContext ()
serialMessageCommand dat = do
  let cmdDat = DM.SerialMessageCommandData {
                DM._jsonrpcSerialMessageCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsSerialMessageCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.serialQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.SerialMessageCommand cmdDat


-- |
--
fileSystemListDirCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemListDirCommand dat = do
  let cmdDat = DM.ListDirFileSystemCommandData {
                DM._jsonrpcListDirFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsListDirFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ListDirFileSystemCommand cmdDat


-- |
--
fileSystemMakeDirCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemMakeDirCommand dat = do
  let cmdDat = DM.MakeDirFileSystemCommandData {
                DM._jsonrpcMakeDirFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsMakeDirFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.MakeDirFileSystemCommand cmdDat


-- |
--
fileSystemReadFileCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemReadFileCommand dat = do
  let cmdDat = DM.ReadFileFileSystemCommandData {
                DM._jsonrpcReadFileFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsReadFileFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ReadFileFileSystemCommand cmdDat

-- |
--
fileSystemWriteFileCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemWriteFileCommand dat = do
  let cmdDat = DM.WriteFileFileSystemCommandData {
                DM._jsonrpcWriteFileFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsWriteFileFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.WriteFileFileSystemCommand cmdDat


-- |
--
fileSystemPatchFileCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemPatchFileCommand dat = do
  let cmdDat = DM.PatchFileFileSystemCommandData {
                DM._jsonrpcPatchFileFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsPatchFileFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.PatchFileFileSystemCommand cmdDat


-- |
--
fileSystemFileInfoCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemFileInfoCommand dat = do
  let cmdDat = DM.FileInfoFileSystemCommandData {
                DM._jsonrpcFileInfoFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsFileInfoFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.FileInfoFileSystemCommand cmdDat


-- |
--
fileSystemGrepFileCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemGrepFileCommand dat = do
  let cmdDat = DM.GrepFileFileSystemCommandData {
                DM._jsonrpcGrepFileFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsGrepFileFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.GrepFileFileSystemCommand cmdDat


-- |
--
fileSystemReplaceFileCommand :: DM.McpToolsCallRequestData -> AppContext ()
fileSystemReplaceFileCommand dat = do
  let cmdDat = DM.ReplaceFileFileSystemCommandData {
                DM._jsonrpcReplaceFileFileSystemCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsReplaceFileFileSystemCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }

  cmdQ <- view DM.fileSystemQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.ReplaceFileFileSystemCommand cmdDat


-- |
--
agentServerListenCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerListenCommand dat = do
  let cmdDat = DM.AgentServerListenCommandData {
                DM._jsonrpcAgentServerListenCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerListenCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerListenCommand cmdDat


-- |
--
agentServerCloseCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerCloseCommand dat = do
  let cmdDat = DM.AgentServerCloseCommandData {
                DM._jsonrpcAgentServerCloseCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerCloseCommand cmdDat


-- |
--
agentServerStatusCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerStatusCommand dat = do
  let cmdDat = DM.AgentServerStatusCommandData {
                DM._jsonrpcAgentServerStatusCommandData = dat^.DM.jsonrpcMcpToolsCallRequestData
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerStatusCommand cmdDat


-- |
--
agentServerEventsCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerEventsCommand dat = do
  let cmdDat = DM.AgentServerEventsCommandData {
                DM._jsonrpcAgentServerEventsCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerEventsCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerEventsCommand cmdDat


-- |
--
agentServerReadCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerReadCommand dat = do
  let cmdDat = DM.AgentServerReadCommandData {
                DM._jsonrpcAgentServerReadCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerReadCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerReadCommand cmdDat


-- |
--
agentServerWriteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerWriteCommand dat = do
  let cmdDat = DM.AgentServerWriteCommandData {
                DM._jsonrpcAgentServerWriteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerWriteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerWriteCommand cmdDat


-- |
--
agentServerReadByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerReadByteCommand dat = do
  let cmdDat = DM.AgentServerReadByteCommandData {
                DM._jsonrpcAgentServerReadByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerReadByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerReadByteCommand cmdDat


-- |
--
agentServerWriteByteCommand :: DM.McpToolsCallRequestData -> AppContext ()
agentServerWriteByteCommand dat = do
  let cmdDat = DM.AgentServerWriteByteCommandData {
                DM._jsonrpcAgentServerWriteByteCommandData   = dat^.DM.jsonrpcMcpToolsCallRequestData
              , DM._argumentsAgentServerWriteByteCommandData = dat^.DM.paramsMcpToolsCallRequestData^.DM.argumentsMcpToolsCallRequestDataParams
              }
  cmdQ <- view DM.agentServerQueueDomainData <$> lift ask
  liftIO $ STM.atomically $ STM.writeTQueue cmdQ $ DM.AgentServerWriteByteCommand cmdDat