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

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.python 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.python 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,18 +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/ssh/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:
@@ -246,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:
@@ -273,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(
@@ -301,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)}",
@@ -334,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>=8.12"
+MACHINECONFIG_VERSION = "machineconfig>=8.45"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 

machineconfig/utils/ssh_utils/copy_from_here.py

@@ -5,7 +5,7 @@ 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 DEFAULT_PICKLE_SUBDIR
-from machineconfig.utils.code import get_uv_run_command
+from machineconfig.utils.code import get_uv_command
 
 
 def copy_from_here(
@@ -96,7 +96,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/utils.py

@@ -3,7 +3,7 @@ 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
-from machineconfig.utils.code import get_uv_run_command
+from machineconfig.utils.code import get_uv_command
 from typing import Union
 
 
@@ -36,7 +36,7 @@ def create_dir_and_check_if_exists(self: "SSH", path_rel2home: str, overwrite_ex
     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)))
     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,

machineconfig/utils/ssh_utils/wsl.py

@@ -1,167 +1,35 @@
-import os
 import platform
-import stat
+import re
 import shutil
 import subprocess
-from pathlib import Path, PureWindowsPath
-
-
-def _ensure_relative_path(requested: Path | str) -> Path:
-    path = Path(requested)
-    if path.is_absolute():
-        raise ValueError("paths must be relative to the home directory")
-    if any(part == ".." for part in path.parts):
-        raise ValueError("paths must stay within the home directory")
-    return path
-
-
-def _remove_path(path: Path) -> None:
-    if path.is_symlink() or path.is_file():
-        path.unlink()
-        return
-    shutil.rmtree(path)
-
-
-def _ensure_wsl_environment() -> None:
-    if os.environ.get("WSL_DISTRO_NAME"):
-        return
-    if "microsoft" in platform.release().lower():
-        return
-    raise RuntimeError("copy_when_inside_wsl must run inside WSL")
-
-
-def _ensure_windows_environment() -> None:
-    if os.name != "nt":
-        raise RuntimeError("copy_when_inside_windows must run inside Windows")
-    if os.environ.get("WSL_DISTRO_NAME"):
-        raise RuntimeError("copy_when_inside_windows must run inside Windows")
-
-
-def _infer_windows_home_from_permissions() -> Path:
-    base_dir = Path("/mnt/c/Users")
-    try:
-        entries = list(base_dir.iterdir())
-    except FileNotFoundError as exc:
-        raise RuntimeError("unable to find /mnt/c/Users") from exc
-    candidates: list[Path] = []
-    for entry in entries:
-        if not entry.is_dir():
-            continue
-        if entry.name.lower() == "public" or entry.name.lower() == "all users":
-            continue
-        try:
-            mode = stat.S_IMODE(entry.stat().st_mode)
-        except OSError:
-            continue
-        if mode == 0o777:
-            candidates.append(entry)
-    if len(candidates) != 1:
-        options = ", ".join(sorted(candidate.name for candidate in candidates)) or "none"
-        raise RuntimeError(f"unable to infer Windows home directory (candidates: {options})")
-    return candidates[0]
-
-
-def _resolve_windows_home_from_wsl() -> Path:
-    user_profile = os.environ.get("USERPROFILE")
-    if user_profile:
-        windows_path = PureWindowsPath(user_profile)
-        drive = windows_path.drive
-        if drive:
-            drive_letter = drive.rstrip(":").lower()
-            tail = Path(*windows_path.parts[1:])
-            candidate = Path("/mnt") / drive_letter / tail
-            if candidate.exists():
-                return candidate
-    return _infer_windows_home_from_permissions()
-
-
-def _decode_wsl_output(raw_bytes: bytes) -> str:
-    try:
-        return raw_bytes.decode("utf-16-le")
-    except UnicodeDecodeError:
-        return raw_bytes.decode()
-
-
-def _get_single_wsl_distribution() -> str:
-    process = subprocess.run(["wsl.exe", "-l"], capture_output=True, text=False, check=True)
-    stdout = _decode_wsl_output(process.stdout).replace("\ufeff", "")
-    distributions: list[str] = []
-    for raw_line in stdout.splitlines():
-        line = raw_line.strip()
-        if not line or line.lower().startswith("windows subsystem for linux"):
-            continue
-        normalized = line.lstrip("* ").replace("(Default)", "").strip()
-        if normalized:
-            distributions.append(normalized)
-    if len(distributions) != 1:
-        raise RuntimeError("unable to pick a single WSL distribution")
-    return distributions[0]
-
-
-def _resolve_wsl_home_on_windows() -> Path:
-    distribution = _get_single_wsl_distribution()
-    home_root = Path(rf"\\wsl$\{distribution}\home")
-    try:
-        entries = list(home_root.iterdir())
-    except FileNotFoundError as exc:
-        raise RuntimeError(f"unable to locate WSL home directories for {distribution}") from exc
-    except OSError as exc:
-        raise RuntimeError(f"unable to inspect WSL home directories for {distribution}") from exc
-    user_dirs = [entry for entry in entries if entry.is_dir()]
-    if len(user_dirs) != 1:
-        options = ", ".join(sorted(entry.name for entry in user_dirs)) or "none"
-        raise RuntimeError(f"unable to infer WSL user directory (candidates: {options})")
-    return user_dirs[0]
-
-
-def _quote_for_powershell(path: Path) -> str:
-    return "'" + str(path).replace("'", "''") + "'"
-
-
-def _run_windows_copy_command(source_path: Path, target_path: Path) -> None:
-    source_is_dir = source_path.is_dir()
-    parent_literal = _quote_for_powershell(target_path.parent)
-    source_literal = _quote_for_powershell(source_path)
-    target_literal = _quote_for_powershell(target_path)
-    script = (
-        "$ErrorActionPreference = 'Stop'; "
-        f"New-Item -ItemType Directory -Path {parent_literal} -Force | Out-Null; "
-        f"Copy-Item -LiteralPath {source_literal} -Destination {target_literal}"
-        f"{' -Recurse' if source_is_dir else ''} -Force"
-    )
-    print(f"Copying {source_path} to {target_path}")
-    subprocess.run(
-        ["powershell.exe", "-NoLogo", "-NoProfile", "-Command", script],
-        check=True,
-    )
-
-
-def _ensure_symlink(link_path: Path, target_path: Path) -> None:
-    if not target_path.exists():
-        raise FileNotFoundError(target_path)
-    if link_path.is_symlink():
-        existing_target = Path(os.path.realpath(link_path))
-        desired_target = Path(os.path.realpath(target_path))
-        if os.path.normcase(str(existing_target)) == os.path.normcase(str(desired_target)):
-            return
-        link_path.unlink()
-    elif link_path.exists():
-        raise FileExistsError(link_path)
-    link_path.symlink_to(target_path, target_is_directory=True)
-
-
-def copy_when_inside_wsl(source: Path | str, target: Path | str, overwrite: bool) -> None:
-    _ensure_wsl_environment()
-    source_relative = _ensure_relative_path(source)
-    target_relative = _ensure_relative_path(target)
+from pathlib import Path
+
+from machineconfig.utils.ssh_utils.wsl_helper import (
+    ensure_relative_path,
+    remove_path,
+    ensure_wsl_environment,
+    ensure_windows_environment,
+    ensure_linux_environment,
+    resolve_windows_home_from_wsl,
+    resolve_wsl_home_on_windows,
+    run_windows_copy_command,
+    ensure_symlink,
+    normalize_port_spec_for_firewall,
+)
+
+
+def copy_when_inside_wsl(source: Path | str, target: Path | str, overwrite: bool, windows_username: str | None) -> None:
+    ensure_wsl_environment()
+    source_relative = ensure_relative_path(source)
+    target_relative = ensure_relative_path(target)
     source_path = Path.home() / source_relative
-    target_path = _resolve_windows_home_from_wsl() / target_relative
+    target_path = resolve_windows_home_from_wsl(windows_username) / target_relative
     if not source_path.exists():
         raise FileNotFoundError(source_path)
     if target_path.exists():
         if not overwrite:
             raise FileExistsError(target_path)
-        _remove_path(target_path)
+        remove_path(target_path)
     target_path.parent.mkdir(parents=True, exist_ok=True)
     if source_path.is_dir():
         shutil.copytree(source_path, target_path, dirs_exist_ok=False)
@@ -171,40 +39,109 @@ def copy_when_inside_wsl(source: Path | str, target: Path | str, overwrite: bool
 
 
 def copy_when_inside_windows(source: Path | str, target: Path | str, overwrite: bool) -> None:
-    _ensure_windows_environment()
-    source_relative = _ensure_relative_path(source)
-    target_relative = _ensure_relative_path(target)
+    ensure_windows_environment()
+    source_relative = ensure_relative_path(source)
+    target_relative = ensure_relative_path(target)
     source_path = Path.home() / source_relative
-    target_path = _resolve_wsl_home_on_windows() / target_relative
+    target_path = resolve_wsl_home_on_windows() / target_relative
     if not source_path.exists():
         raise FileNotFoundError(source_path)
     if target_path.exists():
         if not overwrite:
             raise FileExistsError(target_path)
-        _remove_path(target_path)
-    _run_windows_copy_command(source_path, target_path)
+        remove_path(target_path)
+    run_windows_copy_command(source_path, target_path)
 
 
-def link_wsl_and_windows() -> None:
+def link_wsl_and_windows(windows_username: str | None) -> None:
     system = platform.system()
     if system == "Darwin":
         raise RuntimeError("link_wsl_and_windows is not designed for macOS")
     try:
-        _ensure_wsl_environment()
+        ensure_wsl_environment()
     except RuntimeError:
         try:
-            _ensure_windows_environment()
+            ensure_windows_environment()
         except RuntimeError as exc:
             raise RuntimeError("link_wsl_and_windows must run inside Windows or WSL") from exc
-        target_path = _resolve_wsl_home_on_windows()
+        print("🔗 Running inside Windows, linking to WSL home...")
+        target_path = resolve_wsl_home_on_windows()
         link_path = Path.home() / "wsl"
-        _ensure_symlink(link_path, target_path)
+        created = ensure_symlink(link_path, target_path)
+        if created:
+            print(f"✅ Created symlink: {link_path} -> {target_path}")
+        else:
+            print(f"✅ Symlink already exists: {link_path} -> {target_path}")
         return
-    target_path = _resolve_windows_home_from_wsl()
+    print("🔗 Running inside WSL, linking to Windows home...")
+    target_path = resolve_windows_home_from_wsl(windows_username)
     link_path = Path.home() / "win"
-    _ensure_symlink(link_path, target_path)
+    created = ensure_symlink(link_path, target_path)
+    if created:
+        print(f"✅ Created symlink: {link_path} -> {target_path}")
+    else:
+        print(f"✅ Symlink already exists: {link_path} -> {target_path}")
+
+
+def open_wsl_port(ports_spec: str) -> None:
+    ensure_windows_environment()
+    normalized_ports, description = normalize_port_spec_for_firewall(ports_spec)
+    rule_name = f"WSL Ports {description}"
+    # Build PowerShell array syntax for -LocalPort parameter (e.g., @('3000-4000','8080'))
+    port_parts = normalized_ports.split(",")
+    ps_array = "@(" + ",".join(f"'{p}'" for p in port_parts) + ")"
+    script = f"New-NetFirewallRule -DisplayName '{rule_name}' -Direction Inbound -LocalPort {ps_array} -Protocol TCP -Action Allow"
+    print(f"🔥 Opening firewall for ports: {description}...")
+    result = subprocess.run(["powershell.exe", "-NoLogo", "-NoProfile", "-Command", script], capture_output=True, text=True)
+    if result.returncode == 0:
+        print(f"✅ Firewall rule created for ports: {description}")
+    else:
+        print(f"❌ Failed to create firewall rule: {result.stderr.strip()}")
+
+
+def change_ssh_port(port: int) -> None:
+    ensure_linux_environment()
+    if port < 1 or port > 65535:
+        raise ValueError(f"Invalid port number: {port}")
+
+    sshd_config = Path("/etc/ssh/sshd_config")
+    if not sshd_config.exists():
+        raise FileNotFoundError(f"SSH config file not found: {sshd_config}")
+
+    print(f"🔧 Changing SSH port to {port}...")
+
+    content = sshd_config.read_text()
+    new_content = re.sub(r"^#?\s*Port\s+\d+", f"Port {port}", content, flags=re.MULTILINE)
+    if f"Port {port}" not in new_content:
+        new_content = f"Port {port}\n" + new_content
+
+    print(f"📝 Updating {sshd_config}...")
+    result = subprocess.run(["sudo", "tee", str(sshd_config)], input=new_content.encode(), capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to update sshd_config: {result.stderr.decode()}")
+    print(f"✅ Updated {sshd_config}")
+
+    override_dir = Path("/etc/systemd/system/ssh.socket.d")
+    override_file = override_dir / "override.conf"
+    override_content = f"""[Socket]
+ListenStream=
+ListenStream={port}
+"""
+    print(f"📝 Creating systemd socket override at {override_file}...")
+    subprocess.run(["sudo", "mkdir", "-p", str(override_dir)], check=True)
+    result = subprocess.run(["sudo", "tee", str(override_file)], input=override_content.encode(), capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to create override file: {result.stderr.decode()}")
+    print("✅ Created systemd socket override")
+
+    print("🔄 Restarting SSH services...")
+    subprocess.run(["sudo", "systemctl", "daemon-reload"], check=True)
+    subprocess.run(["sudo", "systemctl", "restart", "ssh.socket"], check=False)
+    subprocess.run(["sudo", "service", "ssh", "restart"], check=False)
+    print(f"✅ SSH port changed to {port}")
+    print(f"⚠️  Remember to open port {port} in Windows Firewall if running in WSL")
 
 
 if __name__ == "__main__":
-    copy_when_inside_wsl(Path("projects/source.txt"), Path("windows_projects/source.txt"), True)
-    copy_when_inside_windows(Path("documents/example.txt"), Path("linux_documents/example.txt"), True)
+    copy_when_inside_wsl(Path("projects/source.txt"), Path("windows_projects/source.txt"), overwrite=True, windows_username=None)
+    copy_when_inside_windows(Path("documents/example.txt"), Path("linux_documents/example.txt"), overwrite=True)