@qingflow-tech/qingflow-cli 1.1.41 → 1.1.43

package/src/qingflow_mcp/server_cloud.py

@@ -10,7 +10,13 @@ from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .cloud_auth import CloudAuthBroker
-from .cloud_context import current_cloud_context
+from .cloud_context import CloudMcpContext, current_call_platform, current_cloud_context
+from .cloud_oauth_proxy import (
+    CloudOAuthProxyConfig,
+    OAuthAccessTokenResolver,
+    OAuthProxyResponse,
+    OAuthServiceProxy,
+)
 from .config import get_cloud_http_allowed_hosts, get_cloud_http_host, get_cloud_http_port
 from .errors import QingflowApiError, is_auth_like_error
 from .server_app_builder import build_builder_server
@@ -18,6 +24,7 @@ from .server_app_user import build_user_server
 
 
 BUILDER_TOOL_PREFIX = "builder_"
+MAX_OAUTH_PROXY_BODY_BYTES = 64 * 1024
 
 
 ASGIApp = Callable[
@@ -36,11 +43,15 @@ class CloudMcpAuthApp:
         app: ASGIApp,
         broker: CloudAuthBroker,
         *,
+        oauth_proxy: OAuthServiceProxy | None = None,
+        oauth_token_resolver: OAuthAccessTokenResolver | None = None,
         allowed_hosts: list[str] | None = None,
         internal_host: str | None = None,
     ) -> None:
         self._app = app
         self._broker = broker
+        self._oauth_proxy = oauth_proxy
+        self._oauth_token_resolver = oauth_token_resolver
         self._allowed_hosts = [
             host.strip().lower()
             for host in (allowed_hosts if allowed_hosts is not None else get_cloud_http_allowed_hosts())
@@ -69,22 +80,65 @@ class CloudMcpAuthApp:
             await self._json_response(send, 200, {"status": "ok"})
             return
 
-        credential = self._extract_credential(scope)
-        if credential is None:
-            await self._json_response(
-                send,
-                401,
-                {
-                    "error": "missing_mcp_credential",
-                    "message": "Authorization: Bearer <mcp_credential> is required",
-                },
-            )
+        if self._oauth_proxy is not None:
+            backend_metadata_path = self._oauth_proxy.config.backend_metadata_path(path)
+            if backend_metadata_path is not None:
+                await self._proxy_oauth_metadata(
+                    scope,
+                    send,
+                    backend_metadata_path,
+                )
+                return
+            backend_oauth_path = self._oauth_proxy.config.backend_oauth_endpoint_path(path)
+            if backend_oauth_path is not None:
+                await self._proxy_oauth_endpoint(
+                    scope,
+                    receive,
+                    send,
+                    backend_oauth_path,
+                )
+                return
+
+        auth_value, explicit_credential, call_platform = self._extract_auth_value(scope)
+        if auth_value is None:
+            await self._authentication_required(send)
             return
 
+        use_oauth = (
+            not explicit_credential
+            and self._oauth_token_resolver is not None
+            and not auth_value.startswith("mcp_")
+        )
+        access_context: dict[str, Any] | None = None
         try:
-            cloud_context = await anyio.to_thread.run_sync(self._broker.resolve, credential)
+            if use_oauth:
+                assert self._oauth_token_resolver is not None
+                access_context = await anyio.to_thread.run_sync(
+                    self._broker.resolve_access_context,
+                    auth_value,
+                )
+                if access_context is not None:
+                    assert self._oauth_proxy is not None
+                    token_resource = str(access_context.get("resource") or "").strip()
+                    if token_resource != self._oauth_proxy.config.resource_url:
+                        raise QingflowApiError(
+                            category="auth",
+                            message="OAuth access token was issued for a different protected resource",
+                        )
+                cloud_context = await anyio.to_thread.run_sync(
+                    self._resolve_oauth_or_legacy_credential,
+                    auth_value,
+                )
+            else:
+                cloud_context = await anyio.to_thread.run_sync(
+                    self._broker.resolve,
+                    auth_value,
+                )
         except QingflowApiError as error:
             status = 401 if is_auth_like_error(error) else 500
+            if status == 401 and use_oauth:
+                await self._oauth_authentication_required(send, "invalid_token", error.message)
+                return
             await self._json_response(
                 send,
                 status,
@@ -97,30 +151,165 @@ class CloudMcpAuthApp:
             )
             return
 
-        token = current_cloud_context.set(cloud_context)
+        trusted_source = (
+            str(access_context.get("source_code") or "").strip()
+            if access_context is not None
+            else ""
+        )
+        if trusted_source:
+            call_platform = trusted_source
+        elif not call_platform:
+            call_platform = await anyio.to_thread.run_sync(
+                self._broker.resolve_call_platform,
+                cloud_context.token,
+            )
+
+        context_token = current_cloud_context.set(cloud_context)
+        call_platform_token = current_call_platform.set(call_platform)
         try:
             scope = _ensure_streamable_http_accept(scope)
             await self._app(scope, receive, send)
         finally:
-            current_cloud_context.reset(token)
+            current_call_platform.reset(call_platform_token)
+            current_cloud_context.reset(context_token)
 
-    def _extract_credential(self, scope: dict[str, Any]) -> str | None:
+    def _resolve_oauth_or_legacy_credential(self, auth_value: str) -> CloudMcpContext:
+        assert self._oauth_token_resolver is not None
+        try:
+            return self._oauth_token_resolver.resolve(auth_value)
+        except QingflowApiError as oauth_error:
+            if not is_auth_like_error(oauth_error):
+                raise
+            try:
+                return self._broker.resolve(auth_value)
+            except QingflowApiError:
+                raise oauth_error
+
+    def _extract_auth_value(self, scope: dict[str, Any]) -> tuple[str | None, bool, str]:
         headers = {
             key.decode("latin1").lower(): value.decode("latin1")
             for key, value in scope.get("headers", [])
         }
+        call_platform = headers.get("x-qf-callplatform", "").strip()
         authorization = headers.get("authorization", "")
         if authorization.lower().startswith("bearer "):
-            credential = authorization[7:].strip()
-            return credential or None
+            bearer_token = authorization[7:].strip()
+            return bearer_token or None, False, call_platform
         credential = headers.get("x-qingflow-client-id", "").strip()
-        return credential or None
+        return credential or None, True, call_platform
+
+    async def _authentication_required(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+    ) -> None:
+        if self._oauth_proxy is not None:
+            await self._oauth_authentication_required(
+                send,
+                "invalid_token",
+                "Authentication required",
+            )
+            return
+        await self._json_response(
+            send,
+            401,
+            {
+                "error": "missing_mcp_credential",
+                "message": "Authorization: Bearer <mcp_credential> is required",
+            },
+        )
+
+    async def _oauth_authentication_required(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        error: str,
+        description: str,
+    ) -> None:
+        assert self._oauth_proxy is not None
+        challenge = (
+            'Bearer realm="OAuth", '
+            f'error="{_escape_auth_param(error)}", '
+            f'error_description="{_escape_auth_param(description)}", '
+            f'resource_metadata="{self._oauth_proxy.config.resource_metadata_url}"'
+        )
+        await self._json_response(
+            send,
+            401,
+            {"error": error, "error_description": description},
+            extra_headers=[
+                (b"www-authenticate", challenge.encode("latin1", errors="replace")),
+                (b"cache-control", b"no-store"),
+                (b"pragma", b"no-cache"),
+            ],
+        )
+
+    async def _proxy_oauth_metadata(
+        self,
+        scope: dict[str, Any],
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        backend_path: str,
+    ) -> None:
+        assert self._oauth_proxy is not None
+        try:
+            response = await anyio.to_thread.run_sync(
+                self._oauth_proxy.request_metadata,
+                str(scope.get("method") or "GET"),
+                backend_path,
+                bytes(scope.get("query_string") or b""),
+            )
+        except QingflowApiError as error:
+            await self._json_response(
+                send,
+                502,
+                {"error": "oauth_service_unavailable", "message": error.message},
+            )
+            return
+        await self._raw_response(send, response)
+
+    async def _proxy_oauth_endpoint(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[[], Awaitable[dict[str, Any]]],
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        backend_path: str,
+    ) -> None:
+        assert self._oauth_proxy is not None
+        try:
+            body = await _read_request_body(receive, MAX_OAUTH_PROXY_BODY_BYTES)
+        except ValueError:
+            await self._json_response(
+                send,
+                413,
+                {
+                    "error": "invalid_request",
+                    "error_description": "OAuth request body is too large",
+                },
+            )
+            return
+        try:
+            response = await anyio.to_thread.run_sync(
+                self._oauth_proxy.request_oauth_endpoint,
+                str(scope.get("method") or "GET"),
+                backend_path,
+                bytes(scope.get("query_string") or b""),
+                body,
+                tuple(scope.get("headers") or ()),
+            )
+        except QingflowApiError as error:
+            await self._json_response(
+                send,
+                502,
+                {"error": "oauth_service_unavailable", "message": error.message},
+            )
+            return
+        await self._raw_response(send, response)
 
     async def _json_response(
         self,
         send: Callable[[dict[str, Any]], Awaitable[None]],
         status: int,
         payload: dict[str, Any],
+        *,
+        extra_headers: list[tuple[bytes, bytes]] | None = None,
     ) -> None:
         body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
         await send(
@@ -130,11 +319,26 @@ class CloudMcpAuthApp:
                 "headers": [
                     (b"content-type", b"application/json; charset=utf-8"),
                     (b"content-length", str(len(body)).encode("ascii")),
-                ],
+                ] + list(extra_headers or []),
             }
         )
         await send({"type": "http.response.body", "body": body})
 
+    async def _raw_response(
+        self,
+        send: Callable[[dict[str, Any]], Awaitable[None]],
+        response: OAuthProxyResponse,
+    ) -> None:
+        await send(
+            {
+                "type": "http.response.start",
+                "status": response.status_code,
+                "headers": list(response.headers)
+                + [(b"content-length", str(len(response.body)).encode("ascii"))],
+            }
+        )
+        await send({"type": "http.response.body", "body": response.body})
+
     async def _plain_response(
         self,
         send: Callable[[dict[str, Any]], Awaitable[None]],
@@ -176,12 +380,25 @@ def build_cloud_user_app() -> CloudMcpAuthApp:
 
 def build_cloud_app() -> CloudMcpAuthApp:
     server = build_combined_server()
-    broker = CloudAuthBroker.from_config(backend=BackendClient())
-    return CloudMcpAuthApp(server.streamable_http_app(), broker)
+    backend = BackendClient()
+    broker = CloudAuthBroker.from_config(backend=backend)
+    oauth_config = CloudOAuthProxyConfig.from_config()
+    oauth_proxy = OAuthServiceProxy(oauth_config) if oauth_config is not None else None
+    oauth_token_resolver = (
+        OAuthAccessTokenResolver.from_config(backend)
+        if oauth_config is not None
+        else None
+    )
+    return CloudMcpAuthApp(
+        server.streamable_http_app(),
+        broker,
+        oauth_proxy=oauth_proxy,
+        oauth_token_resolver=oauth_token_resolver,
+    )
 
 
 def build_combined_server() -> FastMCP:
-    server = build_user_server()
+    server = build_user_server(stateless_http=True)
     builder_server = build_builder_server()
     server._mcp_server.name = "Qingflow Combined MCP"
     _register_prefixed_builder_tools(server, builder_server)
@@ -237,6 +454,22 @@ def _extract_host(scope: dict[str, Any]) -> str:
     return ""
 
 
+async def _read_request_body(
+    receive: Callable[[], Awaitable[dict[str, Any]]],
+    limit: int,
+) -> bytes:
+    body = bytearray()
+    while True:
+        message = await receive()
+        if message.get("type") != "http.request":
+            return bytes(body)
+        body.extend(bytes(message.get("body") or b""))
+        if len(body) > limit:
+            raise ValueError("request body is too large")
+        if not message.get("more_body", False):
+            return bytes(body)
+
+
 def _is_allowed_host(host: str, allowed_hosts: list[str]) -> bool:
     normalized_host = host.strip().lower().rstrip(".")
     host_without_port = _strip_port(normalized_host)
@@ -308,6 +541,16 @@ def _ensure_streamable_http_accept(scope: dict[str, Any]) -> dict[str, Any]:
     return rewritten
 
 
+def _escape_auth_param(value: str) -> str:
+    return (
+        str(value or "")
+        .replace("\\", "\\\\")
+        .replace('"', '\\"')
+        .replace("\r", " ")
+        .replace("\n", " ")
+    )
+
+
 app = LazyCloudApp()
 
 

package/src/qingflow_mcp/tools/auth_tools.py

@@ -6,6 +6,7 @@ from typing import Any
 
 from mcp.server.fastmcp import FastMCP
 
+from ..auth_provider import CliSessionFacade
 from ..backend_client import BackendRequestContext, BackendResponse
 from ..cloud_context import current_cloud_context
 from ..config import (
@@ -16,6 +17,7 @@ from ..config import (
     normalize_base_url,
 )
 from ..errors import QingflowApiError, backend_code_int, is_auth_like_error, raise_tool_error
+from ..oauth_token_store import OAuthTokenBundle
 from ..session_store import SessionStore
 from .base import ToolBase
 
@@ -29,7 +31,7 @@ class AuthTools(ToolBase):
     3. 退出并清理当前 profile 会话。
     """
 
-    def __init__(self, sessions: SessionStore, backend) -> None:
+    def __init__(self, sessions: SessionStore | CliSessionFacade, backend) -> None:
         """执行内部辅助逻辑。"""
         super().__init__(sessions, backend)
         self.sessions.set_profile_refresher(self._refresh_profile_via_credential)
@@ -307,6 +309,130 @@ class AuthTools(ToolBase):
             ),
         }
 
+    def auth_use_oauth_token(
+        self,
+        *,
+        profile: str,
+        base_url: str,
+        qf_version: str | None,
+        issuer: str,
+        resource: str,
+        bundle: OAuthTokenBundle,
+    ) -> dict[str, Any]:
+        """使用 OAuth Token Bundle 建立 CLI 专用会话。"""
+        if not isinstance(self.sessions, CliSessionFacade):
+            raise_tool_error(QingflowApiError.config_error("OAuth login is only available in the Qingflow CLI."))
+        normalized_base_url = self._normalize_base_url(base_url)
+        normalized_qf_version, qf_version_source = self._resolve_qf_version_input(qf_version)
+        resolved_user_info, response_qf_version = self._fetch_user_info(
+            normalized_base_url,
+            bundle.access_token,
+            None,
+            qf_version=normalized_qf_version,
+            qf_version_source=qf_version_source,
+        )
+
+        last_workspace = resolved_user_info.get("lastWsInfo")
+        selected_ws_id = self._coerce_positive_int(
+            last_workspace.get("wsId") if isinstance(last_workspace, dict) else None
+        )
+        selected_ws_name = self._normalize_text(
+            (last_workspace.get("wsName") if isinstance(last_workspace, dict) else None)
+            or (last_workspace.get("workspaceName") if isinstance(last_workspace, dict) else None)
+            or (last_workspace.get("remark") if isinstance(last_workspace, dict) else None)
+        )
+        workspace_qf_version = (
+            self._workspace_system_version(last_workspace) if isinstance(last_workspace, dict) else None
+        )
+        if selected_ws_id is None:
+            fallback_workspace, fallback_qf_version = self._fetch_first_workspace(
+                normalized_base_url,
+                bundle.access_token,
+                qf_version=normalized_qf_version,
+                qf_version_source=qf_version_source,
+            )
+            if isinstance(fallback_workspace, dict):
+                selected_ws_id = self._coerce_positive_int(fallback_workspace.get("wsId"))
+                selected_ws_name = self._normalize_text(
+                    fallback_workspace.get("workspaceName")
+                    or fallback_workspace.get("wsName")
+                    or fallback_workspace.get("remark")
+                ) or selected_ws_name
+                workspace_qf_version = self._workspace_system_version(fallback_workspace) or fallback_qf_version
+        elif selected_ws_name is None or workspace_qf_version is None:
+            workspace = self._fetch_workspace_with_name_fallback(
+                normalized_base_url,
+                bundle.access_token,
+                selected_ws_id,
+                qf_version=normalized_qf_version,
+                qf_version_source=qf_version_source,
+            )
+            if isinstance(workspace, dict):
+                selected_ws_name = self._normalize_text(
+                    workspace.get("workspaceName")
+                    or workspace.get("wsName")
+                    or workspace.get("remark")
+                ) or selected_ws_name
+                workspace_qf_version = self._workspace_system_version(workspace) or workspace_qf_version
+
+        if workspace_qf_version is not None:
+            resolved_qf_version, resolved_qf_version_source = workspace_qf_version, "workspace_system_version"
+        else:
+            resolved_qf_version, resolved_qf_version_source = self._resolve_backend_qf_version(
+                response_qf_version,
+                fallback_qf_version=normalized_qf_version,
+                fallback_source=qf_version_source,
+            )
+        uid = self._coerce_positive_int(resolved_user_info.get("uid"))
+        if uid is None:
+            raise_tool_error(QingflowApiError(category="auth", message="Token validation did not return valid user info"))
+
+        state = self.sessions.activate_oauth(
+            profile=profile,
+            base_url=normalized_base_url,
+            qf_version=resolved_qf_version,
+            qf_version_source=resolved_qf_version_source,
+            uid=uid,
+            email=self._normalize_text(resolved_user_info.get("email")),
+            nick_name=self._normalize_text(
+                resolved_user_info.get("nickName")
+                or resolved_user_info.get("displayName")
+                or resolved_user_info.get("name")
+            ),
+            selected_ws_id=selected_ws_id,
+            selected_ws_name=selected_ws_name,
+            issuer=issuer,
+            resource=resource,
+            bundle=bundle,
+        )
+        return {
+            "profile": state.profile,
+            "base_url": state.base_url,
+            "qf_version": state.qf_version,
+            "qf_version_source": state.qf_version_source,
+            "uid": state.uid,
+            "email": state.email,
+            "nick_name": state.nick_name,
+            "selected_ws_id": state.selected_ws_id,
+            "selected_ws_name": state.selected_ws_name,
+            "suggested_ws_id": state.selected_ws_id,
+            "suggested_ws_name": state.selected_ws_name,
+            "persisted": True,
+            "active_auth_type": "oauth",
+            "auth_source": "oauth_pkce",
+            "source_code": state.source_code,
+            "access_expires_at": state.access_expires_at,
+            "request_route": self._request_route_payload(
+                BackendRequestContext(
+                    base_url=state.base_url or normalized_base_url,
+                    token=bundle.access_token,
+                    ws_id=state.selected_ws_id,
+                    qf_version=state.qf_version,
+                    qf_version_source=state.qf_version_source,
+                )
+            ),
+        }
+
     def _resolve_auth_inputs(
         self,
         *,
@@ -380,6 +506,14 @@ class AuthTools(ToolBase):
 
     def auth_whoami(self, *, profile: str = DEFAULT_PROFILE) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
+        if isinstance(self.sessions, CliSessionFacade) and self.sessions.oauth_state(profile) == "none":
+            return {
+                "profile": profile,
+                "active_auth_type": "none",
+                "auth_source": "none",
+                "persisted": False,
+            }
+
         def build_response(
             session_profile,  # type: ignore[no-untyped-def]
             backend_session,  # type: ignore[no-untyped-def]
@@ -439,6 +573,13 @@ class AuthTools(ToolBase):
                 "persisted": session_profile.persisted,
                 "request_route": self._request_route_payload(context),
             }
+            if isinstance(self.sessions, CliSessionFacade):
+                active_auth_type = self.sessions.active_auth_type(profile)
+                response["active_auth_type"] = active_auth_type
+                if active_auth_type == "oauth":
+                    response.update(self.sessions.oauth_details(profile))
+                else:
+                    response["auth_source"] = active_auth_type
             member_info, member_warnings = self._workspace_member_info(
                 session_profile=session_profile,
                 backend_session=backend_session,
@@ -468,8 +609,18 @@ class AuthTools(ToolBase):
                     return build_response(refreshed_profile, refreshed_backend_session, refreshed_context)
                 except QingflowApiError as refreshed_error:
                     self._handle_error(profile, refreshed_error)
+            if error.looks_like_invalid_token() and self._refresh_oauth_session(profile):
+                try:
+                    refreshed_profile, refreshed_backend_session, refreshed_context = self._require_context(
+                        profile,
+                        require_workspace=False,
+                    )
+                    return build_response(refreshed_profile, refreshed_backend_session, refreshed_context)
+                except QingflowApiError as refreshed_error:
+                    self._handle_error(profile, refreshed_error)
             if (
                 error.looks_like_invalid_token()
+                and not self._uses_oauth(profile)
                 and session_profile is not None
                 and backend_session is not None
                 and self._refresh_session_from_credential(
@@ -511,6 +662,17 @@ class AuthTools(ToolBase):
 
     def auth_logout(self, *, profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict[str, Any]:
         """执行认证与会话相关逻辑。"""
+        if isinstance(self.sessions, CliSessionFacade) and self.sessions.uses_oauth(profile):
+            warnings = self.sessions.oauth_logout(profile)
+            result: dict[str, Any] = {
+                "profile": profile,
+                "logged_out": True,
+                "forgot_persisted": True,
+                "active_auth_type": "none",
+            }
+            if warnings:
+                result["warnings"] = warnings
+            return result
         if not self.sessions.has_profile(profile):
             raise_tool_error(QingflowApiError.auth_required(profile))
         self.sessions.logout(profile, forget_persisted=forget_persisted)