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

machineconfig/scripts/python/{helpers_network → helpers/helpers_network}/address.py

@@ -1,18 +1,21 @@
-
 from typing import Optional, TypedDict, cast
 
+
 class CountryFlag(TypedDict, total=False):
     emoji: str
     unicode: str
 
+
 class CountryCurrency(TypedDict, total=False):
     code: str
     symbol: str
 
+
 class Continent(TypedDict, total=False):
     code: str
     name: str
 
+
 class PublicIpInfo(TypedDict, total=True):
     ip: str
     hostname: str
@@ -33,15 +36,11 @@ class PublicIpInfo(TypedDict, total=True):
 def get_public_ip_address() -> PublicIpInfo:
     from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     import subprocess
+
     install_if_missing("ipinfo")
-    result = subprocess.run(
-        ["ipinfo", "myip", "--json"],
-        check=True,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
+    result = subprocess.run(["ipinfo", "myip", "--json"], check=True, capture_output=True, text=True, encoding="utf-8")
     import json
+
     loaded_json: PublicIpInfo = json.loads(result.stdout)
     return loaded_json
 
@@ -49,6 +48,7 @@ def get_public_ip_address() -> PublicIpInfo:
 def get_all_ipv4_addresses() -> list[tuple[str, str]]:
     import psutil
     import socket
+
     result: list[tuple[str, str]] = []
     for iface, addrs in psutil.net_if_addrs().items():
         for addr in addrs:
@@ -82,19 +82,16 @@ def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
     )
 
     # Light preference for names that look like real NICs
-    PHYSICAL_IFACE_PAT = re.compile(
-        r"^(?:eth\d*|en\d*|enp.*|ens.*|eno.*|wlan\d*|wl.*|.*wifi.*|.*ethernet.*)$",
-        re.IGNORECASE,
-    )
+    PHYSICAL_IFACE_PAT = re.compile(r"^(?:eth\d*|en\d*|enp.*|ens.*|eno.*|wlan\d*|wl.*|.*wifi.*|.*ethernet.*)$", re.IGNORECASE)
 
     # Known noisy CIDRs to avoid
     NOISY_NETS: list[ipaddress.IPv4Network] = [
-        ipaddress.IPv4Network("100.64.0.0/10"),   # CGNAT (Tailscale/others)
-        ipaddress.IPv4Network("172.17.0.0/16"),   # docker0 default
+        ipaddress.IPv4Network("100.64.0.0/10"),  # CGNAT (Tailscale/others)
+        ipaddress.IPv4Network("172.17.0.0/16"),  # docker0 default
         ipaddress.IPv4Network("172.18.0.0/16"),
         ipaddress.IPv4Network("172.19.0.0/16"),
-        ipaddress.IPv4Network("192.168.49.0/24"), # minikube default
-        ipaddress.IPv4Network("10.0.2.0/24"),     # VirtualBox NAT
+        ipaddress.IPv4Network("192.168.49.0/24"),  # minikube default
+        ipaddress.IPv4Network("10.0.2.0/24"),  # VirtualBox NAT
     ]
 
     def _in_any(ip: ipaddress.IPv4Address, nets: Sequence[ipaddress.IPv4Network]) -> bool:
@@ -102,8 +99,9 @@ def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
 
     stats = psutil.net_if_stats()
     best = None
-    best_score = -10**9
+    best_score = -(10**9)
     import socket
+
     for iface, addrs in psutil.net_if_addrs().items():
         st = stats.get(iface)
         if not st or not st.isup:

machineconfig/scripts/python/{helpers_network → helpers/helpers_network}/address_switch.py

@@ -1,7 +1,7 @@
 import subprocess
 import time
 
-from machineconfig.scripts.python.helpers_network.address import get_public_ip_address
+from machineconfig.scripts.python.helpers.helpers_network.address import get_public_ip_address
 
 
 def switch_public_ip_address(max_trials: int = 10, wait_seconds: float = 4.0) -> None:

machineconfig/scripts/python/helpers/helpers_network/ftpx_impl.py

@@ -0,0 +1,276 @@
+"""Pure Python implementation for ftpx command - no typer dependencies."""
+
+from pathlib import Path
+from typing import Optional
+
+
+def ftpx(source: str, target: str, recursive: bool, zipFirst: bool, cloud: bool, overwrite_existing: bool) -> None:
+    """File transfer utility through SSH."""
+    if target == "wsl" or source == "wsl":
+        _handle_wsl_transfer(source=source, target=target, overwrite_existing=overwrite_existing)
+        return
+    elif source == "win" or target == "win":
+        _handle_win_transfer(source=source, target=target, overwrite_existing=overwrite_existing, windows_username=None)
+        return
+
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+
+    console.print(
+        Panel(
+            "\n".join(["🚀 FTP File Transfer", "📋 Starting transfer process..."]),
+            title="Transfer Initialisation",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
+
+    resolved_source, resolved_target, machine, source_is_remote = _resolve_paths(source=source, target=target)
+
+    from machineconfig.utils.accessories import pprint
+
+    pprint({"source": str(resolved_source), "target": str(resolved_target), "machine": machine}, "CLI Resolution")
+
+    ssh = _create_ssh_connection(machine=machine, console=console)
+
+    if cloud:
+        received_file = _handle_cloud_transfer(ssh=ssh, resolved_source=resolved_source, resolved_target=resolved_target, console=console)
+    else:
+        received_file = _handle_direct_transfer(
+            ssh=ssh,
+            resolved_source=resolved_source,
+            resolved_target=resolved_target,
+            source_is_remote=source_is_remote,
+            zipFirst=zipFirst,
+            recursive=recursive,
+            overwrite_existing=overwrite_existing,
+            console=console,
+        )
+    if source_is_remote and received_file is not None:
+        console.print(
+            Panel(
+                "\n".join(["📁 File Received", f"Parent: [cyan]{repr(received_file.parent)}[/cyan]", f"File: [cyan]{repr(received_file)}[/cyan]"]),
+                title="Transfer Result",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    console.print(Panel("File transfer process finished successfully", title="✅ Transfer Complete", border_style="green", padding=(1, 2)))
+
+
+def _handle_wsl_transfer(source: str, target: str, overwrite_existing: bool) -> None:
+    """Handle WSL transfer when inside Windows."""
+    from machineconfig.utils.ssh_utils.wsl import copy_when_inside_windows
+
+    if target == "wsl":
+        target_obj = Path(source).expanduser().absolute().relative_to(Path.home())
+        source_obj = target_obj
+    else:
+        source_obj = Path(target).expanduser().absolute().relative_to(Path.home())
+        target_obj = source_obj
+    copy_when_inside_windows(source_obj, target_obj, overwrite_existing)
+
+
+def _handle_win_transfer(source: str, target: str, overwrite_existing: bool, windows_username: str | None) -> None:
+    """Handle Windows transfer when inside WSL."""
+    from machineconfig.utils.ssh_utils.wsl import copy_when_inside_wsl
+
+    if source == "win":
+        source_obj = Path(target).expanduser().absolute().relative_to(Path.home())
+        target_obj = source_obj
+    else:
+        target_obj = Path(source).expanduser().absolute().relative_to(Path.home())
+        source_obj = target_obj
+    copy_when_inside_wsl(source_obj, target_obj, overwrite_existing, windows_username=windows_username)
+
+
+def _resolve_paths(source: str, target: str) -> tuple[Optional[str], Optional[str], str, bool]:
+    """Resolve source and target paths, determine machine and direction."""
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers.helpers_cloud.helpers2 import ES
+
+    resolved_source: Optional[str] = None
+    resolved_target: Optional[str] = None
+    machine: str = ""
+    source_is_remote: bool = False
+
+    if ":" in source and (source[1] != ":" if len(source) > 1 else True):
+        source_is_remote = True
+        source_parts = source.split(":")
+        machine = source_parts[0]
+        if len(source_parts) > 1 and source_parts[1] == ES:
+            if target == ES:
+                raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+            else:
+                target_path_obj = PathExtended(target).expanduser().absolute()
+            resolved_source = target_path_obj.collapseuser().as_posix()
+            resolved_target = target
+        else:
+            resolved_source = ":".join(source.split(":")[1:])
+            if target == ES:
+                resolved_target = None
+            else:
+                resolved_target = PathExtended(target).expanduser().absolute().as_posix()
+
+    elif ":" in target and (target[1] != ":" if len(target) > 1 else True):
+        source_is_remote = False
+        target_parts = target.split(":")
+        machine = target_parts[0]
+        if len(target_parts) > 1 and target_parts[1] == ES:
+            if source == ES:
+                raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+            else:
+                resolved_source = source
+            resolved_target = None
+        else:
+            resolved_target = ":".join(target.split(":")[1:])
+            if source == ES:
+                resolved_source = None
+            else:
+                resolved_source = PathExtended(source).expanduser().absolute().as_posix()
+    else:
+        raise ValueError("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Path Error
+┃    Either source or target must be a remote path
+┃    Format should be: machine:path
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+
+    return resolved_source, resolved_target, machine, source_is_remote
+
+
+def _create_ssh_connection(machine: str, console: "Console") -> "SSH":  # type: ignore[name-defined]
+    """Create SSH connection, handling authentication."""
+    from machineconfig.utils.ssh import SSH
+    from paramiko.ssh_exception import AuthenticationException  # type: ignore
+    from rich.panel import Panel
+
+    try:
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=True)
+    except AuthenticationException:
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "🔑 Authentication failed. Trying manual authentication...",
+                        "⚠️  Ensure that the username is provided correctly; only password prompts are handled here.",
+                    ]
+                ),
+                title="Authentication Required",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+        import getpass
+
+        pwd = getpass.getpass()
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=pwd, port=22, enable_compression=True)
+
+    return ssh
+
+
+def _handle_cloud_transfer(
+    ssh: "SSH", resolved_source: Optional[str], resolved_target: Optional[str], console: "Console"
+) -> Optional["PathExtended"]:  # type: ignore[name-defined]
+    """Handle cloud transfer mode."""
+    from machineconfig.utils.path_extended import PathExtended
+    from rich.panel import Panel
+
+    console.print(Panel.fit("☁️  Cloud transfer mode — uploading from remote to cloud...", title="Cloud Upload", border_style="cyan"))
+    ssh.run_shell_cmd_on_remote(
+        command=f"cloud copy {resolved_source} :^",
+        verbose_output=True,
+        description="Uploading from remote to the cloud.",
+        strict_stderr=False,
+        strict_return_code=False,
+    )
+    console.print(Panel.fit("⬇️  Cloud transfer mode — downloading from cloud to local...", title="Cloud Download", border_style="cyan"))
+    ssh.run_shell_cmd_on_local(command=f"cloud copy :^ {resolved_target}")
+    return PathExtended(resolved_target)  # type: ignore
+
+
+def _handle_direct_transfer(
+    ssh: "SSH",
+    resolved_source: Optional[str],
+    resolved_target: Optional[str],
+    source_is_remote: bool,
+    zipFirst: bool,
+    recursive: bool,
+    overwrite_existing: bool,
+    console: "Console",
+) -> Optional["PathExtended"]:  # type: ignore[name-defined]
+    """Handle direct SSH transfer."""
+    from rich.panel import Panel
+
+    if source_is_remote:
+        if resolved_source is None:
+            print("❌ Path Error: Source must be a remote path (machine:path)")
+            return None
+        target_display = resolved_target or "<auto>"
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📥 Transfer Mode: Remote → Local",
+                        f"Source: [cyan]{resolved_source}[/cyan]",
+                        f"Target: [cyan]{target_display}[/cyan]",
+                        f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                    ]
+                ),
+                title="Transfer Details",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+        received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, compress_with_zip=zipFirst, recursive=recursive)
+    else:
+        assert resolved_source is not None, "❌ Path Error: Target must be a remote path (machine:path)"
+        target_display = resolved_target or "<auto>"
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📤 Transfer Mode: Local → Remote",
+                        f"Source: [cyan]{resolved_source}[/cyan]",
+                        f"Target: [cyan]{target_display}[/cyan]",
+                        f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                    ]
+                ),
+                title="Transfer Details",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+        received_file = ssh.copy_from_here(
+            source_path=resolved_source,
+            target_rel2home=resolved_target,
+            compress_with_zip=zipFirst,
+            recursive=recursive,
+            overwrite_existing=overwrite_existing,
+        )
+
+    return received_file
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.ssh import SSH
+
+    _ = SSH
+    from machineconfig.utils.path_extended import PathExtended
+
+    _ = PathExtended
+    from rich.console import Console
+
+    _ = Console

machineconfig/scripts/python/{helpers_network → helpers/helpers_network}/mount_ssh.py

@@ -3,7 +3,7 @@
 from platform import system
 import subprocess
 from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended
+from pathlib import Path
 
 from machineconfig.utils.options import choose_ssh_host
 
@@ -35,7 +35,7 @@ def main():
 
     mount_point = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_ssh/{ssh.hostname}]: ")
     if mount_point == "":
-        mount_point = PathExtended.home().joinpath(rf"data/mount_ssh/{ssh.hostname}")
+        mount_point = Path.home().joinpath(rf"data/mount_ssh/{ssh.hostname}")
 
     print(f"\n📁 Mount Point: {mount_point}")
 

machineconfig/scripts/python/helpers/helpers_network/ssh_add_identity.py

@@ -0,0 +1,73 @@
+r"""ID
+
+On windows:
+
+$sshfile = "$env:USERPROFILE/.ssh/id_rsa"
+Set-Service ssh-agent -StartupType Manual  # allow the service to be started manually
+ssh-agent  # start the service
+ssh-add.exe $sshfile # add the key to the agent
+
+# copy ssh key:
+# This is the Windows equivalent of copy-ssh-id on Linux.
+# Just like the original function, it is a convenient way of doing two things in one go:
+# 1- copy a certain public key to the remote machine.
+#    scp ~/.ssh/id_rsa.pub $remote_user@$remote_host:~/.ssh/authorized_keys
+# 2- Store the value on the remote in a file called .ssh/authorized_keys
+#    ssh $remote_user@$remote_host "echo $public_key >> ~/.ssh/authorized_keys"
+# Idea from: https://www.chrisjhart.com/Windows-10-ssh-copy-id/
+
+
+
+"""
+
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.options import choose_from_options
+from rich.console import Console
+from rich.panel import Panel
+
+
+console = Console()
+
+
+def main() -> None:
+    private_keys = [PathExtended(x).with_name(x.stem) for x in PathExtended.home().joinpath(".ssh").glob("*.pub")]
+    key_status = f"Found {len(private_keys)} key(s)" if private_keys else "No keys found"
+    console.print(Panel(f"🔑 SSH Identity Management\n🔍 {key_status} in ~/.ssh", title="[bold blue]Setup[/bold blue]", expand=False))
+
+    choice = choose_from_options(msg="Path to private key to be used when ssh'ing: ", options=[str(x) for x in private_keys] + ["I have the path to the key file", "I want to paste the key itself"], multi=False)
+
+    if choice == "I have the path to the key file":
+        path_to_key = PathExtended(input("📋 Enter path to private key: ")).expanduser().absolute()
+    elif choice == "I want to paste the key itself":
+        key_filename = input("📝 File name (default: my_pasted_key): ") or "my_pasted_key"
+        path_to_key = PathExtended.home().joinpath(f".ssh/{key_filename}")
+        path_to_key.parent.mkdir(parents=True, exist_ok=True)
+        path_to_key.write_text(input("🔑 Paste the private key: "), encoding="utf-8")
+    else:
+        path_to_key = PathExtended(choice)
+
+    txt = f"IdentityFile {path_to_key.collapseuser().as_posix()}"
+    config_path = PathExtended.home().joinpath(".ssh/config")
+
+    if config_path.exists():
+        current = config_path.read_text(encoding="utf-8")
+        config_action = "updated"
+    else:
+        current = txt
+        config_action = "created"
+    lines = current.split("\n")
+    found = False
+    for i, line in enumerate(lines):
+        if txt in line:
+            lines[i] = txt
+            found = True
+    if not found:
+        lines.insert(0, txt)
+    config_path.write_text("\n".join(lines), encoding="utf-8")
+
+    console.print(Panel(f"✅ Identity: {path_to_key.name}\n📄 Config {config_action}: {config_path}", title="[bold green]Complete[/bold green]", expand=False, border_style="green"))
+    return None
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/helpers/helpers_network/ssh_add_ssh_key.py

@@ -0,0 +1,175 @@
+"""SSH"""
+
+from platform import system
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich import box
+from typing import Optional, Annotated
+import typer
+import subprocess
+
+
+console = Console()
+
+
+def _add_ssh_key_windows(path_to_key: Path) -> None:
+    """Add SSH key on Windows using Python with proper UTF-8 encoding.
+    This replaces the PowerShell script that was writing UTF-16LE encoded files which openssh server cannot read.
+    """
+    sshd_dir = Path("C:/ProgramData/ssh")
+    admin_auth_keys = sshd_dir / "administrators_authorized_keys"
+    sshd_config = sshd_dir / "sshd_config"
+    key_content = path_to_key.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)
+
+
+def get_add_ssh_key_script(path_to_key: Path, verbose: bool = True) -> tuple[str, str]:
+    """Returns (program_script, status_message) tuple. For Windows, program_script is empty because we handle it in Python."""
+    os_name = system()
+    if os_name == "Linux" or os_name == "Darwin":
+        authorized_keys = Path.home().joinpath(".ssh/authorized_keys")
+        os_icon, os_label = "🐧", "Linux/macOS"
+    elif os_name == "Windows":
+        authorized_keys = Path("C:/ProgramData/ssh/administrators_authorized_keys")
+        os_icon, os_label = "🪟", "Windows"
+    else:
+        raise NotImplementedError("Only Linux, macOS and Windows are supported")
+
+    status_lines: list[str] = [f"{os_icon} {os_label} │ Auth file: {authorized_keys}"]
+    program = ""
+
+    if authorized_keys.exists():
+        keys_text = authorized_keys.read_text(encoding="utf-8").split("\n")
+        key_count = len([k for k in keys_text if k.strip()])
+        status_lines.append(f"🔑 Existing keys: {key_count}")
+        if path_to_key.read_text(encoding="utf-8") in authorized_keys.read_text(encoding="utf-8"):
+            status_lines.append(f"⚠️  Key [yellow]{path_to_key.name}[/yellow] already authorized, skipping")
+        else:
+            status_lines.append(f"➕ Adding: [green]{path_to_key.name}[/green]")
+            if os_name == "Linux" or os_name == "Darwin":
+                program = f"cat {path_to_key} >> ~/.ssh/authorized_keys"
+            elif os_name == "Windows":
+                _add_ssh_key_windows(path_to_key)
+            else:
+                raise NotImplementedError
+    else:
+        status_lines.append(f"📝 Creating auth file with: [green]{path_to_key.name}[/green]")
+        if os_name == "Linux" or os_name == "Darwin":
+            program = f"cat {path_to_key} > ~/.ssh/authorized_keys"
+        else:
+            _add_ssh_key_windows(path_to_key)
+
+    if os_name == "Linux" or os_name == "Darwin":
+        program += """
+sudo chmod 700 ~/.ssh
+sudo chmod 644 ~/.ssh/authorized_keys
+sudo chmod 644 ~/.ssh/*.pub
+sudo service ssh --full-restart
+# from superuser.com/questions/215504/permissions-on-private-key-in-ssh-folder
+"""
+    return program, "\n".join(status_lines)
+
+
+"""
+Common pitfalls: 
+🚫 Wrong line endings (LF/CRLF) in config files
+🌐 Network port conflicts (try 2222 -> 2223) between WSL and Windows
+sudo service ssh restart
+sudo service ssh status
+sudo nano /etc/ssh/sshd_config
+"""
+
+
+def main(pub_path: Annotated[Optional[str], typer.Argument(help="Path to the public key file")] = None,
+         pub_choose: Annotated[bool, typer.Option("--choose", "-c", help="Choose from available public keys in ~/.ssh")] = False,
+         pub_val: Annotated[bool, typer.Option("--paste", "-p", help="Paste the public key content manually")] = False,
+         from_github: Annotated[Optional[str], typer.Option("--from-github", "-g", help="Fetch public keys from a GitHub username")] = None
+         ) -> None:
+    info_lines: list[str] = []
+    program = ""
+    status_msg = ""
+
+    if pub_path:
+        key_path = Path(pub_path).expanduser().absolute()
+        key_path.parent.mkdir(parents=True, exist_ok=True)
+        if not key_path.exists():
+            console.print(Panel(f"❌ Key path does not exist: {key_path}", title="[bold red]Error[/bold red]", border_style="red"))
+            raise typer.Exit(code=1)
+        info_lines.append(f"📄 Source: Local file │ {key_path}")
+        program, status_msg = get_add_ssh_key_script(key_path)
+
+    elif pub_choose:
+        pub_keys = list(Path.home().joinpath(".ssh").glob("*.pub"))
+        if not pub_keys:
+            console.print(Panel("⚠️  No public keys found in ~/.ssh", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+            return
+        info_lines.append(f"📄 Source: Local ~/.ssh │ Found {len(pub_keys)} key(s)")
+        programs: list[str] = []
+        statuses: list[str] = []
+        for key in pub_keys:
+            p, s = get_add_ssh_key_script(key)
+            programs.append(p)
+            statuses.append(s)
+        program = "\n\n\n".join(programs)
+        status_msg = "\n".join(statuses)
+
+    elif pub_val:
+        key_filename = input("📝 File name (default: my_pasted_key.pub): ") or "my_pasted_key.pub"
+        key_path = Path.home().joinpath(f".ssh/{key_filename}")
+        key_path.parent.mkdir(parents=True, exist_ok=True)
+        key_path.write_text(input("🔑 Paste the public key here: "), encoding="utf-8")
+        info_lines.append(f"📄 Source: Pasted │ Saved to {key_path}")
+        program, status_msg = get_add_ssh_key_script(key_path)
+
+    elif from_github:
+        import requests
+        response = requests.get(f"https://api.github.com/users/{from_github}/keys")
+        if response.status_code != 200:
+            console.print(Panel(f"❌ GitHub API error for user '{from_github}' │ Status: {response.status_code}", title="[bold red]Error[/bold red]", border_style="red"))
+            raise typer.Exit(code=1)
+        keys = response.json()
+        if not keys:
+            console.print(Panel(f"⚠️  No public keys found for GitHub user: {from_github}", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+            return
+        key_path = Path.home().joinpath(f".ssh/{from_github}_github_keys.pub")
+        key_path.parent.mkdir(parents=True, exist_ok=True)
+        key_path.write_text("\n".join([key["key"] for key in keys]), encoding="utf-8")
+        info_lines.append(f"📄 Source: GitHub @{from_github} │ {len(keys)} key(s) → {key_path}")
+        program, status_msg = get_add_ssh_key_script(key_path)
+
+    else:
+        console.print(Panel("❌ No key source specified. Use --help for options.", title="[bold red]Error[/bold red]", border_style="red"))
+        raise typer.Exit(code=1)
+
+    combined_info = "\n".join(info_lines + [""] + status_msg.split("\n"))
+    console.print(Panel(combined_info, title="[bold blue]🔑 SSH Key Authorization[/bold blue]", border_style="blue"))
+
+    if program.strip():
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=program)
+
+    import machineconfig.scripts.python.helpers.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        console.print(Panel("❌ Could not determine local LAN IPv4 address", title="[bold red]Error[/bold red]", border_style="red"))
+        raise typer.Exit(code=1)
+
+    console.print(Panel(f"✅ Complete │ This machine accessible at: [green]{res}[/green]", title="[bold green]SSH Key Authorization[/bold green]", border_style="green", box=box.DOUBLE_EDGE))
+
+
+if __name__ == "__main__":
+    pass