feat: publish CodexPi contest snapshot

tests/test_local_ai_bridge.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import threading
+import time
+import urllib.error
+import urllib.request
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+from codexpi.database import Database
+from codexpi.local_ai_bridge_service import LocalAIBridgeError, LocalAIBridgeService
+
+
+MODELS = [
+    {
+        "name": "qwen2.5-coder:14b",
+        "size": 8_988_000_000,
+        "details": {"parameter_size": "14.8B", "quantization_level": "Q4_K_M"},
+        "capabilities": ["completion", "tools"],
+    },
+    {
+        "name": "gemma3:12b",
+        "size": 8_149_000_000,
+        "details": {"parameter_size": "12.2B", "quantization_level": "Q4_K_M"},
+        "capabilities": ["completion", "vision"],
+    },
+]
+
+
+def load_bridge_script():
+    path = Path(__file__).parents[1] / "scripts" / "codexpi_ai_bridge.py"
+    spec = importlib.util.spec_from_file_location("codexpi_ai_bridge_test", path)
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class FakeOllamaHandler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.0"
+
+    def log_message(self, *_args) -> None:
+        return
+
+    def _send(self, value: dict, status: int = 200) -> None:
+        body = json.dumps(value).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:
+        if self.path in {"/api/tags", "/v1/models"}:
+            self._send({"models": MODELS})
+        elif self.path == "/api/experimental/model-recommendations":
+            self._send({"recommendations": [{
+                "model": "qwen3:8b",
+                "description": "Local reasoning and tools",
+                "vram_bytes": 6_000_000_000,
+                "thinking": {"values": [False, True], "default": True},
+            }]})
+        else:
+            self._send({"error": "missing"}, 404)
+
+    def do_POST(self) -> None:
+        length = int(self.headers.get("Content-Length") or 0)
+        payload = json.loads(self.rfile.read(length) or b"{}")
+        if self.path == "/v1/chat/completions":
+            self._send({"choices": [{"message": {"role": "assistant", "content": payload.get("model")}}]})
+        elif self.path == "/api/show":
+            self._send({"capabilities": ["completion", "tools"]})
+        elif self.path == "/api/pull":
+            rows = [
+                {"status": "pulling manifest"},
+                {"status": "pulling layer", "digest": "sha256:one", "total": 100, "completed": 35},
+                {"status": "pulling layer", "digest": "sha256:one", "total": 100, "completed": 100},
+                {"status": "verifying sha256 digest"},
+                {"status": "success"},
+            ]
+            body = b"".join(json.dumps(item).encode("utf-8") + b"\n" for item in rows)
+            self.send_response(200)
+            self.send_header("Content-Type", "application/x-ndjson")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self._send({"error": "missing"}, 404)
+
+
+@pytest.fixture
+def fake_ollama():
+    server = ThreadingHTTPServer(("127.0.0.1", 0), FakeOllamaHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield server
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+
+
+def test_local_ai_pairing_encrypts_token_and_writes_isolated_opencode_config(tmp_path, fake_ollama):
+    db = Database(tmp_path / "codexpi.db")
+    db.initialize()
+    service = LocalAIBridgeService(db, "test-secret", tmp_path / "data")
+    pairing = service.create_pairing("owner")
+    token = "a" * 48
+    bridge = service.pair(
+        pairing["pairing_id"], pairing["code"], "PC bureau", "Windows",
+        "127.0.0.1", fake_ollama.server_address[1], token,
+    )
+
+    assert bridge["connected"] is True
+    assert bridge["default_model"] == "qwen2.5-coder:14b"
+    assert bridge["models"][0]["capabilities"] == ["completion", "tools"]
+    assert "token" not in bridge and "token_encrypted" not in bridge
+    stored = db.one("SELECT token_encrypted FROM local_ai_bridges WHERE id=?", (bridge["id"],))
+    assert stored and stored["token_encrypted"] != token
+    assert service.token_path.read_text(encoding="utf-8") == token
+    config = json.loads(service.config_path.read_text(encoding="utf-8"))
+    assert config["model"] == "ollama/qwen2.5-coder:14b"
+    assert config["providers"]["ollama"]["settings"]["baseURL"].endswith("/v1")
+    assert token not in service.config_path.read_text(encoding="utf-8")
+
+    with pytest.raises(LocalAIBridgeError, match="déjà utilisé"):
+        service.pair(
+            pairing["pairing_id"], pairing["code"], "PC bureau", "Windows",
+            "127.0.0.1", fake_ollama.server_address[1], token,
+        )
+
+    changed = service.configure(bridge["id"], "gemma3:12b")
+    assert changed["default_model"] == "gemma3:12b"
+    assert json.loads(service.config_path.read_text(encoding="utf-8"))["model"] == "ollama/gemma3:12b"
+    service.revoke(bridge["id"])
+    assert not service.config_path.exists() and not service.token_path.exists()
+
+
+def test_local_ai_service_rejects_public_addresses(tmp_path):
+    db = Database(tmp_path / "codexpi.db")
+    db.initialize()
+    service = LocalAIBridgeService(db, "test-secret", tmp_path / "data")
+    pairing = service.create_pairing("owner")
+    with pytest.raises(LocalAIBridgeError, match="réseau local"):
+        service.pair(pairing["pairing_id"], pairing["code"], "PC", "Windows", "8.8.8.8", 11435, "x" * 48)
+
+
+def test_invalid_pairing_code_never_triggers_network_probe(tmp_path, monkeypatch):
+    db = Database(tmp_path / "codexpi.db")
+    db.initialize()
+    service = LocalAIBridgeService(db, "test-secret", tmp_path / "data")
+    pairing = service.create_pairing("owner")
+    probed = False
+
+    def fail_if_probed(*_args, **_kwargs):
+        nonlocal probed
+        probed = True
+        raise AssertionError("the bridge must not be contacted")
+
+    monkeypatch.setattr(service, "probe", fail_if_probed)
+    with pytest.raises(LocalAIBridgeError, match="Code d’association invalide"):
+        service.pair(
+            pairing["pairing_id"], "wrong-pairing-code", "PC", "Windows",
+            "127.0.0.1", 11435, "x" * 48,
+        )
+    assert probed is False
+
+
+def test_pc_bridge_requires_bearer_and_only_proxies_ollama_routes(fake_ollama):
+    bridge = load_bridge_script()
+    upstream = f"http://127.0.0.1:{fake_ollama.server_address[1]}"
+    server = bridge.create_server("127.0.0.1", 0, upstream, "private-token")
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    base = f"http://127.0.0.1:{server.server_address[1]}"
+    try:
+        with pytest.raises(urllib.error.HTTPError) as unauthorized:
+            urllib.request.urlopen(base + "/api/tags", timeout=2)
+        assert unauthorized.value.code == 401
+
+        request = urllib.request.Request(base + "/api/tags", headers={"Authorization": "Bearer private-token"})
+        with urllib.request.urlopen(request, timeout=2) as response:
+            assert json.loads(response.read())["models"][0]["name"] == "qwen2.5-coder:14b"
+
+        forbidden = urllib.request.Request(base + "/api/delete", headers={"Authorization": "Bearer private-token"})
+        with pytest.raises(urllib.error.HTTPError) as missing:
+            urllib.request.urlopen(forbidden, timeout=2)
+        assert missing.value.code == 404
+
+        chat = urllib.request.Request(
+            base + "/v1/chat/completions",
+            data=json.dumps({"model": "qwen2.5-coder:14b", "messages": []}).encode("utf-8"),
+            method="POST",
+            headers={"Authorization": "Bearer private-token", "Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(chat, timeout=2) as response:
+            assert json.loads(response.read())["choices"][0]["message"]["content"] == "qwen2.5-coder:14b"
+
+        pull = urllib.request.Request(
+            base + "/api/pull",
+            data=json.dumps({"model": "qwen3:8b", "stream": True}).encode("utf-8"),
+            method="POST",
+            headers={"Authorization": "Bearer private-token", "Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(pull, timeout=2) as response:
+            events = [json.loads(line) for line in response if line.strip()]
+        assert events[-1]["status"] == "success"
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+
+
+def test_local_ai_settings_flow_exposes_models_without_exposing_token(logged_in, monkeypatch):
+    client, app, _, _, headers = logged_in
+    monkeypatch.setattr(app.state.local_ai, "probe", lambda *_args, **_kwargs: app.state.local_ai._models({"models": MODELS}))
+
+    created = client.post("/api/local-ai/pairings", headers=headers)
+    assert created.status_code == 201
+    pairing = created.json()
+    paired = client.post("/api/local-ai/agent/pair", json={
+        "pairing_id": pairing["pairing_id"],
+        "code": pairing["code"],
+        "name": "RTX 3060",
+        "platform": "Windows",
+        "address": "127.0.0.1",
+        "port": 11435,
+        "token": "z" * 48,
+    })
+    assert paired.status_code == 201
+    bridge = paired.json()
+    assert bridge["default_model"] == "qwen2.5-coder:14b"
+    assert "token" not in json.dumps(bridge)
+
+    listed = client.get("/api/local-ai/bridges")
+    assert listed.status_code == 200 and listed.json()[0]["name"] == "RTX 3060"
+    options = client.get("/api/codex/options").json()
+    assert options["local_default_model"] == "ollama/qwen2.5-coder:14b"
+    assert options["local_models"][0]["id"] == "ollama/qwen2.5-coder:14b"
+    assert next(item for item in options["engines"] if item["id"] == "opencode")["label"] == "OpenCode · PC local"
+    assert client.get("/api/local-ai/connector").status_code == 200
+    assert client.get("/api/local-ai/guide").status_code == 200
+
+    catalog = client.get(f"/api/local-ai/bridges/{bridge['id']}/catalog")
+    assert catalog.status_code == 200
+    assert any(item["name"] == "qwen2.5-coder:14b" and item["installed"] for item in catalog.json()["models"])
+
+    updated = client.put(
+        f"/api/local-ai/bridges/{bridge['id']}", headers=headers,
+        json={"default_model": "gemma3:12b", "active": True},
+    )
+    assert updated.status_code == 200 and updated.json()["default_model"] == "gemma3:12b"
+    revoked = client.delete(f"/api/local-ai/bridges/{bridge['id']}", headers=headers)
+    assert revoked.status_code == 200
+    assert client.get("/api/local-ai/bridges").json() == []
+
+
+def test_local_ai_pull_tracks_real_stream_progress(tmp_path, fake_ollama):
+    db = Database(tmp_path / "codexpi.db")
+    db.initialize()
+    service = LocalAIBridgeService(db, "test-secret", tmp_path / "data")
+    pairing = service.create_pairing("owner")
+    bridge = service.pair(
+        pairing["pairing_id"], pairing["code"], "PC bureau", "Windows",
+        "127.0.0.1", fake_ollama.server_address[1], "p" * 48,
+    )
+
+    catalog = service.catalog(bridge["id"])
+    recommended = next(item for item in catalog["models"] if item["name"] == "qwen3:8b")
+    assert recommended["recommended"] is True
+    assert recommended["fit"] in {"ideal", "possible", "heavy"}
+
+    job = service.start_pull(bridge["id"], "qwen3:8b")
+    deadline = time.monotonic() + 3
+    while time.monotonic() < deadline:
+        current = service.list_pulls(bridge["id"])[0]
+        if current["status"] not in {"queued", "downloading", "verifying"}:
+            break
+        time.sleep(0.02)
+    assert current["status"] == "completed"
+    assert current["progress"] == 100.0
+    assert current["total"] == 100
+    assert json.loads(service.pulls_path.read_text(encoding="utf-8"))[0]["status"] == "completed"