machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/scripts/python/helpers_navigator/main_app.py

@@ -0,0 +1,272 @@
+"""
+Main TUI application for navigating machineconfig commands.
+"""
+
+import subprocess
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, Input, Tree
+from textual.binding import Binding
+from machineconfig.scripts.python.helpers_navigator.command_builder import CommandBuilderScreen
+from machineconfig.scripts.python.helpers_navigator.command_tree import CommandTree
+from machineconfig.scripts.python.helpers_navigator.command_detail import CommandDetail
+from machineconfig.scripts.python.helpers_navigator.search_bar import SearchBar
+from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo
+
+
+class CommandNavigatorApp(App[None]):
+    """TUI application for navigating machineconfig commands."""
+
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 2 3;
+        grid-rows: auto 1fr auto;
+        grid-columns: 1fr 1fr;
+        height: 100%;
+        width: 100%;
+    }
+
+    Header {
+        column-span: 2;
+        background: $boost;
+        color: $text;
+        width: 100%;
+    }
+
+    #search-bar {
+        column-span: 2;
+        padding: 1;
+        background: $surface;
+        height: auto;
+        width: 100%;
+    }
+
+    .search-label {
+        width: auto;
+        padding-right: 1;
+    }
+
+    #search-input {
+        width: 1fr;
+    }
+
+    #command-tree {
+        row-span: 1;
+        border: solid $primary;
+        padding: 1;
+        width: 100%;
+        height: 100%;
+    }
+
+    #command-detail {
+        row-span: 1;
+        border: solid $primary;
+        padding: 1;
+        width: 100%;
+        height: 100%;
+    }
+
+    Footer {
+        column-span: 2;
+        background: $boost;
+        width: 100%;
+    }
+
+    Button {
+        margin: 1;
+    }
+
+    CommandBuilderScreen {
+        align: center middle;
+    }
+
+    CommandBuilderScreen > VerticalScroll {
+        width: 80;
+        height: auto;
+        max-height: 90%;
+        background: $surface;
+        border: thick $primary;
+        padding: 2;
+    }
+
+    CommandBuilderScreen .title {
+        margin-bottom: 1;
+    }
+
+    CommandBuilderScreen Label {
+        margin-top: 1;
+        margin-bottom: 0;
+    }
+
+    CommandBuilderScreen Input {
+        margin-bottom: 1;
+    }
+
+    CommandBuilderScreen .buttons {
+        margin-top: 2;
+        height: auto;
+        align: center middle;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", priority=True),
+        Binding("c", "copy_command", "Copy Command"),
+        Binding("/", "focus_search", "Search"),
+        Binding("?", "help", "Help"),
+        Binding("r", "run_command", "Run Command"),
+        Binding("b", "build_command", "Build Command"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        yield Header(show_clock=True)
+        yield SearchBar(id="search-bar")
+        yield CommandTree("📚 machineconfig Commands", id="command-tree")
+        yield CommandDetail(id="command-detail")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Actions when app is mounted."""
+        self.title = "machineconfig Command Navigator"
+        self.sub_title = "Navigate and explore all available commands"
+        tree = self.query_one(CommandTree)
+        tree.focus()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected[CommandInfo]) -> None:
+        """Handle tree node selection."""
+        command_info = event.node.data
+        detail_widget = self.query_one("#command-detail", CommandDetail)
+        detail_widget.update_command(command_info)
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle search input changes."""
+        if event.input.id != "search-input":
+            return
+
+        search_term = event.value.lower()
+        tree = self.query_one(CommandTree)
+
+        if not search_term:
+            # Show all nodes - expand all root children
+            for node in tree.root.children:
+                node.expand()
+            return
+
+        # Filter nodes based on search term
+        def filter_tree(node):  # type: ignore
+            if node.data and not node.data.is_group:
+                match = (search_term in node.data.name.lower() or
+                        search_term in node.data.description.lower() or
+                        search_term in node.data.command.lower())
+                return match
+            return False
+
+        # Expand parents of matching nodes by walking through all nodes
+        def walk_nodes(node):  # type: ignore
+            """Recursively walk through tree nodes."""
+            yield node
+            for child in node.children:
+                yield from walk_nodes(child)
+
+        for node in walk_nodes(tree.root):
+            if filter_tree(node):
+                parent = node.parent
+                while parent and parent != tree.root:
+                    parent.expand()
+                    parent = parent.parent  # type: ignore
+
+    def action_copy_command(self) -> None:
+        """Copy the selected command to clipboard."""
+        tree = self.query_one(CommandTree)
+        if tree.cursor_node and tree.cursor_node.data:
+            command = tree.cursor_node.data.command
+            try:
+                import pyperclip  # type: ignore
+                pyperclip.copy(command)
+                self.notify(f"Copied: {command}", severity="information")
+            except ImportError:
+                self.notify("Install pyperclip to enable clipboard support", severity="warning")
+
+    def action_run_command(self) -> None:
+        """Run the selected command without arguments."""
+        tree = self.query_one(CommandTree)
+        if tree.cursor_node and tree.cursor_node.data:
+            command_info = tree.cursor_node.data
+            if command_info.is_group:
+                self.notify("Cannot run command groups directly", severity="warning")
+                return
+
+            self._execute_command(command_info.command)
+
+    def action_build_command(self) -> None:
+        """Open command builder for selected command."""
+        tree = self.query_one(CommandTree)
+        if tree.cursor_node and tree.cursor_node.data:
+            command_info = tree.cursor_node.data
+            if command_info.is_group:
+                self.notify("Cannot build command for groups", severity="warning")
+                return
+
+            self.push_screen(CommandBuilderScreen(command_info), self._handle_builder_result)
+
+    def _handle_builder_result(self, result: str | None) -> None:
+        """Handle result from command builder."""
+        if not result:
+            return
+
+        if result.startswith("EXECUTE:"):
+            command = result[8:]
+            self._execute_command(command)
+        elif result.startswith("COPY:"):
+            command = result[5:]
+            self._copy_to_clipboard(command)
+
+    def _execute_command(self, command: str) -> None:
+        """Execute a shell command."""
+        try:
+            self.notify(f"Executing: {command}", severity="information")
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=30)
+
+            if result.returncode == 0:
+                output = result.stdout.strip()
+                if output:
+                    self.notify(f"Success: {output[:100]}...", severity="information", timeout=5)
+                else:
+                    self.notify("Command executed successfully", severity="information")
+            else:
+                error = result.stderr.strip() or "Unknown error"
+                self.notify(f"Error: {error[:100]}...", severity="error", timeout=10)
+        except subprocess.TimeoutExpired:
+            self.notify("Command timed out after 30 seconds", severity="warning")
+        except Exception as e:
+            self.notify(f"Failed to execute: {str(e)}", severity="error")
+
+    def _copy_to_clipboard(self, command: str) -> None:
+        """Copy command to clipboard."""
+        try:
+            import pyperclip  # type: ignore
+            pyperclip.copy(command)
+            self.notify(f"Copied: {command}", severity="information")
+        except ImportError:
+            self.notify("Install pyperclip to enable clipboard support", severity="warning")
+
+    def action_focus_search(self) -> None:
+        """Focus the search input."""
+        search_input = self.query_one("#search-input", Input)
+        search_input.focus()
+
+    def action_help(self) -> None:
+        """Show help information."""
+        help_text = """
+        Navigation:
+        - ↑↓: Navigate tree
+        - Enter: Expand/collapse node
+        - /: Focus search
+        - c: Copy command to clipboard
+        - r: Run command directly (no args)
+        - b: Build command with arguments
+        - q: Quit
+        - ?: Show this help
+        """
+        self.notify(help_text, severity="information", timeout=10)

machineconfig/scripts/python/helpers_navigator/search_bar.py

@@ -0,0 +1,15 @@
+"""
+Search bar widget for filtering commands.
+"""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Label, Input
+
+
+class SearchBar(Horizontal):
+    """Search bar widget."""
+
+    def compose(self) -> ComposeResult:
+        yield Label("🔍 Search: ", classes="search-label")
+        yield Input(placeholder="Type to search commands...", id="search-input")

machineconfig/scripts/python/helpers_network/address.py

@@ -0,0 +1,132 @@
+
+from typing import cast, Optional
+
+
+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:
+            if addr.family == socket.AF_INET:
+                ip = addr.address
+                result.append((iface, ip))
+    return result
+
+
+def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
+    """
+    Choose the best 'real LAN' IPv4:
+      - Excludes loopback/link-local and (by default) VPN/tunnel/container ifaces
+      - Prefers physical-looking ifaces (eth/en*/wlan/wl*)
+      - Prefers RFC1918 LANs: 192.168/16 > 10/8 > 172.16/12
+      - Requires interface is UP
+    Set prefer_vpn=True to allow tunnel/VPN ifaces to compete.
+    """
+
+    import ipaddress
+    import re
+    from collections.abc import Sequence
+    import psutil
+
+    # Down-rank or exclude: tunnels/VPNs/bridges/containers (add your own if needed)
+    VIRTUAL_IFACE_PAT = re.compile(
+        r"^(?:lo|loopback|docker\d*|br-.*|veth.*|virbr.*|bridge.*|"
+        r"vboxnet.*|vmnet.*|zt.*|ham.*|tailscale.*|wg\d*|utun\d*|llw\d*|awdl\d*|"
+        r"tun\d*|tap\d*|cloudflarewarp.*|warp.*)$",
+        re.IGNORECASE,
+    )
+
+    # 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,
+    )
+
+    # 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("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
+    ]
+
+    def _in_any(ip: ipaddress.IPv4Address, nets: Sequence[ipaddress.IPv4Network]) -> bool:
+        return any(ip in n for n in nets)
+
+    stats = psutil.net_if_stats()
+    best = None
+    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:
+            continue
+
+        for a in addrs:
+            if a.family != socket.AF_INET or not a.address:
+                continue
+
+            ip_str = a.address
+            try:
+                ip = cast(ipaddress.IPv4Address, ipaddress.ip_address(ip_str))
+            except ValueError:
+                continue
+
+            # Exclude unusable classes
+            if ip.is_loopback or ip.is_link_local:  # 127.0.0.0/8, 169.254.0.0/16
+                continue
+
+            # Hard filter: if it looks virtual and we don't prefer VPNs, skip it
+            if not prefer_vpn and VIRTUAL_IFACE_PAT.match(iface):
+                continue
+
+            # Hard filter: known noisy subnets (docker, cgnat, etc.)
+            if _in_any(ip, NOISY_NETS) and not prefer_vpn:
+                continue
+
+            # Base score
+            score = 0
+
+            # Prefer physical-looking names
+            if PHYSICAL_IFACE_PAT.match(iface):
+                score += 200
+
+            # Broadcast present usually means L2 LAN (not point-to-point)
+            # (psutil puts it on the same entry as .broadcast)
+            if getattr(a, "broadcast", None):
+                score += 100
+
+            # Prefer private RFC1918; rank families
+            if ip.is_private:
+                # Order: 192.168.x.x > 10.x.x.x > 172.16-31.x.x
+                ip_net = ipaddress.IPv4Network((ip, 32), strict=False)
+                if ipaddress.IPv4Network("192.168.0.0/16").supernet_of(ip_net):
+                    score += 90
+                elif ipaddress.IPv4Network("10.0.0.0/8").supernet_of(ip_net):
+                    score += 70
+                elif ipaddress.IPv4Network("172.16.0.0/12").supernet_of(ip_net):
+                    score += 50
+            else:
+                # Public on a NIC is unusual for a home/office LAN
+                score -= 50
+
+            # Slight nudge by interface speed if known (>0 means psutil knows it)
+            # (Many tunnels report 0)
+            if getattr(st, "speed", 0) > 0:
+                score += 20
+
+            # Deterministic tie-breaker: prefer shorter iface name (eth0 over eth10)
+            score -= len(iface) * 0.01
+
+            if score > best_score:
+                best_score = score
+                best = ip_str
+
+    return best
+
+
+if __name__ == "__main__":
+    print(select_lan_ipv4(False) or "No LAN IPv4 found")

machineconfig/scripts/python/{devops_add_identity.py → helpers_network/devops_add_identity.py}

@@ -12,9 +12,7 @@ BOX_WIDTH = 150  # width for box drawing
 def main() -> None:
     title = "🔑 SSH IDENTITY MANAGEMENT"
     print(Panel(Text(title, justify="center"), expand=False))
-
     print(Panel("🔍 Searching for existing SSH keys...", expand=False))
-
     private_keys = [x.with_name(x.stem) for x in PathExtended.home().joinpath(".ssh").search("*.pub")]
     private_keys = [x for x in private_keys if x.exists()]
     if private_keys:

machineconfig/scripts/python/helpers_network/devops_add_ssh_key.py

@@ -0,0 +1,153 @@
+"""SSH"""
+
+from platform import system
+from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+from machineconfig.utils.path_extended import PathExtended
+from rich.console import Console
+from rich.panel import Panel
+from rich import box
+from typing import Optional, Annotated
+import typer
+
+
+console = Console()
+
+
+def get_add_ssh_key_script(path_to_key: PathExtended) -> str:
+    console.print(Panel("🔑 SSH KEY CONFIGURATION", title="[bold blue]SSH Setup[/bold blue]"))
+    if system() == "Linux" or system() == "Darwin":
+        authorized_keys = PathExtended.home().joinpath(".ssh/authorized_keys")
+        console.print(Panel(f"🐧 Linux SSH configuration\n📄 Authorized keys file: {authorized_keys}", title="[bold blue]System Info[/bold blue]"))
+    elif system() == "Windows":
+        authorized_keys = PathExtended("C:/ProgramData/ssh/administrators_authorized_keys")
+        console.print(Panel(f"🪟 Windows SSH configuration\n📄 Authorized keys file: {authorized_keys}", title="[bold blue]System Info[/bold blue]"))
+    else:
+        console.print(Panel("❌ ERROR: Unsupported operating system\nOnly Linux and Windows are supported", title="[bold red]Error[/bold red]"))
+        raise NotImplementedError
+
+    if authorized_keys.exists():
+        split = "\n"
+        keys_text = authorized_keys.read_text(encoding="utf-8").split(split)
+        key_count = len([k for k in keys_text if k.strip()])
+        console.print(Panel(f"🔍 Current SSH authorization status\n✅ Found {key_count} authorized key(s)", title="[bold blue]Status[/bold blue]"))
+        if path_to_key.read_text(encoding="utf-8") in authorized_keys.read_text(encoding="utf-8"):
+            console.print(Panel(f"⚠️  Key already authorized\nKey: {path_to_key.name}\nStatus: Already present in authorized_keys file\nNo action required", title="[bold yellow]Warning[/bold yellow]"))
+            program = ""
+        else:
+            console.print(Panel(f"➕ Adding new SSH key to authorized keys\n🔑 Key file: {path_to_key.name}", title="[bold blue]Action[/bold blue]"))
+            if system() == "Linux" or system() == "Darwin":
+                program = f"cat {path_to_key} >> ~/.ssh/authorized_keys"
+            elif system() == "Windows":
+                program_path = LIBRARY_ROOT.joinpath("setup_windows/add-sshkey.ps1")
+                program = program_path.expanduser().read_text(encoding="utf-8")
+                place_holder = r'$sshfile = "$env:USERPROFILE\.ssh\pubkey.pub"'
+                assert place_holder in program, f"This section performs string manipulation on the script {program_path} to add the key to the authorized_keys file. The script has changed and the string {place_holder} is not found."
+                program = program.replace(place_holder, f'$sshfile = "{path_to_key}"')
+                console.print(Panel("🔧 Configured PowerShell script for Windows\n📝 Replaced placeholder with actual key path", title="[bold blue]Configuration[/bold blue]"))
+            else:
+                raise NotImplementedError
+    else:
+        console.print(Panel(f"📝 Creating new authorized_keys file\n🔑 Using key: {path_to_key.name}", title="[bold blue]Action[/bold blue]"))
+        if system() == "Linux" or system() == "Darwin":
+            program = f"cat {path_to_key} > ~/.ssh/authorized_keys"
+        else:
+            program_path = LIBRARY_ROOT.joinpath("setup_windows/openssh-server_add-sshkey.ps1")
+            program = PathExtended(program_path).expanduser().read_text(encoding="utf-8").replace('$sshfile=""', f'$sshfile="{path_to_key}"')
+            console.print(Panel("🔧 Configured PowerShell script for Windows\n📝 Set key path in script", title="[bold blue]Configuration[/bold blue]"))
+
+    if system() == "Linux" or system() == "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
+
+
+"""
+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:
+    
+    if pub_path:
+        key_path = PathExtended(pub_path).expanduser().absolute()
+        key_path.parent.mkdir(parents=True, exist_ok=True)
+        if not key_path.exists():
+            console.print(Panel(f"❌ ERROR: Provided key path does not exist\nPath: {key_path}", title="[bold red]Error[/bold red]"))
+            raise FileNotFoundError(f"Provided key path does not exist: {key_path}")
+        console.print(Panel(f"📄 Using provided public key file: {key_path}", title="[bold blue]Info[/bold blue]"))
+        program = get_add_ssh_key_script(key_path)
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=program)
+        console.print(Panel("✅ SSH KEY AUTHORIZATION COMPLETED", box=box.DOUBLE_EDGE, title_align="left"))
+        return
+    elif pub_choose:
+        console.print(Panel("🔐 SSH PUBLIC KEY AUTHORIZATION TOOL", box=box.DOUBLE_EDGE, title_align="left"))
+        console.print(Panel("🔍 Searching for public keys...", title="[bold blue]SSH Setup[/bold blue]", border_style="blue"))
+        pub_keys = PathExtended.home().joinpath(".ssh").search("*.pub")
+        if pub_keys:
+            console.print(Panel(f"✅ Found {len(pub_keys)} public key(s)", title="[bold green]Status[/bold green]", border_style="green"))
+        else:
+            console.print(Panel("⚠️  No public keys found", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+            return
+        console.print(Panel(f"🔄 Processing all {len(pub_keys)} public keys...", title="[bold blue]Processing[/bold blue]", border_style="blue"))
+        program = "\n\n\n".join([get_add_ssh_key_script(key) for key in pub_keys])
+
+    elif pub_val:
+        console.print(Panel("📋 Please provide a filename and paste the public key content", title="[bold blue]Input Required[/bold blue]", border_style="blue"))
+        key_filename = input("📝 File name (default: my_pasted_key.pub): ") or "my_pasted_key.pub"
+        key_path = PathExtended.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")
+        console.print(Panel(f"💾 Key saved to: {key_path}", title="[bold green]Success[/bold green]", border_style="green"))
+        program = get_add_ssh_key_script(key_path)
+    elif from_github:
+        console.print(Panel(f"🌐 Fetching public keys from GitHub user: {from_github}", title="[bold blue]GitHub Fetch[/bold blue]", border_style="blue"))
+        import requests
+        response = requests.get(f"https://api.github.com/users/{from_github}/keys")
+        if response.status_code != 200:
+            console.print(Panel(f"❌ ERROR: Failed to fetch keys from GitHub user {from_github}\nStatus Code: {response.status_code}", title="[bold red]Error[/bold red]", border_style="red"))
+            raise RuntimeError(f"Failed to fetch keys from GitHub user {from_github}: Status Code {response.status_code}")
+        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
+        console.print(Panel(f"✅ Found {len(keys)} public key(s) for user: {from_github}", title="[bold green]Success[/bold green]", border_style="green"))
+        key_path = PathExtended.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")
+        console.print(Panel(f"💾 Keys saved to: {key_path}", title="[bold green]Success[/bold green]", border_style="green"))
+        program = get_add_ssh_key_script(key_path)
+    else:
+        console.print(Panel("❌ ERROR: No method provided to add SSH key\nUse --help for options", title="[bold red]Error[/bold red]", border_style="red"))
+        raise ValueError("No method provided to add SSH key. Use --help for options.")
+    console.print(Panel("🚀 SSH KEY AUTHORIZATION READY\nRun the generated script to apply changes", box=box.DOUBLE_EDGE, title_align="left"))
+    from machineconfig.utils.code import run_shell_script
+    run_shell_script(script=program)
+
+    import machineconfig.scripts.python.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        console.print(Panel("❌ ERROR: Could not determine local LAN IPv4 address", title="[bold red]Error[/bold red]", border_style="red"))
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
+
+    console.print(Panel(f"🌐 This computer is accessible at: {local_ip_v4}", title="[bold green]Network Info[/bold green]", border_style="green"))
+    console.print(Panel("✅ SSH KEY AUTHORIZATION COMPLETED", box=box.DOUBLE_EDGE, title_align="left"))
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/{linux → python/helpers_network}/mount_nfs

@@ -5,7 +5,6 @@
 # mkdir ~/data/local
 # sudo mount -o nolock,noatime,nodiratime,proto=tcp,timeo=600,retrans=2,noac alex-p51s-5:/home/alex/data/local ./data/local
 
-uv run --python 3.13 --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.mount_nfs
 # Check if remote server is reachable and share folder exists
 if ! ping -c 1 "$remote_server" &> /dev/null; then
   echo "💥 Error: Remote server $remote_server is not reachable."

machineconfig/scripts/python/{mount_nfs.py → helpers_network/mount_nfs.py}

@@ -19,9 +19,9 @@ def main():
         print("\n🔍 Interactive mode selected for choosing share path.")
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
-        ssh = SSH(tmp)
-        default = f"{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_nfs"
-        share_info = choose_from_options(msg="📂 Choose a share path:", options=[f"{ssh.hostname}:{item.split(' ')[0]}" for item in ssh.run("cat /etc/exports").op.split("\n") if not item.startswith("#")] + [default], default=default, multi=False)
+        ssh = SSH(host=tmp, username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=False)
+        default = f"{ssh.hostname}:{ssh.run_shell_cmd_on_remote(command='echo $HOME', verbose_output=False, description='Get home directory', strict_stderr=False, strict_return_code=True).op}/data/share_nfs"
+        share_info = choose_from_options(msg="📂 Choose a share path:", options=[f"{ssh.hostname}:{item.split(' ')[0]}" for item in ssh.run_shell_cmd_on_remote(command="cat /etc/exports", verbose_output=False, description='Get NFS exports', strict_stderr=False, strict_return_code=False).op.split("\n") if not item.startswith("#")] + [default], default=default, multi=False)
         assert isinstance(share_info, str), f"❌ share_info must be a string. Got {type(share_info)}"
 
     remote_server = share_info.split(":")[0]

machineconfig/scripts/{linux → python/helpers_network}/mount_nw_drive

@@ -17,8 +17,7 @@ drive_location=''
 mount_point=''
 username=''
 password=''
-
-uv run --PYTHON 3.13 --no-dev --project $HOME/code/machineconfig python -m machineconfig.scripts.python.mount_nw_drive
+machineconfig.scripts.python.mount_nw_drive
 
 # Check if mount point directory exists, create if not
 if [ ! -d "$mount_point" ]; then

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

@@ -18,10 +18,10 @@ def main():
         print("\n🔍 Interactive mode selected for choosing share path.")
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
-        ssh = SSH(host=tmp)
-        share_info = f"{ssh.username}@{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_ssh"
+        ssh = SSH(host=tmp, username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=False)
+        share_info = f"{ssh.username}@{ssh.hostname}:{ssh.run_shell_cmd_on_remote(command='echo $HOME', verbose_output=False, description='Get home directory', strict_stderr=False, strict_return_code=True).op}/data/share_ssh"
     else:
-        ssh = SSH(share_info.split(":")[0])
+        ssh = SSH(host=share_info.split(":")[0], username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=False)
 
     print(f"\n🌐 Share Info: {share_info}")
 

machineconfig/scripts/python/{onetimeshare.py → helpers_network/onetimeshare.py}

@@ -6,7 +6,6 @@
 # # or use ots executable to do this job
 
 # import requests
-# import crocodile.file_management as fm
 # import base64
 # from typing import Optional