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

machineconfig/utils/ssh_utils/abc.py

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

machineconfig/utils/ssh_utils/copy_from_here.py

@@ -0,0 +1,116 @@
+
+
+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_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(
+    self: "SSH", source_path: str, target_rel2home: Optional[str], compress_with_zip: bool, recursive: bool, overwrite_existing: bool
+) -> None:
+    if self.sftp is None:
+        raise RuntimeError(f"SFTP connection not available for {self.hostname}. Cannot transfer files.")
+    source_obj = Path(source_path).expanduser().absolute()
+    if not source_obj.exists():
+        raise RuntimeError(f"SSH Error: source `{source_obj}` does not exist!")
+    if target_rel2home is None:
+        try:
+            target_rel2home = str(source_obj.relative_to(Path.home()))
+        except ValueError:
+            raise RuntimeError(f"If target is not specified, source must be relative to home directory, but got: {source_obj}")
+    if not compress_with_zip and source_obj.is_dir():
+        if not recursive:
+            raise RuntimeError(
+                f"SSH Error: source `{source_obj}` is a directory! Set `recursive=True` for recursive sending or `compress_with_zip=True` to zip it first."
+            )
+        file_paths_to_upload: list[Path] = [file_path for file_path in source_obj.rglob("*") if file_path.is_file()]
+        self.create_parent_dir_and_check_if_exists(path_rel2home=target_rel2home, overwrite_existing=overwrite_existing)
+        for idx, file_path in enumerate(file_paths_to_upload):
+            print(f"   {idx + 1:03d}. {file_path}")
+        for file_path in file_paths_to_upload:
+            remote_file_target = Path(target_rel2home).joinpath(file_path.relative_to(source_obj))
+            self.copy_from_here(
+                source_path=str(file_path),
+                target_rel2home=str(remote_file_target),
+                compress_with_zip=False,
+                recursive=False,
+                overwrite_existing=overwrite_existing,
+            )
+        return None
+    if compress_with_zip:
+        print("🗜️ ZIPPING ...")
+        import shutil
+
+        zip_path = Path(str(source_obj) + "_archive")
+        if source_obj.is_dir():
+            shutil.make_archive(str(zip_path), "zip", source_obj)
+        else:
+            shutil.make_archive(str(zip_path), "zip", source_obj.parent, source_obj.name)
+        source_obj = Path(str(zip_path) + ".zip")
+        if not target_rel2home.endswith(".zip"):
+            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)
+    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{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()
+        raise
+
+    if compress_with_zip:
+
+        def unzip_archive(zip_file_path: str, overwrite_flag: bool) -> None:
+            from pathlib import Path
+            import shutil
+            import zipfile
+
+            archive_path = Path(zip_file_path).expanduser()
+            extraction_directory = archive_path.parent / archive_path.stem
+            if overwrite_flag and extraction_directory.exists():
+                shutil.rmtree(extraction_directory)
+            with zipfile.ZipFile(archive_path, "r") as archive_handle:
+                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=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)
+        tmp_py_file.write_text(command, encoding="utf-8")
+        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_command(platform=self.remote_specs['system'])} run python {remote_tmp_py}""",
+            verbose_output=False,
+            description=f"UNZIPPING {target_rel2home}",
+            strict_stderr=True,
+            strict_return_code=True,
+        )
+        source_obj.unlink()
+        tmp_py_file.unlink(missing_ok=True)
+    return None
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.ssh import SSH

machineconfig/utils/ssh_utils/copy_to_here.py

@@ -0,0 +1,303 @@
+
+
+from typing import Optional, Union
+from pathlib import Path
+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
+
+
+def copy_to_here(
+    self: "SSH",
+    source: Union[str, Path],
+    target: Optional[Union[str, Path]],
+    compress_with_zip: bool = False,
+    recursive: bool = False,
+    internal_call: bool = False,
+) -> None:
+    if self.sftp is None:
+        raise RuntimeError(f"SFTP connection not available for {self.hostname}. Cannot transfer files.")
+
+    if not internal_call:
+        print(f"{'⬇️' * 5} SFTP DOWNLOADING FROM `{source}` TO `{target}`")
+
+    source_obj = Path(source)
+    expanded_source = self.expand_remote_path(source_path=source_obj)
+
+    if not compress_with_zip:
+        is_dir = self.check_remote_is_dir(source_path=expanded_source)
+
+        if is_dir:
+            if not recursive:
+                raise RuntimeError(
+                    f"SSH Error: source `{source_obj}` is a directory! Set recursive=True for recursive transfer or compress_with_zip=True to zip it."
+                )
+
+            def search_files(directory_path: str, json_output_path: str) -> list[str]:
+                from pathlib import Path
+                import json
+
+                file_paths_list = [
+                    file_path.as_posix() for file_path in Path(directory_path).expanduser().absolute().rglob("*") if file_path.is_file()
+                ]
+                json_result_path = Path(json_output_path)
+                json_result_path.parent.mkdir(parents=True, exist_ok=True)
+                json_result_path.write_text(json.dumps(file_paths_list, indent=2), encoding="utf-8")
+                print(json_result_path.as_posix())
+                return file_paths_list
+
+            remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+            command = lambda_to_python_script(
+                lambda: search_files(directory_path=expanded_source, json_output_path=remote_json_output),
+        in_global=True, import_module=False
+            )
+            response = self.run_py_remotely(
+                python_code=command,
+                uv_with=[MACHINECONFIG_VERSION],
+                uv_project_dir=None,
+                description="Searching for files in source",
+                verbose_output=False,
+                strict_stderr=False,
+                strict_return_code=False,
+            )
+            remote_json_path = response.op.strip()
+            if not remote_json_path:
+                raise RuntimeError(f"Could not resolve source path {source} - no response from remote")
+
+            local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+            self.simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
+            import json
+
+            try:
+                source_list_str = json.loads(local_json.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, FileNotFoundError) as err:
+                raise RuntimeError(f"Could not resolve source path {source} - invalid JSON response: {err}") from err
+            finally:
+                if local_json.exists():
+                    local_json.unlink()
+            assert isinstance(source_list_str, list), f"Could not resolve source path {source}"
+            file_paths_to_download = [Path(file_path_str) for file_path_str in source_list_str]
+
+            if target is None:
+
+                def collapse_to_home_dir(absolute_path: str, json_output_path: str) -> str:
+                    from pathlib import Path
+                    import json
+
+                    source_absolute_path = Path(absolute_path).expanduser().absolute()
+                    try:
+                        relative_to_home = source_absolute_path.relative_to(Path.home())
+                        collapsed_path_posix = (Path("~") / relative_to_home).as_posix()
+                        json_result_path = Path(json_output_path)
+                        json_result_path.parent.mkdir(parents=True, exist_ok=True)
+                        json_result_path.write_text(json.dumps(collapsed_path_posix, indent=2), encoding="utf-8")
+                        print(json_result_path.as_posix())
+                        return collapsed_path_posix
+                    except ValueError:
+                        raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
+
+                remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+                command = lambda_to_python_script(
+                    lambda: collapse_to_home_dir(absolute_path=expanded_source, json_output_path=remote_json_output),
+                    in_global=True,
+                    import_module=False,
+                )
+                response = self.run_py_remotely(
+                    python_code=command,
+                    uv_with=[MACHINECONFIG_VERSION],
+                    uv_project_dir=None,
+                    description="Finding default target via relative source path",
+                    verbose_output=False,
+                    strict_stderr=False,
+                    strict_return_code=False,
+                )
+                remote_json_path_dir = response.op.strip()
+                if not remote_json_path_dir:
+                    raise RuntimeError("Could not resolve target path - no response from remote")
+
+                local_json_dir = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+                self.simple_sftp_get(remote_path=remote_json_path_dir, local_path=local_json_dir)
+                import json
+
+                try:
+                    target_dir_str = json.loads(local_json_dir.read_text(encoding="utf-8"))
+                except (json.JSONDecodeError, FileNotFoundError) as err:
+                    raise RuntimeError(f"Could not resolve target path - invalid JSON response: {err}") from err
+                finally:
+                    if local_json_dir.exists():
+                        local_json_dir.unlink()
+                assert isinstance(target_dir_str, str), "Could not resolve target path"
+                target = Path(target_dir_str)
+
+            target_dir = Path(target).expanduser().absolute()
+
+            for idx, file_path in enumerate(file_paths_to_download):
+                print(f"   {idx + 1:03d}. {file_path}")
+
+            for file_path in file_paths_to_download:
+                local_file_target = target_dir.joinpath(Path(file_path).relative_to(expanded_source))
+                self.copy_to_here(source=file_path, target=local_file_target, compress_with_zip=False, recursive=False, internal_call=True)
+
+            return None
+
+    if compress_with_zip:
+        print("🗜️ ZIPPING ...")
+
+        def zip_source(path_to_zip: str, json_output_path: str) -> str:
+            from pathlib import Path
+            import shutil
+            import json
+
+            source_to_compress = Path(path_to_zip).expanduser().absolute()
+            archive_base_path = source_to_compress.parent / (source_to_compress.name + "_archive")
+            if source_to_compress.is_dir():
+                shutil.make_archive(str(archive_base_path), "zip", source_to_compress)
+            else:
+                shutil.make_archive(str(archive_base_path), "zip", source_to_compress.parent, source_to_compress.name)
+            zip_file_path = str(archive_base_path) + ".zip"
+            json_result_path = Path(json_output_path)
+            json_result_path.parent.mkdir(parents=True, exist_ok=True)
+            json_result_path.write_text(json.dumps(zip_file_path, indent=2), encoding="utf-8")
+            print(json_result_path.as_posix())
+            return zip_file_path
+
+        remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+        command = lambda_to_python_script(
+            lambda: zip_source(path_to_zip=expanded_source, json_output_path=remote_json_output),
+        in_global=True, import_module=False
+        )
+        response = self.run_py_remotely(
+            python_code=command,
+            uv_with=[MACHINECONFIG_VERSION],
+            uv_project_dir=None,
+            description=f"Zipping source file {source}",
+            verbose_output=False,
+            strict_stderr=False,
+            strict_return_code=False,
+        )
+        remote_json_path = response.op.strip()
+        if not remote_json_path:
+            raise RuntimeError(f"Could not zip {source} - no response from remote")
+
+        local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+        self.simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
+        import json
+
+        try:
+            zipped_path = json.loads(local_json.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, FileNotFoundError) as err:
+            raise RuntimeError(f"Could not zip {source} - invalid JSON response: {err}") from err
+        finally:
+            if local_json.exists():
+                local_json.unlink()
+        assert isinstance(zipped_path, str), f"Could not zip {source}"
+        source_obj = Path(zipped_path)
+        expanded_source = zipped_path
+
+    if target is None:
+
+        def collapse_to_home(absolute_path: str, json_output_path: str) -> str:
+            from pathlib import Path
+            import json
+
+            source_absolute_path = Path(absolute_path).expanduser().absolute()
+            try:
+                relative_to_home = source_absolute_path.relative_to(Path.home())
+                collapsed_path_posix = (Path("~") / relative_to_home).as_posix()
+                json_result_path = Path(json_output_path)
+                json_result_path.parent.mkdir(parents=True, exist_ok=True)
+                json_result_path.write_text(json.dumps(collapsed_path_posix, indent=2), encoding="utf-8")
+                print(json_result_path.as_posix())
+                return collapsed_path_posix
+            except ValueError:
+                raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
+
+        remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+        command = lambda_to_python_script(
+            lambda: collapse_to_home(absolute_path=expanded_source, json_output_path=remote_json_output),
+        in_global=True, import_module=False
+        )
+        response = self.run_py_remotely(
+            python_code=command,
+            uv_with=[MACHINECONFIG_VERSION],
+            uv_project_dir=None,
+            description="Finding default target via relative source path",
+            verbose_output=False,
+            strict_stderr=False,
+            strict_return_code=False,
+        )
+        remote_json_path = response.op.strip()
+        if not remote_json_path:
+            raise RuntimeError("Could not resolve target path - no response from remote")
+
+        local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+        self.simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
+        import json
+
+        try:
+            target_str = json.loads(local_json.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, FileNotFoundError) as err:
+            raise RuntimeError(f"Could not resolve target path - invalid JSON response: {err}") from err
+        finally:
+            if local_json.exists():
+                local_json.unlink()
+        assert isinstance(target_str, str), "Could not resolve target path"
+        target = Path(target_str)
+        assert str(target).startswith("~"), f"If target is not specified, source must be relative to home.\n{target=}"
+
+    target_obj = Path(target).expanduser().absolute()
+    target_obj.parent.mkdir(parents=True, exist_ok=True)
+
+    if compress_with_zip and target_obj.suffix != ".zip":
+        target_obj = target_obj.with_suffix(target_obj.suffix + ".zip")
+
+    print(f"""📥 [DOWNLOAD] Receiving: {expanded_source}  ==>  Local Path: {target_obj}""")
+    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}")
+            self.sftp.get(remotepath=expanded_source, localpath=str(target_obj), callback=pbar.view_bar)  # type: ignore
+    except Exception:
+        if target_obj.exists():
+            target_obj.unlink()
+        raise
+
+    if compress_with_zip:
+        import zipfile
+
+        extract_to = target_obj.parent / target_obj.stem
+        with zipfile.ZipFile(target_obj, "r") as zip_ref:
+            zip_ref.extractall(extract_to)
+        target_obj.unlink()
+        target_obj = extract_to
+
+        def delete_temp_zip(path_to_delete: str) -> None:
+            from pathlib import Path
+            import shutil
+
+            file_or_dir_path = Path(path_to_delete)
+            if file_or_dir_path.exists():
+                if file_or_dir_path.is_dir():
+                    shutil.rmtree(file_or_dir_path)
+                else:
+                    file_or_dir_path.unlink()
+
+        command = lambda_to_python_script(lambda: delete_temp_zip(path_to_delete=expanded_source),
+                                in_global=True, import_module=False)
+        self.run_py_remotely(
+            python_code=command,
+            uv_with=[MACHINECONFIG_VERSION],
+            uv_project_dir=None,
+            description="Cleaning temp zip files @ remote.",
+            verbose_output=False,
+            strict_stderr=True,
+            strict_return_code=True,
+        )
+
+    print("\n")
+    return None
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.ssh import SSH
+

machineconfig/utils/ssh_utils/utils.py

@@ -0,0 +1,158 @@
+
+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_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
+        target_path_abs = Path(target_rel2home).expanduser()
+        if not target_path_abs.is_absolute():
+            target_path_abs = Path.home().joinpath(target_path_abs)
+        if overwrite and target_path_abs.exists():
+            if str(target_path_abs) == str(Path.home()):
+                raise RuntimeError("Refusing to overwrite home directory!")
+            if target_path_abs.is_dir():
+                shutil.rmtree(target_path_abs)
+            else:
+                target_path_abs.unlink()
+        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_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")
+    tmp_py_file.parent.mkdir(parents=True, exist_ok=True)
+    tmp_py_file.write_text(command, encoding="utf-8")
+    assert self.sftp is not None
+    tmp_remote_path = ".tmp_pyfile.py"
+    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_command(platform=self.remote_specs['system'])} run python {tmp_remote_path}""",
+        verbose_output=False,
+        description=f"Creating target dir {path_rel2home}",
+        strict_stderr=True,
+        strict_return_code=True,
+    )
+    resp.print(desc=f"Created target dir {path_rel2home}")
+
+
+def check_remote_is_dir(self: "SSH", source_path: Union[str, Path]) -> bool:
+    """Helper to check if a remote path is a directory."""
+
+    def check_is_dir(path_to_check: str, json_output_path: str) -> bool:
+        from pathlib import Path
+        import json
+
+        is_directory = Path(path_to_check).expanduser().absolute().is_dir()
+        json_result_path = Path(json_output_path)
+        json_result_path.parent.mkdir(parents=True, exist_ok=True)
+        json_result_path.write_text(json.dumps(is_directory, indent=2), encoding="utf-8")
+        print(json_result_path.as_posix())
+        return is_directory
+
+    remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+    command = lambda_to_python_script(
+        lambda: check_is_dir(path_to_check=str(source_path), json_output_path=remote_json_output),
+        in_global=True, import_module=False
+    )
+    response = self.run_py_remotely(
+        python_code=command,
+        uv_with=[MACHINECONFIG_VERSION],
+        uv_project_dir=None,
+        description=f"Check if source `{source_path}` is a dir",
+        verbose_output=False,
+        strict_stderr=False,
+        strict_return_code=False,
+    )
+    remote_json_path = response.op.strip()
+    if not remote_json_path:
+        raise RuntimeError(f"Failed to check if {source_path} is directory - no response from remote")
+
+    local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+    self.simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
+    import json
+
+    try:
+        result = json.loads(local_json.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, FileNotFoundError) as err:
+        raise RuntimeError(f"Failed to check if {source_path} is directory - invalid JSON response: {err}") from err
+    finally:
+        if local_json.exists():
+            local_json.unlink()
+    assert isinstance(result, bool), f"Failed to check if {source_path} is directory"
+    return result
+
+def expand_remote_path(self: "SSH", source_path: Union[str, Path]) -> str:
+    """Helper to expand a path on the remote machine."""
+
+    def expand_source(path_to_expand: str, json_output_path: str) -> str:
+        from pathlib import Path
+        import json
+
+        expanded_path_posix = Path(path_to_expand).expanduser().absolute().as_posix()
+        json_result_path = Path(json_output_path)
+        json_result_path.parent.mkdir(parents=True, exist_ok=True)
+        json_result_path.write_text(json.dumps(expanded_path_posix, indent=2), encoding="utf-8")
+        print(json_result_path.as_posix())
+        return expanded_path_posix
+
+    remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
+    command = lambda_to_python_script(
+        lambda: expand_source(path_to_expand=str(source_path), json_output_path=remote_json_output),
+        in_global=True, import_module=False
+    )
+    response = self.run_py_remotely(
+        python_code=command,
+        uv_with=[MACHINECONFIG_VERSION],
+        uv_project_dir=None,
+        description="Resolving source path by expanding user",
+        verbose_output=False,
+        strict_stderr=False,
+        strict_return_code=False,
+    )
+    remote_json_path = response.op.strip()
+    if not remote_json_path:
+        raise RuntimeError(f"Could not resolve source path {source_path} - no response from remote")
+
+    local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
+    self.simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
+    import json
+
+    try:
+        result = json.loads(local_json.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, FileNotFoundError) as err:
+        raise RuntimeError(f"Could not resolve source path {source_path} - invalid JSON response: {err}") from err
+    finally:
+        if local_json.exists():
+            local_json.unlink()
+    assert isinstance(result, str), f"Could not resolve source path {source_path}"
+    return result
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.ssh import SSH