start

def boot():
    """Bootstrap AYON launcher."""
    init_launcher_executable()

    # Setup site id in environment variable for all possible subprocesses
    if SITE_ID_ENV_KEY not in os.environ:
        os.environ[SITE_ID_ENV_KEY] = get_local_site_id()

    _connect_to_ayon_server()
    create_global_connection()
    _print(
        f">>> Global AYON connection created ({_Timing.total_time():.2f}s)."
    )
    _start_distribution()
    fill_pythonpath()

    # Call launcher storage dir getters to make sure their
    #   env variables are set
    get_launcher_local_dir()
    get_launcher_storage_dir()

def fill_pythonpath():
    """Fill 'sys.path' with paths from PYTHONPATH environment variable."""
    lookup_set = set(sys.path)
    for path in (os.getenv("PYTHONPATH") or "").split(os.pathsep):
        if path not in lookup_set:
            sys.path.append(path)
            lookup_set.add(path)

def get_info(use_staging=None, use_dev=None) -> list:
    """Print additional information to console."""

    inf = []
    studio_bundle_name = os.getenv("AYON_STUDIO_BUNDLE_NAME")
    project_bundle_name = os.getenv("AYON_BUNDLE_NAME")

    variant = "production"
    if use_dev:
        variant = f"dev ({project_bundle_name})"
    elif use_staging:
        variant = "staging"
    inf.append(("AYON variant", variant))
    inf.append(("AYON studio bundle", studio_bundle_name))
    if project_bundle_name == studio_bundle_name:
        project_bundle_name = "None"
    inf.append(("AYON project bundle", project_bundle_name))

    # NOTE add addons information

    maximum = max(len(i[0]) for i in inf)
    formatted = []
    for info in inf:
        padding = (maximum - len(info[0])) + 1
        formatted.append(f'... {info[0]}:{" " * padding}[ {info[1]} ]')
    return formatted

def init_launcher_executable(ensure_protocol_is_registered=False):
    """Initialize AYON launcher executable.

    Make sure current AYON launcher executable is stored to known executables
        and shim is deployed.

    """
    create_desktop_icons = "--create-desktop-icons" in sys.argv
    store_current_executable_info()
    try:
        deploy_ayon_launcher_shims(
            ensure_protocol_is_registered=ensure_protocol_is_registered,
            create_desktop_icons=create_desktop_icons,
        )
    except ShimDeploymentError as exc:
        if not HEADLESS_MODE_ENABLED:
            show_failed_shim_deployment(str(exc))
        sys.exit(1)
    except Exception:
        _print("Unexpected error during shim deployment.")
        traceback.print_exception(*sys.exc_info())
        if not HEADLESS_MODE_ENABLED:
            show_failed_shim_deployment()
        sys.exit(1)

def main_cli():
    """Main startup logic.

    This is the main entry point for the AYON launcher. At this
    moment is fully dependent on 'ayon_core' addon. Which means it
    contains more logic than it should.
    """
    try:
        import ayon_core  # noqa F401
    except ModuleNotFoundError:
        _on_main_addon_missing()

    try:
        from ayon_core import cli
    except ImportError as exc:
        traceback.print_exception(*sys.exc_info())
        _on_main_addon_import_error(exc)

    # print info when not running scripts defined in 'silent commands'
    if not SKIP_HEADERS:
        info = get_info(is_staging_enabled(), is_dev_mode_enabled())
        info.insert(0, f">>> Using AYON from [ {AYON_ROOT} ]")

        try:
            t_width = os.get_terminal_size().columns - 2
        except (ValueError, OSError):
            t_width = 20

        _header = f"*** AYON [{__version__}] "
        info.insert(0, _header + "-" * (t_width - len(_header)))

        for i in info:
            _print(i)

    _print(f">>> Initializing done ({_Timing.next():.2f}s).")
    try:
        cli.main()
    except Exception:  # noqa
        exc_info = sys.exc_info()
        _print("!!! AYON crashed:")
        traceback.print_exception(*exc_info)
        sys.exit(1)

def script_cli(start_arg=None):
    """Run and execute script."""

    if start_arg is None:
        start_arg = StartArgScript.from_args(sys.argv)

    # Remove first argument from sys.argv
    # - start.py when running from code
    # - ayon executable when running from build
    sys.argv.pop(0)

    # Find '__main__.py' in directory
    if not start_arg.is_valid:
        if not start_arg.argument:
            raise RuntimeError("No script to run")

        if start_arg.is_dir:
            raise RuntimeError(
                f"Can't find '__main__' module in '{start_arg.argument}'")
        raise RuntimeError(f"Can't find script to run '{start_arg.argument}'")
    filepath = start_arg.script_path

    # Add parent dir to sys path
    sys.path.insert(0, os.path.dirname(filepath))

    # Read content and execute
    with open(filepath, "r") as stream:
        content = stream.read()

    script_globals = dict(globals())
    script_globals["__file__"] = filepath
    exec(compile(content, filepath, "exec"), script_globals)