Welcome to BMO

def find_program(
    name: str, hints: T.List[T.Union[Path, str]] = [], recursive: bool = False
) -> T.Optional[str]:
    """where is a given binary"""
    for hint in hints:
        hint = Path(hint).resolve()
        if not hint.exists():
            continue
        for p in glob.glob(f"{hint}/**/{name}", recursive=recursive):
            prg  = shutil.which(p)
            if prg is not None:
                return prg
    return shutil.which(name)

def is_windows(cygwin_is_windows: bool = True) -> bool:
    """Check if we are running on windows.

    Parameters
    ----------
        cygwin_is_windows : (default `True`). When set to `True`, consider cygwin as Windows.

    Returns
    -------
    `True` if on Windows, `False` otherwise.
    """
    _sys = system()
    if _sys[0].startswith("windows"):
        return True
    return cygwin_is_windows and _sys[1] == "cygwin"

def run_command(
    cmd: str, cwd: Path = Path.cwd(), silent: bool = False, stream: bool = True
) -> str:
    """Run a given command.

    Parameters
    ----------
    cmd : str
        cmd
    cwd : Path
        Current working directory.
    silent : bool
        If `True`, output is not printed onto console.
    stream : bool
        If `True` the output is printed line by line eagerly (as soon as a line is available)
        rather than all at once.

    Returns
    -------
    str

    Credits
    --------
    1. https://stackoverflow.com/questions/18421757/live-output-from-subprocess-command
    """
    logging.debug(f"Running `{cmd}` in {cwd}")
    p = subprocess.Popen(
        cmd.split(),
        cwd=cwd,
        text=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    lines = []
    if p.stdout is not None:
        for line in iter(p.stdout.readline, ""):
            if line is None:
                break
            line = line.rstrip()
            lines.append(f"> {line}")
            if stream and not silent:
                typer.echo(f"> {line}")

    output = "\n".join(lines)
    if not silent and not stream:
        typer.echo(f"> {output}")
    return output

def search_pat(pat, haystack):
    """Search for a pattern in haystack."""
    import re

    return re.search(pat, haystack, flags=re.IGNORECASE)

@app.command("script")
def download_and_run_script(
    script: str, force: bool = False, download_only: bool = False
) -> str:
    """Download a script from https://gitlab.subcom.tech/open/scripts repo and execute it..

    Parameters
    ----------
    script : str
        The name or the full URL of the script.
    force : bool
        When set to `True`, redownload the script even if it exists in the cache.
    download_only:
        When set to `True`, only download the script and do not execute it.

    Returns
    -------
    `True` on success. `False` otherwise.

    """
    SCRIPT_DIR = Path(tempfile.gettempdir()) / "bmo"
    SCRIPT_DIR.mkdir(parents=True, exist_ok=True)
    REPO_URL = "https://gitlab.subcom.tech/open/scripts/"

    if "https://" not in script[-10:] or "http://" not in script[-10:]:
        # Example: https://gitlab.subcom.tech/open/scripts/-/raw/main/bootstrap_debian.sh
        script = f"{REPO_URL}/-/raw/main/{script}"

    scriptname: str = script.rsplit("/", maxsplit=1)[-1]
    scriptpath = SCRIPT_DIR / scriptname
    if not scriptpath.exists() or force:
        res = requests.get(script)
        if res.status_code != 200:
            logging.warning("Failed to download '{script}'. Please check the repository {REPO_URL}")
            return ""
        with open(scriptpath, "w") as f:
            f.write(res.text)

    if download_only:
        with scriptpath.open() as f:
            return f.read()

    output = run_command(f"bash -c {scriptpath}")
    print(output)
    return output