machineconfig 8.45__py3-none-any.whl → 8.50__py3-none-any.whl

machineconfig/scripts/python/helpers/helpers_utils/python.py

@@ -1,5 +1,6 @@
 import typer
 from typing import Optional, Annotated, Literal, TypedDict, cast
+from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION
 
 
 def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
@@ -17,7 +18,7 @@ def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(he
     uv_with = ["textual"]
     uv_project_dir = None
     if not Path.home().joinpath("code/machineconfig").exists():
-        uv_with.append("machineconfig>=8.45")
+        uv_with.append(MACHINECONFIG_VERSION)
     else:
         uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
     run_shell_script(

machineconfig/scripts/python/sessions.py

@@ -19,8 +19,6 @@ def balance_load(
 def run(
     ctx: typer.Context,
     layout_path: Annotated[Optional[str], typer.Argument(..., help="Path to the layout.json file")] = None,
-    max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 10,
-    max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 10,
     sleep_inbetween: Annotated[float, typer.Option(..., "--sleep-inbetween", "-si", help="Sleep time in seconds between launching layouts")] = 1.0,
     monitor: Annotated[bool, typer.Option(..., "--monitor", "-m", help="Monitor the layout sessions for completion")] = False,
     parallel: Annotated[bool, typer.Option(..., "--parallel", "-p", help="Launch multiple layouts in parallel")] = False,
@@ -28,6 +26,8 @@ def run(
     choose: Annotated[Optional[str], typer.Option(..., "--choose", "-c", help="Comma separated names of layouts to be selected from the layout file passed")] = None,
     choose_interactively: Annotated[bool, typer.Option(..., "--choose-interactively", "-i", help="Select layouts interactively")] = False,
     subsitute_home: Annotated[bool, typer.Option(..., "--substitute-home", "-sh", help="Substitute ~ and $HOME in layout file with actual home directory path")] = False,
+    max_tabs: Annotated[int, typer.Option(..., "--max-tabs", "-mt", help="A Sanity checker that throws an error if any layout exceeds the maximum number of tabs to launch.")] = 25,
+    max_layouts: Annotated[int, typer.Option(..., "--max-layouts", "-ml", help="A Sanity checker that throws an error if the total number of *parallel layouts exceeds this number.")] = 25,
 ) -> None:
     """Launch terminal sessions based on a layout configuration file."""
     if layout_path is None:

machineconfig/settings/shells/zsh/init.sh

@@ -88,32 +88,23 @@ eval "$(starship init zsh)"
 
 # LEVE THIS IN THE END TO AVOID EXECUTION FAILURE OF THE REST OF THE SCRIPT
 if command -v mcfly &> /dev/null; then
-    eval "$(mcfly init bash)"
+    eval "$(mcfly init zsh)"
 elif command -v atuin &> /dev/null; then
-    eval "$(atuin init bash)"
+    eval "$(atuin init zsh)"
 else
-    # eval "$(tv init bash)"
     tv_shell_history() {
-        # _disable_bracketed_paste
-        local current_prompt="${READLINE_LINE:0:$READLINE_POINT}"
+        local current_prompt="$LBUFFER"
         local output
-        # move to the next line so that the prompt is not overwritten
         printf "\n"
-        # Get history using tv with the same arguments as zsh version
-        output=$(tv bash-history --input "$current_prompt" --inline)
-
+        output=$(tv zsh-history --input "$current_prompt" --inline)
         if [[ -n "$output" ]]; then
-            # Clear the right side of cursor and set new line
-            READLINE_LINE="$output"
-            READLINE_POINT=${#READLINE_LINE}
-            # Uncomment this to automatically accept the line
-            # (i.e. run the command without having to press enter twice)
-            # accept-line() { echo; }; accept-line
+            BUFFER="$output"
+            CURSOR=${#BUFFER}
         fi
-        # move the cursor back to the previous line
         printf "\033[A"
-        # _enable_bracketed_paste
+        zle reset-prompt
     }
-    bind -x '"\C-r": tv_shell_history'
+    zle -N tv_shell_history
+    bindkey '^R' tv_shell_history
 fi
 

machineconfig/setup_linux/web_shortcuts/interactive.sh

@@ -2,16 +2,16 @@
 . <( curl -sSL "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/uv.sh")
 . <( curl -sSL "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/linux/wrap_mcfg")
 
-alias devops='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" devops'
-alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" cloud'
-alias agents='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" agents'
-alias sessions='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" sessions'
-alias ftpx='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" ftpx'
-alias fire='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" fire'
-alias croshell='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" croshell'
-alias utils='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" utils'
-alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" terminal'
-alias msearch='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.45" msearch'
+alias devops='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" devops'
+alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" cloud'
+alias agents='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" agents'
+alias sessions='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" sessions'
+alias ftpx='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" ftpx'
+alias fire='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" fire'
+alias croshell='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" croshell'
+alias utils='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" utils'
+alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" terminal'
+alias msearch='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=8.50" msearch'
 
 alias d='wrap_in_shell_script devops'
 alias c='wrap_in_shell_script cloud'

machineconfig/setup_windows/web_shortcuts/interactive.ps1

@@ -4,16 +4,16 @@
 irm "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1" | iex
 irm "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/windows/wrap_mcfg.ps1" | iex
 
-function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" devops $args }
-function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" cloud $args }
-function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" agents $args }
-function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" sessions $args }
-function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" ftpx $args }
-function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" fire $args }
-function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" croshell $args }
-function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" utils $args }
-function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" terminal $args }
-function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.45" msearch $args }
+function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" devops $args }
+function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" cloud $args }
+function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" agents $args }
+function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" sessions $args }
+function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" ftpx $args }
+function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" fire $args }
+function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" croshell $args }
+function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" utils $args }
+function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" terminal $args }
+function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=8.50" msearch $args }
 
 function d { wrap_in_shell_script devops @args }
 function c { wrap_in_shell_script cloud @args }

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -10,6 +10,8 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Set, TypedDict
 from urllib.parse import urlparse
 
+from machineconfig.utils.installer_utils.github_release_scraper import scrape_github_release_page
+
 
 class AssetInfo(TypedDict):
     """Type definition for GitHub release asset information."""
@@ -74,7 +76,7 @@ def fetch_github_release_data(
     repo_name: str,
     version: Optional[str] = None,
 ) -> Optional[Dict[str, Any]]:
-    """Fetch GitHub release data for the latest or a specific tag."""
+    """Fetch GitHub release data for the latest or a specific tag. Falls back to HTML scraping if API fails."""
 
     try:
         requested_version = (version or "").strip()
@@ -85,25 +87,24 @@ def fetch_github_release_data(
 
         response = requests.get(url, timeout=30)
         if response.status_code != 200:
-            print(f"❌ Failed to fetch data for {username}/{repo_name}: HTTP {response.status_code}")
-            print(f"   URL: {url}")
-            return None
+            print(f"⚠️ API failed for {username}/{repo_name}: HTTP {response.status_code}, trying HTML scraper...")
+            return scrape_github_release_page(username, repo_name, version)
 
         response_data = response.json()
         message = response_data.get("message")
         if isinstance(message, str):
             if "API rate limit exceeded" in message:
-                print(f"🚫 Rate limit exceeded for {username}/{repo_name}")
-                return None
+                print(f"🚫 Rate limit exceeded for {username}/{repo_name}, trying HTML scraper...")
+                return scrape_github_release_page(username, repo_name, version)
             if "Not Found" in message:
-                print(f"🔍 No releases found for {username}/{repo_name}")
-                return None
+                print(f"🔍 No releases found via API for {username}/{repo_name}, trying HTML scraper...")
+                return scrape_github_release_page(username, repo_name, version)
 
         return response_data
 
     except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as error:
-        print(f"❌ Error fetching {username}/{repo_name}: {error}")
-        return None
+        print(f"⚠️ API error for {username}/{repo_name}: {error}, trying HTML scraper...")
+        return scrape_github_release_page(username, repo_name, version)
 
 
 def get_release_info(
@@ -142,85 +143,3 @@ def extract_release_info(release_data: Dict[str, Any]) -> Optional[ReleaseInfo]:
         "assets_count": len(assets)
     }
 
-
-# def main() -> None:
-#     """Main function to process installer JSON files and fetch GitHub release data."""
-#     # Define paths
-#     current_dir = Path(__file__).parent
-#     installer_dir = current_dir.parent.parent / "jobs" / "installer"
-    
-#     standard_json = installer_dir / "installer_data.json"
-#     output_json = current_dir / "github_releases.json"
-    
-#     print("🔍 Starting GitHub release data extraction...")
-#     print(f"📁 Processing files from: {installer_dir}")
-    
-#     # Extract GitHub repositories from both files
-#     all_github_repos: Set[str] = set()
-    
-#     if standard_json.exists():
-#         print(f"📄 Reading {standard_json.name}...")
-#         repos = extract_github_repos_from_json(standard_json)
-#         all_github_repos.update(repos)
-#         print(f"   Found {len(repos)} GitHub repos")
-#     else:
-#         print(f"⚠️  File not found: {standard_json}")    
-#     print(f"🎯 Total unique GitHub repositories found: {len(all_github_repos)}")
-    
-#     if not all_github_repos:
-#         print("❌ No GitHub repositories found. Exiting.")
-#         return
-    
-#     # Fetch release data with rate limiting
-#     release_mapping: Dict[str, Optional[ReleaseInfo]] = {}
-#     total_repos = len(all_github_repos)
-    
-#     print(f"\n🚀 Fetching release data for {total_repos} repositories...")
-#     print("⏰ Rate limiting: 5 seconds between requests")
-#     print("-" * 60)
-    
-#     for i, repo_url in enumerate(sorted(all_github_repos), 1):
-#         repo_info = get_repo_name_from_url(repo_url)
-        
-#         if not repo_info:
-#             print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
-#             continue
-        
-#         username, repo_name = repo_info
-#         repo_full_name = f"{username}/{repo_name}"
-            
-#         print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_full_name}", end=" ... ")
-        
-#         release_info = get_release_info(username, repo_name)
-
-#         if release_info:
-#             release_mapping[repo_url] = release_info
-#             assets_count = release_info["assets_count"]
-#             tag = release_info["tag_name"]
-#             print(f"✅ {tag} ({assets_count} assets)")
-#         else:
-#             release_mapping[repo_url] = None
-#             print("❌ No data")
-        
-#         # Rate limiting - wait 5 seconds between requests (except for the last one)
-#         if i < total_repos:
-#             time.sleep(5)
-    
-#     # Save results
-#     output_data: OutputData = {
-#         "generated_at": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
-#         "total_repositories": len(all_github_repos),
-#         "successful_fetches": len([v for v in release_mapping.values() if v]),
-#         "releases": release_mapping
-#     }
-    
-#     with open(output_json, 'w', encoding='utf-8') as f:
-#         json.dump(output_data, f, indent=2, ensure_ascii=False)
-    
-#     successful = len([v for v in release_mapping.values() if v])
-#     print("\n📊 Summary:")
-#     print(f"   Total repositories processed: {len(all_github_repos)}")
-#     print(f"   Successful fetches: {successful}")
-#     print(f"   Failed fetches: {len(all_github_repos) - successful}")
-#     print(f"   Output saved to: {output_json}")
-#     print("✅ Done!")

machineconfig/utils/installer_utils/github_release_scraper.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""HTML scraper for GitHub release pages as fallback when API rate limit is exceeded."""
+
+import re
+from typing import Any, Optional
+import requests
+
+
+def extract_tag_from_html(html: str, owner: str, repo: str) -> str:
+    patterns = [
+        rf'/{re.escape(owner)}/{re.escape(repo)}/releases/tag/([^"\'<>\s]+)',
+        rf'/{re.escape(owner)}/{re.escape(repo)}/tree/([^"\'<>\s]+)',
+        r'<span[^>]*class="[^"]*ml-1[^"]*"[^>]*>([^<]+)</span>',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, html, re.IGNORECASE)
+        if match:
+            tag = match.group(1).strip()
+            if tag and not tag.startswith("http"):
+                return tag
+    return ""
+
+
+def extract_release_name(html: str) -> str:
+    patterns = [
+        r'<h1[^>]*class="[^"]*d-inline[^"]*"[^>]*>([^<]+)</h1>',
+        r'<bdi[^>]*class="[^"]*mr-2[^"]*"[^>]*>([^<]+)</bdi>',
+        r'<h1[^>]*>([^<]+)</h1>',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, html)
+        if match:
+            name = match.group(1).strip()
+            if name:
+                return name
+    return ""
+
+
+def extract_published_at(html: str) -> str:
+    pattern = r'<relative-time[^>]*datetime="([^"]+)"'
+    match = re.search(pattern, html)
+    if match:
+        return match.group(1)
+    return ""
+
+
+def fetch_expanded_assets(username: str, repo_name: str, tag_name: str, headers: dict[str, str]) -> list[dict[str, Any]]:
+    """Fetch assets from the expanded_assets endpoint which contains all downloadable files."""
+    assets: list[dict[str, Any]] = []
+    expanded_url = f"https://github.com/{username}/{repo_name}/releases/expanded_assets/{tag_name}"
+    try:
+        response = requests.get(expanded_url, timeout=30, headers=headers)
+        if response.status_code != 200:
+            print(f"⚠️ [Scraper] Could not fetch expanded assets for {username}/{repo_name}: HTTP {response.status_code}")
+            return assets
+        html = response.text
+        pattern = r'href="([^"]*?/releases/download/[^"]+)"[^>]*>.*?<span[^>]*class="[^"]*Truncate-text[^"]*text-bold[^"]*"[^>]*>([^<]+)</span>'
+        seen_urls: set[str] = set()
+        matches = re.findall(pattern, html, re.DOTALL)
+        for href, name in matches:
+            asset_name = name.strip()
+            if not asset_name or asset_name.isspace():
+                continue
+            download_url = f"https://github.com{href}" if href.startswith("/") else href
+            if download_url in seen_urls:
+                continue
+            seen_urls.add(download_url)
+            assets.append({"name": asset_name, "size": 0, "download_count": 0, "content_type": "", "created_at": "", "updated_at": "", "browser_download_url": download_url})
+    except requests.RequestException as error:
+        print(f"⚠️ [Scraper] Error fetching expanded assets for {username}/{repo_name}: {error}")
+    return assets
+
+
+def scrape_github_release_page(username: str, repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
+    """Scrape GitHub release page HTML to extract release information. Falls back to this when API rate limit is hit."""
+    try:
+        requested_version = (version or "").strip()
+        if requested_version and requested_version.lower() != "latest":
+            url = f"https://github.com/{username}/{repo_name}/releases/tag/{requested_version}"
+        else:
+            url = f"https://github.com/{username}/{repo_name}/releases/latest"
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"}
+        response = requests.get(url, timeout=30, headers=headers, allow_redirects=True)
+        if response.status_code != 200:
+            print(f"❌ [Scraper] Failed to fetch page for {username}/{repo_name}: HTTP {response.status_code}")
+            return None
+        html = response.text
+        tag_name = extract_tag_from_html(html, username, repo_name)
+        if not tag_name:
+            print(f"🔍 [Scraper] No tag found for {username}/{repo_name}")
+            return None
+        release_name = extract_release_name(html) or tag_name
+        published_at = extract_published_at(html)
+        assets = fetch_expanded_assets(username, repo_name, tag_name, headers)
+        print(f"✅ [Scraper] Found {len(assets)} assets for {username}/{repo_name} @ {tag_name}")
+        return {"tag_name": tag_name, "name": release_name, "published_at": published_at, "assets": assets}
+    except requests.RequestException as error:
+        print(f"❌ [Scraper] Error fetching {username}/{repo_name}: {error}")
+        return None

machineconfig/utils/io.py

@@ -55,19 +55,36 @@ def read_ini(path: "Path", encoding: Optional[str] = None):
     return res
 
 
+def remove_c_style_comments(text: str) -> str:
+    import re
+    # Step 1: Escape URLs (https:// or any URLs you want to protect)
+    url_pattern = r'https?://[^\s]*'
+    urls = re.findall(url_pattern, text)
+    url_map = {url: f"__URL{index}__" for index, url in enumerate(urls)}
+    
+    # Temporarily replace URLs with placeholders
+    for url, placeholder in url_map.items():
+        text = text.replace(url, placeholder)
+    
+    # Step 2: Remove C-style comments
+    # Remove all // single-line comments
+    text = re.sub(r'//.*', '', text)
+    # Remove all /* … */ block comments (non-greedy)
+    text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
+    
+    # Step 3: Restore URLs
+    for url, placeholder in url_map.items():
+        text = text.replace(placeholder, url)
+    
+    return text
+
+
 def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
     import json
     try:
         mydict = json.loads(Path(path).read_text(encoding="utf-8"), **kwargs)
     except Exception:
-        import re
-        def remove_comments(text: str) -> str:
-            # remove all // single-line comments
-            text = re.sub(r'//.*', '', text)
-            # remove all /* … */ block comments (non-greedy)
-            text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
-            return text
-        mydict = json.loads(remove_comments(Path(path).read_text(encoding="utf-8")), **kwargs)
+        mydict = json.loads(remove_c_style_comments(Path(path).read_text(encoding="utf-8")), **kwargs)
     _ = r
     return mydict
 

machineconfig/utils/ssh_utils/abc.py

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

machineconfig/utils/ssh_utils/copy_from_here.py

@@ -1,12 +1,21 @@
 
 
-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_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
@@ -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)

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_command
-from typing import Union
+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,7 +49,8 @@ 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_command(platform=self.remote_specs['system'])} run python {tmp_remote_path}""",
         verbose_output=False,

{machineconfig-8.45.dist-info → machineconfig-8.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 8.45
+Version: 8.50
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0