machineconfig 6.23__py3-none-any.whl → 8.12__py3-none-any.whl

machineconfig/scripts/python/helpers_devops/cli_self.py

@@ -0,0 +1,172 @@
+
+import typer
+from typing import Annotated, Literal
+
+
+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 --upgrade --editable $HOME/code/machineconfig
+    """
+    else:
+        shell_script = """
+uv self update
+uv tool install --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)
+        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, 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""" {uv_run_command} tool install --upgrade --editable "{str(Path.home().joinpath("code/machineconfig"))}" """)
+    else:
+        run_shell_script(rf""" {uv_run_command} tool install --upgrade "machineconfig>=8.12" """)
+    from machineconfig.profile.create_shell_profile import create_default_shell_profile
+    if not no_copy_assets:
+        create_default_shell_profile()   # involves copying assets too
+
+
+
+def interactive():
+    """🤖 INTERACTIVE configuration of machine."""
+    from machineconfig.scripts.python.interactive import main
+    main()
+
+def status():
+    """📊 STATUS of machine, shell profile, apps, symlinks, dotfiles, etc."""
+    import machineconfig.scripts.python.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 = """--with "machineconfig>=8.12,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=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(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_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

@@ -0,0 +1,142 @@
+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
+
+
+def display_share_url(local_ip_v4: str, port: int, protocol: str = "http") -> None:
+    """Display a flashy, unmissable share 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(
+        ("🚀 ", "bright_red"),
+        ("Share server is now accessible at: ", "bright_white bold"),
+        url_text,
+        (" 🚀", "bright_red")
+    )
+    # Create a fancy panel with borders and styling
+    panel = Panel(
+        Align.center(message),
+        title="[bold bright_green]🌐 SHARE SERVER READY 🌐[/bold bright_green]",
+        subtitle="[italic bright_yellow]⚡ Click the link above to access your shared files! ⚡[/italic bright_yellow]",
+        border_style="bright_magenta",
+        padding=(1, 2),
+        expand=False
+    )
+    # Print with extra spacing and attention-grabbing elements
+    console.print(panel)
+
+
+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,
+    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 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:
+            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_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_share_url(local_ip_v4, port, protocol)
+    
+    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 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(web_file_explorer)
+
+
+if __name__ == "__main__":
+    pass

machineconfig/scripts/python/{devops_helpers/cli_terminal.py → 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,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__":

machineconfig/scripts/python/{devops_helpers → helpers_devops}/devops_backup_retrieve.py

@@ -2,33 +2,30 @@
 
 # import subprocess
 from machineconfig.utils.io import read_ini
-from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT, DEFAULTS_PATH
 from machineconfig.utils.code import print_code
 from machineconfig.utils.options import choose_cloud_interactively, choose_from_options
-from machineconfig.scripts.python.cloud_helpers.helpers2 import ES
+from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
 from platform import system
 from typing import Any, Literal, Optional
 from rich.console import Console
 from rich.panel import Panel
+from pathlib import Path
 import tomllib
 
 
 OPTIONS = Literal["BACKUP", "RETRIEVE"]
 
 
-def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None) -> None:
+def main_backup_retrieve(direction: OPTIONS, which: Optional[str], cloud: Optional[str]) -> None:
     console = Console()
-
     try:
-        cloud: str = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
+        cloud = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
         console.print(Panel(f"⚠️  DEFAULT CLOUD CONFIGURATION\n🌥️  Using default cloud: {cloud}", title="[bold blue]Cloud Configuration[/bold blue]", border_style="blue"))
     except (FileNotFoundError, KeyError, IndexError):
         console.print(Panel("🔍 DEFAULT CLOUD NOT FOUND\n🔄 Please select a cloud configuration from the options below", title="[bold red]Error: Cloud Not Found[/bold red]", border_style="red"))
         cloud = choose_cloud_interactively()
-
     bu_file: dict[str, Any] = tomllib.loads(LIBRARY_ROOT.joinpath("profile/backup.toml").read_text(encoding="utf-8"))
-
     console.print(Panel(f"🧰 LOADING BACKUP CONFIGURATION\n📄 File: {LIBRARY_ROOT.joinpath('profile/backup.toml')}", title="[bold blue]Backup Configuration[/bold blue]", border_style="blue"))
 
     if system() == "Linux":
@@ -59,13 +56,13 @@ def main_backup_retrieve(direction: OPTIONS, which: Optional[str] = None) -> Non
         flags += "e" if item["encrypt"] == "True" else ""
         flags += "r" if item["rel2home"] == "True" else ""
         flags += "o" if system().lower() in item_name else ""
-        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {PathExtended(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
+        console.print(Panel(f"📦 PROCESSING: {item_name}\n📂 Path: {Path(item['path']).as_posix()}\n🏳️  Flags: {flags or 'None'}", title=f"[bold blue]Processing Item: {item_name}[/bold blue]", border_style="blue"))
         if flags:
             flags = "-" + flags
         if direction == "BACKUP":
-            program += f"""\ncloud_copy "{PathExtended(item["path"]).as_posix()}" $cloud {flags}\n"""
+            program += f"""\ncloud_copy "{Path(item["path"]).as_posix()}" $cloud {flags}\n"""
         elif direction == "RETRIEVE":
-            program += f"""\ncloud_copy $cloud "{PathExtended(item["path"]).as_posix()}" {flags}\n"""
+            program += f"""\ncloud_copy $cloud "{Path(item["path"]).as_posix()}" {flags}\n"""
         else:
             console.print(Panel('❌ ERROR: INVALID DIRECTION\n⚠️  Direction must be either "BACKUP" or "RETRIEVE"', title="[bold red]Error: Invalid Direction[/bold red]", border_style="red"))
             raise RuntimeError(f"Unknown direction: {direction}")

machineconfig/scripts/python/{devops_helpers → helpers_devops}/devops_status.py

@@ -17,22 +17,6 @@ from machineconfig.utils.source_of_truth import CONFIG_ROOT, DEFAULTS_PATH, LIBR
 console = Console()
 
 
-def _check_system_info() -> dict[str, str]:
-    """Gather basic system information."""
-    import socket
-    import os
-
-    return {
-        "hostname": socket.gethostname(),
-        "system": platform.system(),
-        "release": platform.release(),
-        "version": platform.version(),
-        "machine": platform.machine(),
-        "processor": platform.processor() or "Unknown",
-        "python_version": platform.python_version(),
-        "user": os.getenv("USER") or os.getenv("USERNAME") or "Unknown",
-    }
-
 
 def _check_shell_profile_status() -> dict[str, Any]:
     """Check shell profile configuration status."""
@@ -480,10 +464,14 @@ def main() -> None:
     console.print("\n")
     console.print(Panel(Text("📊 Machine Status Report", justify="center", style="bold white"), style="bold blue", padding=(1, 2)))
     console.print("\n")
-
-    system_info = _check_system_info()
+    
+    # system_info = _check_system_info()
+    # from machineconfig.scripts.python.helpers_devops.devops_system_info import _check_system_info
+    from machineconfig.scripts.python.helpers_utils.python import get_machine_specs
+    system_info = get_machine_specs()
+    from typing import cast
+    system_info = cast(dict[str, str], system_info)
     _display_system_info(system_info)
-
     shell_status = _check_shell_profile_status()
     _display_shell_status(shell_status)
 

machineconfig/scripts/python/{devops_helpers → helpers_devops}/devops_update_repos.py

@@ -9,7 +9,7 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from machineconfig.scripts.python.repos_helpers.update import RepositoryUpdateResult, run_uv_sync, update_repository
+from machineconfig.scripts.python.helpers_repos.update import RepositoryUpdateResult, run_uv_sync, update_repository
 from machineconfig.utils.io import read_ini
 from machineconfig.utils.source_of_truth import DEFAULTS_PATH