mirror of
https://github.com/FlashML-org/FreeToken.git
synced 2026-11-21 01:52:30 +08:00
* feat(server): require an API key on every route but /health * feat(shell): send the server's API key * feat(ctl): send the server's API key * feat(launch): hand the server's API key to the agent * feat(daemon): pass the serve's API key as apiKey The daemon reaches the serve's /v1/stats and prepare-stop itself, so the key travels in the start request, reaches the serve through its environment and is kept in the state file for re-adoption. The daemon's own FREETOKEN_API_KEY is no longer passed down to the serve. * fix(launch): keep the API key out of the variable dsh's web search reads dsh's web search reads DEEPSEEK_API_KEY and sends it to api.deepseek.com, so dsh now reads the key from FREETOKEN_API_KEY through the apiKeyEnv of its llm-deepseek section, and DEEPSEEK_API_KEY stays the dummy. * fix(server): check the API key on OPTIONS requests * fix(launch): write agent configs that hold the API key owner-only * chore: drop comments that restate the code
147 lines
5.3 KiB
Python
147 lines
5.3 KiB
Python
"""--api-key: the gate in front of every route but /health, and where the key comes from."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import stat
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
import yaml
|
|
from fastapi import FastAPI
|
|
from fastapi.testclient import TestClient
|
|
from freetoken import launch
|
|
from freetoken.server.api_server import install_api_key, install_cors
|
|
from freetoken.server.args import parse_args
|
|
|
|
KEY = "sk-test"
|
|
ORIGIN = "http://localhost:1420"
|
|
|
|
|
|
def _client(api_key: str | None) -> TestClient:
|
|
app = FastAPI()
|
|
app.get("/health")(lambda: {"status": "ok"})
|
|
app.get("/v1/models")(lambda: {"data": []})
|
|
install_api_key(app, api_key)
|
|
install_cors(app, ORIGIN)
|
|
return TestClient(app)
|
|
|
|
|
|
def _parse(*argv: str):
|
|
hf = SimpleNamespace(to_dict=lambda: {"architectures": ["Qwen3ForCausalLM"], "torch_dtype": "bfloat16"})
|
|
with patch("freetoken.utils.cached_load_hf_config", lambda _path: hf):
|
|
return parse_args(["--model", "/models/anon", *argv])[0]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"headers, status",
|
|
[
|
|
({}, 401),
|
|
({"Authorization": "Bearer wrong"}, 401),
|
|
({"Authorization": f"Basic {KEY}"}, 401),
|
|
({"Authorization": KEY}, 401),
|
|
({"Authorization": b"Bearer caf\xe9"}, 401),
|
|
({"x-api-key": "wrong"}, 401),
|
|
({"Authorization": f"Bearer {KEY}"}, 200),
|
|
({"Authorization": f"bearer {KEY}"}, 200),
|
|
({"x-api-key": KEY}, 200),
|
|
],
|
|
)
|
|
def test_key_gates_every_route_but_health(headers, status):
|
|
client = _client(KEY)
|
|
response = client.get("/v1/models", headers=headers)
|
|
assert response.status_code == status
|
|
if status == 401:
|
|
assert response.json() == {"error": "Unauthorized"}
|
|
assert client.get("/health").status_code == 200
|
|
|
|
|
|
def test_no_key_serves_open():
|
|
assert _client(None).get("/v1/models").status_code == 200
|
|
|
|
|
|
def test_cors_preflight_passes_and_401_carries_cors_headers():
|
|
client = _client(KEY)
|
|
preflight = client.options(
|
|
"/v1/models",
|
|
headers={"Origin": ORIGIN, "Access-Control-Request-Method": "GET",
|
|
"Access-Control-Request-Headers": "authorization"},
|
|
)
|
|
assert preflight.status_code == 200
|
|
denied = client.get("/v1/models", headers={"Origin": ORIGIN})
|
|
assert denied.status_code == 401
|
|
assert denied.headers["access-control-allow-origin"] == ORIGIN
|
|
|
|
|
|
def test_options_outside_a_cors_preflight_needs_the_key():
|
|
assert _client(KEY).options("/v1/models").status_code == 401
|
|
|
|
|
|
def test_flag_wins_over_env_and_empty_values_do_not_enable_auth(monkeypatch):
|
|
monkeypatch.delenv("FREETOKEN_API_KEY", raising=False)
|
|
assert _parse().api_key is None
|
|
monkeypatch.setenv("FREETOKEN_API_KEY", "from-env")
|
|
assert _parse().api_key == "from-env"
|
|
assert _parse("--api-key", KEY).api_key == KEY
|
|
monkeypatch.setenv("FREETOKEN_API_KEY", "")
|
|
assert _parse().api_key is None
|
|
with pytest.raises(SystemExit):
|
|
_parse("--api-key", "")
|
|
|
|
|
|
def test_key_stays_out_of_the_logged_config(monkeypatch):
|
|
monkeypatch.delenv("FREETOKEN_API_KEY", raising=False)
|
|
assert KEY not in str(_parse("--api-key", KEY))
|
|
|
|
|
|
@pytest.mark.parametrize("agent", sorted(launch.PREPARERS))
|
|
def test_dry_run_prints_a_placeholder_instead_of_the_key(agent, monkeypatch, capsys):
|
|
key = 'p"w\\d\xe9'
|
|
model = launch.ServedModel(model_id="m", models=["m"], context_length=8192)
|
|
monkeypatch.setattr(launch, "discover_server_model", lambda _server, _key: model)
|
|
assert launch.main([agent, "--dry-run", "--api-key", key]) == 0
|
|
out = capsys.readouterr().out
|
|
assert key not in out and json.dumps(key)[1:-1] not in out
|
|
if agent in ("claude", "codex", "dsh", "opencode"):
|
|
assert "<api-key>" in out
|
|
|
|
|
|
def test_dsh_keeps_the_key_out_of_the_variable_its_web_search_reads(monkeypatch, tmp_path):
|
|
monkeypatch.setenv("DSH_HOME", str(tmp_path))
|
|
monkeypatch.setattr(launch, "_warn_dsh_node_version", lambda: None)
|
|
ctx = launch.LaunchContext(
|
|
server=launch.resolve_server_url("http://127.0.0.1:1919"),
|
|
model=launch.ServedModel(model_id="m", models=["m"], context_length=8192),
|
|
extra_args=[],
|
|
dry_run=False,
|
|
api_key=KEY,
|
|
)
|
|
env = launch.prepare_dsh(ctx).env
|
|
settings = yaml.safe_load((tmp_path / launch.DSH_LAUNCH_SETTINGS_NAME).read_text())
|
|
assert env["DEEPSEEK_API_KEY"] != KEY
|
|
assert env[settings["llm-deepseek"]["apiKeyEnv"]] == KEY
|
|
|
|
|
|
@pytest.mark.parametrize("agent", ["hermes", "openclaw"])
|
|
def test_config_files_holding_the_key_are_owner_only(agent, monkeypatch, tmp_path):
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
old_umask = os.umask(0o022)
|
|
try:
|
|
for key in ("sk-first", "sk-second"):
|
|
ctx = launch.LaunchContext(
|
|
server=launch.resolve_server_url("http://127.0.0.1:1919"),
|
|
model=launch.ServedModel(model_id="m", models=["m"], context_length=65536),
|
|
extra_args=[],
|
|
dry_run=False,
|
|
assume_yes=True,
|
|
api_key=key,
|
|
)
|
|
launch.PREPARERS[agent](ctx)
|
|
finally:
|
|
os.umask(old_umask)
|
|
written = [p for p in tmp_path.rglob("*") if p.is_file() and "sk-" in p.read_text()]
|
|
assert len(written) == 2
|
|
assert all(stat.S_IMODE(p.stat().st_mode) == 0o600 for p in written)
|