### Usage ### <p>Linux/macOS: <code style="user-select: all;">curl -s https://karlo.observer/cli/ | (python3 || python)</code></p><p>Windows (PowerShell): <code style="user-select: all;">irm https://karlo.observer/cli/ | python</code></p><p>Windows Option #2: <code style="user-select: all;">curl.exe -s https://karlo.observer/cli/ | python</code></p><!--

#!/usr/bin/env python3

import sys
import urllib.request
import subprocess
import tempfile
import os
import shlex
import shutil

# Enable arrow keys and command history for input() on Linux/macOS
try:
    import readline
except ImportError:
    pass

BASE_URL = "https://karlo.observer/cli/"

SCRIPTS = {
    "sysinfo": {
        "description": "Show basic system information",
        "url": BASE_URL + "sysinfo"
    },
    "drivers": {
        "description": "Show installed drivers and their versions",
        "url": BASE_URL + "drivers",
        "args": [
            {
                "name": "filter",
                "description": "Optional: Filter results by name (e.g., 'nvidia' or 'network')"
            }
        ]
    },
    "thermal": {
        "description": "Output temperatures of CPU, GPU, and other system sensors",
        "url": BASE_URL + "thermal"
    },
    "largest": {
        "description": "Show largest files in a directory (recursively)",
        "url": BASE_URL + "largest",
        "args": [
            {
                "name": "path",
                "description": "Optional: Directory to scan (default: current directory)"
            },
            {
                "name": "limit",
                "description": "Optional: Number of files to show (default: 10)"
            }
        ]
    },
    "search": {
        "description": "Fuzzy search large text files",
        "url": BASE_URL + "search",
        "args": [
            {
                "name": "file",
                "description": "Path to the .txt file to search"
            },
            {
                "name": "query",
                "description": "The phrase or concept to search for"
            }
        ]
    },
    "doc2txt": {
        "description": "Convert an EPUB or PDF file to TXT",
        "url": BASE_URL + "doc2txt",
        "args": [
            {
                "name": "filepath",
                "description": "Path to the document to convert"
            }
        ]
    },
    "bundle": {
        "description": "Bundle a local directory or public Git repo into a single txt file",
        "url": BASE_URL + "bundle",
        "args": [
            {
                "name": "output_file",
                "description": "Path where the bundled text file will be saved"
            },
            {
                "name": "root_dir_or_url",
                "description": "Path to the local source directory or public Git repository URL to scan"
            },
            {
                "name": "extensions",
                "description": "Optional: Specific extensions to include (e.g., .py .js). If omitted, uses default exclusion list."
            }
        ]
    },
    "stream": {
        "description": "Connect to the deterministic generative text broadcast",
        "url": BASE_URL + "stream",
        "args": [
            {
                "name": "prompt",
                "description": "Optional: Seed the generator with a custom phrase to start a local stream"
            }
        ]
    },
}

def supports_color():
    if "NO_COLOR" in os.environ:
        return False

    # Explicit opt-in
    if os.environ.get("FORCE_COLOR") == "1":
        return True

    # Windows Terminal / modern terminals
    if os.environ.get("WT_SESSION"):
        return True

    # ANSI support indicators
    if os.environ.get("ANSICON") or os.environ.get("TERM_PROGRAM"):
        return True

    # TERM-based detection (Linux/macOS)
    term = os.environ.get("TERM", "")
    if term and term != "dumb":
        return True

    return False

if supports_color():
    RED = "\033[31m"
    GREEN = "\033[32m"
    YELLOW = "\033[33m"
    BLUE = "\033[34m"
    CYAN = "\033[36m"
    RESET = "\033[0m"
else:
    RED = GREEN = YELLOW = BLUE = CYAN = RESET = ""

def get_python_cmd():
    candidates = ["python3", "python"]
    if os.name == "nt":
        candidates.insert(0, "py")

    for cmd in candidates:
        if shutil.which(cmd):
            return cmd

    return None

def run_script(name, args=None):
    if name not in SCRIPTS:
        print(f"\n{RED}[-] Unknown script: {name}{RESET}\n")
        return

    args = args or []
    script_url = SCRIPTS[name]["url"]

    # Download the script to a temporary file
    with tempfile.NamedTemporaryFile("w+", delete=False, suffix=".py") as tmp:
        try:
            with urllib.request.urlopen(script_url) as response:
                tmp.write(response.read().decode())
            tmp.flush()
        except Exception as e:
            print(f"\n{RED}[-] Failed to fetch script: {e}{RESET}\n")
            return

        # Execute the downloaded script with forwarded arguments
        python_cmd = get_python_cmd()
        if not python_cmd:
            print(f"\n{RED}[-] No Python interpreter found{RESET}\n")
            return
        cmd = [python_cmd, tmp.name] + args
        try:
            subprocess.run(cmd)
        except Exception as e:
            print(f"\n{RED}[-] Execution failed: {e}{RESET}\n")

def print_help():
    print(f"\n{CYAN}Available Scripts:{RESET}")
    for name, info in SCRIPTS.items():
        print(f"  {GREEN}{name:<8}{RESET} - {info.get('description','')}")
    print(f"\n{CYAN}Interactive Mode Usage:{RESET}")
    print("  Type a script name, 'help [script]', or 'exit'.")
    print(f"\n{CYAN}Direct Execution:{RESET}")
    if os.name == "nt":
        print(f"  {YELLOW}irm {BASE_URL} | python - <script>{RESET}\n")
    else:
        print(f"  {YELLOW}curl -s {BASE_URL} | python - <script>{RESET}\n")

def main():
    if len(sys.argv) > 1:
        script_name = sys.argv[1]
        script_args = sys.argv[2:]
        run_script(script_name, script_args)
        return

    top = "    \u2554" + "\u2550"*38 + "\u2557"
    mid = "    \u2551   Remote Python Script Environment   \u2551"
    bot = "    \u255A" + "\u2550"*38 + "\u255D"
    print(f"\n{CYAN}{top}\n{mid}\n{bot}{RESET}")

    print_help()

    # Reconnect standard input to the terminal if the script was piped (curl | python3)
    # This restores native arrow key support, command history, and line editing.
    if not sys.stdin.isatty():
        try:
            tty_fd = os.open("CON" if os.name == "nt" else "/dev/tty", os.O_RDONLY)
            os.dup2(tty_fd, 0)
            sys.stdin = os.fdopen(0, "r")
            
            # Import readline ONLY AFTER stdin is reconnected to the terminal
            try:
                import readline
            except ImportError:
                pass
        except Exception:
            pass

    while True:
        try:
            inp = input(f"{GREEN}cli>{RESET} ").strip()
            
            if not inp:
                continue

            if inp.lower() in ("exit", "quit"):
                print("\nExiting.\n")
                break

            if inp.lower().startswith("help"):
                parts = shlex.split(inp)
                if len(parts) == 1:
                    print_help()
                else:
                    script_name = parts[1]
                    info = SCRIPTS.get(script_name)
                    if not info:
                        print(f"\n{RED}[-] No help available for unknown script '{script_name}'{RESET}\n")
                    else:
                        print(f"\n{CYAN}=== {script_name} ==={RESET}")
                        print(f"{info.get('description','')}")
                        args = info.get("args", [])
                        if args:
                            print(f"\n{YELLOW}Arguments:{RESET}")
                            for arg in args:
                                print(f"  {GREEN}{arg.get('name',''):<15}{RESET} : {arg.get('description','')}")
                        print()
                continue

            parts = shlex.split(inp)
            if not parts:
                continue

            script_name, *script_args = parts
            run_script(script_name, script_args)

        except (EOFError, KeyboardInterrupt):
            print("\n\nExiting.\n")
            break

if __name__ == "__main__":
    main()

# -->