machineconfig 7.98__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/utils/path_extended.py

@@ -103,7 +103,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         slf = self.expanduser().resolve()
         if content:
             assert self.is_dir(), NotADirectoryError(f"💥 When `content` flag is set to True, path must be a directory. It is not: `{repr(self)}`")
-            [x.move(folder=path.parent, content=False, overwrite=overwrite) for x in self.search("*")]
+            [x.move(folder=path.parent, content=False, overwrite=overwrite) for x in self.glob("*")]
             return path  # contents live within this directory.
         if overwrite:
             tmp_path = slf.rename(path.parent.absolute() / randstr())
@@ -174,7 +174,8 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             appended_name = f"""{name}_{len(self.parent.search(f"*{self.name.split('.')[0]}*"))}"""
             return self.append(name=appended_name, index=False, verbose=verbose, suffix=suffix, **kwargs)
         full_name = name or ("_" + str(timestamp()))
-        full_suffix = suffix or "".join(("bruh" + self).suffixes)
+        whatever = ("bruh" + self)
+        full_suffix = suffix or "".join(whatever.suffixes)
         subpath = self.name.split(".")[0] + full_name + full_suffix
         dest = self.parent.joinpath(subpath)
         res = PathExtended(dest)
@@ -294,7 +295,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 target = "BROKEN LINK " + str(self)  # avoid infinite recursions for broken links.
             return "🔗 Symlink '" + str(self) + "' ==> " + (str(target) if target == self else str(target))
         elif self.is_absolute():
-            return self._type() + " '" + str(self.clickable()) + "'" + (" | " + datetime.fromtimestamp(self.stat().st_ctime).isoformat()[:-7].replace("T", "  ") if self.exists() else "") + (f" | {self.size()} Mb" if self.is_file() else "")
+            return self._type() + " '" + str(self.clickable()) + "'" + (" | " + datetime.fromtimestamp(self.stat().st_ctime).isoformat()[:-7].replace("T", "  ") if self.exists() else "") + (f" | {round(self.stat().st_size / (1024**2), 1)} Mb" if self.is_file() else "")
         elif "http" in str(self):
             return "🕸️ URL " + str(self.as_url_str())
         else:
@@ -476,7 +477,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         verbose: bool = True,
         content: bool = False,
         orig: bool = False,
-        pwd: Optional[str] = None,
         mode: FILE_MODE = "w",
         **kwargs: Any,
     ) -> "PathExtended":
@@ -493,7 +493,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path_resolved = PathExtended(op_zip)
         else:
             import shutil
-
             if content:
                 root_dir, base_dir = slf, "."
             else:
@@ -501,7 +500,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             base_name = str(path_resolved)[:-4] if str(path_resolved).endswith(".zip") else str(path_resolved)
             op_zip = shutil.make_archive(base_name=base_name, format="zip", root_dir=str(root_dir), base_dir=str(base_dir), verbose=False, **kwargs)
             path_resolved = PathExtended(op_zip)
-        msg = f"ZIPPED {repr(slf)} ==>  {repr(path)}"
+        msg = f"ZIPPED {repr(slf)} ==> {repr(path_resolved)}"
         res_out = PathExtended(path_resolved)
         ret = self if orig else res_out
         delayed_msg = ""
@@ -538,7 +537,9 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         assert merge is False, "I have not implemented this yet"
         assert path is None, "I have not implemented this yet"
         if tmp:
-            return self.unzip(folder=PathExtended.tmp().joinpath("tmp_unzips").joinpath(randstr()), content=True).joinpath(self.stem)
+            tmp_root = PathExtended("~/tmp_results").expanduser()
+            tmp_root.mkdir(parents=True, exist_ok=True)
+            return self.unzip(folder=tmp_root.joinpath("tmp_unzips").joinpath(randstr()), content=True).joinpath(self.stem)
         slf = zipfile__ = self.expanduser().resolve()
         if any(ztype in str(slf.parent) for ztype in (".zip", ".7z")):  # path include a zip archive in the middle.
             tmp__ = [item for item in (".zip", ".7z", "") if item in str(slf)]

machineconfig/utils/scheduler.py

@@ -166,7 +166,10 @@ class CacheMemory[T]():
         else:
             age = datetime.now() - self.time_produced
             if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):
-                self.logger.warning(f"""🔄 CACHE UPDATE ⚠️  {self.name} cache: Updating cache from source func. """ + f""" ⏱️  Age = {age} > {self.expire}""" if not fresh else f""" ⏱️  Age = {age}. Fresh flag raised.""")
+                if not fresh:
+                    self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ )
+                else:
+                    self.logger.warning(f"""⚠️ Fresh flag raised, age = {age} > {tolerance_seconds} seconds of tolerance. Updating {self.name} cache from source func.""")
                 t0 = time.time()
                 self.cache = self.source_func()
                 self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
@@ -202,7 +205,10 @@ class Cache[T]():  # This class helps to accelrate access to latest data coming
             if self.path.exists():  # prefer to read from disk over source func as a default source of cache.
                 age = datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
                 if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):  # cache is old or if fresh flag is raised
-                    self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ if not fresh else """⚠️  Fresh flag raised.""")
+                    if not fresh:
+                        self.logger.warning(f"""🔄 CACHE STALE 📦 {self.name} cache: Populating fresh cache from source func. """ + f"""⏱️  Age = {age} > Expiry {self.expire} """ )
+                    else:
+                        self.logger.warning(f"""⚠️ Fresh flag raised, age = {age} > {tolerance_seconds} seconds of tolerance. Updating {self.name} cache from source func.""")
                     t0 = time.time()
                     self.cache = self.source_func()  # fresh data.
                     self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")

machineconfig/utils/schemas/fire_agents/fire_agents_input.py

@@ -6,7 +6,7 @@ capturing all user inputs collected during interactive execution.
 
 from pathlib import Path
 from typing import TypedDict, Literal, NotRequired
-from machineconfig.scripts.python.helpers_agents.fire_agents_help_launch import AGENTS
+from machineconfig.scripts.python.helpers.helpers_agents.fire_agents_help_launch import AGENTS
 
 SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
 

machineconfig/utils/source_of_truth.py

@@ -5,7 +5,12 @@ Utils
 import machineconfig
 from pathlib import Path
 
-EXCLUDE_DIRS = [".links", ".ai", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"]
+EXCLUDE_DIRS = [".links", "notebooks",
+                "GEMINI.md", "CLAUDE.md", "CRUSH.md", "AGENTS.md",
+                ".cursor", ".clinerules", ".github/instructions", ".github/agents", ".github/prompts",
+                ".ai",
+                ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"
+                ]
 LIBRARY_ROOT = Path(machineconfig.__file__).resolve().parent
 
 CONFIG_ROOT = Path.home().joinpath(".config/machineconfig")

machineconfig/utils/ssh.py

@@ -2,8 +2,8 @@ from typing import Callable, Optional, Any, cast, Union, Literal
 import os
 from pathlib import Path
 import platform
-from machineconfig.scripts.python.helpers_utils.path import MachineSpecs
-from machineconfig.utils.code import get_uv_run_command
+from machineconfig.scripts.python.helpers.helpers_utils.python import MachineSpecs
+from machineconfig.utils.code import get_uv_command
 import rich.console
 from machineconfig.utils.terminal import Response
 from machineconfig.utils.accessories import pprint, randstr
@@ -14,7 +14,6 @@ from machineconfig.utils.ssh_utils.abc import DEFAULT_PICKLE_SUBDIR
 class SSH:
     @staticmethod
     def from_config_file(host: str) -> "SSH":
-        """Create SSH instance from SSH config file entry."""
         return SSH(host=host, username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=False)
 
     def __init__(
@@ -148,8 +147,10 @@ class SSH:
             def view_bar(self, transferred: int, total: int) -> None:
                 if self.progress and self.task is not None:
                     self.progress.update(self.task, completed=transferred, total=total)
+
         self.tqdm_wrap = RichProgressWrapper
-        from machineconfig.scripts.python.helpers_utils.path import get_machine_specs
+        from machineconfig.scripts.python.helpers.helpers_utils.python import get_machine_specs
+
         self.local_specs: MachineSpecs = get_machine_specs()
         resp = self.run_shell_cmd_on_remote(
             command="""~/.local/bin/utils get-machine-specs """,
@@ -160,6 +161,7 @@ class SSH:
         )
         json_str = resp.op
         import ast
+
         self.remote_specs: MachineSpecs = cast(MachineSpecs, ast.literal_eval(json_str))
         self.terminal_responses: list[Response] = []
 
@@ -177,10 +179,22 @@ class SSH:
         local_console = rich.console.Console(file=local_buffer, width=40)
         remote_console = rich.console.Console(file=remote_buffer, width=40)
         inspect(
-            type("LocalInfo", (object,), dict(self.local_specs))(), value=False, title="SSHing From", docs=False, dunder=False, sort=False, console=local_console
+            type("LocalInfo", (object,), dict(self.local_specs))(),
+            value=False,
+            title="SSHing From",
+            docs=False,
+            dunder=False,
+            sort=False,
+            console=local_console,
         )
         inspect(
-            type("RemoteInfo", (object,), dict(self.remote_specs))(), value=False, title="SSHing To", docs=False, dunder=False, sort=False, console=remote_console
+            type("RemoteInfo", (object,), dict(self.remote_specs))(),
+            value=False,
+            title="SSHing To",
+            docs=False,
+            dunder=False,
+            sort=False,
+            console=remote_console,
         )
         local_lines = local_buffer.getvalue().split("\n")
         remote_lines = remote_buffer.getvalue().split("\n")
@@ -215,19 +229,40 @@ class SSH:
         self.copy_from_here(source_path="~/.ssh/id_rsa.pub", target_rel2home=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
         if self.remote_specs["system"] != "Windows":
             raise RuntimeError("send_ssh_key is only supported for Windows remote machines")
-        code_url = "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/setup_windows/openssh-server_add-sshkey.ps1"
-        import urllib.request
-
-        with urllib.request.urlopen(code_url) as response:
-            code = response.read().decode("utf-8")
-        return self.run_shell_cmd_on_remote(command=code, verbose_output=True, description="", strict_stderr=False, strict_return_code=False)
+        python_code = '''
+from pathlib import Path
+import subprocess
+sshd_dir = Path("C:/ProgramData/ssh")
+admin_auth_keys = sshd_dir / "administrators_authorized_keys"
+sshd_config = sshd_dir / "sshd_config"
+pubkey_path = Path.home() / ".ssh" / "id_rsa.pub"
+key_content = pubkey_path.read_text(encoding="utf-8").strip()
+if admin_auth_keys.exists():
+    existing = admin_auth_keys.read_text(encoding="utf-8")
+    if not existing.endswith("\\n"):
+        existing += "\\n"
+    admin_auth_keys.write_text(existing + key_content + "\\n", encoding="utf-8")
+else:
+    admin_auth_keys.write_text(key_content + "\\n", encoding="utf-8")
+icacls_cmd = f'icacls "{admin_auth_keys}" /inheritance:r /grant "Administrators:F" /grant "SYSTEM:F"'
+subprocess.run(icacls_cmd, shell=True, check=True)
+if sshd_config.exists():
+    config_text = sshd_config.read_text(encoding="utf-8")
+    config_text = config_text.replace("#PubkeyAuthentication", "PubkeyAuthentication")
+    sshd_config.write_text(config_text, encoding="utf-8")
+subprocess.run("Restart-Service sshd -Force", shell=True, check=True)
+print("SSH key added successfully")
+'''
+        return self.run_py_remotely(python_code=python_code, uv_with=None, uv_project_dir=None, description="Adding SSH key to Windows remote", verbose_output=True, strict_stderr=False, strict_return_code=False)
 
     def get_remote_repr(self, add_machine: bool = False) -> str:
         return f"{self.username}@{self.hostname}:{self.port}" + (
             f" [{self.remote_specs['system']}][{self.remote_specs['distro']}]" if add_machine else ""
         )
+
     def get_local_repr(self, add_machine: bool = False) -> str:
         import getpass
+
         return f"{getpass.getuser()}@{platform.node()}" + (f" [{platform.system()}][{self.local_specs['distro']}]" if add_machine else "")
 
     def get_ssh_conn_str(self, command: str) -> str:
@@ -247,7 +282,9 @@ class SSH:
         res.output.returncode = os.system(command)
         return res
 
-    def run_shell_cmd_on_remote(self, command: str, verbose_output: bool, description: str, strict_stderr: bool, strict_return_code: bool) -> Response:
+    def run_shell_cmd_on_remote(
+        self, command: str, verbose_output: bool, description: str, strict_stderr: bool, strict_return_code: bool
+    ) -> Response:
         raw = self.ssh.exec_command(command)
         res = Response(stdin=raw[0], stdout=raw[1], stderr=raw[2], cmd=command, desc=description)  # type: ignore
         if verbose_output:
@@ -274,12 +311,12 @@ class SSH:
             with_clause += ""
         match on:
             case "local":
-                uv_run_cmd = get_uv_run_command(platform=self.local_specs["system"])
+                uv_cmd = get_uv_command(platform=self.local_specs["system"])
             case "remote":
-                uv_run_cmd = get_uv_run_command(platform=self.remote_specs["system"])
+                uv_cmd = get_uv_command(platform=self.remote_specs["system"])
             case _:
                 raise ValueError(f"Invalid value for 'on': {on}. Must be 'local' or 'remote'")
-        uv_cmd = f"""{uv_run_cmd} {with_clause} python {py_path.relative_to(Path.home())}"""
+        uv_cmd = f"""{uv_cmd} run {with_clause} python {py_path.relative_to(Path.home())}"""
         return uv_cmd
 
     def run_py_remotely(
@@ -302,8 +339,7 @@ class SSH:
         )
 
     def run_lambda_function(self, func: Callable[..., Any], import_module: bool, uv_with: Optional[list[str]], uv_project_dir: Optional[str]):
-        command = lambda_to_python_script(func,
-            in_global=True, import_module=import_module)
+        command = lambda_to_python_script(func, in_global=True, import_module=import_module)
         # turns ou that the code below for some reason runs but zellij doesn't start, looks like things are assigned to different user.
         # return self.run_py(python_code=command, uv_with=uv_with, uv_project_dir=uv_project_dir,
         #                    description=f"run_py_func {func.__name__} on {self.get_remote_repr(add_machine=False)}",
@@ -335,25 +371,39 @@ class SSH:
 
     def create_parent_dir_and_check_if_exists(self, path_rel2home: str, overwrite_existing: bool) -> None:
         from machineconfig.utils.ssh_utils.utils import create_dir_and_check_if_exists
+
         return create_dir_and_check_if_exists(self, path_rel2home=path_rel2home, overwrite_existing=overwrite_existing)
 
     def check_remote_is_dir(self, source_path: Union[str, Path]) -> bool:
         from machineconfig.utils.ssh_utils.utils import check_remote_is_dir
+
         return check_remote_is_dir(self, source_path=source_path)
 
     def expand_remote_path(self, source_path: Union[str, Path]) -> str:
         from machineconfig.utils.ssh_utils.utils import expand_remote_path
+
         return expand_remote_path(self, source_path=source_path)
 
-    def copy_from_here(self, source_path: str, target_rel2home: Optional[str], compress_with_zip: bool, recursive: bool, overwrite_existing: bool) -> None:
+    def copy_from_here(
+        self, source_path: str, target_rel2home: Optional[str], compress_with_zip: bool, recursive: bool, overwrite_existing: bool
+    ) -> None:
         from machineconfig.utils.ssh_utils.copy_from_here import copy_from_here
-        return copy_from_here(self, source_path=source_path, target_rel2home=target_rel2home, compress_with_zip=compress_with_zip, recursive=recursive, overwrite_existing=overwrite_existing)
 
-    def copy_to_here(self, source: Union[str, Path], target: Optional[Union[str, Path]], compress_with_zip: bool, recursive: bool, internal_call: bool = False) -> None:
+        return copy_from_here(
+            self,
+            source_path=source_path,
+            target_rel2home=target_rel2home,
+            compress_with_zip=compress_with_zip,
+            recursive=recursive,
+            overwrite_existing=overwrite_existing,
+        )
+
+    def copy_to_here(
+        self, source: Union[str, Path], target: Optional[Union[str, Path]], compress_with_zip: bool, recursive: bool, internal_call: bool = False
+    ) -> None:
         from machineconfig.utils.ssh_utils.copy_to_here import copy_to_here
-        return copy_to_here(self, source=source, target=target, compress_with_zip=compress_with_zip, recursive=recursive, internal_call=internal_call)
 
-    
+        return copy_to_here(self, source=source, target=target, compress_with_zip=compress_with_zip, recursive=recursive, internal_call=internal_call)
 
 
 if __name__ == "__main__":

machineconfig/utils/ssh_utils/abc.py

@@ -1,5 +1,5 @@
 
 
-MACHINECONFIG_VERSION = "machineconfig>=7.98"
+MACHINECONFIG_VERSION = "machineconfig>=8.51"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 

machineconfig/utils/ssh_utils/copy_from_here.py

@@ -1,11 +1,20 @@
 
 
-from typing import Optional
-from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+from pathlib import Path, PurePosixPath, PureWindowsPath
 from machineconfig.utils.accessories import randstr
 from machineconfig.utils.meta import lambda_to_python_script
 from machineconfig.utils.ssh_utils.abc import DEFAULT_PICKLE_SUBDIR
-from machineconfig.utils.code import get_uv_run_command
+from machineconfig.utils.code import get_uv_command
+
+if TYPE_CHECKING:
+    from machineconfig.utils.ssh import SSH
+
+
+def _build_remote_path(self: "SSH", home_dir: str, rel_path: str) -> str:
+    if self.remote_specs["system"] == "Windows":
+        return str(PureWindowsPath(home_dir) / rel_path)
+    return str(PurePosixPath(home_dir) / PurePosixPath(rel_path.replace("\\", "/")))
 
 
 def copy_from_here(
@@ -54,15 +63,14 @@ def copy_from_here(
             target_rel2home = target_rel2home + ".zip"
     if Path(target_rel2home).parent.as_posix() not in {"", "."}:
         self.create_parent_dir_and_check_if_exists(path_rel2home=target_rel2home, overwrite_existing=overwrite_existing)
-    print(f"""📤 [SFTP UPLOAD] Sending file: {repr(source_obj)}  ==>  Remote Path: {target_rel2home}""")
+    remote_target_full = _build_remote_path(self, self.remote_specs["home_dir"], target_rel2home)
+    print(f"""📤 [SFTP UPLOAD] Sending file: {repr(source_obj)}  ==>  Remote Path: {remote_target_full}""")
     try:
         with self.tqdm_wrap(ascii=True, unit="b", unit_scale=True) as pbar:
             if self.sftp is None:  # type: ignore[unreachable]
                 raise RuntimeError(f"SFTP connection lost for {self.hostname}")
-            print(f"Uploading {source_obj} to\n{Path(self.remote_specs['home_dir']).joinpath(target_rel2home)}")
-            self.sftp.put(
-                localpath=str(source_obj), remotepath=str(Path(self.remote_specs["home_dir"]).joinpath(target_rel2home)), callback=pbar.view_bar
-            )
+            print(f"Uploading {source_obj} to\n{remote_target_full}")
+            self.sftp.put(localpath=str(source_obj), remotepath=remote_target_full, callback=pbar.view_bar)
     except Exception:
         if compress_with_zip and source_obj.exists() and str(source_obj).endswith("_archive.zip"):
             source_obj.unlink()
@@ -83,12 +91,9 @@ def copy_from_here(
                 archive_handle.extractall(extraction_directory)
             archive_path.unlink()
 
+        remote_zip_path = _build_remote_path(self, self.remote_specs["home_dir"], target_rel2home)
         command = lambda_to_python_script(
-            lambda: unzip_archive(
-                zip_file_path=str(Path(self.remote_specs["home_dir"]).joinpath(target_rel2home)), overwrite_flag=overwrite_existing
-            ),
-            in_global=True,
-            import_module=False,
+            lambda: unzip_archive(zip_file_path=remote_zip_path, overwrite_flag=overwrite_existing), in_global=True, import_module=False
         )
         tmp_py_file = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/create_target_dir_{randstr()}.py")
         tmp_py_file.parent.mkdir(parents=True, exist_ok=True)
@@ -96,7 +101,7 @@ def copy_from_here(
         remote_tmp_py = tmp_py_file.relative_to(Path.home()).as_posix()
         self.copy_from_here(source_path=str(tmp_py_file), target_rel2home=None, compress_with_zip=False, recursive=False, overwrite_existing=True)
         self.run_shell_cmd_on_remote(
-            command=f"""{get_uv_run_command(platform=self.remote_specs['system'])} python {remote_tmp_py}""",
+            command=f"""{get_uv_command(platform=self.remote_specs['system'])} run python {remote_tmp_py}""",
             verbose_output=False,
             description=f"UNZIPPING {target_rel2home}",
             strict_stderr=True,

machineconfig/utils/ssh_utils/copy_to_here.py

@@ -8,7 +8,7 @@ from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION, DEFAULT_PIC
 
 
 def copy_to_here(
-    self: SSH,
+    self: "SSH",
     source: Union[str, Path],
     target: Optional[Union[str, Path]],
     compress_with_zip: bool = False,
@@ -300,3 +300,4 @@ def copy_to_here(
 
 if __name__ == "__main__":
     from machineconfig.utils.ssh import SSH
+

machineconfig/utils/ssh_utils/utils.py

@@ -1,15 +1,30 @@
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath, PureWindowsPath
 from machineconfig.utils.accessories import randstr
 from machineconfig.utils.meta import lambda_to_python_script
 from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION, DEFAULT_PICKLE_SUBDIR
-from machineconfig.utils.code import get_uv_run_command
-from typing import Union
+from machineconfig.utils.code import get_uv_command
+from typing import Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from machineconfig.utils.ssh import SSH
+
+
+def _build_remote_path(self: "SSH", home_dir: str, rel_path: str) -> str:
+    if self.remote_specs["system"] == "Windows":
+        return str(PureWindowsPath(home_dir) / rel_path)
+    return str(PurePosixPath(home_dir) / PurePosixPath(rel_path.replace("\\", "/")))
+
+
+def _normalize_rel_path_for_remote(self: "SSH", rel_path: str) -> str:
+    if self.remote_specs["system"] == "Windows":
+        return str(PureWindowsPath(rel_path))
+    return rel_path.replace("\\", "/")
 
 
 def create_dir_and_check_if_exists(self: "SSH", path_rel2home: str, overwrite_existing: bool) -> None:
     """Helper to create a directory on remote machine and return its path."""
-
+    path_rel2home_normalized = _normalize_rel_path_for_remote(self, path_rel2home)
     def create_target_dir(target_rel2home: str, overwrite: bool):
         from pathlib import Path
         import shutil
@@ -26,7 +41,7 @@ def create_dir_and_check_if_exists(self: "SSH", path_rel2home: str, overwrite_ex
         print(f"Creating directory for path: {target_path_abs}")
         target_path_abs.parent.mkdir(parents=True, exist_ok=True)
     command = lambda_to_python_script(
-        lambda: create_target_dir(target_rel2home=path_rel2home, overwrite=overwrite_existing),
+        lambda: create_target_dir(target_rel2home=path_rel2home_normalized, overwrite=overwrite_existing),
         in_global=True, import_module=False
     )
     tmp_py_file = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/create_target_dir_{randstr()}.py")
@@ -34,9 +49,10 @@ def create_dir_and_check_if_exists(self: "SSH", path_rel2home: str, overwrite_ex
     tmp_py_file.write_text(command, encoding="utf-8")
     assert self.sftp is not None
     tmp_remote_path = ".tmp_pyfile.py"
-    self.sftp.put(localpath=str(tmp_py_file), remotepath=str(Path(self.remote_specs["home_dir"]).joinpath(tmp_remote_path)))
+    remote_tmp_full = _build_remote_path(self, self.remote_specs["home_dir"], tmp_remote_path)
+    self.sftp.put(localpath=str(tmp_py_file), remotepath=remote_tmp_full)
     resp = self.run_shell_cmd_on_remote(
-        command=f"""{get_uv_run_command(platform=self.remote_specs['system'])} python {tmp_remote_path}""",
+        command=f"""{get_uv_command(platform=self.remote_specs['system'])} run python {tmp_remote_path}""",
         verbose_output=False,
         description=f"Creating target dir {path_rel2home}",
         strict_stderr=True,