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

machineconfig/scripts/python/helpers_devops/cli_self.py

@@ -1,49 +1,109 @@
 
 import typer
-from typing import Optional, Annotated
+from typing import Annotated, Literal
 
 
-def update(no_copy_assets: Annotated[bool, typer.Option("--no-assets-copy", "-na", help="Copy (overwrite) assets to the machine after the update")] = False):
+def copy_both_assets():
+    import machineconfig.profile.create_helper as create_helper
+    create_helper.copy_assets_to_machine(which="scripts")
+    create_helper.copy_assets_to_machine(which="settings")
+
+
+def init(which: Annotated[Literal["init", "ia", "live", "wrap"], typer.Argument(..., help="Comma-separated list of script names to run all initialization scripts.")] = "init",
+         run: Annotated[bool, typer.Option("--run/--no-run", "-r/-nr", help="Run the script after displaying it.")] = False,
+                        ) -> None:
+    import platform
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        match which:
+            case "init":
+                import machineconfig.settings as module
+                from pathlib import Path
+                if platform.system() == "Darwin":
+                    init_path = Path(module.__file__).parent.joinpath("shells", "zsh", "init.sh")
+                else: init_path = Path(module.__file__).parent.joinpath("shells", "bash", "init.sh")
+                script = init_path.read_text(encoding="utf-8")
+            case "ia":
+                from machineconfig.setup_linux import INTERACTIVE as script_path
+                script = script_path.read_text(encoding="utf-8")
+            case "live":
+                from machineconfig.setup_linux import LIVE as script_path
+                script = script_path.read_text(encoding="utf-8")
+            case _:
+                typer.echo("Unsupported shell script for Linux.")
+                raise typer.Exit(code=1)
+
+    elif platform.system() == "Windows":
+        match which:
+            case "init":
+                import machineconfig.settings as module
+                from pathlib import Path
+                init_path = Path(module.__file__).parent.joinpath("shells", "powershell", "init.ps1")
+                script = init_path.read_text(encoding="utf-8")
+            case "ia":
+                from machineconfig.setup_windows import INTERACTIVE as script_path
+                script = script_path.read_text(encoding="utf-8")
+            case "live":
+                from machineconfig.setup_windows import LIVE as script_path
+                script = script_path.read_text(encoding="utf-8")
+            case _:
+                typer.echo("Unsupported shell script for Windows.")
+                raise typer.Exit(code=1)
+    else:
+        # raise NotImplementedError("Unsupported platform")
+        typer.echo("Unsupported platform for init scripts.")
+        raise typer.Exit(code=1)
+    if run:
+        from machineconfig.utils.code import exit_then_run_shell_script
+        exit_then_run_shell_script(script, strict=True)
+    else:
+        print(script)
+
+
+def update(copy_assets: Annotated[bool, typer.Option("--assets-copy/--no-assets-copy", "-a/-na", help="Copy (overwrite) assets to the machine after the update")] = True,
+           link_public_configs: Annotated[bool, typer.Option("--link-public-configs/--no-link-public-configs", "-b/-nb", help="Link public configs after update (overwrites your configs!)")] = False,
+           ):
     """🔄 UPDATE uv and machineconfig"""
-    # from machineconfig.utils.source_of_truth import LIBRARY_ROOT
-    # repo_root = LIBRARY_ROOT.parent.parent
     from pathlib import Path
     if Path.home().joinpath("code", "machineconfig").exists():
-        code = """
+        shell_script = """
 uv self update
 cd ~/code/machineconfig
 git pull
 uv tool install --upgrade --editable $HOME/code/machineconfig
     """
     else:
-        code = """
+        shell_script = """
 uv self update
 uv tool install --upgrade machineconfig
     """
     import platform
     if platform.system() == "Windows":
-        # from machineconfig.utils.code import run_shell_script_after_exit
-        # run_shell_script_after_exit(code)
-        print(f'please run {code} in powershell to update machineconfig')
+        from machineconfig.utils.code import exit_then_run_shell_script, get_uv_command_executing_python_script
+        from machineconfig.utils.meta import lambda_to_python_script
+        python_script = lambda_to_python_script(lambda: copy_both_assets(),
+                                                in_global=True, import_module=False)
+        uv_command, _py_file = get_uv_command_executing_python_script(python_script=python_script, uv_with=["machineconfig"], uv_project_dir=None)
+        exit_then_run_shell_script(shell_script + "\n" + uv_command, strict=True)
     else:
         from machineconfig.utils.code import run_shell_script
-        run_shell_script(code)
-    if not no_copy_assets:
-        import machineconfig.profile.create_helper as create_helper
-        create_helper.copy_assets_to_machine(which="scripts")
-        create_helper.copy_assets_to_machine(which="settings")
+        run_shell_script(shell_script)
+        if copy_assets:
+            copy_both_assets()
+        if link_public_configs:
+            import machineconfig.profile.create_links_export as create_links_export
+            create_links_export.main_public_from_parser(method="copy", on_conflict="overwrite-default-path", which="all", interactive=False)
+
+
 def install(no_copy_assets: Annotated[bool, typer.Option("--no-assets-copy", "-na", help="Copy (overwrite) assets to the machine after the update")] = False):
     """📋 CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates."""
-    from machineconfig.utils.code import run_shell_script
+    from machineconfig.utils.code import run_shell_script, get_uv_run_command
     from pathlib import Path
+    import platform
+    uv_run_command = get_uv_run_command(platform=platform.system())  # type: ignore
     if Path.home().joinpath("code/machineconfig").exists():
-        run_shell_script(f"""$HOME/.local/bin/uv tool install --upgrade --editable "{str(Path.home().joinpath("code/machineconfig"))}" """)
+        run_shell_script(f""" {uv_run_command} tool install --upgrade --editable "{str(Path.home().joinpath("code/machineconfig"))}" """)
     else:
-        import platform
-        if platform.system() == "Windows":
-            run_shell_script(r"""& "$HOME\.local\bin\uv.exe" tool install --upgrade "machineconfig>=6.81" """)
-        else:
-            run_shell_script("""$HOME/.local/bin/uv tool install --upgrade "machineconfig>=6.81" """)
+        run_shell_script(rf""" {uv_run_command} tool install --upgrade "machineconfig>=7.98" """)
     from machineconfig.profile.create_shell_profile import create_default_shell_profile
     if not no_copy_assets:
         create_default_shell_profile()   # involves copying assets too
@@ -66,22 +126,11 @@ def navigate():
     import machineconfig.scripts.python as navigator
     from pathlib import Path
     path = Path(navigator.__file__).resolve().parent.joinpath("devops_navigator.py")
-    from machineconfig.utils.code import run_shell_script
+    from machineconfig.utils.code import exit_then_run_shell_script
     if Path.home().joinpath("code/machineconfig").exists(): executable = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" --with textual"""
-    else: executable = """--with "machineconfig>=6.81,textual" """
-    run_shell_script(f"""uv run {executable} {path}""")
-
-
-def run_python(ip: Annotated[str, typer.Argument(..., help="Python command to run in the machineconfig environment")],
-               command: Annotated[Optional[bool], typer.Option(..., "--command", "-c", help="Run as command")] = False):
-    """🐍 RUN python command/file in the machineconfig environment"""
-    if command:
-        exec(ip)
-        return
-    import machineconfig
-    import subprocess
-    import sys
-    subprocess.run([sys.executable, ip], cwd=machineconfig.__path__[0])
+    else: executable = """--with "machineconfig>=7.98,textual" """
+    exit_then_run_shell_script(f"""uv run {executable} {path}""")
+
 def readme():
     from rich.console import Console
     from rich.markdown import Markdown
@@ -104,19 +153,20 @@ def readme():
 
 def get_app():
     cli_app = typer.Typer(help="🔄 [s] self operations subcommands", no_args_is_help=True, add_help_option=False, add_completion=False)
-    cli_app.command("update", no_args_is_help=False, help="🔄  [u] UPDATE machineconfig")(update)
-    cli_app.command("u", no_args_is_help=False, hidden=True)(update)
-    cli_app.command("interactive", no_args_is_help=False, help="🤖  [i] INTERACTIVE configuration of machine.")(interactive)
-    cli_app.command("i", no_args_is_help=False, help="INTERACTIVE configuration of machine.", hidden=True)(interactive)
-    cli_app.command("status", no_args_is_help=False, help="📊  [s] STATUS of machine, shell profile, apps, symlinks, dotfiles, etc.")(status)
-    cli_app.command("s", no_args_is_help=False, help="STATUS of machine, shell profile, apps, symlinks, dotfiles, etc.", hidden=True)(status)
-    cli_app.command("install", no_args_is_help=False, help="📋  [I] CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates.")(install)
-    cli_app.command("I", no_args_is_help=False, help="CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates.", hidden=True)(install)
-    cli_app.command("navigate", no_args_is_help=False, help="📚  [n] NAVIGATE command structure with TUI")(navigate)
+    cli_app.command("update",      no_args_is_help=False, help="🔄 [u] UPDATE machineconfig")(update)
+    cli_app.command("u",           no_args_is_help=False, hidden=True)(update)
+    cli_app.command("interactive", no_args_is_help=False, help="🤖 [i] INTERACTIVE configuration of machine.")(interactive)
+    cli_app.command("i",           no_args_is_help=False, help="INTERACTIVE configuration of machine.", hidden=True)(interactive)
+    cli_app.command(name="init",         no_args_is_help=False, help="🦐 [t] Define and manage configurations")(init)
+    cli_app.command(name="t",            no_args_is_help=False, hidden=True)(init)
+    cli_app.command("status",      no_args_is_help=False, help="📊 [s] STATUS of machine, shell profile, apps, symlinks, dotfiles, etc.")(status)
+    cli_app.command("s",           no_args_is_help=False, help="STATUS of machine, shell profile, apps, symlinks, dotfiles, etc.", hidden=True)(status)
+    cli_app.command("install",     no_args_is_help=False, help="📋 [I] CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates.")(install)
+    cli_app.command("I",           no_args_is_help=False, help="CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates.", hidden=True)(install)
+    cli_app.command("navigate", no_args_is_help=False, help="📚 [n] NAVIGATE command structure with TUI")(navigate)
     cli_app.command("n", no_args_is_help=False, help="NAVIGATE command structure with TUI", hidden=True)(navigate)
-    cli_app.command("python", no_args_is_help=False, help="🐍  [c] python command/file in the machineconfig environment", context_settings={"show_help_on_error": True})(run_python)
-    cli_app.command("c", no_args_is_help=False, help="RUN python command/file in the machineconfig environment", hidden=True)(run_python)
-    cli_app.command("readme", no_args_is_help=False, help="📚  [r] render readme markdown in terminal.")(readme)
+
+    cli_app.command("readme", no_args_is_help=False, help="📚 [r] render readme markdown in terminal.")(readme)
     cli_app.command("r", no_args_is_help=False, hidden=True)(readme)
     return cli_app
 

machineconfig/scripts/python/helpers_devops/cli_share_file.py

@@ -0,0 +1,137 @@
+
+import typer
+from typing import Annotated
+
+
+def share_file_receive(code_args: Annotated[list[str], typer.Argument(help="Receive code or relay command. Examples: '7121-donor-olympic-bicycle' or '--relay 10.17.62.206:443 7121-donor-olympic-bicycle'")],
+) -> None:
+    """Receive a file using croc with relay server.
+Usage examples:
+    devops network receive 7121-donor-olympic-bicycle
+    devops network receive -- --relay 10.17.62.206:443 7121-donor-olympic-bicycle
+    devops network receive -- croc --relay 10.17.62.206:443 7121-donor-olympic-bicycle
+"""
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing(which="croc")
+    import platform
+    import sys
+
+    is_windows = platform.system() == "Windows"
+
+    # If no args passed via typer, try to get them from sys.argv directly
+    # This handles the case where -- was used and arguments weren't parsed by typer
+    if not code_args or (len(code_args) == 1 and code_args[0] in ['--relay', 'croc']):
+        # Find the index of 'rx' or 'receive' in sys.argv and get everything after it
+        try:
+            for i, arg in enumerate(sys.argv):
+                if arg in ['rx', 'receive', 'r'] and i + 1 < len(sys.argv):
+                    code_args = sys.argv[i + 1:]
+                    break
+        except Exception:
+            pass
+
+    # Join all arguments
+    input_str = " ".join(code_args)
+    tokens = input_str.split()
+
+    # Parse input to extract relay server and secret code
+    relay_server: str | None = None
+    secret_code: str | None = None
+
+    # Remove 'croc' and 'export' from tokens if present
+    tokens = [t for t in tokens if t not in ['croc', 'export']]
+
+    # Look for --relay flag and capture next token
+    relay_idx = -1
+    for i, token in enumerate(tokens):
+        if token == '--relay' and i + 1 < len(tokens):
+            relay_server = tokens[i + 1]
+            relay_idx = i
+            break
+
+    # Look for CROC_SECRET= prefix in any token
+    for token in tokens:
+        if token.startswith('CROC_SECRET='):
+            secret_code = token.split('=', 1)[1].strip('"').strip("'")
+            break
+
+    # If no secret code found yet, look for tokens with dashes (typical pattern: number-word-word-word)
+    # Skip relay server and relay flag
+    if not secret_code:
+        for i, token in enumerate(tokens):
+            if '-' in token and not token.startswith('-') and token != relay_server:
+                if relay_idx >= 0 and (i == relay_idx or i == relay_idx + 1):
+                    continue  # Skip relay server parts
+                secret_code = token
+                break
+
+    if not secret_code and not relay_server:
+        typer.echo(f"❌ Error: Could not parse croc receive code from input: {input_str}", err=True)
+        typer.echo("Usage:", err=True)
+        typer.echo("  devops network receive 7121-donor-olympic-bicycle", err=True)
+        typer.echo("  devops network receive -- --relay 10.17.62.206:443 7121-donor-olympic-bicycle", err=True)
+        raise typer.Exit(code=1)
+
+    # Build the appropriate script for current OS
+    if is_windows:
+        # Windows PowerShell format: croc --relay server:port secret-code --yes
+        relay_arg = f"--relay {relay_server}" if relay_server else ""
+        code_arg = f"{secret_code}" if secret_code else ""
+        script = f"""croc {relay_arg} {code_arg} --yes""".strip()
+    else:
+        # Linux/macOS Bash format: CROC_SECRET="secret-code" croc --relay server:port --yes
+        relay_arg = f"--relay {relay_server}" if relay_server else ""
+        if secret_code:
+            script = f"""export CROC_SECRET="{secret_code}"
+croc {relay_arg} --yes""".strip()
+        else:
+            script = f"""croc {relay_arg} --yes""".strip()
+
+    from machineconfig.utils.code import exit_then_run_shell_script, print_code
+    print_code(code=script, desc="🚀 Receiving file with croc", lexer="bash" if platform.system() != "Windows" else "powershell")
+    exit_then_run_shell_script(script=script, strict=False)
+
+
+def share_file_send(path: Annotated[str, typer.Argument(help="Path to the file or directory to send")],
+                    zip_folder: Annotated[bool, typer.Option("--zip", help="Zip folder before sending")] = False,
+                    code: Annotated[str | None, typer.Option("--code", "-c", help="Codephrase used to connect to relay")] = None,
+                    text: Annotated[str | None, typer.Option("--text", "-t", help="Send some text")] = None,
+                    qrcode: Annotated[bool, typer.Option("--qrcode", "--qr", help="Show receive code as a qrcode")] = False,
+                    ) -> None:
+    """Send a file using croc with relay server."""
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing(which="croc")
+    # Get relay server IP from environment or use default
+    import machineconfig.scripts.python.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        typer.echo("❌ Error: Could not determine local LAN IPv4 address for relay.", err=True)
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
+    import platform
+    relay_port = "443"
+    is_windows = platform.system() == "Windows"
+
+    # Build command parts
+    relay_arg = f"--relay {local_ip_v4}:{relay_port} --ip {local_ip_v4}:{relay_port}"
+    zip_arg = "--zip" if zip_folder else ""
+    text_arg = f"--text '{text}'" if text else ""
+    qrcode_arg = "--qrcode" if qrcode else ""
+    path_arg = f"{path}" if not text else ""
+
+    if is_windows:
+        # Windows PowerShell format
+        code_arg = f"--code {code}" if code else ""
+        script = f"""croc {relay_arg} send {zip_arg} {code_arg} {qrcode_arg} {text_arg} {path_arg}"""
+    else:
+        # Linux/macOS Bash format
+        if code:
+            script = f"""export CROC_SECRET="{code}"
+croc {relay_arg} send {zip_arg} {qrcode_arg} {text_arg} {path_arg}"""
+        else:
+            script = f"""croc {relay_arg} send {zip_arg} {qrcode_arg} {text_arg} {path_arg}"""
+
+    typer.echo(f"🚀 Sending file: {path}. Use: devops network receive")
+    from machineconfig.utils.code import exit_then_run_shell_script, print_code
+    print_code(code=script, desc="🚀 sending file with croc", lexer="bash" if platform.system() != "Windows" else "powershell")
+    exit_then_run_shell_script(script=script, strict=False)

machineconfig/scripts/python/helpers_devops/cli_share_server.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 from typing import Optional, Annotated
+from machineconfig.scripts.python.helpers_devops.cli_share_file import share_file_receive, share_file_send
 import typer
 
 
@@ -31,73 +32,110 @@ def display_share_url(local_ip_v4: str, port: int, protocol: str = "http") -> No
     console.print(panel)
 
 
-def main(
+def web_file_explorer(
     path: Annotated[str, typer.Argument(help="Path to the file or directory to share")],
     port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the share server on (default: 8080)")] = None,
     username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for share access (default: current user)")] = None,
     password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for share access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None,
-    over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the share server over the internet using ngrok")] = False
+    over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the share server over the internet using ngrok")] = False,
+    backend: Annotated[str, typer.Option("--backend", "-b", help="Backend to use: filebrowser (default), miniserve, qrcp, or easy-sharing")] = "miniserve",
 ) -> None:
-    from machineconfig.utils.installer_utils.installer import install_if_missing
-    install_if_missing(which="easy-sharing")
-    if over_internet: install_if_missing(which="ngrok", )
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+
+    if backend not in ["filebrowser", "miniserve", "qrcp", "easy-sharing"]:
+        typer.echo(f"❌ ERROR: Invalid backend '{backend}'. Must be one of: filebrowser, miniserve, qrcp, easy-sharing", err=True)
+        raise typer.Exit(code=1)
+    install_if_missing(which=backend)
+    if over_internet:
+        install_if_missing(which="ngrok")
     if username is None:
         import getpass
         username = getpass.getuser()
+    
     if password is None:
         pwd_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
         if pwd_path.exists():
             password = pwd_path.read_text(encoding="utf-8").strip()
         else:
-            # raise ValueError("Password not provided and default password file does not exist.")
             typer.echo(f"⚠️  WARNING: Password not provided and default password file does not exist.\nPath: {pwd_path}\nUsing default password: 'quick_password' (insecure!)", err=True)
-            typer.Exit(code=1)
+            raise typer.Exit(code=1)
 
     if port is None:
-        port = 8080  # Default port for ezshare
+        port = 8080
 
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(('8.8.8.8',80))
-    local_ip_v4 = s.getsockname()[0]
-    s.close()
+    import machineconfig.scripts.python.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        typer.echo("❌ ERROR: Could not determine local LAN IPv4 address for share server.", err=True)
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
 
-    # Display the flashy share announcement  
     protocol = "http"
     display_share_url(local_ip_v4, port, protocol)
-    import subprocess
-    import time
-    # Build ezshare command
-    ezshare_cmd = f"""easy-sharing --port {port} --username {username} --password "{password}" {path}"""
-    ezshare_process = subprocess.Popen(ezshare_cmd, shell=True)
-    processes = [ezshare_process]
     
-    if over_internet:
-        ngrok_process = subprocess.Popen(f"ngrok http {port}", shell=True)
-        processes.append(ngrok_process)
-        time.sleep(3)
-        try:
-            import requests
-            response = requests.get("http://localhost:4040/api/tunnels")
-            data = response.json()
-            public_url = data['tunnels'][0]['public_url']
-            print(f"🌐 Ngrok tunnel ready: {public_url}")
-        except Exception as e:
-            print(f"Could not retrieve ngrok URL: {e}")
+    path_obj = Path(path).resolve()
+    if not path_obj.exists():
+        typer.echo(f"❌ ERROR: Path does not exist: {path}", err=True)
+        raise typer.Exit(code=1)
     
-    try:
-        while True:
-            print("Share server is running. Press Ctrl+C to stop.")
-            time.sleep(2)
-    except KeyboardInterrupt:
-        print("\nTerminating processes...")
-        for p in processes:
-            p.terminate()
-            p.wait()
+    if backend == "filebrowser":
+        db_path = Path.home().joinpath(".config/filebrowser/filebrowser.db")
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        command = f"""
+filebrowser users add {username} "{password}" --database {db_path}
+filebrowser --address 0.0.0.0 --port {port} --root "{path_obj}" --database {db_path}
+"""
+    elif backend == "miniserve":
+        command = f"""miniserve --port {port} --interfaces 0.0.0.0 --auth {username}:{password} --upload-files --mkdir --enable-tar --enable-tar-gz --enable-zip --qrcode "{path_obj}" """
+    elif backend == "easy-sharing":
+        command = f"""easy-sharing --port {port} --username {username} --password "{password}" "{path_obj}" """
+    elif backend == "qrcp":
+        command = f"""qrcp "{path_obj}" """
+    else:
+        typer.echo(f"❌ ERROR: Unknown backend '{backend}'", err=True)
+        raise typer.Exit(code=1)
+
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(script=command, strict=False)
+    # import subprocess
+    # import time
+    # server_process: subprocess.Popen[bytes]
+    # server_process = subprocess.Popen(command, shell=True)
+    # processes = [server_process]
+    # if over_internet:
+    #     ngrok_process = subprocess.Popen(f"ngrok http {port}", shell=True)
+    #     processes.append(ngrok_process)
+    #     time.sleep(3)
+    #     try:
+    #         import requests
+    #         response = requests.get("http://localhost:4040/api/tunnels")
+    #         data = response.json()
+    #         public_url = data['tunnels'][0]['public_url']
+    #         print(f"🌐 Ngrok tunnel ready: {public_url}")
+    #     except Exception as e:
+    #         print(f"Could not retrieve ngrok URL: {e}")
+    
+    # try:
+    #     while True:
+    #         print(f"Share server ({backend}) is running. Press Ctrl+C to stop.")
+    #         time.sleep(2)
+    # except KeyboardInterrupt:
+    #     print("\nTerminating processes...")
+    #     for p in processes:
+    #         p.terminate()
+    #         p.wait()
+
 
+def get_share_file_app():
+    app = typer.Typer(name="share-file", help="Send or receive files using croc with relay server.")
+    app.command(name="send", no_args_is_help=True, hidden=False, help="[s] send files from here.")(share_file_send)
+    app.command(name="s", no_args_is_help=True, hidden=True, help="[s] send files from here.")(share_file_send)
+    app.command(name="receive", no_args_is_help=True, hidden=False, help="[r] receive files to here.")(share_file_receive)
+    app.command(name="r", no_args_is_help=True, hidden=True, help="[r] receive files to here.")(share_file_receive)
+    return app
 
 def main_with_parser():
-    typer.run(main)
+    typer.run(web_file_explorer)
 
 
 if __name__ == "__main__":

machineconfig/scripts/python/helpers_devops/{cli_terminal.py → cli_share_terminal.py}

@@ -1,10 +1,6 @@
-from pathlib import Path
+
 from typing import Optional, Annotated
 import typer
-import subprocess
-import time
-
-
 
 """
 reference:
@@ -17,13 +13,11 @@ reference:
 
 def display_terminal_url(local_ip_v4: str, port: int, protocol: str = "http") -> None:
     """Display a flashy, unmissable terminal URL announcement."""
-
     from rich.console import Console
     from rich.panel import Panel
     from rich.text import Text
     from rich.align import Align
     console = Console()
-    
     # Create the main message with styling
     url_text = Text(f"{protocol}://{local_ip_v4}:{port}", style="bold bright_cyan underline")
     message = Text.assemble(
@@ -42,14 +36,13 @@ def display_terminal_url(local_ip_v4: str, port: int, protocol: str = "http") ->
         padding=(1, 2),
         expand=False
     )
-    
     # Print with extra spacing and attention-grabbing elements
     # console.print("\n" + "🔥" * 60 + "\n", style="bright_red bold")
     console.print(panel)
     # console.print("🔥" * 60 + "\n", style="bright_red bold")
 
 
-def main(
+def share_terminal(
     port: Annotated[Optional[int], typer.Option("--port", "-p", help="Port to run the terminal server on (default: 7681)")] = None,
     username: Annotated[Optional[str], typer.Option("--username", "-u", help="Username for terminal access (default: current user)")] = None,
     password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for terminal access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None,
@@ -60,10 +53,11 @@ def main(
     ssl_ca: Annotated[Optional[str], typer.Option("--ssl-ca", "-A", help="SSL CA file path for client certificate verification")] = None,
     over_internet: Annotated[bool, typer.Option("--over-internet", "-i", help="Expose the terminal over the internet using ngrok")] = False
 ) -> None:
-    from machineconfig.utils.installer_utils.installer import install_if_missing
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
     install_if_missing("ttyd")
     if over_internet: install_if_missing("ngrok")
 
+    from pathlib import Path
     if username is None:
         import getpass
         username = getpass.getuser()
@@ -96,11 +90,12 @@ def main(
         if ssl_ca and not Path(ssl_ca).exists():
             raise FileNotFoundError(f"SSL CA file not found: {ssl_ca}")
 
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(('8.8.8.8',80))
-    local_ip_v4 = s.getsockname()[0]
-    s.close()
+    import machineconfig.scripts.python.helpers_network.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        print("❌ Error: Could not determine local LAN IPv4 address for terminal.")
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
 
     # Display the flashy terminal announcement  
     protocol = "https" if ssl else "http"
@@ -119,7 +114,10 @@ def main(
             start_command = "powershell"
         else:
             start_command = "bash"
-    
+
+    import subprocess
+    import time
+
     ttyd_cmd = f"ttyd --writable -t enableSixel=true {ssl_args} --port {port} --credential \"{username}:{password}\" -t 'theme={{\"background\": \"black\"}}' {start_command}"
     ttyd_process = subprocess.Popen(ttyd_cmd, shell=True)
     processes = [ttyd_process]
@@ -149,7 +147,7 @@ def main(
 
 
 def main_with_parser():
-    typer.run(main)
+    typer.run(share_terminal)
 
 
 if __name__ == "__main__":