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

machineconfig/scripts/python/helpers/helpers_devops/cli_self.py

@@ -0,0 +1,197 @@
+
+import typer
+from typing import Annotated, Literal
+from machineconfig.utils.ssh_utils.abc import MACHINECONFIG_VERSION
+
+
+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 pathlib import Path
+    if Path.home().joinpath("code", "machineconfig").exists():
+        shell_script = """
+uv self update
+cd ~/code/machineconfig
+git pull
+uv tool install --no-cache --upgrade --editable $HOME/code/machineconfig
+    """
+    else:
+        shell_script = """
+uv self update
+uv tool install --no-cache --upgrade machineconfig
+    """
+    import platform
+    if platform.system() == "Windows":
+        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(shell_script, display_script=True, clean_env=False)
+        if copy_assets:
+            copy_both_assets()
+        if link_public_configs:
+            import machineconfig.profile.create_links_export as create_links_export
+            create_links_export.main_from_parser(sensitivity="public", method="copy", on_conflict="overwrite-default-path", which="all")
+
+
+def install(copy_assets: Annotated[bool, typer.Option("--copy-assets/--no-assets-copy", "-a/-na", help="Copy (overwrite) assets to the machine after the update")] = True,
+            dev: Annotated[bool, typer.Option("--dev", "-d", help="Install from local development code instead of PyPI")] = False,
+    
+            ):
+    """📋 CLONE machienconfig locally and incorporate to shell profile for faster execution and nightly updates."""
+    from machineconfig.utils.code import run_shell_script, get_uv_command, get_shell_script_running_lambda_function, exit_then_run_shell_script
+    from pathlib import Path
+    import platform
+    mcfg_path = Path.home().joinpath("code/machineconfig")
+    _ = run_shell_script
+    if dev and not mcfg_path.exists():
+        # clone: https://github.com/thisismygitrepo/machineconfig.git
+        import git
+        mcfg_path.parent.mkdir(parents=True, exist_ok=True)
+        git.Repo.clone_from("https://github.com/thisismygitrepo/machineconfig.git", str(mcfg_path))
+        # now we need to run `uv sync` to install dependencies
+
+    uv_command = get_uv_command(platform=platform.system())
+    if copy_assets:
+        def func():
+            from machineconfig.profile.create_shell_profile import create_default_shell_profile
+            create_default_shell_profile()   # involves copying assets too
+        uv_command2, _script_path = get_shell_script_running_lambda_function(lambda: func(),
+                                                          uv_with=["machineconfig"], uv_project_dir=None)
+    else:
+        uv_command2 = ""
+    if mcfg_path.exists():
+        exit_then_run_shell_script(f"""
+cd {str(mcfg_path)}
+{uv_command} sync
+{uv_command} tool install --upgrade --editable "{str(mcfg_path)}"
+{uv_command2}
+""")
+    else:
+        exit_then_run_shell_script(rf"""
+{uv_command} tool install --upgrade "{MACHINECONFIG_VERSION}"
+{uv_command2}
+""")
+
+
+
+def interactive():
+    """🤖 INTERACTIVE configuration of machine."""
+    from machineconfig.scripts.python.helpers.helpers_devops.interactive import main
+    main()
+
+def status():
+    """📊 STATUS of machine, shell profile, apps, symlinks, dotfiles, etc."""
+    import machineconfig.scripts.python.helpers.helpers_devops.devops_status as helper
+    helper.main()
+
+
+def navigate():
+    """📚 NAVIGATE command structure with TUI"""
+    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 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 = f"""--with "{MACHINECONFIG_VERSION},textual" """
+    exit_then_run_shell_script(f"""uv run {executable} {path}""")
+
+def readme():
+    from rich.console import Console
+    from rich.markdown import Markdown
+    import requests
+
+    # URL of the raw README.md file
+    url_readme = "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/README.md"
+
+    # Fetch the content
+    response = requests.get(url_readme)
+    response.raise_for_status()  # Raise an error for bad responses
+
+    # Parse markdown
+    md = Markdown(response.text)
+
+    # Render in terminal
+    console = Console()
+    console.print(md)
+
+
+def get_app():
+    cli_app = typer.Typer(help="🔄 [s] self operations subcommands", no_args_is_help=True, add_help_option=True, 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="🤖 [ia] INTERACTIVE configuration of machine.")(interactive)
+    cli_app.command("ia",           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("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/helpers_devops/cli_share_file.py

@@ -0,0 +1,151 @@
+
+import typer
+from typing import Annotated, Literal
+
+
+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,
+                    backend: Annotated[Literal["wormhole", "w", "croc", "c"], typer.Option("--backend", "-b", help="Backend to use")] = "croc",
+                    ) -> None:
+    """Send a file using croc with relay server."""
+    import platform
+
+    match backend:
+        case "wormhole" | "w":
+            if code is None: code_line = ""
+            else: code_line = f"--code {code}"
+            if text is not None: text_line = f"--text '{text}'"
+            else: text_line = f"'{path}'"
+            script = f"""
+uvx magic-wormhole send {code_line} {text_line}
+"""
+            print(f"🚀 Sending file: {path}. Use: uvx magic-wormhole receive ")
+        case "croc" | "c":
+            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.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
+            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/helpers_devops/cli_share_server.py

@@ -0,0 +1,125 @@
+from pathlib import Path
+from typing import Optional, Annotated
+from machineconfig.scripts.python.helpers.helpers_devops.cli_share_file import share_file_receive, share_file_send
+from machineconfig.utils.accessories import display_with_flashy_style
+import typer
+
+
+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,
+    no_auth: Annotated[bool, typer.Option("--no-auth", "-na", help="Disable authentication for share access")] = False,
+    password: Annotated[Optional[str], typer.Option("--password", "-w", help="Password for share access (default: from ~/dotfiles/creds/passwords/quick_password)")] = None,
+    bind_address: Annotated[str, typer.Option("--bind", "-a", help="Address to bind the server to")] = "0.0.0.0",
+    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_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 password is None and not no_auth:
+        pwd_path = Path.home().joinpath("dotfiles/creds/passwords/quick_password")
+        if pwd_path.exists():
+            password = pwd_path.read_text(encoding="utf-8").strip()
+            if username is None:
+                import getpass
+                username = getpass.getuser()
+        # else:
+        #     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)
+        #     raise typer.Exit(code=1)
+
+
+    if port is None:
+        port = 8080
+
+    import machineconfig.scripts.python.helpers.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
+
+    protocol = "http"
+    display_with_flashy_style(msg=f"{protocol}://{local_ip_v4}:{port}/", title="Local Network Share URL")
+    
+    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)
+    
+    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 {bind_address} --port {port} --root "{path_obj}" --database {db_path}
+"""
+    elif backend == "miniserve":
+        if username and password:
+            auth_line = f"""--auth "{username}:{password}" """
+        else:
+            auth_line = ""
+        command = f"""miniserve --port {port} --interfaces {bind_address} {auth_line} --upload-files --mkdir --enable-tar --enable-tar-gz --enable-zip --qrcode "{path_obj}" """
+    elif backend == "easy-sharing":
+        if username is None and password is None:
+            auth_line = ""
+        else:
+            auth_line = f'--username "{username}" --password "{password}"'
+        command = f"""easy-sharing --port {port} {auth_line} "{path_obj}" """
+    elif backend == "qrcp":
+        command = f"""qrcp --port {port} --bind {bind_address} "{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(web_file_explorer)
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/{helpers_devops/cli_terminal.py → helpers/helpers_devops/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,17 +36,17 @@ 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,
+    no_auth: Annotated[bool, typer.Option("--no-auth", "-n", help="Disable authentication (not recommended)")] = False,
     start_command: Annotated[Optional[str], typer.Option("--start-command", "-s", help="Command to run on terminal start (default: bash/powershell)")] = None,
     ssl: Annotated[bool, typer.Option("--ssl", "-S", help="Enable SSL")] = False,
     ssl_cert: Annotated[Optional[str], typer.Option("--ssl-cert", "-C", help="SSL certificate file path")] = None,
@@ -60,19 +54,22 @@ 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()
-    if password is None:
+    if password is None and not no_auth:
         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.")
+            # raise ValueError("Password not provided and default password file does not exist.")
+            print("❌ Error: Password not provided and default password file does not exist.")
+            raise typer.Exit(code=1)
 
     if port is None:
         port = 7681  # Default port for ttyd
@@ -89,18 +86,22 @@ def main(
         key_path = Path(ssl_key)
         
         if not cert_path.exists():
-            raise FileNotFoundError(f"SSL certificate file not found: {ssl_cert}")
+            print(f"❌ Error: SSL certificate file not found: {ssl_cert}")
+            raise typer.Exit(code=1)
         if not key_path.exists():
-            raise FileNotFoundError(f"SSL key file not found: {ssl_key}")
+            print(f"❌ Error: SSL key file not found: {ssl_key}")
+            raise typer.Exit(code=1)
         
         if ssl_ca and not Path(ssl_ca).exists():
-            raise FileNotFoundError(f"SSL CA file not found: {ssl_ca}")
+            print(f"❌ Error: SSL CA file not found: {ssl_ca}")
+            raise typer.Exit(code=1)
 
-    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.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 +120,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 +153,7 @@ def main(
 
 
 def main_with_parser():
-    typer.run(main)
+    typer.run(share_terminal)
 
 
 if __name__ == "__main__":