ominfra 0.0.0.dev147__py3-none-any.whl → 0.0.0.dev148__py3-none-any.whl

ominfra/scripts/manage.py

@@ -3,16 +3,20 @@
 # @omlish-lite
 # @omlish-script
 # @omlish-amalg-output ../manage/main.py
-# ruff: noqa: N802 UP006 UP007 UP036
+# ruff: noqa: N802 TC003 UP006 UP007 UP036
 """
 manage.py -s 'docker run -i python:3.12'
 manage.py -s 'ssh -i /foo/bar.pem foo@bar.baz' -q --python=python3.8
 """
 import abc
+import asyncio
+import asyncio.base_subprocess
+import asyncio.subprocess
 import base64
 import collections
 import collections.abc
 import contextlib
+import ctypes as ct
 import dataclasses as dc
 import datetime
 import decimal
@@ -30,6 +34,7 @@ import pwd
 import re
 import shlex
 import shutil
+import signal
 import site
 import struct
 import subprocess
@@ -62,6 +67,9 @@ VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalTy
 VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # noqa
 VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
 
+# ../../omlish/lite/asyncio/asyncio.py
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
 # ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -822,10 +830,8 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
         with open(os.environ.pop(_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR)) as sf:
             main_src = sf.read()
 
-    # Restore original argv0
+    # Restore vars
     sys.executable = os.environ.pop(_PYREMOTE_BOOTSTRAP_ARGV0_VAR)
-
-    # Grab context name
     context_name = os.environ.pop(_PYREMOTE_BOOTSTRAP_CONTEXT_NAME_VAR)
 
     # Write third ack
@@ -1000,12 +1006,102 @@ class PyremoteBootstrapDriver:
             else:
                 raise TypeError(go)
 
+    async def async_run(
+            self,
+            input: ta.Any,  # asyncio.StreamWriter  # noqa
+            output: ta.Any,  # asyncio.StreamReader
+    ) -> Result:
+        gen = self.gen()
+
+        gi: ta.Optional[bytes] = None
+        while True:
+            try:
+                if gi is not None:
+                    go = gen.send(gi)
+                else:
+                    go = next(gen)
+            except StopIteration as e:
+                return e.value
+
+            if isinstance(go, self.Read):
+                if len(gi := await input.read(go.sz)) != go.sz:
+                    raise EOFError
+            elif isinstance(go, self.Write):
+                gi = None
+                output.write(go.d)
+                await output.drain()
+            else:
+                raise TypeError(go)
+
+
+########################################
+# ../../../omlish/lite/asyncio/asyncio.py
+
+
+##
+
+
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+
+
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
+
+    return reader
+
+
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
+
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )
+
+
+##
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut
+
 
 ########################################
 # ../../../omlish/lite/cached.py
 
 
-class _cached_nullary:  # noqa
+##
+
+
+class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
         self._fn = fn
@@ -1013,17 +1109,25 @@ class _cached_nullary:  # noqa
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
+        raise TypeError
 
     def __get__(self, instance, owner):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
 
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
 def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
+    return _CachedNullary(fn)
 
 
 def static_init(fn: CallableT) -> CallableT:
@@ -1032,6 +1136,20 @@ def static_init(fn: CallableT) -> CallableT:
     return fn
 
 
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)
+
+
 ########################################
 # ../../../omlish/lite/check.py
 
@@ -1129,6 +1247,30 @@ def check_non_empty(v: SizedT) -> SizedT:
     return v
 
 
+########################################
+# ../../../omlish/lite/deathsig.py
+
+
+LINUX_PR_SET_PDEATHSIG = 1  # Second arg is a signal
+LINUX_PR_GET_PDEATHSIG = 2  # Second arg is a ptr to return the signal
+
+
+def set_process_deathsig(sig: int) -> bool:
+    if sys.platform == 'linux':
+        libc = ct.CDLL('libc.so.6')
+
+        # int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
+        libc.prctl.restype = ct.c_int
+        libc.prctl.argtypes = [ct.c_int, ct.c_ulong, ct.c_ulong, ct.c_ulong, ct.c_ulong]
+
+        libc.prctl(LINUX_PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
+
+        return True
+
+    else:
+        return False
+
+
 ########################################
 # ../../../omlish/lite/json.py
 
@@ -1910,8 +2052,8 @@ class Command(abc.ABC, ta.Generic[CommandOutputT]):
         pass
 
     @ta.final
-    def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
-        return check_isinstance(executor.execute(self), self.Output)  # type: ignore[return-value]
+    async def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
+        return check_isinstance(await executor.execute(self), self.Output)  # type: ignore[return-value]
 
 
 ##
@@ -1972,10 +2114,10 @@ class CommandOutputOrExceptionData(CommandOutputOrException):
 
 class CommandExecutor(abc.ABC, ta.Generic[CommandT, CommandOutputT]):
     @abc.abstractmethod
-    def execute(self, cmd: CommandT) -> CommandOutputT:
+    def execute(self, cmd: CommandT) -> ta.Awaitable[CommandOutputT]:
         raise NotImplementedError
 
-    def try_execute(
+    async def try_execute(
             self,
             cmd: CommandT,
             *,
@@ -1983,7 +2125,7 @@ class CommandExecutor(abc.ABC, ta.Generic[CommandT, CommandOutputT]):
             omit_exc_object: bool = False,
     ) -> CommandOutputOrException[CommandOutputT]:
         try:
-            o = self.execute(cmd)
+            o = await self.execute(cmd)
 
         except Exception as e:  # noqa
             if log is not None:
@@ -2054,8 +2196,18 @@ def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
 class RemoteConfig:
     payload_file: ta.Optional[str] = None
 
+    set_pgid: bool = True
+
+    deathsig: ta.Optional[str] = 'KILL'
+
     pycharm_remote_debug: ta.Optional[PycharmRemoteDebug] = None
 
+    forward_logging: bool = True
+
+    timebomb_delay_s: ta.Optional[float] = 60 * 60.
+
+    heartbeat_interval_s: float = 3.
+
 
 ########################################
 # ../remote/payload.py
@@ -3788,6 +3940,8 @@ class InterpSpecifier:
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
             s = '~=' + s
+            if s.count('.') < 2:
+                s += '.0'
         return cls(
             specifier=Specifier(s),
             opts=o,
@@ -3834,9 +3988,9 @@ class LocalCommandExecutor(CommandExecutor):
 
         self._command_executors = command_executors
 
-    def execute(self, cmd: Command) -> Command.Output:
+    async def execute(self, cmd: Command) -> Command.Output:
         ce: CommandExecutor = self._command_executors[type(cmd)]
-        return ce.execute(cmd)
+        return await ce.execute(cmd)
 
 
 ########################################
@@ -3882,7 +4036,7 @@ class DeployCommand(Command['DeployCommand.Output']):
 
 
 class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
+    async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
         log.info('Deploying!')
 
         return DeployCommand.Output()
@@ -3904,11 +4058,30 @@ ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMar
 # ../remote/channel.py
 
 
-class RemoteChannel:
+##
+
+
+class RemoteChannel(abc.ABC):
+    @abc.abstractmethod
+    def send_obj(self, o: ta.Any, ty: ta.Any = None) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def recv_obj(self, ty: ta.Type[T]) -> ta.Awaitable[ta.Optional[T]]:
+        raise NotImplementedError
+
+    def set_marshaler(self, msh: ObjMarshalerManager) -> None:  # noqa
+        pass
+
+
+##
+
+
+class RemoteChannelImpl(RemoteChannel):
     def __init__(
             self,
-            input: ta.IO,  # noqa
-            output: ta.IO,
+            input: asyncio.StreamReader,  # noqa
+            output: asyncio.StreamWriter,
             *,
             msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
     ) -> None:
@@ -3918,41 +4091,46 @@ class RemoteChannel:
         self._output = output
         self._msh = msh
 
-        self._lock = threading.RLock()
+        self._input_lock = asyncio.Lock()
+        self._output_lock = asyncio.Lock()
 
     def set_marshaler(self, msh: ObjMarshalerManager) -> None:
         self._msh = msh
 
-    def _send_obj(self, o: ta.Any, ty: ta.Any = None) -> None:
+    #
+
+    async def _send_obj(self, o: ta.Any, ty: ta.Any = None) -> None:
         j = json_dumps_compact(self._msh.marshal_obj(o, ty))
         d = j.encode('utf-8')
 
         self._output.write(struct.pack('<I', len(d)))
         self._output.write(d)
-        self._output.flush()
+        await self._output.drain()
 
-    def send_obj(self, o: ta.Any, ty: ta.Any = None) -> None:
-        with self._lock:
-            return self._send_obj(o, ty)
+    async def send_obj(self, o: ta.Any, ty: ta.Any = None) -> None:
+        async with self._output_lock:
+            return await self._send_obj(o, ty)
+
+    #
 
-    def _recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
-        d = self._input.read(4)
+    async def _recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
+        d = await self._input.read(4)
         if not d:
             return None
         if len(d) != 4:
             raise EOFError
 
         sz = struct.unpack('<I', d)[0]
-        d = self._input.read(sz)
+        d = await self._input.read(sz)
         if len(d) != sz:
             raise EOFError
 
         j = json.loads(d.decode('utf-8'))
         return self._msh.unmarshal_obj(j, ty)
 
-    def recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
-        with self._lock:
-            return self._recv_obj(ty)
+    async def recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
+        async with self._input_lock:
+            return await self._recv_obj(ty)
 
 
 ########################################
@@ -3986,7 +4164,7 @@ def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
         return args
 
 
-def _prepare_subprocess_invocation(
+def prepare_subprocess_invocation(
         *args: str,
         env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
         extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
@@ -3994,9 +4172,9 @@ def _prepare_subprocess_invocation(
         shell: bool = False,
         **kwargs: ta.Any,
 ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug(args)
+    log.debug('prepare_subprocess_invocation: args=%r', args)
     if extra_env:
-        log.debug(extra_env)
+        log.debug('prepare_subprocess_invocation: extra_env=%r', extra_env)
 
     if extra_env:
         env = {**(env if env is not None else os.environ), **extra_env}
@@ -4015,14 +4193,46 @@ def _prepare_subprocess_invocation(
     )
 
 
-def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
-    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    return subprocess.check_call(args, **kwargs)  # type: ignore
+##
+
+
+@contextlib.contextmanager
+def subprocess_common_context(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+    start_time = time.time()
+    try:
+        log.debug('subprocess_common_context.try: args=%r', args)
+        yield
+
+    except Exception as exc:  # noqa
+        log.debug('subprocess_common_context.except: exc=%r', exc)
+        raise
+
+    finally:
+        end_time = time.time()
+        elapsed_s = end_time - start_time
+        log.debug('subprocess_common_context.finally: elapsed_s=%f args=%r', elapsed_s, args)
+
+
+##
+
+
+def subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        **kwargs: ta.Any,
+) -> None:
+    args, kwargs = prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_call(args, **kwargs)  # type: ignore
 
 
-def subprocess_check_output(*args: str, **kwargs: ta.Any) -> bytes:
-    args, kwargs = _prepare_subprocess_invocation(*args, **kwargs)
-    return subprocess.check_output(args, **kwargs)
+def subprocess_check_output(
+        *args: str,
+        **kwargs: ta.Any,
+) -> bytes:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_output(args, **kwargs)
 
 
 def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
@@ -4038,16 +4248,31 @@ DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
 )
 
 
-def subprocess_try_call(
-        *args: str,
+def _subprocess_try_run(
+        fn: ta.Callable[..., T],
+        *args: ta.Any,
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
-) -> bool:
+) -> ta.Union[T, Exception]:
     try:
-        subprocess_check_call(*args, **kwargs)
+        return fn(*args, **kwargs)
     except try_exceptions as e:  # noqa
         if log.isEnabledFor(logging.DEBUG):
             log.exception('command failed')
+        return e
+
+
+def subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(_subprocess_try_run(
+            subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return False
     else:
         return True
@@ -4058,12 +4283,15 @@ def subprocess_try_output(
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
 ) -> ta.Optional[bytes]:
-    try:
-        return subprocess_check_output(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
+    if isinstance(ret := _subprocess_try_run(
+            subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return None
+    else:
+        return ret
 
 
 def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
@@ -4090,175 +4318,922 @@ def subprocess_close(
 
 
 ########################################
-# ../../../omdev/interp/inspect.py
+# ../remote/execution.py
 
 
-@dc.dataclass(frozen=True)
-class InterpInspection:
-    exe: str
-    version: Version
+##
 
-    version_str: str
-    config_vars: ta.Mapping[str, str]
-    prefix: str
-    base_prefix: str
 
-    @property
-    def opts(self) -> InterpOpts:
-        return InterpOpts(
-            threaded=bool(self.config_vars.get('Py_GIL_DISABLED')),
-            debug=bool(self.config_vars.get('Py_DEBUG')),
-        )
+class _RemoteProtocol:
+    class Message(abc.ABC):  # noqa
+        async def send(self, chan: RemoteChannel) -> None:
+            await chan.send_obj(self, _RemoteProtocol.Message)
 
-    @property
-    def iv(self) -> InterpVersion:
-        return InterpVersion(
-            version=self.version,
-            opts=self.opts,
-        )
+        @classmethod
+        async def recv(cls: ta.Type[T], chan: RemoteChannel) -> ta.Optional[T]:
+            return await chan.recv_obj(cls)
 
-    @property
-    def is_venv(self) -> bool:
-        return self.prefix != self.base_prefix
+    #
 
+    class Request(Message, abc.ABC):  # noqa
+        pass
 
-class InterpInspector:
+    @dc.dataclass(frozen=True)
+    class CommandRequest(Request):
+        seq: int
+        cmd: Command
 
-    def __init__(self) -> None:
-        super().__init__()
+    @dc.dataclass(frozen=True)
+    class PingRequest(Request):
+        time: float
 
-        self._cache: ta.Dict[str, ta.Optional[InterpInspection]] = {}
+    #
 
-    _RAW_INSPECTION_CODE = """
-    __import__('json').dumps(dict(
-        version_str=__import__('sys').version,
-        prefix=__import__('sys').prefix,
-        base_prefix=__import__('sys').base_prefix,
-        config_vars=__import__('sysconfig').get_config_vars(),
-    ))"""
+    class Response(Message, abc.ABC):  # noqa
+        pass
 
-    _INSPECTION_CODE = ''.join(l.strip() for l in _RAW_INSPECTION_CODE.splitlines())
+    @dc.dataclass(frozen=True)
+    class LogResponse(Response):
+        s: str
 
-    @staticmethod
-    def _build_inspection(
-            exe: str,
-            output: str,
-    ) -> InterpInspection:
-        dct = json.loads(output)
+    @dc.dataclass(frozen=True)
+    class CommandResponse(Response):
+        seq: int
+        res: CommandOutputOrExceptionData
 
-        version = Version(dct['version_str'].split()[0])
+    @dc.dataclass(frozen=True)
+    class PingResponse(Response):
+        time: float
 
-        return InterpInspection(
-            exe=exe,
-            version=version,
-            **{k: dct[k] for k in (
-                'version_str',
-                'prefix',
-                'base_prefix',
-                'config_vars',
-            )},
-        )
 
-    @classmethod
-    def running(cls) -> 'InterpInspection':
-        return cls._build_inspection(sys.executable, eval(cls._INSPECTION_CODE))  # noqa
+##
 
-    def _inspect(self, exe: str) -> InterpInspection:
-        output = subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
-        return self._build_inspection(exe, output.decode())
 
-    def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
-        try:
-            return self._cache[exe]
-        except KeyError:
-            ret: ta.Optional[InterpInspection]
-            try:
-                ret = self._inspect(exe)
-            except Exception as e:  # noqa
-                if log.isEnabledFor(logging.DEBUG):
-                    log.exception('Failed to inspect interp: %s', exe)
-                ret = None
-            self._cache[exe] = ret
-            return ret
+class _RemoteLogHandler(logging.Handler):
+    def __init__(
+            self,
+            chan: RemoteChannel,
+            loop: ta.Any = None,
+    ) -> None:
+        super().__init__()
 
+        self._chan = chan
+        self._loop = loop
 
-INTERP_INSPECTOR = InterpInspector()
+    def emit(self, record):
+        msg = self.format(record)
 
+        async def inner():
+            await _RemoteProtocol.LogResponse(msg).send(self._chan)
 
-########################################
-# ../commands/subprocess.py
+        loop = self._loop
+        if loop is None:
+            loop = asyncio.get_running_loop()
+        if loop is not None:
+            asyncio.run_coroutine_threadsafe(inner(), loop)
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class SubprocessCommand(Command['SubprocessCommand.Output']):
-    cmd: ta.Sequence[str]
+class _RemoteCommandHandler:
+    def __init__(
+            self,
+            chan: RemoteChannel,
+            executor: CommandExecutor,
+            *,
+            stop: ta.Optional[asyncio.Event] = None,
+    ) -> None:
+        super().__init__()
 
-    shell: bool = False
-    cwd: ta.Optional[str] = None
-    env: ta.Optional[ta.Mapping[str, str]] = None
+        self._chan = chan
+        self._executor = executor
+        self._stop = stop if stop is not None else asyncio.Event()
 
-    stdout: str = 'pipe'  # SubprocessChannelOption
-    stderr: str = 'pipe'  # SubprocessChannelOption
+        self._cmds_by_seq: ta.Dict[int, _RemoteCommandHandler._Command] = {}
 
-    input: ta.Optional[bytes] = None
-    timeout: ta.Optional[float] = None
+    @dc.dataclass(frozen=True)
+    class _Command:
+        req: _RemoteProtocol.CommandRequest
+        fut: asyncio.Future
+
+    async def run(self) -> None:
+        stop_task = asyncio.create_task(self._stop.wait())
+        recv_task: ta.Optional[asyncio.Task] = None
+
+        while not self._stop.is_set():
+            if recv_task is None:
+                recv_task = asyncio.create_task(_RemoteProtocol.Request.recv(self._chan))
+
+            done, pending = await asyncio.wait([
+                stop_task,
+                recv_task,
+            ], return_when=asyncio.FIRST_COMPLETED)
+
+            if recv_task in done:
+                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                    recv_task.result(),
+                    (_RemoteProtocol.Message, type(None)),
+                )
+                recv_task = None
+
+                if msg is None:
+                    break
+
+                await self._handle_message(msg)
+
+    async def _handle_message(self, msg: _RemoteProtocol.Message) -> None:
+        if isinstance(msg, _RemoteProtocol.PingRequest):
+            log.debug('Ping: %r', msg)
+            await _RemoteProtocol.PingResponse(
+                time=msg.time,
+            ).send(self._chan)
+
+        elif isinstance(msg, _RemoteProtocol.CommandRequest):
+            fut = asyncio.create_task(self._handle_command_request(msg))
+            self._cmds_by_seq[msg.seq] = _RemoteCommandHandler._Command(
+                req=msg,
+                fut=fut,
+            )
+
+        else:
+            raise TypeError(msg)
+
+    async def _handle_command_request(self, req: _RemoteProtocol.CommandRequest) -> None:
+        res = await self._executor.try_execute(
+            req.cmd,
+            log=log,
+            omit_exc_object=True,
+        )
+
+        await _RemoteProtocol.CommandResponse(
+            seq=req.seq,
+            res=CommandOutputOrExceptionData(
+                output=res.output,
+                exception=res.exception,
+            ),
+        ).send(self._chan)
+
+        self._cmds_by_seq.pop(req.seq)  # noqa
+
+
+##
+
+
+@dc.dataclass()
+class RemoteCommandError(Exception):
+    e: CommandException
+
+
+class RemoteCommandExecutor(CommandExecutor):
+    def __init__(self, chan: RemoteChannel) -> None:
+        super().__init__()
+
+        self._chan = chan
+
+        self._cmd_seq = itertools.count()
+        self._queue: asyncio.Queue = asyncio.Queue()  # asyncio.Queue[RemoteCommandExecutor._Request]
+        self._stop = asyncio.Event()
+        self._loop_task: ta.Optional[asyncio.Task] = None
+        self._reqs_by_seq: ta.Dict[int, RemoteCommandExecutor._Request] = {}
+
+    #
+
+    async def start(self) -> None:
+        check_none(self._loop_task)
+        check_state(not self._stop.is_set())
+        self._loop_task = asyncio.create_task(self._loop())
+
+    async def aclose(self) -> None:
+        self._stop.set()
+        if self._loop_task is not None:
+            await self._loop_task
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class _Request:
+        seq: int
+        cmd: Command
+        fut: asyncio.Future
+
+    async def _loop(self) -> None:
+        log.debug('RemoteCommandExecutor loop start: %r', self)
+
+        stop_task = asyncio.create_task(self._stop.wait())
+        queue_task: ta.Optional[asyncio.Task] = None
+        recv_task: ta.Optional[asyncio.Task] = None
+
+        while not self._stop.is_set():
+            if queue_task is None:
+                queue_task = asyncio.create_task(self._queue.get())
+            if recv_task is None:
+                recv_task = asyncio.create_task(_RemoteProtocol.Message.recv(self._chan))
+
+            done, pending = await asyncio.wait([
+                stop_task,
+                queue_task,
+                recv_task,
+            ], return_when=asyncio.FIRST_COMPLETED)
+
+            if queue_task in done:
+                req = check_isinstance(queue_task.result(), RemoteCommandExecutor._Request)
+                queue_task = None
+                await self._handle_request(req)
+
+            if recv_task in done:
+                msg: ta.Optional[_RemoteProtocol.Message] = check_isinstance(
+                    recv_task.result(),
+                    (_RemoteProtocol.Message, type(None)),
+                )
+                recv_task = None
+
+                if msg is None:
+                    log.debug('RemoteCommandExecutor got eof: %r', self)
+                    break
+
+                await self._handle_message(msg)
+
+        log.debug('RemoteCommandExecutor loop stopping: %r', self)
+
+        for task in [
+            stop_task,
+            queue_task,
+            recv_task,
+        ]:
+            if task is not None and not task.done():
+                task.cancel()
+
+        for req in self._reqs_by_seq.values():
+            req.fut.cancel()
+
+        log.debug('RemoteCommandExecutor loop exited: %r', self)
+
+    async def _handle_request(self, req: _Request) -> None:
+        self._reqs_by_seq[req.seq] = req
+        await _RemoteProtocol.CommandRequest(
+            seq=req.seq,
+            cmd=req.cmd,
+        ).send(self._chan)
+
+    async def _handle_message(self, msg: _RemoteProtocol.Message) -> None:
+        if isinstance(msg, _RemoteProtocol.PingRequest):
+            log.debug('Ping: %r', msg)
+            await _RemoteProtocol.PingResponse(
+                time=msg.time,
+            ).send(self._chan)
+
+        elif isinstance(msg, _RemoteProtocol.LogResponse):
+            log.info(msg.s)
+
+        elif isinstance(msg, _RemoteProtocol.CommandResponse):
+            req = self._reqs_by_seq.pop(msg.seq)
+            req.fut.set_result(msg.res)
+
+        else:
+            raise TypeError(msg)
+
+    #
+
+    async def _remote_execute(self, cmd: Command) -> CommandOutputOrException:
+        req = RemoteCommandExecutor._Request(
+            seq=next(self._cmd_seq),
+            cmd=cmd,
+            fut=asyncio.Future(),
+        )
+        await self._queue.put(req)
+        return await req.fut
+
+    # @ta.override
+    async def execute(self, cmd: Command) -> Command.Output:
+        r = await self._remote_execute(cmd)
+        if (e := r.exception) is not None:
+            raise RemoteCommandError(e)
+        else:
+            return check_not_none(r.output)
+
+    # @ta.override
+    async def try_execute(
+            self,
+            cmd: Command,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            omit_exc_object: bool = False,
+    ) -> CommandOutputOrException:
+        try:
+            r = await self._remote_execute(cmd)
+
+        except Exception as e:  # noqa
+            if log is not None:
+                log.exception('Exception executing remote command: %r', type(cmd))
+
+            return CommandOutputOrExceptionData(exception=CommandException.of(
+                e,
+                omit_exc_object=omit_exc_object,
+                cmd=cmd,
+            ))
+
+        else:
+            return r
+
+
+########################################
+# ../../../omlish/lite/asyncio/subprocesses.py
+
+
+##
+
+
+@contextlib.asynccontextmanager
+async def asyncio_subprocess_popen(
+        *cmd: str,
+        shell: bool = False,
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
+    fac: ta.Any
+    if shell:
+        fac = functools.partial(
+            asyncio.create_subprocess_shell,
+            check_single(cmd),
+        )
+    else:
+        fac = functools.partial(
+            asyncio.create_subprocess_exec,
+            *cmd,
+        )
+
+    with subprocess_common_context(
+            *cmd,
+            shell=shell,
+            timeout=timeout,
+            **kwargs,
+    ):
+        proc: asyncio.subprocess.Process
+        proc = await fac(**kwargs)
+        try:
+            yield proc
+
+        finally:
+            await asyncio_maybe_timeout(proc.wait(), timeout)
+
+
+##
+
+
+class AsyncioProcessCommunicator:
+    def __init__(
+            self,
+            proc: asyncio.subprocess.Process,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        super().__init__()
+
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        self._proc = proc
+        self._loop = loop
+
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+            proc._transport,  # type: ignore  # noqa
+            asyncio.base_subprocess.BaseSubprocessTransport,
+        )
+
+    @property
+    def _debug(self) -> bool:
+        return self._loop.get_debug()
+
+    async def _feed_stdin(self, input: bytes) -> None:  # noqa
+        stdin = check_not_none(self._proc.stdin)
+        try:
+            if input is not None:
+                stdin.write(input)
+                if self._debug:
+                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+
+            await stdin.drain()
+
+        except (BrokenPipeError, ConnectionResetError) as exc:
+            # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
+            # exceptions.
+            if self._debug:
+                log.debug('%r communicate: stdin got %r', self, exc)
+
+        if self._debug:
+            log.debug('%r communicate: close stdin', self)
+
+        stdin.close()
+
+    async def _noop(self) -> None:
+        return None
+
+    async def _read_stream(self, fd: int) -> bytes:
+        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+
+        if fd == 2:
+            stream = check_not_none(self._proc.stderr)
+        else:
+            check_equal(fd, 1)
+            stream = check_not_none(self._proc.stdout)
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: read %s', self, name)
+
+        output = await stream.read()
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: close %s', self, name)
+
+        transport.close()
+
+        return output
+
+    class Communication(ta.NamedTuple):
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
+
+    async def _communicate(
+            self,
+            input: ta.Any = None,  # noqa
+    ) -> Communication:
+        stdin_fut: ta.Any
+        if self._proc.stdin is not None:
+            stdin_fut = self._feed_stdin(input)
+        else:
+            stdin_fut = self._noop()
+
+        stdout_fut: ta.Any
+        if self._proc.stdout is not None:
+            stdout_fut = self._read_stream(1)
+        else:
+            stdout_fut = self._noop()
+
+        stderr_fut: ta.Any
+        if self._proc.stderr is not None:
+            stderr_fut = self._read_stream(2)
+        else:
+            stderr_fut = self._noop()
+
+        stdin_res, stdout_res, stderr_res = await asyncio.gather(stdin_fut, stdout_fut, stderr_fut)
+
+        await self._proc.wait()
+
+        return AsyncioProcessCommunicator.Communication(stdout_res, stderr_res)
+
+    async def communicate(
+            self,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> Communication:
+        return await asyncio_maybe_timeout(self._communicate(input), timeout)
+
+
+async def asyncio_subprocess_communicate(
+        proc: asyncio.subprocess.Process,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
+
+
+##
+
+
+async def _asyncio_subprocess_check_run(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+
+    proc: asyncio.subprocess.Process
+    async with asyncio_subprocess_popen(*args, **kwargs) as proc:
+        stdout, stderr = await asyncio_subprocess_communicate(proc, input, timeout)
+
+    if proc.returncode:
+        raise subprocess.CalledProcessError(
+            proc.returncode,
+            args,
+            output=stdout,
+            stderr=stderr,
+        )
+
+    return stdout, stderr
+
+
+async def asyncio_subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> None:
+    _, _ = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=stdout,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+
+async def asyncio_subprocess_check_output(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> bytes:
+    stdout, stderr = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    return check_not_none(stdout)
+
+
+async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
+    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+
+
+##
+
+
+async def _asyncio_subprocess_try_run(
+        fn: ta.Callable[..., ta.Awaitable[T]],
+        *args: ta.Any,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Union[T, Exception]:
+    try:
+        return await fn(*args, **kwargs)
+    except try_exceptions as e:  # noqa
+        if log.isEnabledFor(logging.DEBUG):
+            log.exception('command failed')
+        return e
+
+
+async def asyncio_subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return False
+    else:
+        return True
+
+
+async def asyncio_subprocess_try_output(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Optional[bytes]:
+    if isinstance(ret := await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return None
+    else:
+        return ret
+
+
+async def asyncio_subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
+    out = await asyncio_subprocess_try_output(*args, **kwargs)
+    return out.decode().strip() if out is not None else None
+
+
+########################################
+# ../../../omdev/interp/inspect.py
+
+
+@dc.dataclass(frozen=True)
+class InterpInspection:
+    exe: str
+    version: Version
+
+    version_str: str
+    config_vars: ta.Mapping[str, str]
+    prefix: str
+    base_prefix: str
+
+    @property
+    def opts(self) -> InterpOpts:
+        return InterpOpts(
+            threaded=bool(self.config_vars.get('Py_GIL_DISABLED')),
+            debug=bool(self.config_vars.get('Py_DEBUG')),
+        )
+
+    @property
+    def iv(self) -> InterpVersion:
+        return InterpVersion(
+            version=self.version,
+            opts=self.opts,
+        )
+
+    @property
+    def is_venv(self) -> bool:
+        return self.prefix != self.base_prefix
+
+
+class InterpInspector:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._cache: ta.Dict[str, ta.Optional[InterpInspection]] = {}
+
+    _RAW_INSPECTION_CODE = """
+    __import__('json').dumps(dict(
+        version_str=__import__('sys').version,
+        prefix=__import__('sys').prefix,
+        base_prefix=__import__('sys').base_prefix,
+        config_vars=__import__('sysconfig').get_config_vars(),
+    ))"""
+
+    _INSPECTION_CODE = ''.join(l.strip() for l in _RAW_INSPECTION_CODE.splitlines())
+
+    @staticmethod
+    def _build_inspection(
+            exe: str,
+            output: str,
+    ) -> InterpInspection:
+        dct = json.loads(output)
+
+        version = Version(dct['version_str'].split()[0])
+
+        return InterpInspection(
+            exe=exe,
+            version=version,
+            **{k: dct[k] for k in (
+                'version_str',
+                'prefix',
+                'base_prefix',
+                'config_vars',
+            )},
+        )
+
+    @classmethod
+    def running(cls) -> 'InterpInspection':
+        return cls._build_inspection(sys.executable, eval(cls._INSPECTION_CODE))  # noqa
+
+    async def _inspect(self, exe: str) -> InterpInspection:
+        output = await asyncio_subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
+        return self._build_inspection(exe, output.decode())
+
+    async def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
+        try:
+            return self._cache[exe]
+        except KeyError:
+            ret: ta.Optional[InterpInspection]
+            try:
+                ret = await self._inspect(exe)
+            except Exception as e:  # noqa
+                if log.isEnabledFor(logging.DEBUG):
+                    log.exception('Failed to inspect interp: %s', exe)
+                ret = None
+            self._cache[exe] = ret
+            return ret
+
+
+INTERP_INSPECTOR = InterpInspector()
+
+
+########################################
+# ../commands/subprocess.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SubprocessCommand(Command['SubprocessCommand.Output']):
+    cmd: ta.Sequence[str]
+
+    shell: bool = False
+    cwd: ta.Optional[str] = None
+    env: ta.Optional[ta.Mapping[str, str]] = None
+
+    stdout: str = 'pipe'  # SubprocessChannelOption
+    stderr: str = 'pipe'  # SubprocessChannelOption
+
+    input: ta.Optional[bytes] = None
+    timeout: ta.Optional[float] = None
 
     def __post_init__(self) -> None:
         check_not_isinstance(self.cmd, str)
 
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        rc: int
-        pid: int
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        rc: int
+        pid: int
+
+        elapsed_s: float
+
+        stdout: ta.Optional[bytes] = None
+        stderr: ta.Optional[bytes] = None
+
+
+##
+
+
+class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCommand.Output]):
+    async def execute(self, cmd: SubprocessCommand) -> SubprocessCommand.Output:
+        proc: asyncio.subprocess.Process
+        async with asyncio_subprocess_popen(
+            *subprocess_maybe_shell_wrap_exec(*cmd.cmd),
+
+            shell=cmd.shell,
+            cwd=cmd.cwd,
+            env={**os.environ, **(cmd.env or {})},
+
+            stdin=subprocess.PIPE if cmd.input is not None else None,
+            stdout=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, cmd.stdout)],
+            stderr=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, cmd.stderr)],
+
+            timeout=cmd.timeout,
+        ) as proc:
+            start_time = time.time()
+            stdout, stderr = await asyncio_subprocess_communicate(
+                proc,
+                input=cmd.input,
+                timeout=cmd.timeout,
+            )
+            end_time = time.time()
+
+        return SubprocessCommand.Output(
+            rc=check_not_none(proc.returncode),
+            pid=proc.pid,
+
+            elapsed_s=end_time - start_time,
+
+            stdout=stdout,  # noqa
+            stderr=stderr,  # noqa
+        )
+
+
+########################################
+# ../remote/_main.py
+
+
+##
+
+
+class _RemoteExecutionLogHandler(logging.Handler):
+    def __init__(self, fn: ta.Callable[[str], None]) -> None:
+        super().__init__()
+        self._fn = fn
+
+    def emit(self, record):
+        msg = self.format(record)
+        self._fn(msg)
+
+
+##
+
+
+class _RemoteExecutionMain:
+    def __init__(
+            self,
+            chan: RemoteChannel,
+    ) -> None:
+        super().__init__()
+
+        self._chan = chan
+
+        self.__bootstrap: ta.Optional[MainBootstrap] = None
+        self.__injector: ta.Optional[Injector] = None
+
+    @property
+    def _bootstrap(self) -> MainBootstrap:
+        return check_not_none(self.__bootstrap)
+
+    @property
+    def _injector(self) -> Injector:
+        return check_not_none(self.__injector)
+
+    #
+
+    def _timebomb_main(
+            self,
+            delay_s: float,
+            *,
+            sig: int = signal.SIGINT,
+            code: int = 1,
+    ) -> None:
+        time.sleep(delay_s)
+
+        if (pgid := os.getpgid(0)) == os.getpid():
+            os.killpg(pgid, sig)
+
+        os._exit(code)  # noqa
+
+    @cached_nullary
+    def _timebomb_thread(self) -> ta.Optional[threading.Thread]:
+        if (tbd := self._bootstrap.remote_config.timebomb_delay_s) is None:
+            return None
+
+        thr = threading.Thread(
+            target=functools.partial(self._timebomb_main, tbd),
+            name=f'{self.__class__.__name__}.timebomb',
+            daemon=True,
+        )
+
+        thr.start()
 
-        elapsed_s: float
+        log.debug('Started timebomb thread: %r', thr)
 
-        stdout: ta.Optional[bytes] = None
-        stderr: ta.Optional[bytes] = None
+        return thr
 
+    #
 
-##
+    @cached_nullary
+    def _log_handler(self) -> _RemoteLogHandler:
+        return _RemoteLogHandler(self._chan)
 
+    #
 
-class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCommand.Output]):
-    def execute(self, inp: SubprocessCommand) -> SubprocessCommand.Output:
-        with subprocess.Popen(
-            subprocess_maybe_shell_wrap_exec(*inp.cmd),
+    async def _setup(self) -> None:
+        check_none(self.__bootstrap)
+        check_none(self.__injector)
 
-            shell=inp.shell,
-            cwd=inp.cwd,
-            env={**os.environ, **(inp.env or {})},
+        # Bootstrap
 
-            stdin=subprocess.PIPE if inp.input is not None else None,
-            stdout=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, inp.stdout)],
-            stderr=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, inp.stderr)],
-        ) as proc:
-            start_time = time.time()
-            stdout, stderr = proc.communicate(
-                input=inp.input,
-                timeout=inp.timeout,
-            )
-            end_time = time.time()
+        self.__bootstrap = check_not_none(await self._chan.recv_obj(MainBootstrap))
 
-        return SubprocessCommand.Output(
-            rc=proc.returncode,
-            pid=proc.pid,
+        if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
+            pycharm_debug_connect(prd)
 
-            elapsed_s=end_time - start_time,
+        self.__injector = main_bootstrap(self._bootstrap)
 
-            stdout=stdout,  # noqa
-            stderr=stderr,  # noqa
+        self._chan.set_marshaler(self._injector[ObjMarshalerManager])
+
+        # Post-bootstrap
+
+        if self._bootstrap.remote_config.set_pgid:
+            if os.getpgid(0) != os.getpid():
+                log.debug('Setting pgid')
+                os.setpgid(0, 0)
+
+        if (ds := self._bootstrap.remote_config.deathsig) is not None:
+            log.debug('Setting deathsig: %s', ds)
+            set_process_deathsig(int(signal.Signals[f'SIG{ds.upper()}']))
+
+        self._timebomb_thread()
+
+        if self._bootstrap.remote_config.forward_logging:
+            log.debug('Installing log forwarder')
+            logging.root.addHandler(self._log_handler())
+
+    #
+
+    async def run(self) -> None:
+        await self._setup()
+
+        executor = self._injector[LocalCommandExecutor]
+
+        handler = _RemoteCommandHandler(self._chan, executor)
+
+        await handler.run()
+
+
+def _remote_execution_main() -> None:
+    rt = pyremote_bootstrap_finalize()  # noqa
+
+    async def inner() -> None:
+        input = await asyncio_open_stream_reader(rt.input)  # noqa
+        output = await asyncio_open_stream_writer(rt.output)
+
+        chan = RemoteChannelImpl(
+            input,
+            output,
         )
 
+        await _RemoteExecutionMain(chan).run()
+
+    asyncio.run(inner())
+
 
 ########################################
 # ../remote/spawning.py
 
 
-class RemoteSpawning:
+##
+
+
+class RemoteSpawning(abc.ABC):
     @dc.dataclass(frozen=True)
     class Target:
         shell: ta.Optional[str] = None
@@ -4269,15 +5244,35 @@ class RemoteSpawning:
 
         stderr: ta.Optional[str] = None  # SubprocessChannelOption
 
-    #
+    @dc.dataclass(frozen=True)
+    class Spawned:
+        stdin: asyncio.StreamWriter
+        stdout: asyncio.StreamReader
+        stderr: ta.Optional[asyncio.StreamReader]
+
+    @abc.abstractmethod
+    def spawn(
+            self,
+            tgt: Target,
+            src: str,
+            *,
+            timeout: ta.Optional[float] = None,
+            debug: bool = False,
+    ) -> ta.AsyncContextManager[Spawned]:
+        raise NotImplementedError
 
-    class _PreparedCmd(ta.NamedTuple):
+
+##
+
+
+class SubprocessRemoteSpawning(RemoteSpawning):
+    class _PreparedCmd(ta.NamedTuple):  # noqa
         cmd: ta.Sequence[str]
         shell: bool
 
     def _prepare_cmd(
             self,
-            tgt: Target,
+            tgt: RemoteSpawning.Target,
             src: str,
     ) -> _PreparedCmd:
         if tgt.shell is not None:
@@ -4285,44 +5280,38 @@ class RemoteSpawning:
             if tgt.shell_quote:
                 sh_src = shlex.quote(sh_src)
             sh_cmd = f'{tgt.shell} {sh_src}'
-            return RemoteSpawning._PreparedCmd(
-                cmd=[sh_cmd],
-                shell=True,
-            )
+            return SubprocessRemoteSpawning._PreparedCmd([sh_cmd], shell=True)
 
         else:
-            return RemoteSpawning._PreparedCmd(
-                cmd=[tgt.python, '-c', src],
-                shell=False,
-            )
+            return SubprocessRemoteSpawning._PreparedCmd([tgt.python, '-c', src], shell=False)
 
     #
 
-    @dc.dataclass(frozen=True)
-    class Spawned:
-        stdin: ta.IO
-        stdout: ta.IO
-        stderr: ta.Optional[ta.IO]
-
-    @contextlib.contextmanager
-    def spawn(
+    @contextlib.asynccontextmanager
+    async def spawn(
             self,
-            tgt: Target,
+            tgt: RemoteSpawning.Target,
             src: str,
             *,
             timeout: ta.Optional[float] = None,
-    ) -> ta.Generator[Spawned, None, None]:
+            debug: bool = False,
+    ) -> ta.AsyncGenerator[RemoteSpawning.Spawned, None]:
         pc = self._prepare_cmd(tgt, src)
 
-        with subprocess.Popen(
-            subprocess_maybe_shell_wrap_exec(*pc.cmd),
-            shell=pc.shell,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=(
-                SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, tgt.stderr)]
-                if tgt.stderr is not None else None
-            ),
+        cmd = pc.cmd
+        if not debug:
+            cmd = subprocess_maybe_shell_wrap_exec(*cmd)
+
+        async with asyncio_subprocess_popen(
+                *cmd,
+                shell=pc.shell,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=(
+                    SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, tgt.stderr)]
+                    if tgt.stderr is not None else None
+                ),
+                timeout=timeout,
         ) as proc:
             stdin = check_not_none(proc.stdin)
             stdout = check_not_none(proc.stdout)
@@ -4340,8 +5329,6 @@ class RemoteSpawning:
                 except BrokenPipeError:
                     pass
 
-                proc.wait(timeout)
-
 
 ########################################
 # ../../../omdev/interp/providers.py
@@ -4370,17 +5357,17 @@ class InterpProvider(abc.ABC):
             setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
 
     @abc.abstractmethod
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def get_installed_version(self, version: InterpVersion) -> Interp:
+    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
         raise NotImplementedError
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         return []
 
-    def install_version(self, version: InterpVersion) -> Interp:
+    async def install_version(self, version: InterpVersion) -> Interp:
         raise TypeError
 
 
@@ -4392,10 +5379,10 @@ class RunningInterpProvider(InterpProvider):
     def version(self) -> InterpVersion:
         return InterpInspector.running().iv
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         return [self.version()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
         if version != self.version():
             raise KeyError(version)
         return Interp(
@@ -4405,159 +5392,26 @@ class RunningInterpProvider(InterpProvider):
 
 
 ########################################
-# ../remote/execution.py
-
-
-##
-
-
-class _RemoteExecutionLogHandler(logging.Handler):
-    def __init__(self, fn: ta.Callable[[str], None]) -> None:
-        super().__init__()
-        self._fn = fn
-
-    def emit(self, record):
-        msg = self.format(record)
-        self._fn(msg)
-
-
-@dc.dataclass(frozen=True)
-class _RemoteExecutionRequest:
-    c: Command
-
-
-@dc.dataclass(frozen=True)
-class _RemoteExecutionLog:
-    s: str
-
-
-@dc.dataclass(frozen=True)
-class _RemoteExecutionResponse:
-    r: ta.Optional[CommandOutputOrExceptionData] = None
-    l: ta.Optional[_RemoteExecutionLog] = None
-
-
-def _remote_execution_main() -> None:
-    rt = pyremote_bootstrap_finalize()  # noqa
-
-    chan = RemoteChannel(
-        rt.input,
-        rt.output,
-    )
-
-    bs = check_not_none(chan.recv_obj(MainBootstrap))
-
-    if (prd := bs.remote_config.pycharm_remote_debug) is not None:
-        pycharm_debug_connect(prd)
-
-    injector = main_bootstrap(bs)
-
-    chan.set_marshaler(injector[ObjMarshalerManager])
-
-    #
-
-    log_lock = threading.RLock()
-    send_logs = False
-
-    def log_fn(s: str) -> None:
-        with log_lock:
-            if send_logs:
-                chan.send_obj(_RemoteExecutionResponse(l=_RemoteExecutionLog(s)))
-
-    log_handler = _RemoteExecutionLogHandler(log_fn)
-    logging.root.addHandler(log_handler)
-
-    #
-
-    ce = injector[LocalCommandExecutor]
-
-    while True:
-        req = chan.recv_obj(_RemoteExecutionRequest)
-        if req is None:
-            break
-
-        with log_lock:
-            send_logs = True
-
-        r = ce.try_execute(
-            req.c,
-            log=log,
-            omit_exc_object=True,
-        )
-
-        with log_lock:
-            send_logs = False
-
-        chan.send_obj(_RemoteExecutionResponse(r=CommandOutputOrExceptionData(
-            output=r.output,
-            exception=r.exception,
-        )))
+# ../remote/connection.py
 
 
 ##
 
 
-@dc.dataclass()
-class RemoteCommandError(Exception):
-    e: CommandException
-
-
-class RemoteCommandExecutor(CommandExecutor):
-    def __init__(self, chan: RemoteChannel) -> None:
-        super().__init__()
-
-        self._chan = chan
-
-    def _remote_execute(self, cmd: Command) -> CommandOutputOrException:
-        self._chan.send_obj(_RemoteExecutionRequest(cmd))
-
-        while True:
-            if (r := self._chan.recv_obj(_RemoteExecutionResponse)) is None:
-                raise EOFError
-
-            if r.l is not None:
-                log.info(r.l.s)
-
-            if r.r is not None:
-                return r.r
-
-    # @ta.override
-    def execute(self, cmd: Command) -> Command.Output:
-        r = self._remote_execute(cmd)
-        if (e := r.exception) is not None:
-            raise RemoteCommandError(e)
-        else:
-            return check_not_none(r.output)
-
-    # @ta.override
-    def try_execute(
+class RemoteExecutionConnector(abc.ABC):
+    @abc.abstractmethod
+    def connect(
             self,
-            cmd: Command,
-            *,
-            log: ta.Optional[logging.Logger] = None,
-            omit_exc_object: bool = False,
-    ) -> CommandOutputOrException:
-        try:
-            r = self._remote_execute(cmd)
-
-        except Exception as e:  # noqa
-            if log is not None:
-                log.exception('Exception executing remote command: %r', type(cmd))
-
-            return CommandOutputOrExceptionData(exception=CommandException.of(
-                e,
-                omit_exc_object=omit_exc_object,
-                cmd=cmd,
-            ))
-
-        else:
-            return r
+            tgt: RemoteSpawning.Target,
+            bs: MainBootstrap,
+    ) -> ta.AsyncContextManager[RemoteCommandExecutor]:
+        raise NotImplementedError
 
 
 ##
 
 
-class RemoteExecution:
+class PyremoteRemoteExecutionConnector(RemoteExecutionConnector):
     def __init__(
             self,
             *,
@@ -4590,38 +5444,43 @@ class RemoteExecution:
 
     #
 
-    @contextlib.contextmanager
-    def connect(
+    @contextlib.asynccontextmanager
+    async def connect(
             self,
             tgt: RemoteSpawning.Target,
             bs: MainBootstrap,
-    ) -> ta.Generator[RemoteCommandExecutor, None, None]:
+    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
         spawn_src = self._spawn_src()
         remote_src = self._remote_src()
 
-        with self._spawning.spawn(
+        async with self._spawning.spawn(
                 tgt,
                 spawn_src,
+                debug=bs.main_config.debug,
         ) as proc:
-            res = PyremoteBootstrapDriver(  # noqa
+            res = await PyremoteBootstrapDriver(  # noqa
                 remote_src,
                 PyremoteBootstrapOptions(
                     debug=bs.main_config.debug,
                 ),
-            ).run(
+            ).async_run(
                 proc.stdout,
                 proc.stdin,
             )
 
-            chan = RemoteChannel(
+            chan = RemoteChannelImpl(
                 proc.stdout,
                 proc.stdin,
                 msh=self._msh,
             )
 
-            chan.send_obj(bs)
+            await chan.send_obj(bs)
+
+            rce: RemoteCommandExecutor
+            async with contextlib.aclosing(RemoteCommandExecutor(chan)) as rce:
+                await rce.start()
 
-            yield RemoteCommandExecutor(chan)
+                yield rce
 
 
 ########################################
@@ -4643,7 +5502,6 @@ TODO:
 
 
 class Pyenv:
-
     def __init__(
             self,
             *,
@@ -4656,13 +5514,13 @@ class Pyenv:
 
         self._root_kw = root
 
-    @cached_nullary
-    def root(self) -> ta.Optional[str]:
+    @async_cached_nullary
+    async def root(self) -> ta.Optional[str]:
         if self._root_kw is not None:
             return self._root_kw
 
         if shutil.which('pyenv'):
-            return subprocess_check_output_str('pyenv', 'root')
+            return await asyncio_subprocess_check_output_str('pyenv', 'root')
 
         d = os.path.expanduser('~/.pyenv')
         if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
@@ -4670,12 +5528,12 @@ class Pyenv:
 
         return None
 
-    @cached_nullary
-    def exe(self) -> str:
-        return os.path.join(check_not_none(self.root()), 'bin', 'pyenv')
+    @async_cached_nullary
+    async def exe(self) -> str:
+        return os.path.join(check_not_none(await self.root()), 'bin', 'pyenv')
 
-    def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
-        if (root := self.root()) is None:
+    async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
+        if (root := await self.root()) is None:
             return []
         ret = []
         vp = os.path.join(root, 'versions')
@@ -4687,11 +5545,11 @@ class Pyenv:
                 ret.append((dn, ep))
         return ret
 
-    def installable_versions(self) -> ta.List[str]:
-        if self.root() is None:
+    async def installable_versions(self) -> ta.List[str]:
+        if await self.root() is None:
             return []
         ret = []
-        s = subprocess_check_output_str(self.exe(), 'install', '--list')
+        s = await asyncio_subprocess_check_output_str(await self.exe(), 'install', '--list')
         for l in s.splitlines():
             if not l.startswith('  '):
                 continue
@@ -4701,12 +5559,12 @@ class Pyenv:
             ret.append(l)
         return ret
 
-    def update(self) -> bool:
-        if (root := self.root()) is None:
+    async def update(self) -> bool:
+        if (root := await self.root()) is None:
             return False
         if not os.path.isdir(os.path.join(root, '.git')):
             return False
-        subprocess_check_call('git', 'pull', cwd=root)
+        await asyncio_subprocess_check_call('git', 'pull', cwd=root)
         return True
 
 
@@ -4767,17 +5625,16 @@ THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 
 class PyenvInstallOptsProvider(abc.ABC):
     @abc.abstractmethod
-    def opts(self) -> PyenvInstallOpts:
+    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
         raise NotImplementedError
 
 
 class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
-    def opts(self) -> PyenvInstallOpts:
+    async def opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts()
 
 
 class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
-
     @cached_nullary
     def framework_opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts(conf_opts=['--enable-framework'])
@@ -4793,12 +5650,12 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
         'zlib',
     ]
 
-    @cached_nullary
-    def brew_deps_opts(self) -> PyenvInstallOpts:
+    @async_cached_nullary
+    async def brew_deps_opts(self) -> PyenvInstallOpts:
         cflags = []
         ldflags = []
         for dep in self.BREW_DEPS:
-            dep_prefix = subprocess_check_output_str('brew', '--prefix', dep)
+            dep_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', dep)
             cflags.append(f'-I{dep_prefix}/include')
             ldflags.append(f'-L{dep_prefix}/lib')
         return PyenvInstallOpts(
@@ -4806,13 +5663,13 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
             ldflags=ldflags,
         )
 
-    @cached_nullary
-    def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
+    @async_cached_nullary
+    async def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if await asyncio_subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
             return PyenvInstallOpts()
 
-        tcl_tk_prefix = subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
-        tcl_tk_ver_str = subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
+        tcl_tk_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
+        tcl_tk_ver_str = await asyncio_subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
         tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
 
         return PyenvInstallOpts(conf_opts=[
@@ -4827,11 +5684,11 @@ class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
     #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
     #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
 
-    def opts(self) -> PyenvInstallOpts:
+    async def opts(self) -> PyenvInstallOpts:
         return PyenvInstallOpts().merge(
             self.framework_opts(),
-            self.brew_deps_opts(),
-            self.brew_tcl_opts(),
+            await self.brew_deps_opts(),
+            await self.brew_tcl_opts(),
             # self.brew_ssl_opts(),
         )
 
@@ -4863,20 +5720,8 @@ class PyenvVersionInstaller:
     ) -> None:
         super().__init__()
 
-        if no_default_opts:
-            if opts is None:
-                opts = PyenvInstallOpts()
-        else:
-            lst = [opts if opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
-            if interp_opts.debug:
-                lst.append(DEBUG_PYENV_INSTALL_OPTS)
-            if interp_opts.threaded:
-                lst.append(THREADED_PYENV_INSTALL_OPTS)
-            lst.append(PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
-            opts = PyenvInstallOpts().merge(*lst)
-
         self._version = version
-        self._opts = opts
+        self._given_opts = opts
         self._interp_opts = interp_opts
         self._given_install_name = install_name
 
@@ -4887,9 +5732,21 @@ class PyenvVersionInstaller:
     def version(self) -> str:
         return self._version
 
-    @property
-    def opts(self) -> PyenvInstallOpts:
-        return self._opts
+    @async_cached_nullary
+    async def opts(self) -> PyenvInstallOpts:
+        opts = self._given_opts
+        if self._no_default_opts:
+            if opts is None:
+                opts = PyenvInstallOpts()
+        else:
+            lst = [self._given_opts if self._given_opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
+            if self._interp_opts.debug:
+                lst.append(DEBUG_PYENV_INSTALL_OPTS)
+            if self._interp_opts.threaded:
+                lst.append(THREADED_PYENV_INSTALL_OPTS)
+            lst.append(await PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
+            opts = PyenvInstallOpts().merge(*lst)
+        return opts
 
     @cached_nullary
     def install_name(self) -> str:
@@ -4897,17 +5754,18 @@ class PyenvVersionInstaller:
             return self._given_install_name
         return self._version + ('-debug' if self._interp_opts.debug else '')
 
-    @cached_nullary
-    def install_dir(self) -> str:
-        return str(os.path.join(check_not_none(self._pyenv.root()), 'versions', self.install_name()))
+    @async_cached_nullary
+    async def install_dir(self) -> str:
+        return str(os.path.join(check_not_none(await self._pyenv.root()), 'versions', self.install_name()))
 
-    @cached_nullary
-    def install(self) -> str:
-        env = {**os.environ, **self._opts.env}
+    @async_cached_nullary
+    async def install(self) -> str:
+        opts = await self.opts()
+        env = {**os.environ, **opts.env}
         for k, l in [
-            ('CFLAGS', self._opts.cflags),
-            ('LDFLAGS', self._opts.ldflags),
-            ('PYTHON_CONFIGURE_OPTS', self._opts.conf_opts),
+            ('CFLAGS', opts.cflags),
+            ('LDFLAGS', opts.ldflags),
+            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
         ]:
             v = ' '.join(l)
             if k in os.environ:
@@ -4915,13 +5773,13 @@ class PyenvVersionInstaller:
             env[k] = v
 
         conf_args = [
-            *self._opts.opts,
+            *opts.opts,
             self._version,
         ]
 
         if self._given_install_name is not None:
             full_args = [
-                os.path.join(check_not_none(self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),
+                os.path.join(check_not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
                 *conf_args,
                 self.install_dir(),
             ]
@@ -4932,12 +5790,12 @@ class PyenvVersionInstaller:
                 *conf_args,
             ]
 
-        subprocess_check_call(
+        await asyncio_subprocess_check_call(
             *full_args,
             env=env,
         )
 
-        exe = os.path.join(self.install_dir(), 'bin', 'python')
+        exe = os.path.join(await self.install_dir(), 'bin', 'python')
         if not os.path.isfile(exe):
             raise RuntimeError(f'Interpreter not found: {exe}')
         return exe
@@ -4947,7 +5805,6 @@ class PyenvVersionInstaller:
 
 
 class PyenvInterpProvider(InterpProvider):
-
     def __init__(
             self,
             pyenv: Pyenv = Pyenv(),
@@ -4990,11 +5847,11 @@ class PyenvInterpProvider(InterpProvider):
         exe: str
         version: InterpVersion
 
-    def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
         iv: ta.Optional[InterpVersion]
         if self._inspect:
             try:
-                iv = check_not_none(self._inspector.inspect(ep)).iv
+                iv = check_not_none(await self._inspector.inspect(ep)).iv
             except Exception as e:  # noqa
                 return None
         else:
@@ -5007,10 +5864,10 @@ class PyenvInterpProvider(InterpProvider):
             version=iv,
         )
 
-    def installed(self) -> ta.Sequence[Installed]:
+    async def installed(self) -> ta.Sequence[Installed]:
         ret: ta.List[PyenvInterpProvider.Installed] = []
-        for vn, ep in self._pyenv.version_exes():
-            if (i := self._make_installed(vn, ep)) is None:
+        for vn, ep in await self._pyenv.version_exes():
+            if (i := await self._make_installed(vn, ep)) is None:
                 log.debug('Invalid pyenv version: %s', vn)
                 continue
             ret.append(i)
@@ -5018,11 +5875,11 @@ class PyenvInterpProvider(InterpProvider):
 
     #
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in self.installed()]
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for i in self.installed():
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for i in await self.installed():
             if i.version == version:
                 return Interp(
                     exe=i.exe,
@@ -5032,10 +5889,10 @@ class PyenvInterpProvider(InterpProvider):
 
     #
 
-    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
         lst = []
 
-        for vs in self._pyenv.installable_versions():
+        for vs in await self._pyenv.installable_versions():
             if (iv := self.guess_version(vs)) is None:
                 continue
             if iv.opts.debug:
@@ -5045,16 +5902,16 @@ class PyenvInterpProvider(InterpProvider):
 
         return lst
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = self._get_installable_versions(spec)
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
 
         if self._try_update and not any(v in spec for v in lst):
             if self._pyenv.update():
-                lst = self._get_installable_versions(spec)
+                lst = await self._get_installable_versions(spec)
 
         return lst
 
-    def install_version(self, version: InterpVersion) -> Interp:
+    async def install_version(self, version: InterpVersion) -> Interp:
         inst_version = str(version.version)
         inst_opts = version.opts
         if inst_opts.threaded:
@@ -5066,7 +5923,7 @@ class PyenvInterpProvider(InterpProvider):
             interp_opts=inst_opts,
         )
 
-        exe = installer.install()
+        exe = await installer.install()
         return Interp(exe, version)
 
 
@@ -5145,7 +6002,7 @@ class SystemInterpProvider(InterpProvider):
 
     #
 
-    def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
         if not self.inspect:
             s = os.path.basename(exe)
             if s.startswith('python'):
@@ -5155,13 +6012,13 @@ class SystemInterpProvider(InterpProvider):
                     return InterpVersion.parse(s)
                 except InvalidVersion:
                     pass
-        ii = self.inspector.inspect(exe)
+        ii = await self.inspector.inspect(exe)
         return ii.iv if ii is not None else None
 
-    def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
         lst = []
         for e in self.exes():
-            if (ev := self.get_exe_version(e)) is None:
+            if (ev := await self.get_exe_version(e)) is None:
                 log.debug('Invalid system version: %s', e)
                 continue
             lst.append((e, ev))
@@ -5169,11 +6026,11 @@ class SystemInterpProvider(InterpProvider):
 
     #
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in self.exe_versions()]
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for e, ev in self.exe_versions():
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in await self.exe_versions():
             if ev != version:
                 continue
             return Interp(
@@ -5194,9 +6051,11 @@ def bind_remote(
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(remote_config),
 
-        inj.bind(RemoteSpawning, singleton=True),
+        inj.bind(SubprocessRemoteSpawning, singleton=True),
+        inj.bind(RemoteSpawning, to_key=SubprocessRemoteSpawning),
 
-        inj.bind(RemoteExecution, singleton=True),
+        inj.bind(PyremoteRemoteExecutionConnector, singleton=True),
+        inj.bind(RemoteExecutionConnector, to_key=PyremoteRemoteExecutionConnector),
     ]
 
     if (pf := remote_config.payload_file) is not None:
@@ -5220,13 +6079,14 @@ class InterpResolver:
             providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
     ) -> None:
         super().__init__()
+
         self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
-    def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
+    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
         lst = [
             (i, si)
             for i, p in enumerate(self._providers.values())
-            for si in p.get_installed_versions(spec)
+            for si in await p.get_installed_versions(spec)
             if spec.contains(si)
         ]
 
@@ -5238,16 +6098,16 @@ class InterpResolver:
         bp = list(self._providers.values())[bi]
         return (bp, bv)
 
-    def resolve(
+    async def resolve(
             self,
             spec: InterpSpecifier,
             *,
             install: bool = False,
     ) -> ta.Optional[Interp]:
-        tup = self._resolve_installed(spec)
+        tup = await self._resolve_installed(spec)
         if tup is not None:
             bp, bv = tup
-            return bp.get_installed_version(bv)
+            return await bp.get_installed_version(bv)
 
         if not install:
             return None
@@ -5255,21 +6115,21 @@ class InterpResolver:
         tp = list(self._providers.values())[0]  # noqa
 
         sv = sorted(
-            [s for s in tp.get_installable_versions(spec) if s in spec],
+            [s for s in await tp.get_installable_versions(spec) if s in spec],
             key=lambda s: s.version,
         )
         if not sv:
             return None
 
         bv = sv[-1]
-        return tp.install_version(bv)
+        return await tp.install_version(bv)
 
-    def list(self, spec: InterpSpecifier) -> None:
+    async def list(self, spec: InterpSpecifier) -> None:
         print('installed:')
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installed_versions(spec)
+                for si in await p.get_installed_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -5283,7 +6143,7 @@ class InterpResolver:
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installable_versions(spec)
+                for si in await p.get_installable_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -5325,9 +6185,9 @@ class InterpCommand(Command['InterpCommand.Output']):
 
 
 class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
-    def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
+    async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
         i = InterpSpecifier.parse(check_not_none(cmd.spec))
-        o = check_not_none(DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        o = check_not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),
@@ -5366,7 +6226,7 @@ def bind_command(
 class _FactoryCommandExecutor(CommandExecutor):
     factory: ta.Callable[[], CommandExecutor]
 
-    def execute(self, i: Command) -> Command.Output:
+    def execute(self, i: Command) -> ta.Awaitable[Command.Output]:
         return self.factory().execute(i)
 
 
@@ -5521,31 +6381,7 @@ def main_bootstrap(bs: MainBootstrap) -> Injector:
 ##
 
 
-def _main() -> None:
-    import argparse
-
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument('--_payload-file')
-
-    parser.add_argument('-s', '--shell')
-    parser.add_argument('-q', '--shell-quote', action='store_true')
-    parser.add_argument('--python', default='python3')
-
-    parser.add_argument('--pycharm-debug-port', type=int)
-    parser.add_argument('--pycharm-debug-host')
-    parser.add_argument('--pycharm-debug-version')
-
-    parser.add_argument('--debug', action='store_true')
-
-    parser.add_argument('--local', action='store_true')
-
-    parser.add_argument('command', nargs='+')
-
-    args = parser.parse_args()
-
-    #
-
+async def _async_main(args: ta.Any) -> None:
     bs = MainBootstrap(
         main_config=MainConfig(
             log_level='DEBUG' if args.debug else 'INFO',
@@ -5558,12 +6394,16 @@ def _main() -> None:
 
             pycharm_remote_debug=PycharmRemoteDebug(
                 port=args.pycharm_debug_port,
-                host=args.pycharm_debug_host,
+                **(dict(host=args.pycharm_debug_host) if args.pycharm_debug_host is not None else {}),
                 install_version=args.pycharm_debug_version,
             ) if args.pycharm_debug_port is not None else None,
+
+            timebomb_delay_s=args.remote_timebomb_delay_s,
         ),
     )
 
+    #
+
     injector = main_bootstrap(
         bs,
     )
@@ -5582,7 +6422,7 @@ def _main() -> None:
 
     #
 
-    with contextlib.ExitStack() as es:
+    async with contextlib.AsyncExitStack() as es:
         ce: CommandExecutor
 
         if args.local:
@@ -5595,16 +6435,51 @@ def _main() -> None:
                 python=args.python,
             )
 
-            ce = es.enter_context(injector[RemoteExecution].connect(tgt, bs))  # noqa
+            ce = await es.enter_async_context(injector[RemoteExecutionConnector].connect(tgt, bs))  # noqa
 
-        for cmd in cmds:
-            r = ce.try_execute(
+        async def run_command(cmd: Command) -> None:
+            res = await ce.try_execute(
                 cmd,
                 log=log,
                 omit_exc_object=True,
             )
 
-            print(msh.marshal_obj(r, opts=ObjMarshalOptions(raw_bytes=True)))
+            print(msh.marshal_obj(res, opts=ObjMarshalOptions(raw_bytes=True)))
+
+        await asyncio.gather(*[
+            run_command(cmd)
+            for cmd in cmds
+        ])
+
+
+def _main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--_payload-file')
+
+    parser.add_argument('-s', '--shell')
+    parser.add_argument('-q', '--shell-quote', action='store_true')
+    parser.add_argument('--python', default='python3')
+
+    parser.add_argument('--pycharm-debug-port', type=int)
+    parser.add_argument('--pycharm-debug-host')
+    parser.add_argument('--pycharm-debug-version')
+
+    parser.add_argument('--remote-timebomb-delay-s', type=float)
+
+    parser.add_argument('--debug', action='store_true')
+
+    parser.add_argument('--local', action='store_true')
+
+    parser.add_argument('command', nargs='+')
+
+    args = parser.parse_args()
+
+    #
+
+    asyncio.run(_async_main(args))
 
 
 if __name__ == '__main__':