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

machineconfig/scripts/python/helpers/helpers_network/{ssh_debug_linux.py → ssh/ssh_debug_linux.py}

@@ -6,45 +6,13 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 from rich import box
-import subprocess
 import os
 import re
 
-
-console = Console()
-
-
-def _run(cmd: list[str]) -> tuple[bool, str]:
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
-        return result.returncode == 0, result.stdout.strip()
-    except FileNotFoundError:
-        return False, ""
+from machineconfig.scripts.python.helpers.helpers_network.ssh.ssh_debug_linux_utils import check_sshd_installed, detect_package_manager, run_cmd
 
 
-def _check_sshd_installed() -> tuple[bool, str]:
-    sshd_paths = ["/usr/sbin/sshd", "/usr/bin/sshd", "/sbin/sshd"]
-    for path in sshd_paths:
-        if Path(path).exists():
-            return True, path
-    ok, which_out = _run(["which", "sshd"])
-    if ok and which_out:
-        return True, which_out
-    return False, ""
-
-
-def _detect_package_manager() -> tuple[str, str]:
-    if Path("/usr/bin/apt").exists() or Path("/usr/bin/apt-get").exists():
-        return "apt", "sudo apt update && sudo apt install -y openssh-server"
-    if Path("/usr/bin/dnf").exists():
-        return "dnf", "sudo dnf install -y openssh-server"
-    if Path("/usr/bin/yum").exists():
-        return "yum", "sudo yum install -y openssh-server"
-    if Path("/usr/bin/pacman").exists():
-        return "pacman", "sudo pacman -S --noconfirm openssh"
-    if Path("/usr/bin/zypper").exists():
-        return "zypper", "sudo zypper install -y openssh"
-    return "unknown", "# Install openssh-server using your package manager"
+console = Console()
 
 
 def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
@@ -57,12 +25,12 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     ssh_port = "22"
     ip_addresses: list[str] = []
 
-    ok, hostname = _run(["hostname"])
+    ok, hostname = run_cmd(["hostname"])
     hostname = hostname if ok else "unknown"
 
     install_info: list[str] = []
-    sshd_installed, sshd_path = _check_sshd_installed()
-    _pkg_manager, install_cmd = _detect_package_manager()
+    sshd_installed, sshd_path = check_sshd_installed()
+    _pkg_manager, install_cmd = detect_package_manager()
     if not sshd_installed:
         results["installation"] = {"status": "error", "message": "OpenSSH Server not installed"}
         issues.append(("sshd not installed", "Cannot accept incoming SSH connections", install_cmd))
@@ -124,8 +92,8 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     console.print(Panel("\n".join(perm_info), title="[bold]Permissions[/bold]", border_style="blue"))
 
     svc_info: list[str] = []
-    ssh_ok, _ = _run(["systemctl", "is-active", "ssh"])
-    sshd_ok, _ = _run(["systemctl", "is-active", "sshd"])
+    ssh_ok, _ = run_cmd(["systemctl", "is-active", "ssh"])
+    sshd_ok, _ = run_cmd(["systemctl", "is-active", "sshd"])
     if ssh_ok or sshd_ok:
         svc_name = "ssh" if ssh_ok else "sshd"
         results["ssh_service"] = {"status": "ok", "message": f"{svc_name} running"}
@@ -138,7 +106,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     console.print(Panel("\n".join(svc_info), title="[bold]Service[/bold]", border_style="blue"))
 
     net_info: list[str] = []
-    ok, ip_out = _run(["ip", "addr", "show"])
+    ok, ip_out = run_cmd(["ip", "addr", "show"])
     if ok:
         ip_addresses = re.findall(r'inet\s+(\d+\.\d+\.\d+\.\d+)/\d+.*scope\s+global', ip_out)
         if ip_addresses:
@@ -151,6 +119,34 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
             sshd_config = p
             break
 
+    sshd_config_d = Path("/etc/ssh/sshd_config.d")
+    cloud_init_overrides: dict[str, Path] = {}
+    cloud_init_files: list[Path] = []
+    if sshd_config_d.exists():
+        for conf_file in sorted(sshd_config_d.glob("*.conf")):
+            cloud_init_files.append(conf_file)
+            try:
+                conf_text = conf_file.read_text(encoding="utf-8")
+                for line in conf_text.split("\n"):
+                    line_stripped = line.strip()
+                    if line_stripped and not line_stripped.startswith("#"):
+                        key = line_stripped.split()[0] if line_stripped.split() else ""
+                        if key:
+                            cloud_init_overrides[key] = conf_file
+            except Exception:
+                pass
+
+    if cloud_init_files:
+        cloud_info: list[str] = []
+        cloud_info.append(f"⚠️  Found [yellow]{len(cloud_init_files)}[/yellow] override file(s) in /etc/ssh/sshd_config.d/")
+        cloud_info.append("   [dim]These files can override settings in the main sshd_config![/dim]")
+        for cf in cloud_init_files:
+            cloud_info.append(f"   \u2022 [cyan]{cf.name}[/cyan]")
+        if cloud_init_overrides:
+            overridden_keys = list(cloud_init_overrides.keys())[:5]
+            cloud_info.append(f"   Overriding: {', '.join(overridden_keys)}{'...' if len(cloud_init_overrides) > 5 else ''}")
+        console.print(Panel("\n".join(cloud_info), title="[bold yellow]Cloud-Init SSH Overrides[/bold yellow]", border_style="yellow"))
+
     if sshd_config:
         try:
             config_text = sshd_config.read_text(encoding="utf-8")
@@ -160,22 +156,45 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
             net_info.append(f"🔌 Port: [cyan]{ssh_port}[/cyan]")
 
             pubkey_lines = [line for line in config_text.split("\n") if "PubkeyAuthentication" in line and not line.strip().startswith("#")]
+            pubkey_override_file: Path | None = cloud_init_overrides.get("PubkeyAuthentication")
+            if pubkey_override_file:
+                try:
+                    override_text = pubkey_override_file.read_text(encoding="utf-8")
+                    override_pubkey_lines = [line for line in override_text.split("\n") if "PubkeyAuthentication" in line and not line.strip().startswith("#")]
+                    if override_pubkey_lines:
+                        pubkey_lines = override_pubkey_lines
+                except Exception:
+                    pass
             if pubkey_lines and "no" in pubkey_lines[-1].lower():
                 results["pubkey_auth"] = {"status": "error", "message": "PubkeyAuthentication disabled"}
-                issues.append(("PubkeyAuthentication disabled", "Key-based login won't work", f"Edit {sshd_config}: set PubkeyAuthentication yes, then sudo systemctl restart ssh"))
-                net_info.append("❌ PubkeyAuthentication: [red]disabled[/red]")
+                fix_target = pubkey_override_file if pubkey_override_file else sshd_config
+                issues.append(("PubkeyAuthentication disabled", "Key-based login won't work", f"Edit {fix_target}: set PubkeyAuthentication yes, then sudo systemctl restart ssh"))
+                override_note = f" (overridden in {pubkey_override_file.name})" if pubkey_override_file else ""
+                net_info.append(f"❌ PubkeyAuthentication: [red]disabled[/red]{override_note}")
             else:
                 net_info.append("✅ PubkeyAuthentication: enabled")
 
             password_lines = [line for line in config_text.split("\n") if "PasswordAuthentication" in line and not line.strip().startswith("#")]
+            password_override_file: Path | None = cloud_init_overrides.get("PasswordAuthentication")
+            if password_override_file:
+                try:
+                    override_text = password_override_file.read_text(encoding="utf-8")
+                    override_password_lines = [line for line in override_text.split("\n") if "PasswordAuthentication" in line and not line.strip().startswith("#")]
+                    if override_password_lines:
+                        password_lines = override_password_lines
+                except Exception:
+                    pass
             if password_lines:
                 password_enabled = "yes" in password_lines[-1].lower()
+                override_note = f" (from {password_override_file.name})" if password_override_file else ""
                 if password_enabled:
                     results["password_auth"] = {"status": "ok", "message": "PasswordAuthentication enabled"}
-                    net_info.append("✅ PasswordAuthentication: [green]enabled[/green]")
+                    net_info.append(f"✅ PasswordAuthentication: [green]enabled[/green]{override_note}")
                 else:
                     results["password_auth"] = {"status": "info", "message": "PasswordAuthentication disabled"}
-                    net_info.append("ℹ️  PasswordAuthentication: [yellow]disabled[/yellow] (key-only)")
+                    net_info.append(f"ℹ️  PasswordAuthentication: [yellow]disabled[/yellow] (key-only){override_note}")
+                    if password_override_file:
+                        issues.append((f"PasswordAuth disabled by {password_override_file.name}", "Password login blocked by cloud-init config", f"Edit {password_override_file}: set PasswordAuthentication yes, then sudo systemctl restart ssh"))
             else:
                 results["password_auth"] = {"status": "ok", "message": "PasswordAuthentication enabled (default)"}
                 net_info.append("✅ PasswordAuthentication: [green]enabled[/green] (default)")
@@ -187,7 +206,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
         except Exception:
             pass
 
-    ok, ss_out = _run(["ss", "-tlnp"])
+    ok, ss_out = run_cmd(["ss", "-tlnp"])
     if ok:
         listening = [line for line in ss_out.split("\n") if f":{ssh_port}" in line]
         if not listening:
@@ -203,7 +222,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
             net_info.append(f"✅ Listening: 0.0.0.0:{ssh_port}")
 
     fw_checked = False
-    ok, ufw_out = _run(["ufw", "status"])
+    ok, ufw_out = run_cmd(["ufw", "status"])
     if ok and "Status: active" in ufw_out:
         fw_checked = True
         if f"{ssh_port}/tcp" in ufw_out.lower() or "ssh" in ufw_out.lower() or f" {ssh_port} " in ufw_out:
@@ -216,10 +235,10 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
             net_info.append("   [dim]Active firewall without SSH rule = blocked[/dim]")
 
     if not fw_checked:
-        ok, fwd_out = _run(["firewall-cmd", "--state"])
+        ok, fwd_out = run_cmd(["firewall-cmd", "--state"])
         if ok and "running" in fwd_out.lower():
             fw_checked = True
-            ok2, svc_out = _run(["firewall-cmd", "--list-services"])
+            ok2, svc_out = run_cmd(["firewall-cmd", "--list-services"])
             if ok2 and "ssh" in svc_out.lower():
                 results["firewall"] = {"status": "ok", "message": "firewalld allows SSH"}
                 net_info.append("✅ Firewall (firewalld): allows SSH")
@@ -229,7 +248,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
                 net_info.append("❌ Firewall (firewalld): [red]blocking SSH[/red]")
 
     if not fw_checked:
-        ok, ipt_out = _run(["iptables", "-L", "INPUT", "-n"])
+        ok, ipt_out = run_cmd(["iptables", "-L", "INPUT", "-n"])
         if ok and ipt_out:
             has_drop_policy = "policy DROP" in ipt_out or "policy REJECT" in ipt_out
             has_ssh_allow = f"dpt:{ssh_port}" in ipt_out or "dpt:ssh" in ipt_out
@@ -264,7 +283,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
         except Exception:
             pass
 
-    ok, se_out = _run(["getenforce"])
+    ok, se_out = run_cmd(["getenforce"])
     if ok and se_out:
         if se_out == "Enforcing":
             other_info.append("ℹ️  SELinux: Enforcing (run [cyan]restorecon -Rv ~/.ssh[/cyan] if issues)")
@@ -274,7 +293,7 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     log_files = [Path("/var/log/auth.log"), Path("/var/log/secure")]
     for lf in log_files:
         if lf.exists():
-            ok, tail = _run(["tail", "-n", "20", str(lf)])
+            ok, tail = run_cmd(["tail", "-n", "20", str(lf)])
             if ok:
                 errors = [line for line in tail.split("\n") if any(k in line.lower() for k in ["error", "failed", "refused", "denied"]) and "ssh" in line.lower()]
                 if errors:

machineconfig/scripts/python/helpers/helpers_network/ssh/ssh_debug_linux_utils.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import subprocess
+
+
+def run_cmd(cmd: list[str]) -> tuple[bool, str]:
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        return result.returncode == 0, result.stdout.strip()
+    except FileNotFoundError:
+        return False, ""
+
+
+def check_sshd_installed() -> tuple[bool, str]:
+    sshd_paths = ["/usr/sbin/sshd", "/usr/bin/sshd", "/sbin/sshd"]
+    for path in sshd_paths:
+        if Path(path).exists():
+            return True, path
+    ok, which_out = run_cmd(["which", "sshd"])
+    if ok and which_out:
+        return True, which_out
+    return False, ""
+
+
+def detect_package_manager() -> tuple[str, str]:
+    if Path("/usr/bin/apt").exists() or Path("/usr/bin/apt-get").exists():
+        return "apt", "sudo apt update && sudo apt install -y openssh-server"
+    if Path("/usr/bin/dnf").exists():
+        return "dnf", "sudo dnf install -y openssh-server"
+    if Path("/usr/bin/yum").exists():
+        return "yum", "sudo yum install -y openssh-server"
+    if Path("/usr/bin/pacman").exists():
+        return "pacman", "sudo pacman -S --noconfirm openssh"
+    if Path("/usr/bin/zypper").exists():
+        return "zypper", "sudo zypper install -y openssh"
+    return "unknown", "# Install openssh-server using your package manager"

machineconfig/scripts/python/helpers/helpers_network/{ssh_debug_windows.py → ssh/ssh_debug_windows.py}

@@ -9,40 +9,10 @@ from rich import box
 import subprocess
 import os
 
-
-console = Console()
-
-
-def _run_ps(cmd: str) -> tuple[bool, str]:
-    result = subprocess.run(["powershell", "-Command", cmd], capture_output=True, text=True, check=False)
-    return result.returncode == 0, result.stdout.strip()
+from machineconfig.scripts.python.helpers.helpers_network.ssh.ssh_debug_windows_utils import check_sshd_binary_exists, detect_openssh, run_powershell
 
 
-def _check_sshd_binary_exists() -> tuple[bool, str]:
-    sshd_locations = [
-        Path("C:/Windows/System32/OpenSSH/sshd.exe"),
-        Path("C:/Program Files/OpenSSH/sshd.exe"),
-        Path("C:/Program Files (x86)/OpenSSH/sshd.exe"),
-    ]
-    for loc in sshd_locations:
-        if loc.exists():
-            return True, str(loc)
-    ok, which_out = _run_ps("Get-Command sshd -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source")
-    if ok and which_out:
-        return True, which_out
-    return False, ""
-
-
-def _detect_openssh() -> tuple[str, Path | None, Path | None]:
-    capability_sshd = Path("C:/Windows/System32/OpenSSH/sshd.exe")
-    winget_sshd = Path("C:/Program Files/OpenSSH/sshd.exe")
-    programdata_config = Path("C:/ProgramData/ssh")
-    capability_config = Path("C:/ProgramData/ssh")
-    if capability_sshd.exists():
-        return ("capability", capability_sshd, capability_config)
-    if winget_sshd.exists():
-        return ("winget", winget_sshd, programdata_config)
-    return ("not_found", None, None)
+console = Console()
 
 
 def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
@@ -55,9 +25,9 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
     ssh_port = "22"
     ip_addresses: list[str] = []
 
-    sshd_exists, sshd_path = _check_sshd_binary_exists()
-    install_type, _sshd_exe, config_dir = _detect_openssh()
-    ok, hostname = _run_ps("hostname")
+    sshd_exists, sshd_path = check_sshd_binary_exists()
+    install_type, _sshd_exe, config_dir = detect_openssh()
+    ok, hostname = run_powershell("hostname")
     hostname = hostname if ok else "unknown"
 
     install_info: list[str] = []
@@ -76,7 +46,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
         install_info.append(f"   Binary: {sshd_path}")
         install_info.append(f"   Config: {config_dir}")
 
-    ok, status = _run_ps("Get-Service -Name sshd -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Status")
+    ok, status = run_powershell("Get-Service -Name sshd -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Status")
     if not ok or not status:
         results["ssh_service"] = {"status": "error", "message": "sshd service not found"}
         issues.append(("sshd service missing", "SSH daemon not installed", "Install OpenSSH Server first"))
@@ -87,7 +57,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
         install_info.append(f"❌ sshd service: [yellow]{status}[/yellow]")
     else:
         results["ssh_service"] = {"status": "ok", "message": "sshd running"}
-        ok, startup = _run_ps("Get-Service -Name sshd | Select-Object -ExpandProperty StartType")
+        ok, startup = run_powershell("Get-Service -Name sshd | Select-Object -ExpandProperty StartType")
         startup_note = f" (startup: {startup})" if ok else ""
         install_info.append(f"✅ sshd service: [green]Running[/green]{startup_note}")
 
@@ -98,7 +68,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
     admin_auth_keys = Path("C:/ProgramData/ssh/administrators_authorized_keys")
     perm_info: list[str] = []
 
-    ok, is_admin_str = _run_ps("([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)")
+    ok, is_admin_str = run_powershell("([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)")
     is_admin = "True" in is_admin_str
 
     if is_admin:
@@ -124,7 +94,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
             perm_info.append(f"\n⚠️  Could not read {target_auth_keys.name}: {e}")
 
     if is_admin and admin_auth_keys.exists():
-        ok, icacls_out = _run_ps(f'icacls "{admin_auth_keys}"')
+        ok, icacls_out = run_powershell(f'icacls "{admin_auth_keys}"')
         if ok:
             needs_fix = "BUILTIN\\Users" in icacls_out or "Everyone" in icacls_out
             if needs_fix:
@@ -137,7 +107,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
     console.print(Panel("\n".join(perm_info), title="[bold]Keys & Permissions[/bold]", border_style="blue"))
 
     net_info: list[str] = []
-    ok, ip_out = _run_ps("Get-NetIPAddress -AddressFamily IPv4 -PrefixOrigin Dhcp,Manual | Where-Object {$_.IPAddress -notlike '127.*' -and $_.IPAddress -notlike '169.254.*'} | Select-Object -ExpandProperty IPAddress")
+    ok, ip_out = run_powershell("Get-NetIPAddress -AddressFamily IPv4 -PrefixOrigin Dhcp,Manual | Where-Object {$_.IPAddress -notlike '127.*' -and $_.IPAddress -notlike '169.254.*'} | Select-Object -ExpandProperty IPAddress")
     if ok and ip_out:
         ip_addresses = [ip.strip() for ip in ip_out.split("\n") if ip.strip()]
         net_info.append(f"🌐 IP addresses: [cyan]{', '.join(ip_addresses)}[/cyan]")
@@ -148,7 +118,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
         try:
             config_text = sshd_config.read_text(encoding="utf-8")
         except PermissionError:
-            ok, config_text_ps = _run_ps(f'Get-Content "{sshd_config}" -Raw')
+            ok, config_text_ps = run_powershell(f'Get-Content "{sshd_config}" -Raw')
             config_text = config_text_ps if ok and config_text_ps else None
         except Exception:
             config_text = None
@@ -219,7 +189,7 @@ def ssh_debug_windows() -> dict[str, dict[str, str | bool]]:
             $rules | Select-Object Name, DisplayName, Enabled, Action | Format-List
         }}
     """
-    ok, fw_out = _run_ps(fw_cmd)
+    ok, fw_out = run_powershell(fw_cmd)
     if ok and fw_out.strip():
         has_allow = "Enabled : True" in fw_out and "Action : Allow" in fw_out
         if has_allow:

machineconfig/scripts/python/helpers/helpers_network/ssh/ssh_debug_windows_utils.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+import subprocess
+
+
+def run_powershell(cmd: str) -> tuple[bool, str]:
+    result = subprocess.run(["powershell", "-Command", cmd], capture_output=True, text=True, check=False)
+    return result.returncode == 0, result.stdout.strip()
+
+
+def check_sshd_binary_exists() -> tuple[bool, str]:
+    sshd_locations = [
+        Path("C:/Windows/System32/OpenSSH/sshd.exe"),
+        Path("C:/Program Files/OpenSSH/sshd.exe"),
+        Path("C:/Program Files (x86)/OpenSSH/sshd.exe"),
+    ]
+    for loc in sshd_locations:
+        if loc.exists():
+            return True, str(loc)
+    ok, which_out = run_powershell("Get-Command sshd -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source")
+    if ok and which_out:
+        return True, which_out
+    return False, ""
+
+
+def detect_openssh() -> tuple[str, Path | None, Path | None]:
+    capability_sshd = Path("C:/Windows/System32/OpenSSH/sshd.exe")
+    winget_sshd = Path("C:/Program Files/OpenSSH/sshd.exe")
+    programdata_config = Path("C:/ProgramData/ssh")
+    capability_config = Path("C:/ProgramData/ssh")
+    if capability_sshd.exists():
+        return ("capability", capability_sshd, capability_config)
+    if winget_sshd.exists():
+        return ("winget", winget_sshd, programdata_config)
+    return ("not_found", None, None)

machineconfig/scripts/python/helpers/helpers_repos/cloud_repo_sync.py

@@ -20,8 +20,8 @@ def get_tmp_file():
 
 
 def main(
+    repo: Annotated[str, typer.Argument(..., help="Path to the local repository. Defaults to current working directory.")],
     cloud: Annotated[Optional[str], typer.Option(..., "--cloud", "-c", help="Cloud storage profile name. If not provided, uses default from config.")] = None,
-    repo: Annotated[Optional[str], typer.Option(..., "--repo", "-r", help="Path to the local repository. Defaults to current working directory.")] = None,
     message: Annotated[Optional[str], typer.Option(..., "--message", "-m", help="Commit message for local changes.")] = None,
     on_conflict: Annotated[Literal["ask", "a",
                                    "push-local-merge", "p",
@@ -66,7 +66,6 @@ def main(
     if cloud is None:
         try:
             from machineconfig.utils.io import read_ini
-
             cloud_resolved = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
             console.print(Panel(f"⚠️  Using default cloud: `{cloud_resolved}` from {DEFAULTS_PATH}", title="Default Cloud", border_style="yellow"))
         except FileNotFoundError:
@@ -74,7 +73,7 @@ def main(
             return ""
     else:
         cloud_resolved = cloud
-    repo_local_root = PathExtended.cwd() if repo is None else PathExtended(repo).expanduser().absolute()
+    repo_local_root = PathExtended.cwd() if repo == "." else PathExtended(repo).expanduser().absolute()
     try:
         repo_local_obj = git.Repo(repo_local_root, search_parent_directories=True)
     except git.InvalidGitRepositoryError:

machineconfig/scripts/python/helpers/{helpers_terminal/terminal_impl.py → helpers_sessions/attach_impl.py}

@@ -1,23 +1,29 @@
-import re
+
 import subprocess
 from pathlib import Path
+from machineconfig.settings.zellij import layouts
 
-
-_ANSI_ESCAPE_RE = re.compile(
-    r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
-)
-
+root = layouts.__path__[0]
+STANDARD = Path(root).joinpath("st2.kdl")
+# STANDARD = "st2.kdl"
+# a = 1 + "sd"
 
 def strip_ansi_codes(text: str) -> str:
+    import re
+    _ANSI_ESCAPE_RE = re.compile(
+        r"(?:\x1B|\u001B|\033)\[[0-?]*[ -/]*[@-~]|\[[0-9;?]+[ -/]*[@-~]|\[m"
+    )
     return _ANSI_ESCAPE_RE.sub("", text)
 
 
 def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -> tuple[str, str | None]:
     """Choose a Zellij session. Returns tuple of (action, script_to_run) where action is 'run_script', 'exit', or 'error'."""
+    # from machineoncif
+
     if name is not None:
         return ("run_script", f"zellij attach {name}")
     if new_session:
-        cmd = "zellij --layout st2"
+        cmd = f"zellij --layout {STANDARD}"
         if kill_all:
             cmd = f"zellij kill-all-sessions --yes\n{cmd}"
         return ("run_script", cmd)
@@ -32,7 +38,7 @@ def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -
     if "current" in sessions:
         return ("error", "Already in a Zellij session, avoiding nesting and exiting.")
     if len(sessions) == 0:
-        return ("run_script", "zellij --layout st2")
+        return ("run_script", f"zellij --layout {STANDARD}")
     if len(sessions) == 1:
         sn = strip_ansi_codes(sessions[0])
         session_name = sn.split(" [Created")[0]
@@ -46,12 +52,12 @@ def choose_zellij_session(name: str | None, new_session: bool, kill_all: bool) -
     except Exception as e:
         return ("error", f"Error choosing Zellij session: {e}")
     if session_name == NEW_SESSION_LABEL:
-        cmd = "zellij --layout st2"
+        cmd = f"zellij --layout {STANDARD}"
         if kill_all:
             cmd = f"zellij kill-all-sessions --yes\n{cmd}"
         return ("run_script", cmd)
     if session_name == KILL_ALL_AND_NEW_LABEL:
-        return ("run_script", "zellij kill-all-sessions --yes\nzellij --layout st2")
+        return ("run_script", f"zellij kill-all-sessions --yes\nzellij --layout {STANDARD}")
     session_name_clean = strip_ansi_codes(session_name)
     session_name_clean = session_name_clean.split(" [Created")[0]
     return ("run_script", f"zellij attach {session_name_clean}")
@@ -79,18 +85,3 @@ def get_session_tabs() -> list[tuple[str, str]]:
     return result
 
 
-def start_wt(layout_name: str) -> tuple[str, str | None]:
-    """Start a Windows Terminal layout by name. Returns tuple of (status, message) where status is 'success' or 'error'."""
-    import json
-    from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
-    from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
-    layouts_file = Path.home().joinpath("dotfiles/machineconfig/layouts.json")
-    if not layouts_file.exists():
-        return ("error", f"❌ Layouts file not found: {layouts_file}")
-    layouts_data: LayoutsFile = json.loads(layouts_file.read_text(encoding="utf-8"))
-    chosen_layout = next((a_layout for a_layout in layouts_data["layouts"] if a_layout["layoutName"] == layout_name), None)
-    if not chosen_layout:
-        available_layouts = [a_layout["layoutName"] for a_layout in layouts_data["layouts"]]
-        return ("error", f"❌ Layout '{layout_name}' not found in layouts file.\nAvailable layouts: {', '.join(available_layouts)}")
-    run_wt_layout(layout_config=chosen_layout)
-    return ("success", None)