subprocess.h | 🐜 single header process launching solution for C and C++

You are overquoting. The quotes in -SomeArgField="Some Value with Spaces" are only needed to prevent the shell from splitting the argument by whitespace, passing its content as separate arguments to the subprocess. Since you're using create_subrocess_exec which doesn't go through a shell, you don't have that problem to begin with and don't need to quote at all:

Yes, I can reproduce this problem in C++.

You can use CreateFile to get the output handle of the console，and then use the handle as a parameter when calling the windows console apis .

The CreateFile function enables a process to get a handle to its console's input buffer and active screen buffer, even if STDIN and STDOUT have been redirected. To open a handle to a console's input buffer, specify the CONIN$ value in a call to CreateFile. Specify the CONOUT$ value in a call to CreateFile to open a handle to a console's active screen buffer. CreateFile enables you to specify the read/write access of the handle that it returns.

Refer: Console Handles

In C++ it looks like this,

An unprivileged user needs access to functionality only available by a privileged user in a secure manner.

Create an server-client interface where functionality is decoupled from the actual system as to prevent security issues (ie: don't just pipe commands or options directly from client for execution by the server).

Consider using gRPC for this server-client interface. If you haven't used gRPC before, here's an example of what this entails:

Create a temperature.proto:

The only issue is, I don't know how to run this in the background without polluting my entire codebase with async.

It's not entirely clear from this sentence what the actual constraint is, i.e. how far you are willing to go with async code. Normally a program that uses asyncio is assumed to run inside an asyncio event loop, and then the whole program is async, i.e. uses callbacks and/or coroutines. However, if you have a large code base using blocking code and threads, you can also introduce asyncio in a separate thread. For example:

Repeated quotation marks are the problem: when specifying the command as a list, arguments should be f'{srcdir}' etc. rather than f'"{srcdir}"', otherwise Robocopy is receiving "c:\path\to\file" (with the quotes) which perhaps it doesn't know to strip away.
When the command is passed as a string, the quotation marks are evaluated and stripped away by the shell.

Something like

Try using subprocess.check_output instead of os.system, see Running shell command and capturing the output for an example.

Is there something akin to select() call?

The answer to this must be yes, as asyncio is wholly built around a call to select(). However it's not always obvious how to translate that to a select on the level of streams. The thing to notice is that you shouldn't try to select the stream exactly - instead, start reading on the stream and rely on the ability to select the progress of the coroutines. The equivalent of select() would thus be to use asyncio.wait(return_when=FIRST_COMPLETED) to drive the reads in a loop.

An even more elegant alternative is to spawn separate tasks where each does its thing, and just let them run in parallel. The code is easier to understand than with a select, boiling down to a single call to gather, and yet under the hood asyncio performs exactly the kind of select() that was requested:

This is possible using {}, such as: