@josephyan/qingflow-app-builder-mcp 0.2.0-beta.7 → 0.2.0-beta.71

package/src/qingflow_mcp/tools/auth_tools.py

@@ -307,11 +307,20 @@ class AuthTools(ToolBase):
 
     def auth_whoami(self, *, profile: str = DEFAULT_PROFILE) -> dict[str, Any]:
         try:
-            session_profile, _, context = self._require_context(profile, require_workspace=False)
+            session_profile, backend_session, context = self._require_context(profile, require_workspace=False)
         except QingflowApiError as error:
             self._handle_error(profile, error)
             raise AssertionError("unreachable")
-        return {
+        if self._should_refresh_identity_metadata(session_profile):
+            refreshed_profile = self._refresh_identity_metadata(
+                profile=profile,
+                session_profile=session_profile,
+                backend_session=backend_session,
+                context=context,
+            )
+            if refreshed_profile is not None:
+                session_profile = refreshed_profile
+        response = {
             "profile": session_profile.profile,
             "base_url": session_profile.base_url,
             "qf_version": session_profile.qf_version,
@@ -324,6 +333,14 @@ class AuthTools(ToolBase):
             "persisted": session_profile.persisted,
             "request_route": self._request_route_payload(context),
         }
+        member_info, member_warnings = self._workspace_member_info(
+            session_profile=session_profile,
+            backend_session=backend_session,
+        )
+        response.update(member_info)
+        if member_warnings:
+            response["warnings"] = member_warnings
+        return response
 
     def auth_logout(self, *, profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict[str, Any]:
         if not self.sessions.has_profile(profile):
@@ -520,6 +537,385 @@ class AuthTools(ToolBase):
             "qf_version_source": context.qf_version_source or ("context" if context.qf_version else "unknown"),
         }
 
+    def _should_refresh_identity_metadata(self, session_profile) -> bool:  # type: ignore[no-untyped-def]
+        return (
+            session_profile.uid == 0
+            or session_profile.email is None
+            or session_profile.nick_name is None
+            or session_profile.selected_ws_name is None
+        )
+
+    def _refresh_identity_metadata(
+        self,
+        *,
+        profile: str,
+        session_profile,  # type: ignore[no-untyped-def]
+        backend_session,  # type: ignore[no-untyped-def]
+        context: BackendRequestContext,
+    ):
+        try:
+            user_info, _ = self._fetch_user_info(
+                session_profile.base_url,
+                backend_session.token,
+                session_profile.selected_ws_id,
+                qf_version=session_profile.qf_version,
+                qf_version_source=session_profile.qf_version_source,
+            )
+        except QingflowApiError:
+            return None
+
+        ws_name = session_profile.selected_ws_name
+        if session_profile.selected_ws_id is not None:
+            workspace = self._fetch_workspace_with_name_fallback(
+                session_profile.base_url,
+                backend_session.token,
+                session_profile.selected_ws_id,
+                qf_version=session_profile.qf_version,
+                qf_version_source=session_profile.qf_version_source,
+            )
+            if isinstance(workspace, dict):
+                ws_name = (
+                    str(workspace.get("workspaceName") or workspace.get("wsName") or workspace.get("remark") or "").strip()
+                    or ws_name
+                )
+        email = user_info["email"] if "email" in user_info else session_profile.email
+        nick_name = (
+            user_info.get("nickName")
+            or user_info.get("displayName")
+            or user_info.get("name")
+            or session_profile.nick_name
+        )
+
+        uid = user_info.get("uid")
+        refreshed = self.sessions.update_profile_metadata(
+            profile,
+            uid=int(uid) if uid is not None else session_profile.uid,
+            email=email,
+            nick_name=nick_name,
+            selected_ws_id=session_profile.selected_ws_id,
+            selected_ws_name=ws_name,
+        )
+        return refreshed
+
+    def _workspace_member_info(
+        self,
+        *,
+        session_profile,  # type: ignore[no-untyped-def]
+        backend_session,  # type: ignore[no-untyped-def]
+    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+        default_payload = {
+            "departments": [],
+            "roles": [],
+            "permission_level": None,
+        }
+        ws_id = session_profile.selected_ws_id
+        if ws_id is None:
+            return default_payload, []
+
+        context = BackendRequestContext(
+            base_url=backend_session.base_url,
+            token=backend_session.token,
+            ws_id=ws_id,
+            qf_version=backend_session.qf_version,
+            qf_version_source=backend_session.qf_version_source,
+        )
+        permission_level = self._resolve_permission_level(
+            self._workspace_auth(context, ws_id=ws_id)
+        )
+        payload = dict(default_payload)
+        payload["permission_level"] = permission_level
+
+        member = self._lookup_current_member(
+            context=context,
+            uid=session_profile.uid,
+            email=session_profile.email,
+            nick_name=session_profile.nick_name,
+        )
+        if member is None:
+            return payload, [
+                {
+                    "code": "CURRENT_MEMBER_PROFILE_UNAVAILABLE",
+                    "message": (
+                        "auth_whoami could not resolve current member departments and roles "
+                        f"in workspace {ws_id}."
+                    ),
+                }
+            ]
+
+        payload["departments"] = self._compact_departments(member)
+        payload["roles"] = self._compact_roles(member)
+        return payload, []
+
+    def _workspace_auth(self, context: BackendRequestContext, *, ws_id: int) -> int | None:
+        workspace = self._fetch_workspace_auth_from_detail(context, ws_id=ws_id)
+        if workspace is not None:
+            return workspace
+        return self._fetch_workspace_auth_from_list(context, ws_id=ws_id)
+
+    def _fetch_workspace_auth_from_detail(self, context: BackendRequestContext, *, ws_id: int) -> int | None:
+        try:
+            workspace = self.backend.request("GET", context, f"/user/workspace/{ws_id}")
+        except QingflowApiError:
+            return None
+        if not isinstance(workspace, dict):
+            return None
+        return self._coerce_auth_value(workspace.get("auth"))
+
+    def _fetch_workspace_auth_from_list(self, context: BackendRequestContext, *, ws_id: int) -> int | None:
+        try:
+            payload = self.backend.request(
+                "POST",
+                context,
+                "/user/workspaceList/pageQuery",
+                json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2, 3]},
+            )
+        except QingflowApiError:
+            return None
+        workspaces = payload.get("list") if isinstance(payload, dict) else []
+        if not isinstance(workspaces, list):
+            return None
+        for item in workspaces:
+            if not isinstance(item, dict) or item.get("wsId") != ws_id:
+                continue
+            return self._coerce_auth_value(item.get("auth"))
+        return None
+
+    def _lookup_current_member(
+        self,
+        *,
+        context: BackendRequestContext,
+        uid: int | None,
+        email: str | None,
+        nick_name: str | None,
+    ) -> dict[str, Any] | None:
+        candidates: list[dict[str, Any]] = []
+        for keyword in (email, nick_name):
+            member = self._search_member_once(context, uid=uid, keyword=keyword)
+            if member is not None:
+                return member
+            if keyword:
+                candidates.extend(self._search_member_items(context, keyword=keyword))
+        if uid is not None and uid > 0:
+            for item in candidates:
+                if self._same_member(item, uid=uid):
+                    return item
+            return self._search_member_once(context, uid=uid, keyword=None)
+        return None
+
+    def _search_member_once(
+        self,
+        context: BackendRequestContext,
+        *,
+        uid: int | None,
+        keyword: str | None,
+    ) -> dict[str, Any] | None:
+        for item in self._search_member_items(context, keyword=keyword):
+            if self._same_member(item, uid=uid):
+                return item
+        return None
+
+    def _search_member_items(self, context: BackendRequestContext, *, keyword: str | None) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"pageNum": 1, "pageSize": 100, "containDisable": True}
+        normalized_keyword = str(keyword or "").strip()
+        if normalized_keyword:
+            params["keyword"] = normalized_keyword
+        try:
+            payload = self.backend.request("GET", context, "/contact", params=params)
+        except QingflowApiError:
+            return []
+        items = self._extract_items(payload)
+        return [item for item in items if isinstance(item, dict)]
+
+    def _same_member(self, item: dict[str, Any], *, uid: int | None) -> bool:
+        if uid is None or uid <= 0:
+            return False
+        for key in ("uid", "id", "userId"):
+            value = item.get(key)
+            if value is None:
+                continue
+            coerced = self._coerce_int(value)
+            if coerced is not None and coerced == uid:
+                return True
+            if str(value).strip() == str(uid):
+                return True
+        return False
+
+    def _compact_departments(self, member: dict[str, Any]) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        seen: set[tuple[int | None, str | None]] = set()
+        for depart in self._walk_nested_items(member.get("departs")):
+            if not isinstance(depart, dict):
+                continue
+            dept_id = self._coerce_int(
+                depart.get("deptId", depart.get("departId", depart.get("id")))
+            )
+            dept_name = self._normalize_text(
+                depart.get("deptName", depart.get("departName", depart.get("name")))
+            )
+            key = (dept_id, dept_name)
+            if key in seen or (dept_id is None and dept_name is None):
+                continue
+            seen.add(key)
+            item = {"dept_id": dept_id, "dept_name": dept_name}
+            items.append({k: v for k, v in item.items() if v is not None})
+        return items
+
+    def _compact_roles(self, member: dict[str, Any]) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        seen: set[tuple[int | None, str | None]] = set()
+        for role in self._walk_nested_items(member.get("roles")):
+            if not isinstance(role, dict):
+                continue
+            role_id = self._coerce_int(role.get("roleId", role.get("id")))
+            role_name = self._normalize_text(role.get("roleName", role.get("name")))
+            key = (role_id, role_name)
+            if key in seen or (role_id is None and role_name is None):
+                continue
+            seen.add(key)
+            item = {"role_id": role_id, "role_name": role_name}
+            items.append({k: v for k, v in item.items() if v is not None})
+        return items
+
+    def _resolve_permission_level(self, auth_code: int | None) -> str | None:
+        mapping = {
+            2: "超级管理",
+            1: "系统管理员",
+            3: "子管理员",
+            0: "基本成员",
+        }
+        return mapping.get(auth_code)
+
+    def _coerce_auth_value(self, value: Any) -> int | None:
+        coerced = self._coerce_int(value)
+        if coerced is not None:
+            return coerced
+        normalized = self._normalize_text(value)
+        if normalized is None:
+            return None
+        lowered = normalized.lower()
+        if lowered in {"creator", "workspaccreator", "workspacecreator"}:
+            return 2
+        if lowered in {"admin", "administrator"}:
+            return 1
+        if lowered in {"subadmin", "dataadmin"}:
+            return 3
+        if lowered in {"member", "visitor", "normal"}:
+            return 0
+        return None
+
+    def _extract_items(self, payload: Any) -> list[Any]:
+        if isinstance(payload, list):
+            return payload
+        if not isinstance(payload, dict):
+            return []
+        for key in ("list", "items", "rows", "result"):
+            value = payload.get(key)
+            if isinstance(value, list):
+                return value
+        for key in ("data", "page"):
+            nested = payload.get(key)
+            if isinstance(nested, list):
+                return nested
+            if isinstance(nested, dict):
+                for nested_key in ("list", "items", "rows", "result"):
+                    value = nested.get(nested_key)
+                    if isinstance(value, list):
+                        return value
+        return []
+
+    def _walk_nested_items(self, value: Any) -> list[Any]:
+        if isinstance(value, list):
+            items: list[Any] = []
+            for item in value:
+                items.extend(self._walk_nested_items(item))
+            return items
+        return [value]
+
+    def _coerce_int(self, value: Any) -> int | None:
+        if isinstance(value, bool) or value is None:
+            return None
+        if isinstance(value, int):
+            return value
+        try:
+            return int(str(value).strip())
+        except (TypeError, ValueError):
+            return None
+
+    def _normalize_text(self, value: Any) -> str | None:
+        if value is None:
+            return None
+        text = str(value).strip()
+        return text or None
+
+    def _fetch_workspace_with_name_fallback(
+        self,
+        base_url: str,
+        token: str,
+        ws_id: int,
+        *,
+        qf_version: str | None,
+        qf_version_source: str | None,
+    ) -> dict[str, Any] | None:
+        try:
+            workspace = self._fetch_workspace(
+                base_url,
+                token,
+                ws_id,
+                qf_version=qf_version,
+                qf_version_source=qf_version_source,
+            )
+        except QingflowApiError:
+            workspace = None
+        if isinstance(workspace, dict):
+            workspace_name = str(workspace.get("workspaceName") or workspace.get("wsName") or "").strip()
+            if workspace_name:
+                return workspace
+        try:
+            fallback = self._fetch_workspace_from_list(
+                base_url,
+                token,
+                ws_id,
+                qf_version=qf_version,
+                qf_version_source=qf_version_source,
+            )
+        except QingflowApiError:
+            fallback = None
+        return fallback or workspace
+
+    def _fetch_workspace_from_list(
+        self,
+        base_url: str,
+        token: str,
+        ws_id: int,
+        *,
+        qf_version: str | None,
+        qf_version_source: str | None,
+    ) -> dict[str, Any] | None:
+        payload = self.backend.request(
+            "POST",
+            BackendRequestContext(
+                base_url=base_url,
+                token=token,
+                ws_id=ws_id,
+                qf_version=qf_version,
+                qf_version_source=qf_version_source,
+            ),
+            "/user/workspaceList/pageQuery",
+            json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2]},
+        )
+        workspaces = payload.get("list") if isinstance(payload, dict) else []
+        if not isinstance(workspaces, list):
+            return None
+        found = next(
+            (
+                item
+                for item in workspaces
+                if isinstance(item, dict) and item.get("wsId") == ws_id
+            ),
+            None,
+        )
+        return found if isinstance(found, dict) else None
+
     def _fetch_public_key(self, base_url: str, *, qf_version: str | None) -> str | None:
         # Endpoints to try (order matters, lowercase 'pubkey' is for Public Cloud)
         endpoints = ["/user/pubkey", "/api/user/pubkey", "/user/publicKey", "/api/user/publicKey"]