You could take a hint from a similar question on StackOverflow and use a bash Here document:

ssh root@host 'bash -s' << EOF
  command1
  command2
  command3
EOF

You can use expect script. It can automate ssh connection and run commands on the remote machine. This code should shed some light on automating the ssh connection.

you are looking for something like this. store the following code in a file foo.expect

#login to the remote machine
spawn ssh username@hostname
expect "?assword" { send "yourpassword\r"}

#execute the required commands; following demonstration uses echo command
expect "$ " {send "echo The falcon has landed\r"}
expect "$ " {send "echo The falcons have landed\r"}
expect "$ " {send "echo Will the BFR? land? \r"}

#exit from the remote machine
expect "$ " {send "exit\r"}

run it as expect foo.expect

You need expect application to run this script. It can be installed with the command apt-get install expect

This book will help you explore expect script. Happy scripting!

Independant file descriptor for one or more SSH connections

I addition to ControlPath and ControlPersist correct way, proposed by muru's answer, I would like to present an alternative:

Method

1. Create a fifo you will use for ssh's outputs

   You have to create this file in a path you are confident

   mkfifo $HOME/sshfifo
   

2. Run long-running command:

   exec 8> >(exec ssh user@host /bin/bash >$HOME/sshfifo
   exec 9<$HOME/sshfifo
   

3. Then now you don't need anymore the fifo

   rm $HOME/sshfifo
   

4. You are now ready to send and recieve commands from your connection:

   echo >&8 uptime
   while read -t .002 -r -u 9 answer;do echo "$answer";done
   

   Nota: 0.002 seconds may be insufficient on poor internet connections... Timeout could be useless depending on type of requests. At all this could be adapted to which kind of dialog is attented.

   And so on...

   myremote() {
       echo "$@" >&8
       while IFS= read -t .02 -r -u 9 answer;do
            echo "$answer"
       done
   }
   

5. This will stay until you explicitely close this connection:

   exec 8>&-
   exec 9<&-
   

Further

This is not perfect. You could

• Bind STDERR too, with a second fifo

  mkfifo $HOME/sshfifo{out,err}
  exec 8> >(exec ssh user@host /bin/bash >$HOME/sshfifoout 2>$HOME/sshfifoerr)
  exec 9<$HOME/sshfifoout
  exec 10<$HOME/sshfifoerr
  rm $HOME/sshfifo{out,err}
  

• Use interactive bash, then reduce timeout

  mkfifo $HOME/sshfifo{out,err}
  exec 8> >(exec ssh -tT user@host /bin/bash -i >$HOME/sshfifoout 2>$HOME/sshfifoerr)
  exec 9<$HOME/sshfifoout
  exec 10<$HOME/sshfifoerr
  rm $HOME/sshfifo{out,err}
  echo >&8 'set -i;PS1="ReAdY aS BoUnD\\n"'
  while IFS= read -d '' -rn 1 -t .02 -u 9 foo;do echo -n "$foo";done
  while IFS= read -d '' -rn 1 -t .02 -u 10 foo;do echo -n "$foo";done
  

  ... then watching for /^ReAdY aS BoUnD$/ from fd/10 as marker for end of execution of last command, you could avoid timout for STDERR (-u 10), then reduce timemout for STDOUT (-u 9 -t .002).

And from there

It is even possible to open multiple connection to be used together

mkfifo $HOME/sshfifo
exec 8> >(exec ssh user1@hostA /bin/bash >$HOME/sshfifo 2>&1)
exec 9<$HOME/sshfifo
rm $HOME/sshfifo

mkfifo $HOME/sshfifo
exec 11> >(exec ssh user2@hostB /bin/bash >$HOME/sshfifo 2>&1)
exec 12<$HOME/sshfifo
rm $HOME/sshfifo

Then

tee <<<uptime /dev/fd/8 >&11
read -u  9 -t .02 ansA
read -u 12 -t .02 ansB

to send same command simultaneously to both ends...

You can use cat to concatenate all the files and then pipe them to ssh.

cat command1 command2 command3 | ssh root@host 'bash -s'