✨ feat: 初步实现aide decide

aide-program/aide/decide/server.py

@@ -0,0 +1,202 @@
+"""HTTP 服务器生命周期管理。"""
+
+from __future__ import annotations
+
+import json
+import socket
+import time
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from aide.core import output
+from aide.core.config import ConfigManager
+from aide.decide.errors import DecideError
+from aide.decide.handlers import DecideHandlers, Response
+from aide.decide.storage import DecideStorage
+
+
+class DecideHTTPServer(HTTPServer):
+    """附带处理器实例的 HTTPServer。"""
+
+    def __init__(self, server_address, RequestHandlerClass, handlers: DecideHandlers):
+        self.handlers = handlers
+        super().__init__(server_address, RequestHandlerClass)
+
+
+class DecideServer:
+    """启动、监听与关闭 HTTP 服务。"""
+
+    def __init__(self, root, storage: DecideStorage):
+        self.root = root
+        self.storage = storage
+        self.port = 3721
+        self.timeout = 0
+        self.web_dir = root / "aide" / "decide" / "web"
+        self.should_close = False
+        self.close_reason: str | None = None
+        self.httpd: DecideHTTPServer | None = None
+
+    def start(self) -> bool:
+        try:
+            config = ConfigManager(self.root).load_config()
+            start_port = _get_int(config, "decide", "port", default=3721)
+            self.timeout = _get_int(config, "decide", "timeout", default=0)
+            end_port = start_port + 9
+            available = self._find_available_port(start_port)
+            if available is None:
+                output.err(f"无法启动服务: 端口 {start_port}-{end_port} 均被占用")
+                output.info("建议: 关闭占用端口的程序，或在配置中指定其他端口")
+                return False
+            self.port = available
+
+            handlers = DecideHandlers(
+                storage=self.storage,
+                web_dir=self.web_dir,
+                stop_callback=self.stop,
+            )
+            RequestHandler = self._build_request_handler(handlers)
+            self.httpd = DecideHTTPServer(("127.0.0.1", self.port), RequestHandler, handlers)
+            self.httpd.timeout = 1.0
+
+            output.info("Web 服务已启动")
+            output.info(f"请访问: http://localhost:{self.port}")
+            output.info("等待用户完成决策...")
+
+            self._serve_forever()
+
+            if self.close_reason == "completed":
+                output.ok("决策已完成")
+                return True
+            if self.close_reason == "timeout":
+                output.warn("服务超时，已自动关闭")
+                return True
+            if self.close_reason == "interrupted":
+                output.warn("服务已中断")
+                return True
+            return True
+        except DecideError as exc:
+            output.err(str(exc))
+            return False
+
+    def stop(self, reason: str) -> None:
+        if self.should_close:
+            return
+        self.should_close = True
+        self.close_reason = reason
+
+    def _find_available_port(self, start: int) -> int | None:
+        attempts = 10
+        for offset in range(attempts):
+            port = start + offset
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                try:
+                    sock.bind(("127.0.0.1", port))
+                    return port
+                except OSError:
+                    continue
+        return None
+
+    def _serve_forever(self) -> None:
+        if self.httpd is None:
+            return
+        deadline = None if self.timeout <= 0 else time.time() + self.timeout
+
+        try:
+            while not self.should_close:
+                if deadline is not None and time.time() >= deadline:
+                    self.stop("timeout")
+                    break
+                self.httpd.handle_request()
+        except KeyboardInterrupt:
+            self.stop("interrupted")
+        finally:
+            try:
+                self.httpd.server_close()
+            except Exception:
+                pass
+
+    def _build_request_handler(self, handlers: DecideHandlers):
+        server = self
+
+        class RequestHandler(BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.1"
+
+            def do_GET(self):
+                self._dispatch("GET")
+
+            def do_POST(self):
+                self._dispatch("POST")
+
+            def do_OPTIONS(self):
+                self._dispatch("OPTIONS")
+
+            def _dispatch(self, method: str) -> None:
+                length = self.headers.get("Content-Length")
+                body = b""
+                if method == "POST":
+                    try:
+                        content_length = int(length) if length else 0
+                    except ValueError:
+                        self._send_response(
+                            (400, handlers._cors_headers({"Content-Type": "application/json; charset=utf-8"}), b'{"error":"决策数据无效","detail":"无效的 Content-Length"}')
+                        )
+                        return
+                    if content_length > 1024 * 1024:
+                        self._send_response(
+                            (
+                                413,
+                                handlers._cors_headers({"Content-Type": "application/json; charset=utf-8"}),
+                                b'{"error":"请求体过大","detail":"单次提交限制 1MB"}',
+                            )
+                        )
+                        return
+                    body = self.rfile.read(content_length)
+
+                try:
+                    response = handlers.handle(method, self.path, body)
+                except Exception as exc:  # pragma: no cover - 兜底防御
+                    payload = (
+                        b'{"error":"服务器内部错误","detail":'
+                        + json.dumps(str(exc), ensure_ascii=False).encode("utf-8")
+                        + b"}"
+                    )
+                    response = (
+                        500,
+                        handlers._cors_headers({"Content-Type": "application/json; charset=utf-8"}),
+                        payload,
+                    )
+                self._send_response(response)
+
+                if server.should_close:
+                    # 已由 handlers 设置关闭标志，等待当前请求结束
+                    pass
+
+            def log_message(self, format: str, *args) -> None:  # noqa: A003
+                # 静默日志，避免干扰 CLI 输出
+                return
+
+            def _send_response(self, response: Response) -> None:
+                status, headers, body = response
+                self.send_response(status)
+                for key, value in headers.items():
+                    self.send_header(key, value)
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                if body:
+                    self.wfile.write(body)
+
+        return RequestHandler
+
+
+def _get_int(config: dict, section: str, key: str, default: int) -> int:
+    try:
+        section_data = config.get(section, {}) if isinstance(config, dict) else {}
+        value = section_data.get(key, default)
+        if isinstance(value, bool):
+            return default
+        if isinstance(value, (int, float)):
+            as_int = int(value)
+            return as_int if as_int >= 0 else default
+    except Exception:
+        return default
+    return default