@josephyan/qingflow-cli 0.2.0-beta.69 → 0.2.0-beta.71

package/src/qingflow_mcp/tools/auth_tools.py

@@ -320,7 +320,7 @@ class AuthTools(ToolBase):
             )
             if refreshed_profile is not None:
                 session_profile = refreshed_profile
-        return {
+        response = {
             "profile": session_profile.profile,
             "base_url": session_profile.base_url,
             "qf_version": session_profile.qf_version,
@@ -333,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):
@@ -589,6 +597,256 @@ class AuthTools(ToolBase):
         )
         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,

package/src/qingflow_mcp/tools/import_tools.py

@@ -129,6 +129,25 @@ class ImportTools(ToolBase):
             import_id: str | None = None,
             process_id_str: str | None = None,
         ) -> dict[str, Any]:
+            selector_count = sum(
+                1
+                for item in (
+                    bool(_normalize_optional_text(process_id_str)),
+                    bool(_normalize_optional_text(import_id)),
+                    bool(str(app_key or "").strip()),
+                )
+                if item
+            )
+            if selector_count != 1:
+                return self._failed_status_result(
+                    error_code="CONFIG_ERROR",
+                    message="record_import_status_get accepts exactly one selector: process_id_str, import_id, or app_key",
+                    extra={
+                        "details": {
+                            "fix_hint": "Use `process_id_str` or `import_id` for a known import, or use only `app_key` to inspect the latest import in that app.",
+                        }
+                    },
+                )
             return self.record_import_status_get(
                 profile=profile,
                 app_key=app_key,
@@ -729,30 +748,62 @@ class ImportTools(ToolBase):
         self,
         *,
         profile: str,
-        app_key: str,
+        app_key: str = "",
         import_id: str | None = None,
         process_id_str: str | None = None,
     ) -> dict[str, Any]:
-        if not app_key.strip():
-            return self._failed_status_result(error_code="IMPORT_STATUS_AMBIGUOUS", message="app_key is required")
+        normalized_app_key = (app_key or "").strip()
+        normalized_import_id = _normalize_optional_text(import_id)
+        normalized_process_id = _normalize_optional_text(process_id_str)
+        if normalized_import_id and normalized_process_id:
+            return self._failed_status_result(
+                error_code="CONFIG_ERROR",
+                message="record_import_status_get accepts import_id or process_id_str, but not both at the same time",
+                extra={
+                    "details": {
+                        "fix_hint": "Use only one of `import_id` or `process_id_str`. You may pass `app_key` as an optional routing hint for direct method compatibility.",
+                    }
+                },
+            )
+        if not normalized_process_id and not normalized_import_id and not normalized_app_key:
+            return self._failed_status_result(
+                error_code="CONFIG_ERROR",
+                message="record_import_status_get requires at least one selector: process_id_str, import_id, or app_key",
+                extra={
+                    "details": {
+                        "fix_hint": "Use `process_id_str` or `import_id` for a known import, or use only `app_key` to inspect the latest import in that app.",
+                    }
+                },
+            )
 
         def runner(_session_profile, context):
             local_job = None
-            normalized_import_id = _normalize_optional_text(import_id)
-            normalized_process_id = _normalize_optional_text(process_id_str)
             if normalized_import_id:
                 local_job = self._job_store.get(normalized_import_id)
             if local_job is None and normalized_process_id:
                 matches = [item for item in self._job_store.list() if _normalize_optional_text(item.get("process_id_str")) == normalized_process_id]
                 local_job = matches[0] if len(matches) == 1 else None
+            resolved_app_key = normalized_app_key
+            if not resolved_app_key and isinstance(local_job, dict):
+                resolved_app_key = str(local_job.get("app_key") or "").strip()
+            if not resolved_app_key:
+                return self._failed_status_result(
+                    error_code="CONFIG_ERROR",
+                    message="record_import_status_get could not determine app_key from the provided selector",
+                    extra={
+                        "details": {
+                            "fix_hint": "Use the original `app_key`, or call import status with the latest-import mode: only `app_key`.",
+                        }
+                    },
+                )
             if local_job is None and not normalized_import_id and not normalized_process_id:
-                recent = [item for item in self._job_store.list() if str(item.get("app_key")) == app_key]
+                recent = [item for item in self._job_store.list() if str(item.get("app_key")) == resolved_app_key]
                 local_job = recent[0] if recent else None
             page = self.backend.request(
                 "GET",
                 context,
                 "/app/apply/dataImport/record",
-                params={"appKey": app_key, "pageNum": 1, "pageSize": 100},
+                params={"appKey": resolved_app_key, "pageNum": 1, "pageSize": 100},
             )
             records = _extract_import_records(page)
             matched_record, matched_by = _match_import_record(
@@ -785,6 +836,7 @@ class ImportTools(ToolBase):
             return {
                 "ok": True,
                 "status": _normalize_optional_text(matched_record.get("processStatus")) or "unknown",
+                "app_key": resolved_app_key,
                 "import_id": normalized_import_id or (local_job.get("import_id") if isinstance(local_job, dict) else None),
                 "process_id_str": normalized_process,
                 "matched_by": matched_by,

package/src/qingflow_mcp/tools/qingbi_report_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from uuid import uuid4
 
 from mcp.server.fastmcp import FastMCP
@@ -18,6 +19,37 @@ def _qingbi_base_url(base_url: str) -> str:
     return normalized[:-4] if normalized.endswith("/api") else normalized
 
 
+def _should_retry_qflow_base(error: QingflowApiError) -> bool:
+    return int(getattr(error, "backend_code", 0) or 0) == 81007
+
+
+def _should_retry_asos_data(error: QingflowApiError) -> bool:
+    backend_code = int(getattr(error, "backend_code", 0) or 0)
+    http_status = getattr(error, "http_status", None)
+    return backend_code in {44011, 81007} or http_status == 404
+
+
+def _coerce_tool_error(error: RuntimeError | QingflowApiError) -> QingflowApiError | None:
+    if isinstance(error, QingflowApiError):
+        return error
+    if not isinstance(error, RuntimeError):
+        return None
+    try:
+        payload = json.loads(str(error))
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    return QingflowApiError(
+        category=str(payload.get("category") or "runtime"),
+        message=str(payload.get("message") or str(error)),
+        backend_code=payload.get("backend_code"),
+        request_id=payload.get("request_id"),
+        http_status=payload.get("http_status"),
+        details=payload.get("details") if isinstance(payload.get("details"), dict) else None,
+    )
+
+
 class QingbiReportTools(ToolBase):
     def register(self, mcp: FastMCP) -> None:
         @mcp.tool()
@@ -127,7 +159,13 @@ class QingbiReportTools(ToolBase):
 
     def qingbi_report_get_base(self, *, profile: str, chart_id: str) -> JSONObject:
         self._require_chart_id(chart_id)
-        return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        try:
+            return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_qflow_base(error):
+                raise
+        return self._request(profile, "GET", f"/qingbi/charts/qflow/baseinfo/{chart_id}", chart_id=chart_id)
 
     def qingbi_report_update_base(self, *, profile: str, chart_id: str, payload: JSONObject) -> JSONObject:
         self._require_chart_id(chart_id)
@@ -155,16 +193,46 @@ class QingbiReportTools(ToolBase):
         page_size_y: int | None = None,
     ) -> JSONObject:
         self._require_chart_id(chart_id)
-        params = {"qfUUID": uuid4().hex}
-        if page_num is not None:
-            params["pageNum"] = page_num
-        if page_size is not None:
-            params["pageSize"] = page_size
+        params = {
+            "qfUUID": uuid4().hex,
+            # Match Qingflow's real BI/qflow read path defaults so a caller can
+            # fetch chart data without having to synthesize pagination first.
+            "pageNum": page_num if page_num is not None else 1,
+            "pageSize": page_size if page_size is not None else 20,
+        }
         if page_num_y is not None:
             params["pageNumY"] = page_num_y
         if page_size_y is not None:
             params["pageSizeY"] = page_size_y
-        return self._request(profile, "POST", f"/qingbi/charts/data/{chart_id}", chart_id=chart_id, params=params, json_body=payload)
+        try:
+            if payload:
+                return self._request(
+                    profile,
+                    "POST",
+                    f"/qingbi/charts/data/qflow/{chart_id}/detail",
+                    chart_id=chart_id,
+                    params=params,
+                    json_body=payload,
+                )
+            return self._request(
+                profile,
+                "GET",
+                f"/qingbi/charts/data/qflow/{chart_id}",
+                chart_id=chart_id,
+                params=params,
+            )
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_asos_data(error):
+                raise
+        return self._request(
+            profile,
+            "POST",
+            f"/qingbi/charts/data/qflow/{chart_id}/asos",
+            chart_id=chart_id,
+            params=params,
+            json_body=payload or {},
+        )
 
     def qingbi_report_delete(self, *, profile: str, chart_id: str) -> JSONObject:
         self._require_chart_id(chart_id)

package/src/qingflow_mcp/tools/record_tools.py

@@ -317,9 +317,6 @@ class RecordTools(ToolBase):
             limit: int = 50,
             strict_full: bool = True,
             view_id: str | None = None,
-            list_type: int | None = None,
-            view_key: str | None = None,
-            view_name: str | None = None,
             output_profile: str = "normal",
         ) -> JSONObject:
             return self.record_analyze(
@@ -332,9 +329,9 @@ class RecordTools(ToolBase):
                 limit=limit,
                 strict_full=strict_full,
                 view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
+                list_type=None,
+                view_key=None,
+                view_name=None,
                 output_profile=output_profile,
             )
 
@@ -354,9 +351,6 @@ class RecordTools(ToolBase):
             limit: int = 50,
             page: int = 1,
             view_id: str | None = None,
-            list_type: int | None = None,
-            view_key: str | None = None,
-            view_name: str | None = None,
             output_profile: str = "normal",
         ) -> JSONObject:
             return self.record_list(
@@ -368,9 +362,9 @@ class RecordTools(ToolBase):
                 limit=limit,
                 page=page,
                 view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
+                list_type=None,
+                view_key=None,
+                view_name=None,
                 output_profile=output_profile,
             )