That sort of middleware is a Game Engine

From your diagram, it looks like you only want to write game logic and maybe a little bit of presentation/UI, and are looking for a piece of middleware to handle the rest.

The purpose of a game engine is to allow designers to focus on writing the unique game logic of their game, and the engine takes care of the rest. Therefore, the thing that is most likely to solve your problem here is a game engine.

But game engines take control over the program flow away!

Any middleware that solves your problem here will have to take control of the program flow. You will not be able to write a program that starts with int main(void) and which uses networks unless you write your own netcode.

The reason for this is that netcode for a MUD imposes a bunch of requirements on the program's flow, and adhering to those requirements is exactly what makes netcode hard.

Net-code is always multi-threaded

A MUD server needs to be able to receive new log-in requests at any time, and maintain the state of each connection. It also needs to receive input from already connected players, and actively maintain the connections with players who are not currently sending input (to detect when they get disconnected ungracefully).

Every implementation of this that I've seen or worked on has used threads. One thread listens for new connections, each already active connection gets a thread, and the game logic runs on yet another thread.

Net-code is a mess of tricky edge cases, all different

A lot of things can happen when you try to receive data on a socket. Maybe you get the data you expected. Maybe you get data you didn't expect (like a hacker testing your defenses by sending malformed packets). Maybe you don't get data at all because the connection is gone. If you write your own netcode, you have to decide how to handle each of these cases. If you use an engine, you'll have out-of-the-box solutions that just work, based on industry standard practices.

You will probably need to persist character/account data

Your players will probably disconnect and reconnect. Sometimes this will be for network-related reasons, but quite often because humans need to sleep. Handling accounts and authentication yourself will take a lot longer than you think it will.

Are there engines that don't restrict my game logic?

Yes, lots. At a quick search, I found TinyMud-Server which seems pretty close to what you're looking for - but it's a complete program that you add your code to, not just a piece of middleware that you can link with.

If that doesn't meet your needs, there's dozens of other engines out there. A google search for mud server engine c++ will turn up a few hits.

What if I really do want to write my own?

If you're really looking to write your own server, I'd recommend the following:

• Allocate enough time to learn. Going from "what is a socket?" to "writing a MUD from scratch" will take more than a week, and probably more than a couple months. (It took me two years, but I wrote a couple of other games in between.)
• Write a TCP echo server. Follow a tutorial for creating a simple one-connection-at-a-time TCP echo server and client. There's lots of such tutorials out there: search for "TCP echo server tutorial C++" to get started.
• Expand that server to multiple connections. Once you've created a one-connection-at-a-time server, the next step is to handle multiple clients. listen on one thread, receive on one thread per client, and whenever a message comes in, post it to a queue where another thread will see it and send it back to each client.
• Turn it into a chat server with accounts and sign-in. Add a sign-in process to your initial connection and prepend each message that gets re-sent with the account name.
• Convert the send thread into your game logic. Once you have the above all finished, it should be straightforward to turn it into a MUD by replacing the main "send message" thread.