258 lines
7.4 KiB
Python
258 lines
7.4 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import socket
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import time
|
|
import traceback
|
|
from typing import NoReturn
|
|
|
|
import httpx
|
|
import uvicorn
|
|
|
|
from traderai.config import edge_profile_dir, log_path
|
|
|
|
|
|
def resource_path(*parts: str) -> Path:
|
|
base = Path(getattr(sys, "_MEIPASS", Path(__file__).resolve().parent.parent))
|
|
return base.joinpath(*parts)
|
|
|
|
|
|
def main() -> None:
|
|
try:
|
|
_chdir_to_app_dir()
|
|
backend_port = _backend_port_from_args()
|
|
if backend_port is not None:
|
|
_run_server(backend_port)
|
|
return
|
|
_log("TraderAI desktop starting")
|
|
_log(f"cwd={Path.cwd()}")
|
|
_log(f"executable={sys.executable}")
|
|
_log(f"frozen={getattr(sys, 'frozen', False)} meipass={getattr(sys, '_MEIPASS', '')}")
|
|
port = _select_port()
|
|
url = f"http://127.0.0.1:{port}"
|
|
_log(f"selected_url={url}")
|
|
if _existing_server_ready(url):
|
|
_log("existing TraderAI backend found; opening window")
|
|
_open_window(url)
|
|
return
|
|
if getattr(sys, "frozen", False):
|
|
backend_process = _start_backend_process(port)
|
|
_log(f"backend process started pid={backend_process.pid}")
|
|
else:
|
|
server_thread = threading.Thread(target=_run_server, args=(port,), daemon=True)
|
|
server_thread.start()
|
|
_log("backend thread started")
|
|
_wait_for_server(url)
|
|
_log("backend health check passed")
|
|
_open_window(url)
|
|
_log("webview closed")
|
|
except Exception:
|
|
_log("fatal startup error")
|
|
_log(traceback.format_exc())
|
|
raise
|
|
|
|
|
|
def _chdir_to_app_dir() -> None:
|
|
if getattr(sys, "frozen", False):
|
|
os.chdir(Path(sys.executable).resolve().parent)
|
|
|
|
|
|
def _select_port() -> int:
|
|
preferred = int(os.getenv("TRADERAI_PORT", "8765"))
|
|
if _port_available(preferred):
|
|
return preferred
|
|
_log(f"preferred port {preferred} is in use")
|
|
return _free_port()
|
|
|
|
|
|
def _backend_port_from_args() -> int | None:
|
|
args = sys.argv[1:]
|
|
if len(args) >= 2 and args[0] == "--backend-port":
|
|
return int(args[1])
|
|
return None
|
|
|
|
|
|
def _start_backend_process(port: int) -> subprocess.Popen:
|
|
command = [sys.executable, "--backend-port", str(port)]
|
|
_log(f"starting backend subprocess: {' '.join(command)}")
|
|
kwargs: dict[str, object] = {}
|
|
if sys.platform == "win32":
|
|
kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
|
|
return subprocess.Popen(command, **kwargs)
|
|
|
|
|
|
def _port_available(port: int) -> bool:
|
|
try:
|
|
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
|
|
sock.bind(("127.0.0.1", port))
|
|
return True
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def _free_port() -> int:
|
|
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
|
|
sock.bind(("127.0.0.1", 0))
|
|
return int(sock.getsockname()[1])
|
|
|
|
|
|
def _existing_server_ready(url: str) -> bool:
|
|
try:
|
|
response = httpx.get(f"{url}/api/health", timeout=1)
|
|
return response.status_code < 500 and response.headers.get("content-type", "").startswith("application/json")
|
|
except httpx.HTTPError:
|
|
return False
|
|
|
|
|
|
def _run_server(port: int) -> NoReturn:
|
|
try:
|
|
_log(f"backend starting on port {port}")
|
|
if sys.platform == "win32" and hasattr(asyncio, "WindowsProactorEventLoopPolicy"):
|
|
asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
|
|
_log("set Windows Proactor event loop policy for subprocess-compatible backend")
|
|
from traderai.server import app
|
|
|
|
config = uvicorn.Config(
|
|
app,
|
|
host="127.0.0.1",
|
|
port=port,
|
|
log_level="info",
|
|
log_config=None,
|
|
lifespan="on",
|
|
)
|
|
server = uvicorn.Server(config)
|
|
server.run()
|
|
_log("backend server stopped")
|
|
raise SystemExit(0)
|
|
except BaseException:
|
|
_log("backend thread crashed")
|
|
_log(traceback.format_exc())
|
|
raise
|
|
|
|
|
|
def _wait_for_server(url: str) -> None:
|
|
deadline = time.monotonic() + 30
|
|
last_error = ""
|
|
while time.monotonic() < deadline:
|
|
try:
|
|
response = httpx.get(f"{url}/api/health", timeout=1)
|
|
_log(f"health probe status={response.status_code}")
|
|
if response.status_code < 500:
|
|
return
|
|
except httpx.HTTPError as exc:
|
|
last_error = str(exc)
|
|
_log(f"health probe failed: {last_error}")
|
|
time.sleep(0.25)
|
|
raise RuntimeError(f"TraderAI backend did not start within 30 seconds. {last_error}")
|
|
|
|
|
|
def _open_window(url: str) -> None:
|
|
mode = os.getenv("TRADERAI_DESKTOP_UI", "edge").casefold()
|
|
_log(f"ui_mode={mode}")
|
|
if mode == "webview":
|
|
_open_webview(url)
|
|
return
|
|
if _open_edge_app(url):
|
|
return
|
|
_open_browser(url)
|
|
|
|
|
|
def _open_webview(url: str) -> None:
|
|
_log("importing pywebview")
|
|
import webview
|
|
|
|
_log("creating pywebview window")
|
|
webview.create_window(
|
|
"TraderAI",
|
|
url,
|
|
width=1320,
|
|
height=860,
|
|
min_size=(980, 680),
|
|
text_select=True,
|
|
icon=str(resource_path("web", "art", "LBC_Logo.ico")),
|
|
)
|
|
_log("starting pywebview")
|
|
webview.start(gui="edgechromium", debug=False)
|
|
|
|
|
|
def _open_edge_app(url: str) -> bool:
|
|
edge = _edge_path()
|
|
if not edge:
|
|
_log("msedge not found; falling back to default browser")
|
|
return False
|
|
profile_dir = edge_profile_dir()
|
|
profile_dir.mkdir(parents=True, exist_ok=True)
|
|
command = [
|
|
str(edge),
|
|
f"--app={url}",
|
|
f"--user-data-dir={profile_dir}",
|
|
"--new-window",
|
|
"--no-first-run",
|
|
"--disable-features=Translate",
|
|
f"--app-icon={resource_path('web', 'art', 'LBC_Logo.ico')}",
|
|
]
|
|
_log(f"launching edge app: {' '.join(command)}")
|
|
process = subprocess.Popen(command)
|
|
_log(f"edge process id={process.pid}")
|
|
time.sleep(2)
|
|
if process.poll() is None:
|
|
process.wait()
|
|
_log("edge app process exited")
|
|
return True
|
|
_log(f"edge app process exited early code={process.returncode}; keeping backend alive")
|
|
_keep_alive()
|
|
return True
|
|
|
|
|
|
def _open_browser(url: str) -> None:
|
|
import webbrowser
|
|
|
|
_log(f"opening default browser at {url}")
|
|
webbrowser.open(url)
|
|
_keep_alive()
|
|
|
|
|
|
def _keep_alive() -> None:
|
|
_log("backend staying alive; close TraderAI from Task Manager if no app window owns this process")
|
|
while True:
|
|
time.sleep(60)
|
|
|
|
|
|
def _edge_path() -> Path | None:
|
|
edge = shutil.which("msedge")
|
|
if edge:
|
|
return Path(edge)
|
|
candidates = [
|
|
Path(os.environ.get("ProgramFiles", "")) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
|
|
Path(os.environ.get("ProgramFiles(x86)", "")) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
|
|
Path(os.environ.get("LocalAppData", "")) / "Microsoft" / "Edge" / "Application" / "msedge.exe",
|
|
]
|
|
for candidate in candidates:
|
|
if candidate.exists():
|
|
return candidate
|
|
return None
|
|
|
|
|
|
def _log(message: str) -> None:
|
|
try:
|
|
log_path = _log_path()
|
|
timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
|
|
with log_path.open("a", encoding="utf-8") as file:
|
|
file.write(f"[{timestamp}] {message}\n")
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _log_path() -> Path:
|
|
return log_path()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|