Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Cloudflare tunnel start gate, incl. --secure on loopback. Imports run.py
directly, so run under the Unsloth venv."""
from __future__ import annotations
import sys
from pathlib import Path
import pytest
_BACKEND = Path(__file__).resolve().parents[1]
if str(_BACKEND) not in sys.path:
sys.path.insert(0, str(_BACKEND))
from run import _cloudflare_tunnel_should_start as should_start # noqa: E402
@pytest.mark.parametrize(
"cloudflare,host,secure,api_only,is_colab,expected",
[
(True, "0.0.0.0", False, False, False, True),
(True, "::", False, False, False, True),
(True, "::0", False, False, False, True),
(True, "0:0:0:0:0:0:0:0", False, False, False, True),
(True, "0", False, False, False, True),
(True, "::ffff:0.0.0.0", False, False, False, True),
(True, "127.0.0.1", False, False, False, False),
(True, "localhost", False, False, False, False),
(True, "127.0.0.1", True, False, False, True),
(True, "0.0.0.0", True, False, False, True),
(False, "0.0.0.0", False, False, False, False),
(False, "::", False, False, False, False),
(False, "127.0.0.1", True, False, False, False),
(None, "0.0.0.0", False, False, False, False),
(None, "::", False, False, False, False),
(None, "127.0.0.1", False, False, False, False),
(True, "0.0.0.0", False, True, False, False),
(True, "::", False, True, False, False),
(True, "127.0.0.1", True, True, False, True),
(True, "0.0.0.0", False, False, True, False),
(True, "::", False, False, True, False),
(True, "127.0.0.1", True, False, True, False),
(True, "127.0.0.1", True, True, True, False),
],
)
def test_cloudflare_gate(cloudflare, host, secure, api_only, is_colab, expected):
assert (
should_start(
cloudflare = cloudflare,
host = host,
secure = secure,
api_only = api_only,
is_colab = is_colab,
)
is expected
)
@pytest.mark.parametrize(
"inherited,cloudflare,secure,expected",
[
("unset", False, False, "unset"),
("disabled", False, False, "disabled"),
(None, False, False, "disabled"),
(None, None, False, "unset"),
(None, None, True, "enabled"),
],
)
def test_cloudflare_intent_preserves_compatibility_provenance(
monkeypatch, inherited, cloudflare, secure, expected
):
import run
if inherited is None:
monkeypatch.delenv(run._CLOUDFLARE_INTENT_ENV, raising = False)
else:
monkeypatch.setenv(run._CLOUDFLARE_INTENT_ENV, inherited)
assert run._consume_cloudflare_intent(cloudflare, secure) == expected
assert run._CLOUDFLARE_INTENT_ENV not in run.os.environ
def test_run_server_accepts_secure_kwarg():
import inspect
import run
assert "secure" in inspect.signature(run.run_server).parameters
assert inspect.signature(run.run_server).parameters["secure"].default is False
def test_final_bound_port_uses_uvicorn_listener_for_ephemeral_bind():
from types import SimpleNamespace
import run
sock = SimpleNamespace(getsockname = lambda: ("127.0.0.1", 43123))
server = SimpleNamespace(servers = [SimpleNamespace(sockets = [sock])])
assert run._final_bound_port(server, 0) == 43123
assert run._final_bound_port(server, 8888) == 8888
source = (_BACKEND / "run.py").read_text(encoding = "utf-8")
resolved = source.index("port = _final_bound_port(_server, port)")
assert all(
resolved < source.index(consumer, resolved)
for consumer in (
"app.state.server_request_host",
"app.state.remote_access_port",
"TAURI_PORT={port}",
"start_studio_tunnel(",
)
)
assert "origin_host = app.state.server_request_host" in source[resolved:]
@pytest.mark.parametrize(
"address,expected",
[
(("0.0.0.0", 43123), "127.0.0.1"),
(("::", 43123, 0, 0), "::1"),
(("192.0.2.24", 43123), "192.0.2.24"),
(("fe80::1234", 43123, 0, 7), "fe80::1234%7"),
],
)
def test_bound_request_host_uses_the_active_listener_address(address, expected):
from types import SimpleNamespace
import run
sock = SimpleNamespace(getsockname = lambda: address)
server = SimpleNamespace(servers = [SimpleNamespace(sockets = [sock])])
assert run._bound_request_host(server) == expected
def test_bound_request_host_fails_closed_without_a_listener():
from types import SimpleNamespace
import run
with pytest.raises(RuntimeError, match = "did not expose its bound address"):
run._bound_request_host(SimpleNamespace(servers = []))
def test_arg_parser_secure_polarity_and_not_secure_alias():
# --not-secure is a hidden back-compat alias for --no-secure; the last flag wins.
import run
parser = run._build_arg_parser()
assert parser.parse_args([]).secure is False
assert parser.parse_args(["--secure"]).secure is True
assert parser.parse_args(["--no-secure"]).secure is False
assert parser.parse_args(["--not-secure"]).secure is False
assert parser.parse_args(["--secure", "--not-secure"]).secure is False
assert parser.parse_args(["--not-secure", "--secure"]).secure is True
def test_arg_parser_cloudflare_help_names_the_saved_auto_start_setting(monkeypatch):
import run
monkeypatch.setenv("COLUMNS", "1000")
help_text = run._build_arg_parser().format_help()
assert "'Start automatically' setting also starts one on every launch" in help_text
assert "--no-cloudflare forces both off" in help_text
def test_arg_parser_dns_pinning_opt_out_defaults_off():
import run
parser = run._build_arg_parser()
assert parser.parse_args([]).disable_dns_pinning is False
assert parser.parse_args(["--disable-dns-pinning"]).disable_dns_pinning is True
def test_run_server_accepts_enable_tools_kwarg():
import inspect
import run
params = inspect.signature(run.run_server).parameters
assert "enable_tools" in params
assert params["enable_tools"].default is None
def test_tool_policy_not_auto_disabled_by_bind():
# The tools-on default belongs to `unsloth studio run`; the backend never sets policy from host/secure.
import run
from state.tool_policy import (
get_tool_policy,
get_tool_policy_default,
reset_tool_policy,
)
for host in ("127.0.0.1", "localhost", "0.0.0.0"):
reset_tool_policy()
run._apply_cli_tool_policy(None)
assert get_tool_policy() is None, host
assert get_tool_policy_default() is None, host
reset_tool_policy()
run._apply_cli_tool_policy(True)
assert get_tool_policy() is True
reset_tool_policy()
run._apply_cli_tool_policy(False)
assert get_tool_policy() is False
reset_tool_policy()
def test_apply_cli_tool_policy_is_idempotent():
import run
from state.tool_policy import get_tool_policy, get_tool_policy_default, reset_tool_policy
for flag in (None, True, False):
reset_tool_policy()
run._apply_cli_tool_policy(flag)
first = (get_tool_policy(), get_tool_policy_default())
run._apply_cli_tool_policy(flag)
assert (get_tool_policy(), get_tool_policy_default()) == first, flag
reset_tool_policy()
def test_tool_policy_notice_wording():
import run
for host, secure_mode in (("127.0.0.1", False), ("0.0.0.0", False), ("127.0.0.1", True)):
notice = run._tool_policy_notice(host, secure_mode, None)
assert "follow each request's enable_tools" in notice, notice
assert "--enable-tools to force them on" in notice, notice
assert run._tool_policy_notice("0.0.0.0", False, False) == (
"Server-side tools are DISABLED (--disable-tools)."
)
assert "ENABLED (--enable-tools)" in run._tool_policy_notice("0.0.0.0", False, True)
def test_startup_output_emits_tool_notice_on_network_bind(capsys, monkeypatch):
import run
monkeypatch.setattr(run, "_verify_global_reachability", lambda *a, **k: None)
monkeypatch.setattr(run, "_print_cloudflare_line", lambda *a, **k: None)
monkeypatch.setattr(run, "_localhost_ipv6_mismatch_url", lambda *a, **k: None)
run._emit_startup_output("0.0.0.0", 8000, "0.0.0.0", secure = False, enable_tools = None)
out = capsys.readouterr().out
assert "Server-side tools" in out
assert "follow each request's enable_tools" in out
def test_startup_output_auto_start_on_wildcard_does_not_say_tunnel_off(capsys, monkeypatch):
import run
monkeypatch.setattr(run, "_verify_global_reachability", lambda *a, **k: None)
monkeypatch.setattr(run, "_localhost_ipv6_mismatch_url", lambda *a, **k: None)
monkeypatch.setattr(run, "_is_wsl_nat", lambda: False)
monkeypatch.setattr(run, "_cloudflare_url", None)
monkeypatch.setattr(run, "_cloudflare_requested", False)
monkeypatch.setattr(run, "_cloudflare_flag", None)
run._emit_startup_output("0.0.0.0", 8000, "0.0.0.0", remote_access_starting = True)
out = capsys.readouterr().out
assert "PUBLIC Cloudflare URL" in out
assert "Cloudflare tunnel: OFF" not in out
def test_startup_output_auto_start_keeps_the_public_raw_port_warning(capsys, monkeypatch):
import run
def _reachable(*a, **k):
run._public_reachable = True
monkeypatch.setattr(run, "_verify_global_reachability", _reachable)
monkeypatch.setattr(run, "_localhost_ipv6_mismatch_url", lambda *a, **k: None)
monkeypatch.setattr(run, "_is_wsl_nat", lambda: False)
monkeypatch.setattr(run, "_cloudflare_url", None)
monkeypatch.setattr(run, "_cloudflare_requested", False)
monkeypatch.setattr(run, "_cloudflare_flag", None)
run._emit_startup_output("0.0.0.0", 8000, "203.0.113.5", remote_access_starting = True)
out = capsys.readouterr().out
assert "raw port is also reachable from the public internet" in out
assert "bind 127.0.0.1" in out
assert "Cloudflare tunnel: OFF" not in out
def test_startup_output_auto_start_on_wildcard_keeps_a_ready_tunnel_url(capsys, monkeypatch):
import run
monkeypatch.setattr(run, "_verify_global_reachability", lambda *a, **k: None)
monkeypatch.setattr(run, "_localhost_ipv6_mismatch_url", lambda *a, **k: None)
monkeypatch.setattr(run, "_is_wsl_nat", lambda: False)
monkeypatch.setattr(run, "_cloudflare_url", "https://ready.trycloudflare.com")
monkeypatch.setattr(run, "_cloudflare_requested", False)
monkeypatch.setattr(run, "_cloudflare_flag", None)
run._emit_startup_output("0.0.0.0", 8000, "0.0.0.0", remote_access_starting = True)
assert "https://ready.trycloudflare.com" in capsys.readouterr().out
def test_startup_output_emits_disabled_notice(capsys, monkeypatch):
import run
monkeypatch.setattr(run, "_localhost_ipv6_mismatch_url", lambda *a, **k: None)
run._emit_startup_output("127.0.0.1", 8000, "127.0.0.1", secure = False, enable_tools = False)
out = capsys.readouterr().out
assert "Server-side tools are DISABLED" in out
def test_run_server_rejects_secure_without_cloudflare():
import run
with pytest.raises(SystemExit) as exc:
run.run_server(secure = True, cloudflare = False)
assert "do not combine it with --no-cloudflare" in str(exc.value)
def test_failclosed_message_present_in_source():
# The exact, user-facing fail-closed message must not drift.
src = (_BACKEND / "run.py").read_text(encoding = "utf-8")
assert (
"A secure Cloudflare link is not allowed, use --no-secure which provides a 0.0.0.0 link"
in src
)
@pytest.mark.parametrize(
"api_only,secure,expected",
[
(False, False, ["*"]),
(False, True, ["*"]),
(True, True, ["*"]),
(True, False, "tauri"),
],
)
def test_cors_origins_for_mode(api_only, secure, expected):
from utils.host_policy import cors_origins_for_mode
origins = cors_origins_for_mode(api_only = api_only, secure = secure)
if expected == "tauri":
assert origins != ["*"] and any(o.startswith("tauri://") for o in origins)
else:
assert origins == expected
def test_api_only_cors_tracks_published_public_url():
from types import SimpleNamespace
from starlette.datastructures import Headers
from main import RemoteAccessCORSMiddleware
state = SimpleNamespace(cloudflare_url = None)
middleware = RemoteAccessCORSMiddleware(
lambda *_: None,
remote_access_state = state,
allow_origins = ["tauri://localhost"],
allow_credentials = True,
allow_methods = ["*"],
allow_headers = ["*"],
)
def _preflight(origin):
return middleware.preflight_response(
Headers(
{
"origin": origin,
"access-control-request-method": "POST",
"access-control-request-headers": "authorization,content-type",
}
)
)
published = "https://public.trycloudflare.com"
assert _preflight(published).status_code == 400
state.cloudflare_url = published
response = _preflight(published)
assert response.status_code == 200
assert response.headers["access-control-allow-origin"] == published
assert _preflight("https://browser-client.example").status_code == 400
state.cloudflare_url = None
assert _preflight(published).status_code == 400
def test_run_server_exports_secure_env_for_cors():
# run_server must export UNSLOTH_SECURE before importing main so CORS can tell secure from Tauri.
src = (_BACKEND / "run.py").read_text(encoding = "utf-8")
assert 'os.environ["UNSLOTH_SECURE"] = "1"' in src
assert "set_studio_tunnel_runtime_callback(set_remote_connector_active)" in src
main_src = (_BACKEND / "main.py").read_text(encoding = "utf-8")
assert "RemoteAccessCORSMiddleware,\n remote_access_state = app.state" in main_src
assert '"X-Unsloth-Monitor-ID"' in main_src
def test_run_server_emit_tauri_port_defaults_on():
# Default on keeps the desktop app's stdout contract; the headless
# `run --api-only` path opts out explicitly.
import inspect
import run
params = inspect.signature(run.run_server).parameters
assert "emit_tauri_port" in params
assert params["emit_tauri_port"].default is True
def test_tauri_port_print_is_gated_in_source():
src = (_BACKEND / "run.py").read_text(encoding = "utf-8")
assert "if api_only and emit_tauri_port:" in src
def test_cors_preflight_cache_window_is_short():
# A cached CORS preflight outlives the tunnel; Starlette's 600s default let requests through after Stop.
from types import SimpleNamespace
from starlette.datastructures import Headers
from main import RemoteAccessCORSMiddleware
middleware = RemoteAccessCORSMiddleware(
lambda *_: None,
remote_access_state = SimpleNamespace(cloudflare_url = "https://x.trycloudflare.com"),
allow_origins = ["tauri://localhost"],
allow_credentials = True,
allow_methods = ["*"],
allow_headers = ["*"],
max_age = 60,
)
response = middleware.preflight_response(
Headers(
{
"origin": "https://x.trycloudflare.com",
"access-control-request-method": "POST",
"access-control-request-headers": "authorization",
}
)
)
assert response.status_code == 200
assert int(response.headers["access-control-max-age"]) <= 60
main_src = (_BACKEND / "main.py").read_text(encoding = "utf-8")
assert "max_age = 60" in main_src, "the mounted middleware must pin max_age"