@josephyan/qingflow-cli 0.2.0-beta.68 → 0.2.0-beta.70

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

@@ -155,16 +155,33 @@ 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)
+        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,
+        )
 
     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,
             )
 

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -139,21 +139,28 @@ class WorkspaceTools(ToolBase):
                     qf_version=workspace_qf_version,
                     qf_version_source="workspace_system_version",
                 )
+            active_context = BackendRequestContext(
+                base_url=session_profile.base_url,
+                token=context.token,
+                ws_id=session_profile.selected_ws_id,
+                qf_version=session_profile.qf_version,
+                qf_version_source=session_profile.qf_version_source,
+            )
+            workspace_version = self._workspace_version_summary(
+                self._fetch_workspace_account_info(active_context),
+                workspace_base_info=self._fetch_workspace_base_info(active_context),
+                workspace_detail=result,
+            )
             return {
                 "profile": profile,
                 "selected_ws_id": session_profile.selected_ws_id,
                 "selected_ws_name": session_profile.selected_ws_name,
                 "workspace": result,
+                "workspace_version": workspace_version,
                 "qf_version": session_profile.qf_version,
                 "qf_version_source": session_profile.qf_version_source,
                 "request_route": self.backend.describe_route(
-                    BackendRequestContext(
-                        base_url=session_profile.base_url,
-                        token=context.token,
-                        ws_id=session_profile.selected_ws_id,
-                        qf_version=session_profile.qf_version,
-                        qf_version_source=session_profile.qf_version_source,
-                    )
+                    active_context
                 ),
             }
 
@@ -189,6 +196,116 @@ class WorkspaceTools(ToolBase):
         normalized = str(value).strip()
         return normalized or None
 
+    def _fetch_workspace_base_info(self, context: BackendRequestContext) -> dict[str, Any] | None:
+        try:
+            payload = self.backend.request("GET", context, "/ws/baseInfo")
+        except QingflowApiError:
+            return None
+        return payload if isinstance(payload, dict) else None
+
+    def _fetch_workspace_account_info(self, context: BackendRequestContext) -> dict[str, Any] | None:
+        try:
+            payload = self.backend.request("GET", context, "/ws/account")
+        except QingflowApiError:
+            return None
+        return payload if isinstance(payload, dict) else None
+
+    def _workspace_version_summary(
+        self,
+        payload: Any,
+        *,
+        workspace_base_info: Any,
+        workspace_detail: Any,
+    ) -> dict[str, Any]:
+        account_info = payload if isinstance(payload, dict) else {}
+        base_info = workspace_base_info if isinstance(workspace_base_info, dict) else {}
+        detail_info = workspace_detail if isinstance(workspace_detail, dict) else {}
+        level_code = self._first_present_int(
+            account_info.get("accountLevel"),
+            base_info.get("accountLevel"),
+            detail_info.get("accountLevel"),
+        )
+        level_name = self._account_level_name(level_code)
+        return {
+            "level_code": level_code,
+            "level_name": level_name,
+            "display_name": self._account_level_display_name(level_name),
+            "being_trial": self._first_present_bool(
+                account_info.get("trial"),
+                base_info.get("trial"),
+                detail_info.get("trial"),
+            ),
+            "expire_date": self._first_present_value(
+                account_info.get("expireDate"),
+                base_info.get("expireDate"),
+                detail_info.get("expireDate"),
+            ),
+        }
+
+    def _account_level_name(self, level_code: int | None) -> str | None:
+        mapping = {
+            0: "FREE",
+            10: "AIR",
+            20: "BASIC",
+            30: "TEAM",
+            35: "PROFESSIONAL",
+            40: "ENTERPRISE",
+        }
+        return mapping.get(level_code)
+
+    def _account_level_display_name(self, level_name: str | None) -> str | None:
+        mapping = {
+            "FREE": "免费版",
+            "AIR": "Air版",
+            "BASIC": "Pro版",
+            "TEAM": "团队版",
+            "PROFESSIONAL": "专业版",
+            "ENTERPRISE": "企业版",
+        }
+        return mapping.get(level_name)
+
+    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 _coerce_bool(self, value: Any) -> bool | None:
+        if isinstance(value, bool):
+            return value
+        if value is None:
+            return None
+        normalized = str(value).strip().lower()
+        if normalized in {"true", "1"}:
+            return True
+        if normalized in {"false", "0"}:
+            return False
+        return None
+
+    def _first_present_int(self, *values: Any) -> int | None:
+        for value in values:
+            coerced = self._coerce_int(value)
+            if coerced is not None:
+                return coerced
+        return None
+
+    def _first_present_bool(self, *values: Any) -> bool | None:
+        for value in values:
+            coerced = self._coerce_bool(value)
+            if coerced is not None:
+                return coerced
+        return None
+
+    def _first_present_value(self, *values: Any) -> Any:
+        for value in values:
+            if value is not None:
+                return value
+        return None
+
     def workspace_set_plugin_status(
         self,
         *,