⚠ LIVE-MODUS — Orders werden mit echtem Geld ausgeführt.
Training
@@ -131,11 +152,12 @@ async function refresh() {
["%", r => `${num(r.pnl_pct * 100)}`],
["Konfidenz", r => num(r.entry_confidence)], ["Bars", r => r.bars_held]],
(s.recent_trades || []).slice().reverse());
+ renderTrading(s.trading || {});
renderTraining(s.training || {});
} catch (e) { document.getElementById("sub").textContent = "Status nicht erreichbar: " + e; }
}
-// ---------------------------------------------------------------- Training
+// ---------------------------------------------------------------- Steuerung
const $ = id => document.getElementById(id);
let barsTouched = false;
$("bars").addEventListener("input", () => { barsTouched = true; });
@@ -158,6 +180,51 @@ async function post(path, body) {
return data;
}
+let lastTrading = {};
+function renderTrading(t) {
+ lastTrading = t;
+ if (!t.control_enabled) return;
+ $("trading-section").hidden = false;
+ $("live-banner").hidden = t.simulated !== false;
+
+ const halted = !!t.halted;
+ $("trade-dot").className = "dot " + (halted ? "busy" : t.active ? "on" : "off");
+ $("trade-state").textContent = halted
+ ? "durch Risikoregel gestoppt"
+ : (t.active ? "läuft" : "pausiert") + (t.simulated ? " (simuliert)" : " (ECHTES GELD)");
+
+ const btn = $("trade-btn");
+ btn.textContent = t.active ? "Handel pausieren" : "Handel starten";
+ btn.className = (!t.active && !t.simulated) ? "danger" : (t.active ? "ghost" : "");
+ btn.disabled = false;
+
+ setHint($("trade-hint"), halted ? t.halt_reason : "", halted);
+ const bits = [];
+ if (!t.active) bits.push("Es werden keine neuen Positionen eröffnet. Marktdaten, Signalauswertung "
+ + "und Lernen laufen weiter, offene Positionen bleiben unter Stop-Überwachung.");
+ if (t.paused_signals) bits.push(`${t.paused_signals} Signal(e) während der Pause nur gelernt.`);
+ if (t.open_positions) bits.push(`${t.open_positions} Position(en) offen.`);
+ if (!t.autostart) bits.push("Autostart ist aus – nach einem Neustart muss neu gestartet werden.");
+ $("trade-detail").textContent = bits.join(" ");
+}
+
+$("trade-btn").addEventListener("click", async () => {
+ const turnOn = !lastTrading.active;
+ const body = { enabled: turnOn };
+ if (turnOn && lastTrading.requires_confirmation) {
+ const phrase = lastTrading.confirmation_phrase || "";
+ const answer = prompt(
+ "LIVE-MODUS: Es werden Orders mit echtem Geld ausgeführt.\n\n"
+ + "Zum Bestätigen exakt eingeben:\n" + phrase);
+ if (answer === null) return;
+ body.confirm = answer;
+ }
+ $("trade-btn").disabled = true;
+ try { await post("control/trading", body); setHint($("trade-hint"), ""); }
+ catch (e) { setHint($("trade-hint"), e.message, true); }
+ refresh();
+});
+
function renderTraining(t) {
if (!t.control_enabled) return;
$("training-section").hidden = false;
@@ -268,6 +335,8 @@ class StatusServer:
web.get("/control/training", self._training_state),
web.post("/control/train/history", self._train_history),
web.post("/control/train/live", self._train_live),
+ web.get("/control/trading", self._trading_state),
+ web.post("/control/trading", self._set_trading),
]
)
return app
@@ -376,6 +445,37 @@ class StatusServer:
result = self._controller.set_online_learning(payload["enabled"])
return web.json_response(result, status=200 if result.get("accepted") else 409, dumps=_dumps)
+ async def _trading_state(self, request: web.Request) -> web.Response:
+ denied = await self._guard(request)
+ if denied is not None:
+ return denied
+ assert self._controller is not None
+ return web.json_response(self._controller.trading_control_status(), dumps=_dumps)
+
+ async def _set_trading(self, request: web.Request) -> web.Response:
+ denied = await self._guard(request)
+ if denied is not None:
+ return denied
+ assert self._controller is not None
+
+ try:
+ payload = await request.json()
+ except ValueError:
+ return web.json_response({"error": "Ungültiges JSON"}, status=400)
+ if not isinstance(payload, dict) or not isinstance(payload.get("enabled"), bool):
+ return web.json_response({"error": "'enabled' (true/false) wird erwartet"}, status=400)
+
+ confirm = payload.get("confirm")
+ if confirm is not None and not isinstance(confirm, str):
+ return web.json_response({"error": "'confirm' muss eine Zeichenkette sein"}, status=400)
+
+ result = self._controller.set_trading(payload["enabled"], confirm)
+ if result.get("accepted"):
+ return web.json_response(result, status=200, dumps=_dumps)
+ # Fehlende Live-Bestätigung ist kein Konflikt, sondern eine unvollständige Anfrage.
+ status = 428 if result.get("requires_confirmation") and payload["enabled"] else 409
+ return web.json_response(result, status=status, dumps=_dumps)
+
async def _metrics(self, _: web.Request) -> web.Response:
state = self._status()
samples: list[tuple[str, float]] = []
diff --git a/tests/test_control.py b/tests/test_control.py
index 928c4a8..e92aa7a 100644
--- a/tests/test_control.py
+++ b/tests/test_control.py
@@ -8,8 +8,12 @@ import numpy as np
import pytest
from aiohttp import web
-from trademind.config import Config, ServerConfig
-from trademind.features import N_FEATURES
+from trademind.app import _guard_control_exposure
+from trademind.backtest import BacktestRunner
+from trademind.config import LIVE_CONFIRMATION_PHRASE, Config, ServerConfig
+from trademind.engine import LIVE_TRADING_CONFIRMATION, Bar
+from trademind.features import N_FEATURES, compute_features
+from trademind.models import ExitReason, Side
from trademind.server import TOKEN_HEADER, StatusServer
from .conftest import make_candles
@@ -200,6 +204,136 @@ async def test_control_disabled_rejects_commands(base_config):
assert engine.set_online_learning(False)["accepted"] is False
+# ------------------------------------------------------ Automatisierter Handel
+
+
+def trading_config(base_config: Config, **trading: object) -> Config:
+ return Config.model_validate(
+ {**control_config(base_config).model_dump(), "trading": trading}
+ )
+
+
+async def test_trading_is_active_by_default(base_config):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+ assert engine.trading_active is True
+ assert engine.trading_control_status()["simulated"] is True
+
+
+async def test_autostart_false_starts_paused(base_config):
+ engine = build_engine(trading_config(base_config, autostart=False), feed=StaticFeed())
+ await engine.prepare()
+ assert engine.trading_active is False
+
+
+async def test_trading_can_be_paused_and_resumed(base_config):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+
+ assert engine.set_trading(False)["active"] is False
+ assert engine.trading_active is False
+ assert engine.set_trading(True)["active"] is True
+ assert engine.trading_active is True
+
+
+async def test_repeated_state_is_accepted_without_change(base_config):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+ result = engine.set_trading(True)
+ assert result["accepted"] is True
+ assert "bereits" in result["reason"]
+
+
+async def test_paused_bot_opens_no_positions(base_config):
+ engine = build_engine(trading_config(base_config, autostart=False))
+ await engine.prepare()
+ await BacktestRunner(engine, {"BTC/USDT": cyclical_series()}, progress_every=0).run()
+
+ assert engine.portfolio.trades == []
+ assert engine.portfolio.positions == {}
+ assert engine.paused_signals > 0, "es hätte Signale geben müssen, die nur gelernt wurden"
+
+
+async def test_paused_bot_keeps_learning(base_config):
+ """Kern der Anforderung: Pausiert fließen weiter Daten ins Modell."""
+ paused = build_engine(trading_config(base_config, autostart=False))
+ await paused.prepare()
+ await BacktestRunner(paused, {"BTC/USDT": cyclical_series()}, progress_every=0).run()
+
+ assert paused.strategy.learner.stats.samples_seen > 0
+ assert paused.strategy.learner.stats.shadow_samples > 0
+ assert paused.strategy.learner.stats.updates > 0
+ assert paused.strategy.candidates_seen > 0
+ # Ohne Trades gibt es logischerweise keine Trade-Labels, nur Shadow-Labels.
+ assert paused.strategy.learner.stats.trade_samples == 0
+
+
+async def test_active_bot_trades_on_the_same_data(base_config):
+ active = build_engine(control_config(base_config))
+ await active.prepare()
+ await BacktestRunner(active, {"BTC/USDT": cyclical_series()}, progress_every=0).run()
+ assert active.portfolio.stats.trades > 0
+
+
+async def test_pausing_keeps_stop_loss_active(base_config):
+ """Eine offene Position darf beim Pausieren nicht ungeschützt stehenbleiben."""
+ engine = build_engine(control_config(base_config))
+ await engine.prepare()
+ fill = await engine.broker.execute("BTC/USDT", Side.BUY, 0.05, 30_000.0)
+ engine.portfolio.open_position(
+ fill, stop_loss=29_500.0, take_profit=None,
+ features=np.ones(N_FEATURES), confidence=0.6, exploratory=False,
+ )
+ engine.set_trading(False)
+
+ snapshot = compute_features(cyclical_series(), base_config.strategy.rules)
+ bar = Bar(timestamp=1, open=29_600.0, high=29_700.0, low=29_000.0, close=29_400.0, volume=5.0)
+ await engine.process_bar("BTC/USDT", snapshot, bar)
+
+ assert engine.portfolio.positions == {}
+ assert engine.portfolio.trades[-1].exit_reason is ExitReason.STOP_LOSS
+
+
+async def test_live_mode_requires_confirmation(base_config, monkeypatch):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+ monkeypatch.setattr(type(engine.config), "is_simulated", property(lambda self: False))
+ engine.trading_active = False
+
+ denied = engine.set_trading(True)
+ assert denied["accepted"] is False
+ assert LIVE_TRADING_CONFIRMATION in denied["reason"]
+ assert engine.trading_active is False
+
+ assert engine.set_trading(True, "falsch")["accepted"] is False
+ assert engine.trading_active is False
+
+ ok = engine.set_trading(True, LIVE_TRADING_CONFIRMATION)
+ assert ok["accepted"] is True
+ assert engine.trading_active is True
+
+
+async def test_pausing_live_never_needs_confirmation(base_config, monkeypatch):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+ monkeypatch.setattr(type(engine.config), "is_simulated", property(lambda self: False))
+ assert engine.set_trading(False)["accepted"] is True
+
+
+async def test_paper_mode_needs_no_confirmation(base_config):
+ engine = build_engine(control_config(base_config), feed=StaticFeed())
+ await engine.prepare()
+ engine.set_trading(False)
+ assert engine.set_trading(True)["accepted"] is True
+
+
+async def test_trading_control_rejected_when_disabled(base_config):
+ engine = build_engine(control_config(base_config, enable_control=False), feed=StaticFeed())
+ await engine.prepare()
+ assert engine.set_trading(False)["accepted"] is False
+ assert engine.trading_active is True
+
+
# --------------------------------------------------------------- HTTP-Schicht
@@ -314,6 +448,111 @@ async def test_training_state_endpoint(client):
assert data["min_bars"] == 500
+async def test_http_trading_toggle(client):
+ http, engine = await client()
+ response = await http.post("/control/trading", json={"enabled": False})
+ assert response.status == 200
+ assert (await response.json())["active"] is False
+ assert engine.trading_active is False
+
+ state = await (await http.get("/control/trading")).json()
+ assert state["active"] is False
+ assert state["mode"] == "paper"
+
+
+async def test_http_trading_rejects_bad_payload(client):
+ http, _ = await client()
+ assert (await http.post("/control/trading", json={})).status == 400
+ assert (await http.post("/control/trading", json={"enabled": 1})).status == 400
+ assert (await http.post("/control/trading", json={"enabled": True, "confirm": 5})).status == 400
+
+
+async def test_http_trading_needs_token(client):
+ http, engine = await client(control_token="geheim")
+ assert (await http.post("/control/trading", json={"enabled": False})).status == 401
+ assert engine.trading_active is True
+
+ ok = await http.post(
+ "/control/trading", json={"enabled": False}, headers={TOKEN_HEADER: "geheim"}
+ )
+ assert ok.status == 200
+ assert engine.trading_active is False
+
+
+async def test_http_live_start_without_confirmation_returns_428(client, monkeypatch):
+ http, engine = await client()
+ monkeypatch.setattr(type(engine.config), "is_simulated", property(lambda self: False))
+ engine.trading_active = False
+
+ response = await http.post("/control/trading", json={"enabled": True})
+ assert response.status == 428
+ assert engine.trading_active is False
+
+ ok = await http.post(
+ "/control/trading", json={"enabled": True, "confirm": LIVE_TRADING_CONFIRMATION}
+ )
+ assert ok.status == 200
+ assert engine.trading_active is True
+
+
+async def test_status_and_dashboard_expose_trading(client):
+ http, _ = await client()
+ status = await (await http.get("/status")).json()
+ assert status["trading"]["active"] is True
+ assert status["trading"]["simulated"] is True
+
+ page = await (await http.get("/")).text()
+ assert "Automatisierter Handel" in page
+ assert "control/trading" in page
+ assert "LIVE-MODUS" in page
+
+
+# ------------------------------------------- Absicherung beim Zusammenbau
+
+
+def test_live_without_token_on_open_port_disables_control():
+ config = Config.model_validate(
+ {
+ "mode": "live",
+ "live_confirmation": LIVE_CONFIRMATION_PHRASE,
+ "exchange": {"api_key": "k", "api_secret": "s"},
+ "server": {"enabled": True, "host": "0.0.0.0", "enable_control": True},
+ }
+ )
+ guarded = _guard_control_exposure(config)
+ assert guarded.server.enable_control is False
+
+
+def test_live_with_token_keeps_control():
+ config = Config.model_validate(
+ {
+ "mode": "live",
+ "live_confirmation": LIVE_CONFIRMATION_PHRASE,
+ "exchange": {"api_key": "k", "api_secret": "s"},
+ "server": {"enabled": True, "host": "0.0.0.0", "enable_control": True,
+ "control_token": "geheim"},
+ }
+ )
+ assert _guard_control_exposure(config).server.enable_control is True
+
+
+def test_live_on_loopback_keeps_control():
+ config = Config.model_validate(
+ {
+ "mode": "live",
+ "live_confirmation": LIVE_CONFIRMATION_PHRASE,
+ "exchange": {"api_key": "k", "api_secret": "s"},
+ "server": {"enabled": True, "host": "127.0.0.1", "enable_control": True},
+ }
+ )
+ assert _guard_control_exposure(config).server.enable_control is True
+
+
+def test_paper_on_open_port_keeps_control(base_config):
+ config = control_config(base_config, host="0.0.0.0", enable_control=True)
+ assert _guard_control_exposure(config).server.enable_control is True
+
+
def test_server_app_builds_without_controller(base_config):
srv = StatusServer(ServerConfig(), lambda: {}, controller=None)
app = srv._build_app()