ominfra 0.0.0.dev157__py3-none-any.whl → 0.0.0.dev158__py3-none-any.whl

ominfra/scripts/manage.py

@@ -100,7 +100,7 @@ CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
 
 # deploy/paths.py
 DeployPathKind = ta.Literal['dir', 'file']  # ta.TypeAlias
-DeployPathSpec = ta.Literal['app', 'tag']  # ta.TypeAlias
+DeployPathPlaceholder = ta.Literal['app', 'tag']  # ta.TypeAlias
 
 # ../../omlish/argparse/cli.py
 ArgparseCommandFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
@@ -118,7 +118,7 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 # ../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
-# ../../omlish/lite/subprocesses.py
+# ../../omlish/subprocesses.py
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']  # ta.TypeAlias
 
 # system/packages.py
@@ -1365,6 +1365,9 @@ class MainConfig:
 # ../deploy/config.py
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class DeployConfig:
     deploy_home: ta.Optional[str] = None
@@ -1539,7 +1542,7 @@ def _pyremote_bootstrap_main(context_name: str) -> None:
     # Get pid
     pid = os.getpid()
 
-    # Two copies of main src to be sent to parent
+    # Two copies of payload src to be sent to parent
     r0, w0 = os.pipe()
     r1, w1 = os.pipe()
 
@@ -1578,17 +1581,17 @@ def _pyremote_bootstrap_main(context_name: str) -> None:
         # Write pid
         os.write(1, struct.pack('<Q', pid))
 
-        # Read main src from stdin
-        main_z_len = struct.unpack('<I', os.read(0, 4))[0]
-        if len(main_z := os.fdopen(0, 'rb').read(main_z_len)) != main_z_len:
+        # Read payload src from stdin
+        payload_z_len = struct.unpack('<I', os.read(0, 4))[0]
+        if len(payload_z := os.fdopen(0, 'rb').read(payload_z_len)) != payload_z_len:
             raise EOFError
-        main_src = zlib.decompress(main_z)
+        payload_src = zlib.decompress(payload_z)
 
-        # Write both copies of main src. Must write to w0 (parent stdin) before w1 (copy pipe) as pipe will likely fill
-        # and block and need to be drained by pyremote_bootstrap_finalize running in parent.
+        # Write both copies of payload src. Must write to w0 (parent stdin) before w1 (copy pipe) as pipe will likely
+        # fill and block and need to be drained by pyremote_bootstrap_finalize running in parent.
         for w in [w0, w1]:
             fp = os.fdopen(w, 'wb', 0)
-            fp.write(main_src)
+            fp.write(payload_src)
             fp.close()
 
         # Write second ack
@@ -1652,7 +1655,7 @@ class PyremotePayloadRuntime:
     input: ta.BinaryIO
     output: ta.BinaryIO
     context_name: str
-    main_src: str
+    payload_src: str
     options: PyremoteBootstrapOptions
     env_info: PyremoteEnvInfo
 
@@ -1660,9 +1663,9 @@ class PyremotePayloadRuntime:
 def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
     # If src file var is not present we need to do initial finalization
     if _PYREMOTE_BOOTSTRAP_SRC_FILE_VAR not in os.environ:
-        # Read second copy of main src
+        # Read second copy of payload src
         r1 = os.fdopen(_PYREMOTE_BOOTSTRAP_SRC_FD, 'rb', 0)
-        main_src = r1.read().decode('utf-8')
+        payload_src = r1.read().decode('utf-8')
         r1.close()
 
         # Reap boostrap child. Must be done after reading second copy of source because source may be too big to fit in
@@ -1680,7 +1683,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
             # Write temp source file
             import tempfile
             tfd, tfn = tempfile.mkstemp('-pyremote.py')
-            os.write(tfd, main_src.encode('utf-8'))
+            os.write(tfd, payload_src.encode('utf-8'))
             os.close(tfd)
 
             # Set vars
@@ -1699,7 +1702,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
 
         # Read temp source file
         with open(os.environ.pop(_PYREMOTE_BOOTSTRAP_SRC_FILE_VAR)) as sf:
-            main_src = sf.read()
+            payload_src = sf.read()
 
     # Restore vars
     sys.executable = os.environ.pop(_PYREMOTE_BOOTSTRAP_ARGV0_VAR)
@@ -1732,7 +1735,7 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
         input=input,
         output=output,
         context_name=context_name,
-        main_src=main_src,
+        payload_src=payload_src,
         options=options,
         env_info=env_info,
     )
@@ -1744,31 +1747,31 @@ def pyremote_bootstrap_finalize() -> PyremotePayloadRuntime:
 class PyremoteBootstrapDriver:
     def __init__(
             self,
-            main_src: ta.Union[str, ta.Sequence[str]],
+            payload_src: ta.Union[str, ta.Sequence[str]],
             options: PyremoteBootstrapOptions = PyremoteBootstrapOptions(),
     ) -> None:
         super().__init__()
 
-        self._main_src = main_src
+        self._payload_src = payload_src
         self._options = options
 
-        self._prepared_main_src = self._prepare_main_src(main_src, options)
-        self._main_z = zlib.compress(self._prepared_main_src.encode('utf-8'))
+        self._prepared_payload_src = self._prepare_payload_src(payload_src, options)
+        self._payload_z = zlib.compress(self._prepared_payload_src.encode('utf-8'))
 
         self._options_json = json.dumps(dc.asdict(options), indent=None, separators=(',', ':')).encode('utf-8')  # noqa
     #
 
     @classmethod
-    def _prepare_main_src(
+    def _prepare_payload_src(
             cls,
-            main_src: ta.Union[str, ta.Sequence[str]],
+            payload_src: ta.Union[str, ta.Sequence[str]],
             options: PyremoteBootstrapOptions,
     ) -> str:
         parts: ta.List[str]
-        if isinstance(main_src, str):
-            parts = [main_src]
+        if isinstance(payload_src, str):
+            parts = [payload_src]
         else:
-            parts = list(main_src)
+            parts = list(payload_src)
 
         if (mn := options.main_name_override) is not None:
             parts.insert(0, f'__name__ = {mn!r}')
@@ -1804,9 +1807,9 @@ class PyremoteBootstrapDriver:
         d = yield from self._read(8)
         pid = struct.unpack('<Q', d)[0]
 
-        # Write main src
-        yield from self._write(struct.pack('<I', len(self._main_z)))
-        yield from self._write(self._main_z)
+        # Write payload src
+        yield from self._write(struct.pack('<I', len(self._payload_z)))
+        yield from self._write(self._payload_z)
 
         # Read second ack (after writing src copies)
         yield from self._expect(_PYREMOTE_BOOTSTRAP_ACK1)
@@ -2540,6 +2543,13 @@ json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
 
 
+########################################
+# ../../../omlish/lite/logs.py
+
+
+log = logging.getLogger(__name__)
+
+
 ########################################
 # ../../../omlish/lite/maybes.py
 
@@ -2754,6 +2764,116 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
+########################################
+# ../../../omlish/logs/filters.py
+
+
+class TidLogFilter(logging.Filter):
+    def filter(self, record):
+        record.tid = threading.get_native_id()
+        return True
+
+
+########################################
+# ../../../omlish/logs/proxy.py
+
+
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
+
+    @property
+    def filters(self):
+        return self._underlying.filters
+
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
+
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
+
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
+
+    def filter(self, record):
+        return self._underlying.filter(record)
+
+
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
+
+    _underlying: logging.Handler
+
+    @property
+    def underlying(self) -> logging.Handler:
+        return self._underlying
+
+    def get_name(self):
+        return self._underlying.get_name()
+
+    def set_name(self, name):
+        self._underlying.set_name(name)
+
+    @property
+    def name(self):
+        return self._underlying.name
+
+    @property
+    def level(self):
+        return self._underlying.level
+
+    @level.setter
+    def level(self, level):
+        self._underlying.level = level
+
+    @property
+    def formatter(self):
+        return self._underlying.formatter
+
+    @formatter.setter
+    def formatter(self, formatter):
+        self._underlying.formatter = formatter
+
+    def createLock(self):
+        self._underlying.createLock()
+
+    def acquire(self):
+        self._underlying.acquire()
+
+    def release(self):
+        self._underlying.release()
+
+    def setLevel(self, level):
+        self._underlying.setLevel(level)
+
+    def format(self, record):
+        return self._underlying.format(record)
+
+    def emit(self, record):
+        self._underlying.emit(record)
+
+    def handle(self, record):
+        return self._underlying.handle(record)
+
+    def setFormatter(self, fmt):
+        self._underlying.setFormatter(fmt)
+
+    def flush(self):
+        self._underlying.flush()
+
+    def close(self):
+        self._underlying.close()
+
+    def handleError(self, record):
+        self._underlying.handleError(record)
+
+
 ########################################
 # ../../../omlish/os/deathsig.py
 
@@ -3939,22 +4059,22 @@ def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
 ~deploy
   deploy.pid (flock)
   /app
-    /<appspec> - shallow clone
+    /<appplaceholder> - shallow clone
   /conf
     /env
-      <appspec>.env
+      <appplaceholder>.env
     /nginx
-      <appspec>.conf
+      <appplaceholder>.conf
     /supervisor
-      <appspec>.conf
+      <appplaceholder>.conf
   /venv
-    /<appspec>
+    /<appplaceholder>
 
 ?
   /logs
-    /wrmsr--omlish--<spec>
+    /wrmsr--omlish--<placeholder>
 
-spec = <name>--<rev>--<when>
+placeholder = <name>--<rev>--<when>
 
 ==
 
@@ -3975,10 +4095,10 @@ for dn in [
 ##
 
 
-DEPLOY_PATH_SPEC_PLACEHOLDER = '@'
-DEPLOY_PATH_SPEC_SEPARATORS = '-.'
+DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER = '@'
+DEPLOY_PATH_PLACEHOLDER_SEPARATORS = '-.'
 
-DEPLOY_PATH_SPECS: ta.FrozenSet[str] = frozenset([
+DEPLOY_PATH_PLACEHOLDERS: ta.FrozenSet[str] = frozenset([
     'app',
     'tag',  # <rev>-<dt>
 ])
@@ -3996,7 +4116,7 @@ class DeployPathPart(abc.ABC):  # noqa
         raise NotImplementedError
 
     @abc.abstractmethod
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         raise NotImplementedError
 
 
@@ -4010,9 +4130,9 @@ class DirDeployPathPart(DeployPathPart, abc.ABC):
 
     @classmethod
     def parse(cls, s: str) -> 'DirDeployPathPart':
-        if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check.equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
-            return SpecDirDeployPathPart(s[1:])
+        if DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER in s:
+            check.equal(s[0], DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER)
+            return PlaceholderDirDeployPathPart(s[1:])
         else:
             return ConstDirDeployPathPart(s)
 
@@ -4024,13 +4144,13 @@ class FileDeployPathPart(DeployPathPart, abc.ABC):
 
     @classmethod
     def parse(cls, s: str) -> 'FileDeployPathPart':
-        if DEPLOY_PATH_SPEC_PLACEHOLDER in s:
-            check.equal(s[0], DEPLOY_PATH_SPEC_PLACEHOLDER)
-            if not any(c in s for c in DEPLOY_PATH_SPEC_SEPARATORS):
-                return SpecFileDeployPathPart(s[1:], '')
+        if DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER in s:
+            check.equal(s[0], DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER)
+            if not any(c in s for c in DEPLOY_PATH_PLACEHOLDER_SEPARATORS):
+                return PlaceholderFileDeployPathPart(s[1:], '')
             else:
-                p = min(f for c in DEPLOY_PATH_SPEC_SEPARATORS if (f := s.find(c)) > 0)
-                return SpecFileDeployPathPart(s[1:p], s[p:])
+                p = min(f for c in DEPLOY_PATH_PLACEHOLDER_SEPARATORS if (f := s.find(c)) > 0)
+                return PlaceholderFileDeployPathPart(s[1:p], s[p:])
         else:
             return ConstFileDeployPathPart(s)
 
@@ -4045,9 +4165,9 @@ class ConstDeployPathPart(DeployPathPart, abc.ABC):
     def __post_init__(self) -> None:
         check.non_empty_str(self.name)
         check.not_in('/', self.name)
-        check.not_in(DEPLOY_PATH_SPEC_PLACEHOLDER, self.name)
+        check.not_in(DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, self.name)
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         return self.name
 
 
@@ -4063,40 +4183,40 @@ class ConstFileDeployPathPart(ConstDeployPathPart, FileDeployPathPart):
 
 
 @dc.dataclass(frozen=True)
-class SpecDeployPathPart(DeployPathPart, abc.ABC):
-    spec: str  # DeployPathSpec
+class PlaceholderDeployPathPart(DeployPathPart, abc.ABC):
+    placeholder: str  # DeployPathPlaceholder
 
     def __post_init__(self) -> None:
-        check.non_empty_str(self.spec)
-        for c in [*DEPLOY_PATH_SPEC_SEPARATORS, DEPLOY_PATH_SPEC_PLACEHOLDER, '/']:
-            check.not_in(c, self.spec)
-        check.in_(self.spec, DEPLOY_PATH_SPECS)
-
-    def _render_spec(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        if specs is not None:
-            return specs[self.spec]  # type: ignore
+        check.non_empty_str(self.placeholder)
+        for c in [*DEPLOY_PATH_PLACEHOLDER_SEPARATORS, DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, '/']:
+            check.not_in(c, self.placeholder)
+        check.in_(self.placeholder, DEPLOY_PATH_PLACEHOLDERS)
+
+    def _render_placeholder(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        if placeholders is not None:
+            return placeholders[self.placeholder]  # type: ignore
         else:
-            return DEPLOY_PATH_SPEC_PLACEHOLDER + self.spec
+            return DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER + self.placeholder
 
 
 @dc.dataclass(frozen=True)
-class SpecDirDeployPathPart(SpecDeployPathPart, DirDeployPathPart):
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        return self._render_spec(specs)
+class PlaceholderDirDeployPathPart(PlaceholderDeployPathPart, DirDeployPathPart):
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        return self._render_placeholder(placeholders)
 
 
 @dc.dataclass(frozen=True)
-class SpecFileDeployPathPart(SpecDeployPathPart, FileDeployPathPart):
+class PlaceholderFileDeployPathPart(PlaceholderDeployPathPart, FileDeployPathPart):
     suffix: str
 
     def __post_init__(self) -> None:
         super().__post_init__()
         if self.suffix:
-            for c in [DEPLOY_PATH_SPEC_PLACEHOLDER, '/']:
+            for c in [DEPLOY_PATH_PLACEHOLDER_PLACEHOLDER, '/']:
                 check.not_in(c, self.suffix)
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
-        return self._render_spec(specs) + self.suffix
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
+        return self._render_placeholder(placeholders) + self.suffix
 
 
 ##
@@ -4113,22 +4233,22 @@ class DeployPath:
 
         pd = {}
         for i, p in enumerate(self.parts):
-            if isinstance(p, SpecDeployPathPart):
-                if p.spec in pd:
-                    raise DeployPathError('Duplicate specs in path', self)
-                pd[p.spec] = i
+            if isinstance(p, PlaceholderDeployPathPart):
+                if p.placeholder in pd:
+                    raise DeployPathError('Duplicate placeholders in path', self)
+                pd[p.placeholder] = i
 
         if 'tag' in pd:
             if 'app' not in pd or pd['app'] >= pd['tag']:
-                raise DeployPathError('Tag spec in path without preceding app', self)
+                raise DeployPathError('Tag placeholder in path without preceding app', self)
 
     @property
     def kind(self) -> ta.Literal['file', 'dir']:
         return self.parts[-1].kind
 
-    def render(self, specs: ta.Optional[ta.Mapping[DeployPathSpec, str]] = None) -> str:
+    def render(self, placeholders: ta.Optional[ta.Mapping[DeployPathPlaceholder, str]] = None) -> str:
         return os.path.join(  # noqa
-            *[p.render(specs) for p in self.parts],
+            *[p.render(placeholders) for p in self.parts],
             *([''] if self.kind == 'dir' else []),
         )
 
@@ -4156,6 +4276,34 @@ class DeployPathOwner(abc.ABC):
         raise NotImplementedError
 
 
+########################################
+# ../deploy/specs.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployGitRepo:
+    host: ta.Optional[str] = None
+    username: ta.Optional[str] = None
+    path: ta.Optional[str] = None
+
+    def __post_init__(self) -> None:
+        check.not_in('..', check.non_empty_str(self.host))
+        check.not_in('.', check.non_empty_str(self.path))
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeploySpec:
+    app: DeployApp
+    repo: DeployGitRepo
+    rev: DeployRev
+
+
 ########################################
 # ../remote/config.py
 
@@ -4216,6 +4364,75 @@ def get_remote_payload_src(
     return importlib.resources.files(__package__.split('.')[0] + '.scripts').joinpath('manage.py').read_text()
 
 
+########################################
+# ../system/platforms.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Platform(abc.ABC):  # noqa
+    pass
+
+
+class LinuxPlatform(Platform, abc.ABC):
+    pass
+
+
+class UbuntuPlatform(LinuxPlatform):
+    pass
+
+
+class AmazonLinuxPlatform(LinuxPlatform):
+    pass
+
+
+class GenericLinuxPlatform(LinuxPlatform):
+    pass
+
+
+class DarwinPlatform(Platform):
+    pass
+
+
+class UnknownPlatform(Platform):
+    pass
+
+
+##
+
+
+def _detect_system_platform() -> Platform:
+    plat = sys.platform
+
+    if plat == 'linux':
+        if (osr := LinuxOsRelease.read()) is None:
+            return GenericLinuxPlatform()
+
+        if osr.id == 'amzn':
+            return AmazonLinuxPlatform()
+
+        elif osr.id == 'ubuntu':
+            return UbuntuPlatform()
+
+        else:
+            return GenericLinuxPlatform()
+
+    elif plat == 'darwin':
+        return DarwinPlatform()
+
+    else:
+        return UnknownPlatform()
+
+
+@cached_nullary
+def detect_system_platform() -> Platform:
+    platform = _detect_system_platform()
+    log.info('Detected platform: %r', platform)
+    return platform
+
+
 ########################################
 # ../targets/targets.py
 """
@@ -5540,1150 +5757,994 @@ inj = Injection
 
 
 ########################################
-# ../../../omlish/lite/logs.py
+# ../../../omlish/lite/marshal.py
 """
 TODO:
- - translate json keys
- - debug
+ - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
+ - namedtuple
+ - literals
+ - newtypes?
 """
 
 
-log = logging.getLogger(__name__)
+##
 
 
-##
+@dc.dataclass(frozen=True)
+class ObjMarshalOptions:
+    raw_bytes: bool = False
+    nonstrict_dataclasses: bool = False
 
 
-class TidLogFilter(logging.Filter):
+class ObjMarshaler(abc.ABC):
+    @abc.abstractmethod
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
-    def filter(self, record):
-        record.tid = threading.get_native_id()
-        return True
+    @abc.abstractmethod
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        raise NotImplementedError
 
 
-##
+class NopObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-class JsonLogFormatter(logging.Formatter):
 
-    KEYS: ta.Mapping[str, bool] = {
-        'name': False,
-        'msg': False,
-        'args': False,
-        'levelname': False,
-        'levelno': False,
-        'pathname': False,
-        'filename': False,
-        'module': False,
-        'exc_info': True,
-        'exc_text': True,
-        'stack_info': True,
-        'lineno': False,
-        'funcName': False,
-        'created': False,
-        'msecs': False,
-        'relativeCreated': False,
-        'thread': False,
-        'threadName': False,
-        'processName': False,
-        'process': False,
-    }
+@dc.dataclass()
+class ProxyObjMarshaler(ObjMarshaler):
+    m: ta.Optional[ObjMarshaler] = None
 
-    def format(self, record: logging.LogRecord) -> str:
-        dct = {
-            k: v
-            for k, o in self.KEYS.items()
-            for v in [getattr(record, k)]
-            if not (o and v is None)
-        }
-        return json_dumps_compact(dct)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).marshal(o, ctx)
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check.not_none(self.m).unmarshal(o, ctx)
 
-##
 
+@dc.dataclass(frozen=True)
+class CastObjMarshaler(ObjMarshaler):
+    ty: type
 
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)-6s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(o)
 
-class StandardLogFormatter(logging.Formatter):
 
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
+class DynamicObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return ctx.manager.marshal_obj(o, opts=ctx.options)
 
-    converter = datetime.datetime.fromtimestamp  # type: ignore
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o
 
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)  # type: ignore
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
 
+@dc.dataclass(frozen=True)
+class Base64ObjMarshaler(ObjMarshaler):
+    ty: type
 
-##
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return base64.b64encode(o).decode('ascii')
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(base64.b64decode(o))
 
-class ProxyLogFilterer(logging.Filterer):
-    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
-        self._underlying = underlying
 
-    @property
-    def underlying(self) -> logging.Filterer:
-        return self._underlying
+@dc.dataclass(frozen=True)
+class BytesSwitchedObjMarshaler(ObjMarshaler):
+    m: ObjMarshaler
 
-    @property
-    def filters(self):
-        return self._underlying.filters
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
+            return o
+        return self.m.marshal(o, ctx)
 
-    @filters.setter
-    def filters(self, filters):
-        self._underlying.filters = filters
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
+            return o
+        return self.m.unmarshal(o, ctx)
 
-    def addFilter(self, filter):  # noqa
-        self._underlying.addFilter(filter)
 
-    def removeFilter(self, filter):  # noqa
-        self._underlying.removeFilter(filter)
+@dc.dataclass(frozen=True)
+class EnumObjMarshaler(ObjMarshaler):
+    ty: type
 
-    def filter(self, record):
-        return self._underlying.filter(record)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o.name
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty.__members__[o]  # type: ignore
 
-class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
-    def __init__(self, underlying: logging.Handler) -> None:  # noqa
-        ProxyLogFilterer.__init__(self, underlying)
 
-    _underlying: logging.Handler
+@dc.dataclass(frozen=True)
+class OptionalObjMarshaler(ObjMarshaler):
+    item: ObjMarshaler
 
-    @property
-    def underlying(self) -> logging.Handler:
-        return self._underlying
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if o is None:
+            return None
+        return self.item.marshal(o, ctx)
 
-    def get_name(self):
-        return self._underlying.get_name()
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if o is None:
+            return None
+        return self.item.unmarshal(o, ctx)
 
-    def set_name(self, name):
-        self._underlying.set_name(name)
 
-    @property
-    def name(self):
-        return self._underlying.name
+@dc.dataclass(frozen=True)
+class MappingObjMarshaler(ObjMarshaler):
+    ty: type
+    km: ObjMarshaler
+    vm: ObjMarshaler
 
-    @property
-    def level(self):
-        return self._underlying.level
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
 
-    @level.setter
-    def level(self, level):
-        self._underlying.level = level
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
 
-    @property
-    def formatter(self):
-        return self._underlying.formatter
 
-    @formatter.setter
-    def formatter(self, formatter):
-        self._underlying.formatter = formatter
+@dc.dataclass(frozen=True)
+class IterableObjMarshaler(ObjMarshaler):
+    ty: type
+    item: ObjMarshaler
 
-    def createLock(self):
-        self._underlying.createLock()
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return [self.item.marshal(e, ctx) for e in o]
 
-    def acquire(self):
-        self._underlying.acquire()
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(self.item.unmarshal(e, ctx) for e in o)
 
-    def release(self):
-        self._underlying.release()
 
-    def setLevel(self, level):
-        self._underlying.setLevel(level)
+@dc.dataclass(frozen=True)
+class DataclassObjMarshaler(ObjMarshaler):
+    ty: type
+    fs: ta.Mapping[str, ObjMarshaler]
+    nonstrict: bool = False
 
-    def format(self, record):
-        return self._underlying.format(record)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {
+            k: m.marshal(getattr(o, k), ctx)
+            for k, m in self.fs.items()
+        }
 
-    def emit(self, record):
-        self._underlying.emit(record)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(**{
+            k: self.fs[k].unmarshal(v, ctx)
+            for k, v in o.items()
+            if not (self.nonstrict or ctx.options.nonstrict_dataclasses) or k in self.fs
+        })
 
-    def handle(self, record):
-        return self._underlying.handle(record)
 
-    def setFormatter(self, fmt):
-        self._underlying.setFormatter(fmt)
+@dc.dataclass(frozen=True)
+class PolymorphicObjMarshaler(ObjMarshaler):
+    class Impl(ta.NamedTuple):
+        ty: type
+        tag: str
+        m: ObjMarshaler
 
-    def flush(self):
-        self._underlying.flush()
+    impls_by_ty: ta.Mapping[type, Impl]
+    impls_by_tag: ta.Mapping[str, Impl]
 
-    def close(self):
-        self._underlying.close()
+    @classmethod
+    def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
+        return cls(
+            {i.ty: i for i in impls},
+            {i.tag: i for i in impls},
+        )
 
-    def handleError(self, record):
-        self._underlying.handleError(record)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        impl = self.impls_by_ty[type(o)]
+        return {impl.tag: impl.m.marshal(o, ctx)}
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        [(t, v)] = o.items()
+        impl = self.impls_by_tag[t]
+        return impl.m.unmarshal(v, ctx)
 
-##
 
+@dc.dataclass(frozen=True)
+class DatetimeObjMarshaler(ObjMarshaler):
+    ty: type
 
-class StandardLogHandler(ProxyLogHandler):
-    pass
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return o.isoformat()
 
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty.fromisoformat(o)  # type: ignore
 
-##
 
+class DecimalObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return str(check.isinstance(o, decimal.Decimal))
 
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return decimal.Decimal(check.isinstance(v, str))
 
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
 
-    else:
-        raise Exception("Can't find lock in logging module")
+class FractionObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        fr = check.isinstance(o, fractions.Fraction)
+        return [fr.numerator, fr.denominator]
 
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        num, denom = check.isinstance(v, list)
+        return fractions.Fraction(num, denom)
 
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardLogHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
 
-        #
+class UuidObjMarshaler(ObjMarshaler):
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return str(o)
 
-        if not force:
-            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
-                return None
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return uuid.UUID(o)
 
-        #
 
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
+##
 
-        #
 
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLogFormatter()
-        else:
-            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
+_DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
+    **{t: NopObjMarshaler() for t in (type(None),)},
+    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
+    **{t: BytesSwitchedObjMarshaler(Base64ObjMarshaler(t)) for t in (bytes, bytearray)},
+    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
+    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
 
-        #
+    ta.Any: DynamicObjMarshaler(),
 
-        handler.addFilter(TidLogFilter())
+    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
+    decimal.Decimal: DecimalObjMarshaler(),
+    fractions.Fraction: FractionObjMarshaler(),
+    uuid.UUID: UuidObjMarshaler(),
+}
 
-        #
+_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (dict,)},
+    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
+}
 
-        target.addHandler(handler)
+_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
+    **{t: t for t in (list, tuple, set, frozenset)},
+    collections.abc.Set: frozenset,
+    collections.abc.MutableSet: set,
+    collections.abc.Sequence: tuple,
+    collections.abc.MutableSequence: list,
+}
 
-        #
 
-        if level is not None:
-            target.setLevel(level)
+##
 
-        #
 
-        return StandardLogHandler(handler)
+class ObjMarshalerManager:
+    def __init__(
+            self,
+            *,
+            default_options: ObjMarshalOptions = ObjMarshalOptions(),
 
+            default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
+            generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
+            generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
+    ) -> None:
+        super().__init__()
 
-########################################
-# ../../../omlish/lite/marshal.py
-"""
-TODO:
- - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version
- - namedtuple
- - literals
- - newtypes?
-"""
+        self._default_options = default_options
 
+        self._obj_marshalers = dict(default_obj_marshalers)
+        self._generic_mapping_types = generic_mapping_types
+        self._generic_iterable_types = generic_iterable_types
 
-##
+        self._lock = threading.RLock()
+        self._marshalers: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
+        self._proxies: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
 
+    #
 
-@dc.dataclass(frozen=True)
-class ObjMarshalOptions:
-    raw_bytes: bool = False
-    nonstrict_dataclasses: bool = False
+    def make_obj_marshaler(
+            self,
+            ty: ta.Any,
+            rec: ta.Callable[[ta.Any], ObjMarshaler],
+            *,
+            nonstrict_dataclasses: bool = False,
+    ) -> ObjMarshaler:
+        if isinstance(ty, type):
+            if abc.ABC in ty.__bases__:
+                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
+                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
+                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
+                else:
+                    ins = {ity: ity.__qualname__ for ity in impls}
+                return PolymorphicObjMarshaler.of([
+                    PolymorphicObjMarshaler.Impl(
+                        ity,
+                        itn,
+                        rec(ity),
+                    )
+                    for ity, itn in ins.items()
+                ])
 
+            if issubclass(ty, enum.Enum):
+                return EnumObjMarshaler(ty)
 
-class ObjMarshaler(abc.ABC):
-    @abc.abstractmethod
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
+            if dc.is_dataclass(ty):
+                return DataclassObjMarshaler(
+                    ty,
+                    {f.name: rec(f.type) for f in dc.fields(ty)},
+                    nonstrict=nonstrict_dataclasses,
+                )
 
-    @abc.abstractmethod
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        raise NotImplementedError
+        if is_generic_alias(ty):
+            try:
+                mt = self._generic_mapping_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                k, v = ta.get_args(ty)
+                return MappingObjMarshaler(mt, rec(k), rec(v))
 
+            try:
+                st = self._generic_iterable_types[ta.get_origin(ty)]
+            except KeyError:
+                pass
+            else:
+                [e] = ta.get_args(ty)
+                return IterableObjMarshaler(st, rec(e))
 
-class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+            if is_union_alias(ty):
+                return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+        raise TypeError(ty)
 
+    #
 
-@dc.dataclass()
-class ProxyObjMarshaler(ObjMarshaler):
-    m: ta.Optional[ObjMarshaler] = None
+    def register_opj_marshaler(self, ty: ta.Any, m: ObjMarshaler) -> None:
+        with self._lock:
+            if ty in self._obj_marshalers:
+                raise KeyError(ty)
+            self._obj_marshalers[ty] = m
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).marshal(o, ctx)
+    def get_obj_marshaler(
+            self,
+            ty: ta.Any,
+            *,
+            no_cache: bool = False,
+            **kwargs: ta.Any,
+    ) -> ObjMarshaler:
+        with self._lock:
+            if not no_cache:
+                try:
+                    return self._obj_marshalers[ty]
+                except KeyError:
+                    pass
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check.not_none(self.m).unmarshal(o, ctx)
+            try:
+                return self._proxies[ty]
+            except KeyError:
+                pass
 
+            rec = functools.partial(
+                self.get_obj_marshaler,
+                no_cache=no_cache,
+                **kwargs,
+            )
 
-@dc.dataclass(frozen=True)
-class CastObjMarshaler(ObjMarshaler):
-    ty: type
+            p = ProxyObjMarshaler()
+            self._proxies[ty] = p
+            try:
+                m = self.make_obj_marshaler(ty, rec, **kwargs)
+            finally:
+                del self._proxies[ty]
+            p.m = m
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+            if not no_cache:
+                self._obj_marshalers[ty] = m
+            return m
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(o)
+    #
 
+    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+        return ObjMarshalContext(
+            options=opts or self._default_options,
+            manager=self,
+        )
 
-class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return ctx.manager.marshal_obj(o, opts=ctx.options)
+    def marshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        m = self.get_obj_marshaler(ty if ty is not None else type(o))
+        return m.marshal(o, self._make_context(opts))
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o
+    def unmarshal_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Union[ta.Type[T], ta.Any],
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> T:
+        m = self.get_obj_marshaler(ty)
+        return m.unmarshal(o, self._make_context(opts))
+
+    def roundtrip_obj(
+            self,
+            o: ta.Any,
+            ty: ta.Any = None,
+            opts: ta.Optional[ObjMarshalOptions] = None,
+    ) -> ta.Any:
+        if ty is None:
+            ty = type(o)
+        m: ta.Any = self.marshal_obj(o, ty, opts)
+        u: ta.Any = self.unmarshal_obj(m, ty, opts)
+        return u
 
 
 @dc.dataclass(frozen=True)
-class Base64ObjMarshaler(ObjMarshaler):
-    ty: type
+class ObjMarshalContext:
+    options: ObjMarshalOptions
+    manager: ObjMarshalerManager
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return base64.b64encode(o).decode('ascii')
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(base64.b64decode(o))
+##
 
 
-@dc.dataclass(frozen=True)
-class BytesSwitchedObjMarshaler(ObjMarshaler):
-    m: ObjMarshaler
+OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if ctx.options.raw_bytes:
-            return o
-        return self.m.marshal(o, ctx)
+register_opj_marshaler = OBJ_MARSHALER_MANAGER.register_opj_marshaler
+get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if ctx.options.raw_bytes:
-            return o
-        return self.m.unmarshal(o, ctx)
+marshal_obj = OBJ_MARSHALER_MANAGER.marshal_obj
+unmarshal_obj = OBJ_MARSHALER_MANAGER.unmarshal_obj
 
 
-@dc.dataclass(frozen=True)
-class EnumObjMarshaler(ObjMarshaler):
-    ty: type
+########################################
+# ../../../omlish/lite/runtime.py
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o.name
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.__members__[o]  # type: ignore
+@cached_nullary
+def is_debugger_attached() -> bool:
+    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
 
 
-@dc.dataclass(frozen=True)
-class OptionalObjMarshaler(ObjMarshaler):
-    item: ObjMarshaler
+REQUIRED_PYTHON_VERSION = (3, 8)
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if o is None:
-            return None
-        return self.item.marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        if o is None:
-            return None
-        return self.item.unmarshal(o, ctx)
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
 
 
-@dc.dataclass(frozen=True)
-class MappingObjMarshaler(ObjMarshaler):
-    ty: type
-    km: ObjMarshaler
-    vm: ObjMarshaler
+########################################
+# ../../../omlish/logs/json.py
+"""
+TODO:
+ - translate json keys
+"""
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
+class JsonLogFormatter(logging.Formatter):
+    KEYS: ta.Mapping[str, bool] = {
+        'name': False,
+        'msg': False,
+        'args': False,
+        'levelname': False,
+        'levelno': False,
+        'pathname': False,
+        'filename': False,
+        'module': False,
+        'exc_info': True,
+        'exc_text': True,
+        'stack_info': True,
+        'lineno': False,
+        'funcName': False,
+        'created': False,
+        'msecs': False,
+        'relativeCreated': False,
+        'thread': False,
+        'threadName': False,
+        'processName': False,
+        'process': False,
+    }
 
+    def __init__(
+            self,
+            *args: ta.Any,
+            json_dumps: ta.Optional[ta.Callable[[ta.Any], str]] = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
 
-@dc.dataclass(frozen=True)
-class IterableObjMarshaler(ObjMarshaler):
-    ty: type
-    item: ObjMarshaler
+        if json_dumps is None:
+            json_dumps = json_dumps_compact
+        self._json_dumps = json_dumps
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return [self.item.marshal(e, ctx) for e in o]
+    def format(self, record: logging.LogRecord) -> str:
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
+        return self._json_dumps(dct)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(self.item.unmarshal(e, ctx) for e in o)
+
+########################################
+# ../../../omdev/interp/types.py
+
+
+# See https://peps.python.org/pep-3149/
+INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
+    ('debug', 'd'),
+    ('threaded', 't'),
+])
+
+INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
+    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
+)
 
 
 @dc.dataclass(frozen=True)
-class DataclassObjMarshaler(ObjMarshaler):
-    ty: type
-    fs: ta.Mapping[str, ObjMarshaler]
-    nonstrict: bool = False
+class InterpOpts:
+    threaded: bool = False
+    debug: bool = False
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return {
-            k: m.marshal(getattr(o, k), ctx)
-            for k, m in self.fs.items()
-        }
+    def __str__(self) -> str:
+        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty(**{
-            k: self.fs[k].unmarshal(v, ctx)
-            for k, v in o.items()
-            if not (self.nonstrict or ctx.options.nonstrict_dataclasses) or k in self.fs
-        })
+    @classmethod
+    def parse(cls, s: str) -> 'InterpOpts':
+        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+
+    @classmethod
+    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
+        kw = {}
+        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
+            s, kw[a] = s[:-1], True
+        return s, cls(**kw)
 
 
 @dc.dataclass(frozen=True)
-class PolymorphicObjMarshaler(ObjMarshaler):
-    class Impl(ta.NamedTuple):
-        ty: type
-        tag: str
-        m: ObjMarshaler
+class InterpVersion:
+    version: Version
+    opts: InterpOpts
 
-    impls_by_ty: ta.Mapping[type, Impl]
-    impls_by_tag: ta.Mapping[str, Impl]
+    def __str__(self) -> str:
+        return str(self.version) + str(self.opts)
 
     @classmethod
-    def of(cls, impls: ta.Iterable[Impl]) -> 'PolymorphicObjMarshaler':
+    def parse(cls, s: str) -> 'InterpVersion':
+        s, o = InterpOpts.parse_suffix(s)
+        v = Version(s)
         return cls(
-            {i.ty: i for i in impls},
-            {i.tag: i for i in impls},
+            version=v,
+            opts=o,
         )
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o, ctx)}
-
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        [(t, v)] = o.items()
-        impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v, ctx)
+    @classmethod
+    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
+        try:
+            return cls.parse(s)
+        except (KeyError, InvalidVersion):
+            return None
 
 
 @dc.dataclass(frozen=True)
-class DatetimeObjMarshaler(ObjMarshaler):
-    ty: type
+class InterpSpecifier:
+    specifier: Specifier
+    opts: InterpOpts
 
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return o.isoformat()
+    def __str__(self) -> str:
+        return str(self.specifier) + str(self.opts)
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return self.ty.fromisoformat(o)  # type: ignore
+    @classmethod
+    def parse(cls, s: str) -> '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,
+        )
 
+    def contains(self, iv: InterpVersion) -> bool:
+        return self.specifier.contains(iv.version) and self.opts == iv.opts
 
-class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(check.isinstance(o, decimal.Decimal))
+    def __contains__(self, iv: InterpVersion) -> bool:
+        return self.contains(iv)
 
-    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return decimal.Decimal(check.isinstance(v, str))
 
+@dc.dataclass(frozen=True)
+class Interp:
+    exe: str
+    version: InterpVersion
 
-class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        fr = check.isinstance(o, fractions.Fraction)
-        return [fr.numerator, fr.denominator]
 
-    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        num, denom = check.isinstance(v, list)
-        return fractions.Fraction(num, denom)
+########################################
+# ../../configs.py
 
 
-class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(o)
+def parse_config_file(
+        name: str,
+        f: ta.TextIO,
+) -> ConfigMapping:
+    if name.endswith('.toml'):
+        return toml_loads(f.read())
 
-    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return uuid.UUID(o)
+    elif any(name.endswith(e) for e in ('.yml', '.yaml')):
+        yaml = __import__('yaml')
+        return yaml.safe_load(f)
 
+    elif name.endswith('.ini'):
+        import configparser
+        cp = configparser.ConfigParser()
+        cp.read_file(f)
+        config_dct: ta.Dict[str, ta.Any] = {}
+        for sec in cp.sections():
+            cd = config_dct
+            for k in sec.split('.'):
+                cd = cd.setdefault(k, {})
+            cd.update(cp.items(sec))
+        return config_dct
 
-##
+    else:
+        return json.loads(f.read())
 
 
-_DEFAULT_OBJ_MARSHALERS: ta.Dict[ta.Any, ObjMarshaler] = {
-    **{t: NopObjMarshaler() for t in (type(None),)},
-    **{t: CastObjMarshaler(t) for t in (int, float, str, bool)},
-    **{t: BytesSwitchedObjMarshaler(Base64ObjMarshaler(t)) for t in (bytes, bytearray)},
-    **{t: IterableObjMarshaler(t, DynamicObjMarshaler()) for t in (list, tuple, set, frozenset)},
-    **{t: MappingObjMarshaler(t, DynamicObjMarshaler(), DynamicObjMarshaler()) for t in (dict,)},
-
-    ta.Any: DynamicObjMarshaler(),
+def read_config_file(
+        path: str,
+        cls: ta.Type[T],
+        *,
+        prepare: ta.Optional[ta.Callable[[ConfigMapping], ConfigMapping]] = None,
+) -> T:
+    with open(path) as cf:
+        config_dct = parse_config_file(os.path.basename(path), cf)
 
-    **{t: DatetimeObjMarshaler(t) for t in (datetime.date, datetime.time, datetime.datetime)},
-    decimal.Decimal: DecimalObjMarshaler(),
-    fractions.Fraction: FractionObjMarshaler(),
-    uuid.UUID: UuidObjMarshaler(),
-}
+    if prepare is not None:
+        config_dct = prepare(config_dct)
 
-_OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (dict,)},
-    **{t: dict for t in (collections.abc.Mapping, collections.abc.MutableMapping)},
-}
+    return unmarshal_obj(config_dct, cls)
 
-_OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
-    **{t: t for t in (list, tuple, set, frozenset)},
-    collections.abc.Set: frozenset,
-    collections.abc.MutableSet: set,
-    collections.abc.Sequence: tuple,
-    collections.abc.MutableSequence: list,
-}
 
+def build_config_named_children(
+        o: ta.Union[
+            ta.Sequence[ConfigMapping],
+            ta.Mapping[str, ConfigMapping],
+            None,
+        ],
+        *,
+        name_key: str = 'name',
+) -> ta.Optional[ta.Sequence[ConfigMapping]]:
+    if o is None:
+        return None
 
-##
+    lst: ta.List[ConfigMapping] = []
+    if isinstance(o, ta.Mapping):
+        for k, v in o.items():
+            check.isinstance(v, ta.Mapping)
+            if name_key in v:
+                n = v[name_key]
+                if k != n:
+                    raise KeyError(f'Given names do not match: {n} != {k}')
+                lst.append(v)
+            else:
+                lst.append({name_key: k, **v})
 
+    else:
+        check.not_isinstance(o, str)
+        lst.extend(o)
 
-class ObjMarshalerManager:
-    def __init__(
-            self,
-            *,
-            default_options: ObjMarshalOptions = ObjMarshalOptions(),
+    seen = set()
+    for d in lst:
+        n = d['name']
+        if n in d:
+            raise KeyError(f'Duplicate name: {n}')
+        seen.add(n)
 
-            default_obj_marshalers: ta.Dict[ta.Any, ObjMarshaler] = _DEFAULT_OBJ_MARSHALERS,  # noqa
-            generic_mapping_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_MAPPING_TYPES,  # noqa
-            generic_iterable_types: ta.Dict[ta.Any, type] = _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES,  # noqa
-    ) -> None:
-        super().__init__()
+    return lst
 
-        self._default_options = default_options
 
-        self._obj_marshalers = dict(default_obj_marshalers)
-        self._generic_mapping_types = generic_mapping_types
-        self._generic_iterable_types = generic_iterable_types
+########################################
+# ../commands/marshal.py
 
-        self._lock = threading.RLock()
-        self._marshalers: ta.Dict[ta.Any, ObjMarshaler] = dict(_DEFAULT_OBJ_MARSHALERS)
-        self._proxies: ta.Dict[ta.Any, ProxyObjMarshaler] = {}
 
-    #
+def install_command_marshaling(
+        cmds: CommandNameMap,
+        msh: ObjMarshalerManager,
+) -> None:
+    for fn in [
+        lambda c: c,
+        lambda c: c.Output,
+    ]:
+        msh.register_opj_marshaler(
+            fn(Command),
+            PolymorphicObjMarshaler.of([
+                PolymorphicObjMarshaler.Impl(
+                    fn(cmd),
+                    name,
+                    msh.get_obj_marshaler(fn(cmd)),
+                )
+                for name, cmd in cmds.items()
+            ]),
+        )
 
-    def make_obj_marshaler(
-            self,
-            ty: ta.Any,
-            rec: ta.Callable[[ta.Any], ObjMarshaler],
-            *,
-            nonstrict_dataclasses: bool = False,
-    ) -> ObjMarshaler:
-        if isinstance(ty, type):
-            if abc.ABC in ty.__bases__:
-                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
-                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
-                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
-                else:
-                    ins = {ity: ity.__qualname__ for ity in impls}
-                return PolymorphicObjMarshaler.of([
-                    PolymorphicObjMarshaler.Impl(
-                        ity,
-                        itn,
-                        rec(ity),
-                    )
-                    for ity, itn in ins.items()
-                ])
 
-            if issubclass(ty, enum.Enum):
-                return EnumObjMarshaler(ty)
+########################################
+# ../commands/ping.py
 
-            if dc.is_dataclass(ty):
-                return DataclassObjMarshaler(
-                    ty,
-                    {f.name: rec(f.type) for f in dc.fields(ty)},
-                    nonstrict=nonstrict_dataclasses,
-                )
 
-        if is_generic_alias(ty):
-            try:
-                mt = self._generic_mapping_types[ta.get_origin(ty)]
-            except KeyError:
-                pass
-            else:
-                k, v = ta.get_args(ty)
-                return MappingObjMarshaler(mt, rec(k), rec(v))
+##
 
-            try:
-                st = self._generic_iterable_types[ta.get_origin(ty)]
-            except KeyError:
-                pass
-            else:
-                [e] = ta.get_args(ty)
-                return IterableObjMarshaler(st, rec(e))
 
-            if is_union_alias(ty):
-                return OptionalObjMarshaler(rec(get_optional_alias_arg(ty)))
+@dc.dataclass(frozen=True)
+class PingCommand(Command['PingCommand.Output']):
+    time: float = dc.field(default_factory=time.time)
 
-        raise TypeError(ty)
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        time: float
 
-    #
 
-    def register_opj_marshaler(self, ty: ta.Any, m: ObjMarshaler) -> None:
-        with self._lock:
-            if ty in self._obj_marshalers:
-                raise KeyError(ty)
-            self._obj_marshalers[ty] = m
+class PingCommandExecutor(CommandExecutor[PingCommand, PingCommand.Output]):
+    async def execute(self, cmd: PingCommand) -> PingCommand.Output:
+        return PingCommand.Output(cmd.time)
 
-    def get_obj_marshaler(
-            self,
-            ty: ta.Any,
-            *,
-            no_cache: bool = False,
-            **kwargs: ta.Any,
-    ) -> ObjMarshaler:
-        with self._lock:
-            if not no_cache:
-                try:
-                    return self._obj_marshalers[ty]
-                except KeyError:
-                    pass
 
-            try:
-                return self._proxies[ty]
-            except KeyError:
-                pass
+########################################
+# ../commands/types.py
 
-            rec = functools.partial(
-                self.get_obj_marshaler,
-                no_cache=no_cache,
-                **kwargs,
-            )
 
-            p = ProxyObjMarshaler()
-            self._proxies[ty] = p
-            try:
-                m = self.make_obj_marshaler(ty, rec, **kwargs)
-            finally:
-                del self._proxies[ty]
-            p.m = m
+CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
 
-            if not no_cache:
-                self._obj_marshalers[ty] = m
-            return m
 
-    #
+########################################
+# ../deploy/commands.py
 
-    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
-        return ObjMarshalContext(
-            options=opts or self._default_options,
-            manager=self,
-        )
 
-    def marshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        m = self.get_obj_marshaler(ty if ty is not None else type(o))
-        return m.marshal(o, self._make_context(opts))
+##
 
-    def unmarshal_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Union[ta.Type[T], ta.Any],
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> T:
-        m = self.get_obj_marshaler(ty)
-        return m.unmarshal(o, self._make_context(opts))
 
-    def roundtrip_obj(
-            self,
-            o: ta.Any,
-            ty: ta.Any = None,
-            opts: ta.Optional[ObjMarshalOptions] = None,
-    ) -> ta.Any:
-        if ty is None:
-            ty = type(o)
-        m: ta.Any = self.marshal_obj(o, ty, opts)
-        u: ta.Any = self.unmarshal_obj(m, ty, opts)
-        return u
+@dc.dataclass(frozen=True)
+class DeployCommand(Command['DeployCommand.Output']):
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pass
 
 
-@dc.dataclass(frozen=True)
-class ObjMarshalContext:
-    options: ObjMarshalOptions
-    manager: ObjMarshalerManager
+class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
+    async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
+        log.info('Deploying!')
 
+        return DeployCommand.Output()
 
-##
 
+########################################
+# ../marshal.py
 
-OBJ_MARSHALER_MANAGER = ObjMarshalerManager()
 
-register_opj_marshaler = OBJ_MARSHALER_MANAGER.register_opj_marshaler
-get_obj_marshaler = OBJ_MARSHALER_MANAGER.get_obj_marshaler
-
-marshal_obj = OBJ_MARSHALER_MANAGER.marshal_obj
-unmarshal_obj = OBJ_MARSHALER_MANAGER.unmarshal_obj
+@dc.dataclass(frozen=True)
+class ObjMarshalerInstaller:
+    fn: ta.Callable[[ObjMarshalerManager], None]
 
 
-########################################
-# ../../../omlish/lite/runtime.py
+ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])
 
 
-@cached_nullary
-def is_debugger_attached() -> bool:
-    return any(frame[1].endswith('pydevd.py') for frame in inspect.stack())
+########################################
+# ../remote/channel.py
 
 
-REQUIRED_PYTHON_VERSION = (3, 8)
+##
 
 
-def check_runtime_version() -> None:
-    if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+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
 
-########################################
-# ../../../omdev/interp/types.py
+    def set_marshaler(self, msh: ObjMarshalerManager) -> None:  # noqa
+        pass
 
 
-# See https://peps.python.org/pep-3149/
-INTERP_OPT_GLYPHS_BY_ATTR: ta.Mapping[str, str] = collections.OrderedDict([
-    ('debug', 'd'),
-    ('threaded', 't'),
-])
+##
 
-INTERP_OPT_ATTRS_BY_GLYPH: ta.Mapping[str, str] = collections.OrderedDict(
-    (g, a) for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items()
-)
 
+class RemoteChannelImpl(RemoteChannel):
+    def __init__(
+            self,
+            input: asyncio.StreamReader,  # noqa
+            output: asyncio.StreamWriter,
+            *,
+            msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
+    ) -> None:
+        super().__init__()
 
-@dc.dataclass(frozen=True)
-class InterpOpts:
-    threaded: bool = False
-    debug: bool = False
+        self._input = input
+        self._output = output
+        self._msh = msh
 
-    def __str__(self) -> str:
-        return ''.join(g for a, g in INTERP_OPT_GLYPHS_BY_ATTR.items() if getattr(self, a))
+        self._input_lock = asyncio.Lock()
+        self._output_lock = asyncio.Lock()
 
-    @classmethod
-    def parse(cls, s: str) -> 'InterpOpts':
-        return cls(**{INTERP_OPT_ATTRS_BY_GLYPH[g]: True for g in s})
+    def set_marshaler(self, msh: ObjMarshalerManager) -> None:
+        self._msh = msh
 
-    @classmethod
-    def parse_suffix(cls, s: str) -> ta.Tuple[str, 'InterpOpts']:
-        kw = {}
-        while s and (a := INTERP_OPT_ATTRS_BY_GLYPH.get(s[-1])):
-            s, kw[a] = s[:-1], True
-        return s, cls(**kw)
+    #
 
+    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')
 
-@dc.dataclass(frozen=True)
-class InterpVersion:
-    version: Version
-    opts: InterpOpts
+        self._output.write(struct.pack('<I', len(d)))
+        self._output.write(d)
+        await self._output.drain()
 
-    def __str__(self) -> str:
-        return str(self.version) + str(self.opts)
+    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)
 
-    @classmethod
-    def parse(cls, s: str) -> 'InterpVersion':
-        s, o = InterpOpts.parse_suffix(s)
-        v = Version(s)
-        return cls(
-            version=v,
-            opts=o,
-        )
+    #
 
-    @classmethod
-    def try_parse(cls, s: str) -> ta.Optional['InterpVersion']:
-        try:
-            return cls.parse(s)
-        except (KeyError, InvalidVersion):
+    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 = await self._input.read(sz)
+        if len(d) != sz:
+            raise EOFError
 
-@dc.dataclass(frozen=True)
-class InterpSpecifier:
-    specifier: Specifier
-    opts: InterpOpts
-
-    def __str__(self) -> str:
-        return str(self.specifier) + str(self.opts)
+        j = json.loads(d.decode('utf-8'))
+        return self._msh.unmarshal_obj(j, ty)
 
-    @classmethod
-    def parse(cls, s: str) -> '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,
-        )
+    async def recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
+        async with self._input_lock:
+            return await self._recv_obj(ty)
 
-    def contains(self, iv: InterpVersion) -> bool:
-        return self.specifier.contains(iv.version) and self.opts == iv.opts
 
-    def __contains__(self, iv: InterpVersion) -> bool:
-        return self.contains(iv)
+########################################
+# ../system/config.py
 
 
 @dc.dataclass(frozen=True)
-class Interp:
-    exe: str
-    version: InterpVersion
+class SystemConfig:
+    platform: ta.Optional[Platform] = None
 
 
 ########################################
-# ../../configs.py
+# ../../../omlish/logs/standard.py
+"""
+TODO:
+ - structured
+ - prefixed
+ - debug
+"""
 
 
-def parse_config_file(
-        name: str,
-        f: ta.TextIO,
-) -> ConfigMapping:
-    if name.endswith('.toml'):
-        return toml_loads(f.read())
+##
 
-    elif any(name.endswith(e) for e in ('.yml', '.yaml')):
-        yaml = __import__('yaml')
-        return yaml.safe_load(f)
 
-    elif name.endswith('.ini'):
-        import configparser
-        cp = configparser.ConfigParser()
-        cp.read_file(f)
-        config_dct: ta.Dict[str, ta.Any] = {}
-        for sec in cp.sections():
-            cd = config_dct
-            for k in sec.split('.'):
-                cd = cd.setdefault(k, {})
-            cd.update(cp.items(sec))
-        return config_dct
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)-6s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
 
-    else:
-        return json.loads(f.read())
 
+class StandardLogFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
 
-def read_config_file(
-        path: str,
-        cls: ta.Type[T],
-        *,
-        prepare: ta.Optional[ta.Callable[[ConfigMapping], ConfigMapping]] = None,
-) -> T:
-    with open(path) as cf:
-        config_dct = parse_config_file(os.path.basename(path), cf)
+    converter = datetime.datetime.fromtimestamp  # type: ignore
 
-    if prepare is not None:
-        config_dct = prepare(config_dct)
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)  # type: ignore
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
-    return unmarshal_obj(config_dct, cls)
 
+##
 
-def build_config_named_children(
-        o: ta.Union[
-            ta.Sequence[ConfigMapping],
-            ta.Mapping[str, ConfigMapping],
-            None,
-        ],
-        *,
-        name_key: str = 'name',
-) -> ta.Optional[ta.Sequence[ConfigMapping]]:
-    if o is None:
-        return None
 
-    lst: ta.List[ConfigMapping] = []
-    if isinstance(o, ta.Mapping):
-        for k, v in o.items():
-            check.isinstance(v, ta.Mapping)
-            if name_key in v:
-                n = v[name_key]
-                if k != n:
-                    raise KeyError(f'Given names do not match: {n} != {k}')
-                lst.append(v)
-            else:
-                lst.append({name_key: k, **v})
+class StandardLogHandler(ProxyLogHandler):
+    pass
 
-    else:
-        check.not_isinstance(o, str)
-        lst.extend(o)
 
-    seen = set()
-    for d in lst:
-        n = d['name']
-        if n in d:
-            raise KeyError(f'Duplicate name: {n}')
-        seen.add(n)
+##
 
-    return lst
 
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
 
-########################################
-# ../commands/marshal.py
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
 
-
-def install_command_marshaling(
-        cmds: CommandNameMap,
-        msh: ObjMarshalerManager,
-) -> None:
-    for fn in [
-        lambda c: c,
-        lambda c: c.Output,
-    ]:
-        msh.register_opj_marshaler(
-            fn(Command),
-            PolymorphicObjMarshaler.of([
-                PolymorphicObjMarshaler.Impl(
-                    fn(cmd),
-                    name,
-                    msh.get_obj_marshaler(fn(cmd)),
-                )
-                for name, cmd in cmds.items()
-            ]),
-        )
-
-
-########################################
-# ../commands/ping.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class PingCommand(Command['PingCommand.Output']):
-    time: float = dc.field(default_factory=time.time)
-
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        time: float
-
-
-class PingCommandExecutor(CommandExecutor[PingCommand, PingCommand.Output]):
-    async def execute(self, cmd: PingCommand) -> PingCommand.Output:
-        return PingCommand.Output(cmd.time)
-
-
-########################################
-# ../commands/types.py
-
-
-CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
-
-
-########################################
-# ../deploy/commands.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class DeployCommand(Command['DeployCommand.Output']):
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        pass
-
-
-class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
-        log.info('Deploying!')
-
-        return DeployCommand.Output()
-
-
-########################################
-# ../marshal.py
-
-
-@dc.dataclass(frozen=True)
-class ObjMarshalerInstaller:
-    fn: ta.Callable[[ObjMarshalerManager], None]
-
-
-ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])
-
-
-########################################
-# ../remote/channel.py
-
-
-##
-
-
-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: asyncio.StreamReader,  # noqa
-            output: asyncio.StreamWriter,
-            *,
-            msh: ObjMarshalerManager = OBJ_MARSHALER_MANAGER,
-    ) -> None:
-        super().__init__()
-
-        self._input = input
-        self._output = output
-        self._msh = msh
-
-        self._input_lock = asyncio.Lock()
-        self._output_lock = asyncio.Lock()
-
-    def set_marshaler(self, msh: ObjMarshalerManager) -> None:
-        self._msh = msh
-
-    #
-
-    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)
-        await self._output.drain()
-
-    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)
-
-    #
-
-    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 = 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)
-
-    async def recv_obj(self, ty: ta.Type[T]) -> ta.Optional[T]:
-        async with self._input_lock:
-            return await self._recv_obj(ty)
+    else:
+        raise Exception("Can't find lock in logging module")
 
 
-########################################
-# ../system/platforms.py
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class Platform(abc.ABC):  # noqa
-    pass
-
-
-class LinuxPlatform(Platform, abc.ABC):
-    pass
-
-
-class UbuntuPlatform(LinuxPlatform):
-    pass
-
-
-class AmazonLinuxPlatform(LinuxPlatform):
-    pass
-
-
-class GenericLinuxPlatform(LinuxPlatform):
-    pass
-
-
-class DarwinPlatform(Platform):
-    pass
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardLogHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
 
+        #
 
-class UnknownPlatform(Platform):
-    pass
+        if not force:
+            if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
+                return None
 
+        #
 
-##
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
 
+        #
 
-def _detect_system_platform() -> Platform:
-    plat = sys.platform
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLogFormatter()
+        else:
+            formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
 
-    if plat == 'linux':
-        if (osr := LinuxOsRelease.read()) is None:
-            return GenericLinuxPlatform()
+        #
 
-        if osr.id == 'amzn':
-            return AmazonLinuxPlatform()
+        handler.addFilter(TidLogFilter())
 
-        elif osr.id == 'ubuntu':
-            return UbuntuPlatform()
+        #
 
-        else:
-            return GenericLinuxPlatform()
+        target.addHandler(handler)
 
-    elif plat == 'darwin':
-        return DarwinPlatform()
+        #
 
-    else:
-        return UnknownPlatform()
+        if level is not None:
+            target.setLevel(level)
 
+        #
 
-@cached_nullary
-def detect_system_platform() -> Platform:
-    platform = _detect_system_platform()
-    log.info('Detected platform: %r', platform)
-    return platform
+        return StandardLogHandler(handler)
 
 
 ########################################
-# ../../../omlish/lite/subprocesses.py
+# ../../../omlish/subprocesses.py
 
 
 ##
@@ -6734,8 +6795,8 @@ def subprocess_close(
 ##
 
 
-class AbstractSubprocesses(abc.ABC):  # noqa
-    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = log
+class BaseSubprocesses(abc.ABC):  # noqa
+    DEFAULT_LOGGER: ta.ClassVar[ta.Optional[logging.Logger]] = None
 
     def __init__(
             self,
@@ -6748,6 +6809,9 @@ class AbstractSubprocesses(abc.ABC):  # noqa
         self._log = log if log is not None else self.DEFAULT_LOGGER
         self._try_exceptions = try_exceptions if try_exceptions is not None else self.DEFAULT_TRY_EXCEPTIONS
 
+    def set_logger(self, log: ta.Optional[logging.Logger]) -> None:
+        self._log = log
+
     #
 
     def prepare_args(
@@ -6859,23 +6923,25 @@ class AbstractSubprocesses(abc.ABC):  # noqa
 ##
 
 
-class Subprocesses(AbstractSubprocesses):
+class AbstractSubprocesses(BaseSubprocesses, abc.ABC):
+    @abc.abstractmethod
     def check_call(
             self,
             *cmd: str,
             stdout: ta.Any = sys.stderr,
             **kwargs: ta.Any,
     ) -> None:
-        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
-            subprocess.check_call(cmd, **kwargs)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def check_output(
             self,
             *cmd: str,
             **kwargs: ta.Any,
     ) -> bytes:
-        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
-            return subprocess.check_output(cmd, **kwargs)
+        raise NotImplementedError
+
+    #
 
     def check_output_str(
             self,
@@ -6917,9 +6983,109 @@ class Subprocesses(AbstractSubprocesses):
             return ret.decode().strip()
 
 
+##
+
+
+class Subprocesses(AbstractSubprocesses):
+    def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, **kwargs) as (cmd, kwargs):  # noqa
+            subprocess.check_call(cmd, **kwargs)
+
+    def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, **kwargs) as (cmd, kwargs):  # noqa
+            return subprocess.check_output(cmd, **kwargs)
+
+
 subprocesses = Subprocesses()
 
 
+##
+
+
+class AbstractAsyncSubprocesses(BaseSubprocesses):
+    @abc.abstractmethod
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        raise NotImplementedError
+
+    #
+
+    async def check_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> str:
+        return (await self.check_output(*cmd, **kwargs)).decode().strip()
+
+    #
+
+    async def try_call(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bool:
+        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
+            return False
+        else:
+            return True
+
+    async def try_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[bytes]:
+        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
+            return None
+        else:
+            return ret
+
+    async def try_output_str(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[str]:
+        if (ret := await self.try_output(*cmd, **kwargs)) is None:
+            return None
+        else:
+            return ret.decode().strip()
+
+
+########################################
+# ../bootstrap.py
+
+
+@dc.dataclass(frozen=True)
+class MainBootstrap:
+    main_config: MainConfig = MainConfig()
+
+    deploy_config: DeployConfig = DeployConfig()
+
+    remote_config: RemoteConfig = RemoteConfig()
+
+    system_config: SystemConfig = SystemConfig()
+
+
 ########################################
 # ../commands/local.py
 
@@ -7337,16 +7503,7 @@ class RemoteCommandExecutor(CommandExecutor):
 
 
 ########################################
-# ../system/config.py
-
-
-@dc.dataclass(frozen=True)
-class SystemConfig:
-    platform: ta.Optional[Platform] = None
-
-
-########################################
-# ../../../omlish/lite/asyncio/subprocesses.py
+# ../../../omlish/asyncs/asyncio/subprocesses.py
 
 
 ##
@@ -7357,6 +7514,8 @@ class AsyncioProcessCommunicator:
             self,
             proc: asyncio.subprocess.Process,
             loop: ta.Optional[ta.Any] = None,
+            *,
+            log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
 
@@ -7365,6 +7524,7 @@ class AsyncioProcessCommunicator:
 
         self._proc = proc
         self._loop = loop
+        self._log = log
 
         self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
@@ -7380,19 +7540,19 @@ class AsyncioProcessCommunicator:
         try:
             if input is not None:
                 stdin.write(input)
-                if self._debug:
-                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+                if self._debug and self._log is not None:
+                    self._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 and self._log is not None:
+                self._log.debug('%r communicate: stdin got %r', self, exc)
 
-        if self._debug:
-            log.debug('%r communicate: close stdin', self)
+        if self._debug and self._log is not None:
+            self._log.debug('%r communicate: close stdin', self)
 
         stdin.close()
 
@@ -7408,15 +7568,15 @@ class AsyncioProcessCommunicator:
             check.equal(fd, 1)
             stream = check.not_none(self._proc.stdout)
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: read %s', self, name)
+            self._log.debug('%r communicate: read %s', self, name)
 
         output = await stream.read()
 
-        if self._debug:
+        if self._debug and self._log is not None:
             name = 'stdout' if fd == 1 else 'stderr'
-            log.debug('%r communicate: close %s', self, name)
+            self._log.debug('%r communicate: close %s', self, name)
 
         transport.close()
 
@@ -7465,7 +7625,7 @@ class AsyncioProcessCommunicator:
 ##
 
 
-class AsyncioSubprocesses(AbstractSubprocesses):
+class AsyncioSubprocesses(AbstractAsyncSubprocesses):
     async def communicate(
             self,
             proc: asyncio.subprocess.Process,
@@ -7562,45 +7722,6 @@ class AsyncioSubprocesses(AbstractSubprocesses):
         with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
             return check.not_none((await self.run(*cmd, **kwargs)).stdout)
 
-    async def check_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> str:
-        return (await self.check_output(*cmd, **kwargs)).decode().strip()
-
-    #
-
-    async def try_call(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> bool:
-        if isinstance(await self.async_try_fn(self.check_call, *cmd, **kwargs), Exception):
-            return False
-        else:
-            return True
-
-    async def try_output(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[bytes]:
-        if isinstance(ret := await self.async_try_fn(self.check_output, *cmd, **kwargs), Exception):
-            return None
-        else:
-            return ret
-
-    async def try_output_str(
-            self,
-            *cmd: str,
-            **kwargs: ta.Any,
-    ) -> ta.Optional[str]:
-        if (ret := await self.try_output(*cmd, **kwargs)) is None:
-            return None
-        else:
-            return ret.decode().strip()
-
 
 asyncio_subprocesses = AsyncioSubprocesses()
 
@@ -7700,21 +7821,6 @@ class InterpInspector:
 INTERP_INSPECTOR = InterpInspector()
 
 
-########################################
-# ../bootstrap.py
-
-
-@dc.dataclass(frozen=True)
-class MainBootstrap:
-    main_config: MainConfig = MainConfig()
-
-    deploy_config: DeployConfig = DeployConfig()
-
-    remote_config: RemoteConfig = RemoteConfig()
-
-    system_config: SystemConfig = SystemConfig()
-
-
 ########################################
 # ../commands/subprocess.py
 
@@ -7801,39 +7907,22 @@ github.com/wrmsr/omlish@rev
 ##
 
 
-@dc.dataclass(frozen=True)
-class DeployGitRepo:
-    host: ta.Optional[str] = None
-    username: ta.Optional[str] = None
-    path: ta.Optional[str] = None
-
-    def __post_init__(self) -> None:
-        check.not_in('..', check.non_empty_str(self.host))
-        check.not_in('.', check.non_empty_str(self.path))
-
-
-@dc.dataclass(frozen=True)
-class DeployGitSpec:
-    repo: DeployGitRepo
-    rev: DeployRev
-
-
-##
-
-
 class DeployGitManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: DeployHome,
+            deploy_home: ta.Optional[DeployHome] = None,
     ) -> None:
         super().__init__()
 
         self._deploy_home = deploy_home
-        self._dir = os.path.join(deploy_home, 'git')
 
         self._repo_dirs: ta.Dict[DeployGitRepo, DeployGitManager.RepoDir] = {}
 
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'git')
+
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
             DeployPath.parse('git'),
@@ -7850,7 +7939,7 @@ class DeployGitManager(DeployPathOwner):
             self._git = git
             self._repo = repo
             self._dir = os.path.join(
-                self._git._dir,  # noqa
+                self._git._dir(),  # noqa
                 check.non_empty_str(repo.host),
                 check.non_empty_str(repo.path),
             )
@@ -7907,8 +7996,8 @@ class DeployGitManager(DeployPathOwner):
             repo_dir = self._repo_dirs[repo] = DeployGitManager.RepoDir(self, repo)
             return repo_dir
 
-    async def checkout(self, spec: DeployGitSpec, dst_dir: str) -> None:
-        await self.get_repo_dir(spec.repo).checkout(spec.rev, dst_dir)
+    async def checkout(self, repo: DeployGitRepo, rev: DeployRev, dst_dir: str) -> None:
+        await self.get_repo_dir(repo).checkout(rev, dst_dir)
 
 
 ########################################
@@ -7924,12 +8013,15 @@ class DeployVenvManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: DeployHome,
+            deploy_home: ta.Optional[DeployHome] = None,
     ) -> None:
         super().__init__()
 
         self._deploy_home = deploy_home
-        self._dir = os.path.join(deploy_home, 'venvs')
+
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'venvs')
 
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
@@ -7966,66 +8058,208 @@ class DeployVenvManager(DeployPathOwner):
 
     async def setup_app_venv(self, app_tag: DeployAppTag) -> None:
         await self.setup_venv(
-            os.path.join(self._deploy_home, 'apps', app_tag.app, app_tag.tag),
-            os.path.join(self._deploy_home, 'venvs', app_tag.app, app_tag.tag),
+            os.path.join(check.non_empty_str(self._deploy_home), 'apps', app_tag.app, app_tag.tag),
+            os.path.join(self._dir(), app_tag.app, app_tag.tag),
         )
 
 
 ########################################
-# ../remote/spawning.py
+# ../remote/_main.py
 
 
 ##
 
 
-class RemoteSpawning(abc.ABC):
-    @dc.dataclass(frozen=True)
-    class Target:
-        shell: ta.Optional[str] = None
-        shell_quote: bool = False
+class _RemoteExecutionLogHandler(logging.Handler):
+    def __init__(self, fn: ta.Callable[[str], None]) -> None:
+        super().__init__()
+        self._fn = fn
 
-        DEFAULT_PYTHON: ta.ClassVar[str] = 'python3'
-        python: str = DEFAULT_PYTHON
+    def emit(self, record):
+        msg = self.format(record)
+        self._fn(msg)
 
-        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(
+
+class _RemoteExecutionMain:
+    def __init__(
             self,
-            tgt: Target,
-            src: str,
-            *,
-            timeout: ta.Optional[float] = None,
-            debug: bool = False,
-    ) -> ta.AsyncContextManager[Spawned]:
-        raise NotImplementedError
+            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)
 
-class SubprocessRemoteSpawning(RemoteSpawning):
-    class _PreparedCmd(ta.NamedTuple):  # noqa
-        cmd: ta.Sequence[str]
-        shell: bool
+    @property
+    def _injector(self) -> Injector:
+        return check.not_none(self.__injector)
 
-    def _prepare_cmd(
-            self,
-            tgt: RemoteSpawning.Target,
-            src: str,
-    ) -> _PreparedCmd:
-        if tgt.shell is not None:
-            sh_src = f'{tgt.python} -c {shlex.quote(src)}'
-            if tgt.shell_quote:
-                sh_src = shlex.quote(sh_src)
-            sh_cmd = f'{tgt.shell} {sh_src}'
-            return SubprocessRemoteSpawning._PreparedCmd([sh_cmd], shell=True)
+    #
+
+    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()
+
+        log.debug('Started timebomb thread: %r', thr)
+
+        return thr
+
+    #
+
+    @cached_nullary
+    def _log_handler(self) -> _RemoteLogHandler:
+        return _RemoteLogHandler(self._chan)
+
+    #
+
+    async def _setup(self) -> None:
+        check.none(self.__bootstrap)
+        check.none(self.__injector)
+
+        # Bootstrap
+
+        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
+
+        if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
+            pycharm_debug_connect(prd)
+
+        self.__injector = main_bootstrap(self._bootstrap)
+
+        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(abc.ABC):
+    @dc.dataclass(frozen=True)
+    class Target:
+        shell: ta.Optional[str] = None
+        shell_quote: bool = False
+
+        DEFAULT_PYTHON: ta.ClassVar[str] = 'python3'
+        python: str = DEFAULT_PYTHON
+
+        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 SubprocessRemoteSpawning(RemoteSpawning):
+    class _PreparedCmd(ta.NamedTuple):  # noqa
+        cmd: ta.Sequence[str]
+        shell: bool
+
+    def _prepare_cmd(
+            self,
+            tgt: RemoteSpawning.Target,
+            src: str,
+    ) -> _PreparedCmd:
+        if tgt.shell is not None:
+            sh_src = f'{tgt.python} -c {shlex.quote(src)}'
+            if tgt.shell_quote:
+                sh_src = shlex.quote(sh_src)
+            sh_cmd = f'{tgt.shell} {sh_src}'
+            return SubprocessRemoteSpawning._PreparedCmd([sh_cmd], shell=True)
 
         else:
             return SubprocessRemoteSpawning._PreparedCmd([tgt.python, '-c', src], shell=False)
@@ -8366,14 +8600,14 @@ def make_deploy_tag(
         now = datetime.datetime.utcnow()  # noqa
     now_fmt = '%Y%m%dT%H%M%S'
     now_str = now.strftime(now_fmt)
-    return DeployTag('-'.join([rev, now_str]))
+    return DeployTag('-'.join([now_str, rev]))
 
 
 class DeployAppManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: DeployHome,
+            deploy_home: ta.Optional[DeployHome] = None,
             git: DeployGitManager,
             venvs: DeployVenvManager,
     ) -> None:
@@ -8383,7 +8617,9 @@ class DeployAppManager(DeployPathOwner):
         self._git = git
         self._venvs = venvs
 
-        self._dir = os.path.join(deploy_home, 'apps')
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), 'apps')
 
     def get_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
@@ -8392,20 +8628,16 @@ class DeployAppManager(DeployPathOwner):
 
     async def prepare_app(
             self,
-            app: DeployApp,
-            rev: DeployRev,
-            repo: DeployGitRepo,
+            spec: DeploySpec,
     ):
-        app_tag = DeployAppTag(app, make_deploy_tag(rev))
-        app_dir = os.path.join(self._dir, app, app_tag.tag)
+        app_tag = DeployAppTag(spec.app, make_deploy_tag(spec.rev))
+        app_dir = os.path.join(self._dir(), spec.app, app_tag.tag)
 
         #
 
         await self._git.checkout(
-            DeployGitSpec(
-                repo=repo,
-                rev=rev,
-            ),
+            spec.repo,
+            spec.rev,
             app_dir,
         )
 
@@ -8415,145 +8647,122 @@ class DeployAppManager(DeployPathOwner):
 
 
 ########################################
-# ../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)
+# ../remote/connection.py
 
 
 ##
 
 
-class _RemoteExecutionMain:
+class PyremoteRemoteExecutionConnector:
     def __init__(
             self,
-            chan: RemoteChannel,
+            *,
+            spawning: RemoteSpawning,
+            msh: ObjMarshalerManager,
+            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
     ) -> None:
         super().__init__()
 
-        self._chan = chan
+        self._spawning = spawning
+        self._msh = msh
+        self._payload_file = payload_file
 
-        self.__bootstrap: ta.Optional[MainBootstrap] = None
-        self.__injector: ta.Optional[Injector] = None
+    #
 
-    @property
-    def _bootstrap(self) -> MainBootstrap:
-        return check.not_none(self.__bootstrap)
+    @cached_nullary
+    def _payload_src(self) -> str:
+        return get_remote_payload_src(file=self._payload_file)
 
-    @property
-    def _injector(self) -> Injector:
-        return check.not_none(self.__injector)
+    @cached_nullary
+    def _remote_src(self) -> ta.Sequence[str]:
+        return [
+            self._payload_src(),
+            '_remote_execution_main()',
+        ]
+
+    @cached_nullary
+    def _spawn_src(self) -> str:
+        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
 
     #
 
-    def _timebomb_main(
+    @contextlib.asynccontextmanager
+    async def connect(
             self,
-            delay_s: float,
-            *,
-            sig: int = signal.SIGINT,
-            code: int = 1,
-    ) -> None:
-        time.sleep(delay_s)
+            tgt: RemoteSpawning.Target,
+            bs: MainBootstrap,
+    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        spawn_src = self._spawn_src()
+        remote_src = self._remote_src()
 
-        if (pgid := os.getpgid(0)) == os.getpid():
-            os.killpg(pgid, sig)
+        async with self._spawning.spawn(
+                tgt,
+                spawn_src,
+                debug=bs.main_config.debug,
+        ) as proc:
+            res = await PyremoteBootstrapDriver(  # noqa
+                remote_src,
+                PyremoteBootstrapOptions(
+                    debug=bs.main_config.debug,
+                ),
+            ).async_run(
+                proc.stdout,
+                proc.stdin,
+            )
 
-        os._exit(code)  # noqa
+            chan = RemoteChannelImpl(
+                proc.stdout,
+                proc.stdin,
+                msh=self._msh,
+            )
 
-    @cached_nullary
-    def _timebomb_thread(self) -> ta.Optional[threading.Thread]:
-        if (tbd := self._bootstrap.remote_config.timebomb_delay_s) is None:
-            return None
+            await chan.send_obj(bs)
 
-        thr = threading.Thread(
-            target=functools.partial(self._timebomb_main, tbd),
-            name=f'{self.__class__.__name__}.timebomb',
-            daemon=True,
-        )
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(chan)) as rce:
+                await rce.start()
 
-        thr.start()
-
-        log.debug('Started timebomb thread: %r', thr)
-
-        return thr
-
-    #
-
-    @cached_nullary
-    def _log_handler(self) -> _RemoteLogHandler:
-        return _RemoteLogHandler(self._chan)
-
-    #
-
-    async def _setup(self) -> None:
-        check.none(self.__bootstrap)
-        check.none(self.__injector)
-
-        # Bootstrap
-
-        self.__bootstrap = check.not_none(await self._chan.recv_obj(MainBootstrap))
-
-        if (prd := self._bootstrap.remote_config.pycharm_remote_debug) is not None:
-            pycharm_debug_connect(prd)
-
-        self.__injector = main_bootstrap(self._bootstrap)
-
-        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())
+                yield rce
 
-    #
 
-    async def run(self) -> None:
-        await self._setup()
-
-        executor = self._injector[LocalCommandExecutor]
+##
 
-        handler = _RemoteCommandHandler(self._chan, executor)
 
-        await handler.run()
+class InProcessRemoteExecutionConnector:
+    def __init__(
+            self,
+            *,
+            msh: ObjMarshalerManager,
+            local_executor: LocalCommandExecutor,
+    ) -> None:
+        super().__init__()
 
+        self._msh = msh
+        self._local_executor = local_executor
 
-def _remote_execution_main() -> None:
-    rt = pyremote_bootstrap_finalize()  # noqa
+    @contextlib.asynccontextmanager
+    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
+        r0, w0 = asyncio_create_bytes_channel()
+        r1, w1 = asyncio_create_bytes_channel()
 
-    async def inner() -> None:
-        input = await asyncio_open_stream_reader(rt.input)  # noqa
-        output = await asyncio_open_stream_writer(rt.output)
+        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
+        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
 
-        chan = RemoteChannelImpl(
-            input,
-            output,
+        rch = _RemoteCommandHandler(
+            remote_chan,
+            self._local_executor,
         )
+        rch_task = asyncio.create_task(rch.run())  # noqa
+        try:
+            rce: RemoteCommandExecutor
+            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
+                await rce.start()
 
-        await _RemoteExecutionMain(chan).run()
+                yield rce
 
-    asyncio.run(inner())
+        finally:
+            rch.stop()
+            await rch_task
 
 
 ########################################
@@ -8899,521 +9108,256 @@ class PyenvVersionInstaller:
                 self._pyenv.exe(),
                 'install',
                 *conf_args,
-            ]
-
-        await asyncio_subprocesses.check_call(
-            *full_args,
-            env=env,
-        )
-
-        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
-
-
-##
-
-
-class PyenvInterpProvider(InterpProvider):
-    def __init__(
-            self,
-            pyenv: Pyenv = Pyenv(),
-
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
-
-            *,
-
-            try_update: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self._pyenv = pyenv
-
-        self._inspect = inspect
-        self._inspector = inspector
-
-        self._try_update = try_update
-
-    #
-
-    @staticmethod
-    def guess_version(s: str) -> ta.Optional[InterpVersion]:
-        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
-            if s.endswith(sfx):
-                return s[:-len(sfx)], True
-            return s, False
-        ok = {}
-        s, ok['debug'] = strip_sfx(s, '-debug')
-        s, ok['threaded'] = strip_sfx(s, 't')
-        try:
-            v = Version(s)
-        except InvalidVersion:
-            return None
-        return InterpVersion(v, InterpOpts(**ok))
-
-    class Installed(ta.NamedTuple):
-        name: str
-        exe: str
-        version: InterpVersion
-
-    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
-        iv: ta.Optional[InterpVersion]
-        if self._inspect:
-            try:
-                iv = check.not_none(await self._inspector.inspect(ep)).iv
-            except Exception as e:  # noqa
-                return None
-        else:
-            iv = self.guess_version(vn)
-        if iv is None:
-            return None
-        return PyenvInterpProvider.Installed(
-            name=vn,
-            exe=ep,
-            version=iv,
-        )
-
-    async def installed(self) -> ta.Sequence[Installed]:
-        ret: ta.List[PyenvInterpProvider.Installed] = []
-        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)
-        return ret
-
-    #
-
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in await 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,
-                    version=i.version,
-                )
-        raise KeyError(version)
-
-    #
-
-    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = []
-
-        for vs in await self._pyenv.installable_versions():
-            if (iv := self.guess_version(vs)) is None:
-                continue
-            if iv.opts.debug:
-                raise Exception('Pyenv installable versions not expected to have debug suffix')
-            for d in [False, True]:
-                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
-
-        return lst
-
-    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 = await self._get_installable_versions(spec)
-
-        return lst
-
-    async def install_version(self, version: InterpVersion) -> Interp:
-        inst_version = str(version.version)
-        inst_opts = version.opts
-        if inst_opts.threaded:
-            inst_version += 't'
-            inst_opts = dc.replace(inst_opts, threaded=False)
-
-        installer = PyenvVersionInstaller(
-            inst_version,
-            interp_opts=inst_opts,
-        )
-
-        exe = await installer.install()
-        return Interp(exe, version)
-
-
-########################################
-# ../../../omdev/interp/system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
-
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
-
-    #
-
-    @staticmethod
-    def _re_which(
-            pat: re.Pattern,
-            *,
-            mode: int = os.F_OK | os.X_OK,
-            path: ta.Optional[str] = None,
-    ) -> ta.List[str]:
-        if path is None:
-            path = os.environ.get('PATH', None)
-            if path is None:
-                try:
-                    path = os.confstr('CS_PATH')
-                except (AttributeError, ValueError):
-                    path = os.defpath
-
-        if not path:
-            return []
-
-        path = os.fsdecode(path)
-        pathlst = path.split(os.pathsep)
-
-        def _access_check(fn: str, mode: int) -> bool:
-            return os.path.exists(fn) and os.access(fn, mode)
-
-        out = []
-        seen = set()
-        for d in pathlst:
-            normdir = os.path.normcase(d)
-            if normdir not in seen:
-                seen.add(normdir)
-                if not _access_check(normdir, mode):
-                    continue
-                for thefile in os.listdir(d):
-                    name = os.path.join(d, thefile)
-                    if not (
-                            os.path.isfile(name) and
-                            pat.fullmatch(thefile) and
-                            _access_check(name, mode)
-                    ):
-                        continue
-                    out.append(name)
-
-        return out
-
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
-
-    #
-
-    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
-        if not self.inspect:
-            s = os.path.basename(exe)
-            if s.startswith('python'):
-                s = s[len('python'):]
-            if '.' in s:
-                try:
-                    return InterpVersion.parse(s)
-                except InvalidVersion:
-                    pass
-        ii = await self.inspector.inspect(exe)
-        return ii.iv if ii is not None else None
-
-    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
-        lst = []
-        for e in self.exes():
-            if (ev := await self.get_exe_version(e)) is None:
-                log.debug('Invalid system version: %s', e)
-                continue
-            lst.append((e, ev))
-        return lst
-
-    #
-
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in await 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(
-                exe=e,
-                version=ev,
-            )
-        raise KeyError(version)
-
-
-########################################
-# ../remote/connection.py
-
-
-##
-
-
-class PyremoteRemoteExecutionConnector:
-    def __init__(
-            self,
-            *,
-            spawning: RemoteSpawning,
-            msh: ObjMarshalerManager,
-            payload_file: ta.Optional[RemoteExecutionPayloadFile] = None,
-    ) -> None:
-        super().__init__()
-
-        self._spawning = spawning
-        self._msh = msh
-        self._payload_file = payload_file
-
-    #
-
-    @cached_nullary
-    def _payload_src(self) -> str:
-        return get_remote_payload_src(file=self._payload_file)
-
-    @cached_nullary
-    def _remote_src(self) -> ta.Sequence[str]:
-        return [
-            self._payload_src(),
-            '_remote_execution_main()',
-        ]
-
-    @cached_nullary
-    def _spawn_src(self) -> str:
-        return pyremote_build_bootstrap_cmd(__package__ or 'manage')
-
-    #
-
-    @contextlib.asynccontextmanager
-    async def connect(
-            self,
-            tgt: RemoteSpawning.Target,
-            bs: MainBootstrap,
-    ) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        spawn_src = self._spawn_src()
-        remote_src = self._remote_src()
-
-        async with self._spawning.spawn(
-                tgt,
-                spawn_src,
-                debug=bs.main_config.debug,
-        ) as proc:
-            res = await PyremoteBootstrapDriver(  # noqa
-                remote_src,
-                PyremoteBootstrapOptions(
-                    debug=bs.main_config.debug,
-                ),
-            ).async_run(
-                proc.stdout,
-                proc.stdin,
-            )
-
-            chan = RemoteChannelImpl(
-                proc.stdout,
-                proc.stdin,
-                msh=self._msh,
-            )
-
-            await chan.send_obj(bs)
-
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(chan)) as rce:
-                await rce.start()
+            ]
 
-                yield rce
+        await asyncio_subprocesses.check_call(
+            *full_args,
+            env=env,
+        )
+
+        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
 
 
 ##
 
 
-class InProcessRemoteExecutionConnector:
+class PyenvInterpProvider(InterpProvider):
     def __init__(
             self,
+            pyenv: Pyenv = Pyenv(),
+
+            inspect: bool = False,
+            inspector: InterpInspector = INTERP_INSPECTOR,
+
             *,
-            msh: ObjMarshalerManager,
-            local_executor: LocalCommandExecutor,
+
+            try_update: bool = False,
     ) -> None:
         super().__init__()
 
-        self._msh = msh
-        self._local_executor = local_executor
+        self._pyenv = pyenv
 
-    @contextlib.asynccontextmanager
-    async def connect(self) -> ta.AsyncGenerator[RemoteCommandExecutor, None]:
-        r0, w0 = asyncio_create_bytes_channel()
-        r1, w1 = asyncio_create_bytes_channel()
+        self._inspect = inspect
+        self._inspector = inspector
 
-        remote_chan = RemoteChannelImpl(r0, w1, msh=self._msh)
-        local_chan = RemoteChannelImpl(r1, w0, msh=self._msh)
+        self._try_update = try_update
 
-        rch = _RemoteCommandHandler(
-            remote_chan,
-            self._local_executor,
-        )
-        rch_task = asyncio.create_task(rch.run())  # noqa
+    #
+
+    @staticmethod
+    def guess_version(s: str) -> ta.Optional[InterpVersion]:
+        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
+            if s.endswith(sfx):
+                return s[:-len(sfx)], True
+            return s, False
+        ok = {}
+        s, ok['debug'] = strip_sfx(s, '-debug')
+        s, ok['threaded'] = strip_sfx(s, 't')
         try:
-            rce: RemoteCommandExecutor
-            async with aclosing(RemoteCommandExecutor(local_chan)) as rce:
-                await rce.start()
+            v = Version(s)
+        except InvalidVersion:
+            return None
+        return InterpVersion(v, InterpOpts(**ok))
 
-                yield rce
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
 
-        finally:
-            rch.stop()
-            await rch_task
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+        iv: ta.Optional[InterpVersion]
+        if self._inspect:
+            try:
+                iv = check.not_none(await self._inspector.inspect(ep)).iv
+            except Exception as e:  # noqa
+                return None
+        else:
+            iv = self.guess_version(vn)
+        if iv is None:
+            return None
+        return PyenvInterpProvider.Installed(
+            name=vn,
+            exe=ep,
+            version=iv,
+        )
 
+    async def installed(self) -> ta.Sequence[Installed]:
+        ret: ta.List[PyenvInterpProvider.Installed] = []
+        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)
+        return ret
 
-########################################
-# ../system/inject.py
+    #
 
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
 
-def bind_system(
-        *,
-        system_config: SystemConfig,
-) -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind(system_config),
-    ]
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for i in await self.installed():
+            if i.version == version:
+                return Interp(
+                    exe=i.exe,
+                    version=i.version,
+                )
+        raise KeyError(version)
 
     #
 
-    platform = system_config.platform or detect_system_platform()
-    lst.append(inj.bind(platform, key=Platform))
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
 
-    #
+        for vs in await self._pyenv.installable_versions():
+            if (iv := self.guess_version(vs)) is None:
+                continue
+            if iv.opts.debug:
+                raise Exception('Pyenv installable versions not expected to have debug suffix')
+            for d in [False, True]:
+                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
 
-    if isinstance(platform, AmazonLinuxPlatform):
-        lst.extend([
-            inj.bind(YumSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=YumSystemPackageManager),
-        ])
+        return lst
 
-    elif isinstance(platform, LinuxPlatform):
-        lst.extend([
-            inj.bind(AptSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=AptSystemPackageManager),
-        ])
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
 
-    elif isinstance(platform, DarwinPlatform):
-        lst.extend([
-            inj.bind(BrewSystemPackageManager, singleton=True),
-            inj.bind(SystemPackageManager, to_key=BrewSystemPackageManager),
-        ])
+        if self._try_update and not any(v in spec for v in lst):
+            if self._pyenv.update():
+                lst = await self._get_installable_versions(spec)
 
-    #
+        return lst
 
-    lst.extend([
-        bind_command(CheckSystemPackageCommand, CheckSystemPackageCommandExecutor),
-    ])
+    async def install_version(self, version: InterpVersion) -> Interp:
+        inst_version = str(version.version)
+        inst_opts = version.opts
+        if inst_opts.threaded:
+            inst_version += 't'
+            inst_opts = dc.replace(inst_opts, threaded=False)
 
-    #
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
+        )
 
-    return inj.as_bindings(*lst)
+        exe = await installer.install()
+        return Interp(exe, version)
 
 
 ########################################
-# ../../../omdev/interp/resolvers.py
-
-
-INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
-    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
-}
+# ../../../omdev/interp/system.py
+"""
+TODO:
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
+"""
 
 
-class InterpResolver:
-    def __init__(
-            self,
-            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
-    ) -> None:
-        super().__init__()
+##
 
-        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
-    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 await p.get_installed_versions(spec)
-            if spec.contains(si)
-        ]
+@dc.dataclass(frozen=True)
+class SystemInterpProvider(InterpProvider):
+    cmd: str = 'python3'
+    path: ta.Optional[str] = None
 
-        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
-        if not slst:
-            return None
+    inspect: bool = False
+    inspector: InterpInspector = INTERP_INSPECTOR
 
-        bi, bv = slst[-1]
-        bp = list(self._providers.values())[bi]
-        return (bp, bv)
+    #
 
-    async def resolve(
-            self,
-            spec: InterpSpecifier,
+    @staticmethod
+    def _re_which(
+            pat: re.Pattern,
             *,
-            install: bool = False,
-    ) -> ta.Optional[Interp]:
-        tup = await self._resolve_installed(spec)
-        if tup is not None:
-            bp, bv = tup
-            return await bp.get_installed_version(bv)
+            mode: int = os.F_OK | os.X_OK,
+            path: ta.Optional[str] = None,
+    ) -> ta.List[str]:
+        if path is None:
+            path = os.environ.get('PATH', None)
+            if path is None:
+                try:
+                    path = os.confstr('CS_PATH')
+                except (AttributeError, ValueError):
+                    path = os.defpath
 
-        if not install:
-            return None
+        if not path:
+            return []
 
-        tp = list(self._providers.values())[0]  # noqa
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
 
-        sv = sorted(
-            [s for s in await tp.get_installable_versions(spec) if s in spec],
-            key=lambda s: s.version,
-        )
-        if not sv:
-            return None
+        def _access_check(fn: str, mode: int) -> bool:
+            return os.path.exists(fn) and os.access(fn, mode)
+
+        out = []
+        seen = set()
+        for d in pathlst:
+            normdir = os.path.normcase(d)
+            if normdir not in seen:
+                seen.add(normdir)
+                if not _access_check(normdir, mode):
+                    continue
+                for thefile in os.listdir(d):
+                    name = os.path.join(d, thefile)
+                    if not (
+                            os.path.isfile(name) and
+                            pat.fullmatch(thefile) and
+                            _access_check(name, mode)
+                    ):
+                        continue
+                    out.append(name)
 
-        bv = sv[-1]
-        return await tp.install_version(bv)
+        return out
 
-    async def list(self, spec: InterpSpecifier) -> None:
-        print('installed:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installed_versions(spec)
-                if spec.contains(si)
-            ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self.path,
+        )
 
-        print()
+    #
 
-        print('installable:')
-        for n, p in self._providers.items():
-            lst = [
-                si
-                for si in await p.get_installable_versions(spec)
-                if spec.contains(si)
-            ]
-            if lst:
-                print(f'  {n}')
-                for si in lst:
-                    print(f'    {si}')
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self.inspect:
+            s = os.path.basename(exe)
+            if s.startswith('python'):
+                s = s[len('python'):]
+            if '.' in s:
+                try:
+                    return InterpVersion.parse(s)
+                except InvalidVersion:
+                    pass
+        ii = await self.inspector.inspect(exe)
+        return ii.iv if ii is not None else None
 
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+        lst = []
+        for e in self.exes():
+            if (ev := await self.get_exe_version(e)) is None:
+                log.debug('Invalid system version: %s', e)
+                continue
+            lst.append((e, ev))
+        return lst
 
-DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
-    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
-    PyenvInterpProvider(try_update=True),
+    #
 
-    RunningInterpProvider(),
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
 
-    SystemInterpProvider(),
-]])
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in await self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)
 
 
 ########################################
@@ -9444,6 +9388,54 @@ def bind_remote(
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../system/inject.py
+
+
+def bind_system(
+        *,
+        system_config: SystemConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(system_config),
+    ]
+
+    #
+
+    platform = system_config.platform or detect_system_platform()
+    lst.append(inj.bind(platform, key=Platform))
+
+    #
+
+    if isinstance(platform, AmazonLinuxPlatform):
+        lst.extend([
+            inj.bind(YumSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=YumSystemPackageManager),
+        ])
+
+    elif isinstance(platform, LinuxPlatform):
+        lst.extend([
+            inj.bind(AptSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=AptSystemPackageManager),
+        ])
+
+    elif isinstance(platform, DarwinPlatform):
+        lst.extend([
+            inj.bind(BrewSystemPackageManager, singleton=True),
+            inj.bind(SystemPackageManager, to_key=BrewSystemPackageManager),
+        ])
+
+    #
+
+    lst.extend([
+        bind_command(CheckSystemPackageCommand, CheckSystemPackageCommandExecutor),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # ../targets/connection.py
 
@@ -9579,33 +9571,101 @@ class SshManageTargetConnector(ManageTargetConnector):
 
 
 ########################################
-# ../deploy/interp.py
+# ../../../omdev/interp/resolvers.py
 
 
-##
+INTERP_PROVIDER_TYPES_BY_NAME: ta.Mapping[str, ta.Type[InterpProvider]] = {
+    cls.name: cls for cls in deep_subclasses(InterpProvider) if abc.ABC not in cls.__bases__  # type: ignore
+}
 
 
-@dc.dataclass(frozen=True)
-class InterpCommand(Command['InterpCommand.Output']):
-    spec: str
-    install: bool = False
+class InterpResolver:
+    def __init__(
+            self,
+            providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
+    ) -> None:
+        super().__init__()
 
-    @dc.dataclass(frozen=True)
-    class Output(Command.Output):
-        exe: str
-        version: str
-        opts: InterpOpts
+        self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
+    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 await p.get_installed_versions(spec)
+            if spec.contains(si)
+        ]
 
-class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
-    async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
-        i = InterpSpecifier.parse(check.not_none(cmd.spec))
-        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
-        return InterpCommand.Output(
-            exe=o.exe,
-            version=str(o.version.version),
-            opts=o.version.opts,
+        slst = sorted(lst, key=lambda t: (-t[0], t[1].version))
+        if not slst:
+            return None
+
+        bi, bv = slst[-1]
+        bp = list(self._providers.values())[bi]
+        return (bp, bv)
+
+    async def resolve(
+            self,
+            spec: InterpSpecifier,
+            *,
+            install: bool = False,
+    ) -> ta.Optional[Interp]:
+        tup = await self._resolve_installed(spec)
+        if tup is not None:
+            bp, bv = tup
+            return await bp.get_installed_version(bv)
+
+        if not install:
+            return None
+
+        tp = list(self._providers.values())[0]  # noqa
+
+        sv = sorted(
+            [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 await tp.install_version(bv)
+
+    async def list(self, spec: InterpSpecifier) -> None:
+        print('installed:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installed_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+        print()
+
+        print('installable:')
+        for n, p in self._providers.items():
+            lst = [
+                si
+                for si in await p.get_installable_versions(spec)
+                if spec.contains(si)
+            ]
+            if lst:
+                print(f'  {n}')
+                for si in lst:
+                    print(f'    {si}')
+
+
+DEFAULT_INTERP_RESOLVER = InterpResolver([(p.name, p) for p in [
+    # pyenv is preferred to system interpreters as it tends to have more support for things like tkinter
+    PyenvInterpProvider(try_update=True),
+
+    RunningInterpProvider(),
+
+    SystemInterpProvider(),
+]])
 
 
 ########################################
@@ -9637,6 +9697,36 @@ def bind_targets() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../deploy/interp.py
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class InterpCommand(Command['InterpCommand.Output']):
+    spec: str
+    install: bool = False
+
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        exe: str
+        version: str
+        opts: InterpOpts
+
+
+class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
+    async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
+        i = InterpSpecifier.parse(check.not_none(cmd.spec))
+        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        return InterpCommand.Output(
+            exe=o.exe,
+            version=str(o.version.version),
+            opts=o.version.opts,
+        )
+
+
 ########################################
 # ../deploy/inject.py