@josephyan/qingflow-cli 0.2.0-beta.78 → 0.2.0-beta.79

package/src/qingflow_mcp/builder_facade/service.py

@@ -58,14 +58,17 @@ from .models import (
     PortalReadSummaryResponse,
     PortalSectionPatch,
     PublicDepartmentScopeMode,
+    PublicExternalVisibilityMode,
     PublicFieldType,
     PublicRelationMode,
     PublicChartType,
     PublicButtonTriggerAction,
+    PublicVisibilityMode,
     PublicViewType,
     PublicViewButtonConfigType,
     PublicViewButtonType,
     SchemaPlanRequest,
+    VisibilityPatch,
     ViewButtonBindingPatch,
     ViewUpsertPatch,
     ViewFilterOperator,
@@ -175,6 +178,16 @@ class RelationHydrationResult:
     degraded_expectations: list[dict[str, Any]] = field(default_factory=list)
 
 
+@dataclass(slots=True)
+class VisibilityResolutionError(Exception):
+    error_code: str
+    message: str
+    details: JSONObject = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        return self.message
+
+
 class AiBuilderFacade:
     def __init__(
         self,
@@ -272,12 +285,14 @@ class AiBuilderFacade:
         package_name: str,
         icon: str | None = None,
         color: str | None = None,
+        visibility: VisibilityPatch | None = None,
     ) -> JSONObject:
         requested = str(package_name or "").strip()
         normalized_args = {
             "package_name": requested,
             **({"icon": icon} if icon else {}),
             **({"color": color} if color else {}),
+            **({"visibility": visibility.model_dump(mode="json")} if visibility is not None else {}),
         }
         if not requested:
             return _failed(
@@ -292,6 +307,16 @@ class AiBuilderFacade:
             title=requested,
             fallback_icon_name="files-folder",
         )
+        try:
+            desired_auth = self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
+        except VisibilityResolutionError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details=error.details,
+                suggested_next_call=None,
+            )
         existing = self.package_resolve(profile=profile, package_name=requested)
         lookup_permission_blocked = None
         if existing.get("status") == "success":
@@ -327,7 +352,7 @@ class AiBuilderFacade:
         try:
             created = self.packages.package_create(
                 profile=profile,
-                payload={"tagName": requested, "tagIcon": desired_tag_icon},
+                payload={"tagName": requested, "tagIcon": desired_tag_icon, "auth": desired_auth},
             )
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
@@ -378,6 +403,169 @@ class AiBuilderFacade:
             "tag_id": tag_id,
             "tag_name": tag_name,
             "tag_icon": tag_icon,
+            "visibility": _public_visibility_from_member_auth(desired_auth),
+        }
+
+    def package_get(self, *, profile: str, tag_id: int) -> JSONObject:
+        normalized_args = {"tag_id": tag_id}
+        if _coerce_positive_int(tag_id) is None:
+            return _failed("TAG_ID_REQUIRED", "tag_id must be positive", normalized_args=normalized_args, suggested_next_call=None)
+        try:
+            detail_result = self.packages.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+            base_result = self.packages.package_get_base(profile=profile, tag_id=tag_id, include_raw=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PACKAGE_GET_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"tag_id": tag_id},
+                suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "tag_id": tag_id}},
+            )
+        detail = detail_result.get("result") if isinstance(detail_result.get("result"), dict) else {}
+        base = base_result.get("result") if isinstance(base_result.get("result"), dict) else {}
+        summary = detail_result.get("summary") if isinstance(detail_result.get("summary"), dict) else {}
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "read package detail",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": None,
+            "suggested_next_call": None,
+            "noop": False,
+            "warnings": [],
+            "verification": {"package_exists": True},
+            "verified": True,
+            "tag_id": _coerce_positive_int(detail.get("tagId") or base.get("tagId")) or tag_id,
+            "tag_name": str(detail.get("tagName") or base.get("tagName") or "").strip() or None,
+            "tag_icon": str(detail.get("tagIcon") or base.get("tagIcon") or "").strip() or None,
+            "publish_status": detail.get("publishStatus") if detail.get("publishStatus") is not None else base.get("publishStatus"),
+            "item_count": summary.get("itemCount"),
+            "item_preview": deepcopy(summary.get("itemPreview") or []),
+            "add_app_status": base.get("addAppStatus") if base.get("addAppStatus") is not None else summary.get("addAppStatus"),
+            "edit_app_status": base.get("editAppStatus") if base.get("editAppStatus") is not None else summary.get("editAppStatus"),
+            "del_app_status": base.get("delAppStatus") if base.get("delAppStatus") is not None else summary.get("delAppStatus"),
+            "edit_tag_status": base.get("editTagStatus") if base.get("editTagStatus") is not None else summary.get("editTagStatus"),
+            "visibility": _public_visibility_from_member_auth(base.get("auth") or detail.get("auth")),
+        }
+
+    def package_update(
+        self,
+        *,
+        profile: str,
+        tag_id: int,
+        package_name: str | None = None,
+        icon: str | None = None,
+        color: str | None = None,
+        visibility: VisibilityPatch | None = None,
+    ) -> JSONObject:
+        normalized_args = {
+            "tag_id": tag_id,
+            **({"package_name": package_name} if str(package_name or "").strip() else {}),
+            **({"icon": icon} if icon else {}),
+            **({"color": color} if color else {}),
+            **({"visibility": visibility.model_dump(mode="json")} if visibility is not None else {}),
+        }
+        if _coerce_positive_int(tag_id) is None:
+            return _failed("TAG_ID_REQUIRED", "tag_id must be positive", normalized_args=normalized_args, suggested_next_call=None)
+        try:
+            current = self.packages.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+            current_base = self.packages.package_get_base(profile=profile, tag_id=tag_id, include_raw=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PACKAGE_UPDATE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"tag_id": tag_id},
+                suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "tag_id": tag_id}},
+            )
+        raw_current = current.get("result") if isinstance(current.get("result"), dict) else {}
+        raw_current_base = current_base.get("result") if isinstance(current_base.get("result"), dict) else {}
+        current_name = str(raw_current.get("tagName") or "").strip() or None
+        desired_name = str(package_name or current_name or "").strip() or current_name or "未命名应用包"
+        desired_icon = encode_workspace_icon_with_defaults(
+            icon=icon,
+            color=color,
+            title=desired_name,
+            fallback_icon_name="files-folder",
+            existing_icon=str(raw_current.get("tagIcon") or raw_current_base.get("tagIcon") or "").strip() or None,
+        )
+        try:
+            desired_auth = (
+                self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
+                if visibility is not None
+                else deepcopy(raw_current_base.get("auth") or raw_current.get("auth") or default_member_auth())
+            )
+        except VisibilityResolutionError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details=error.details,
+                suggested_next_call=None,
+            )
+        try:
+            update_result = self.packages.package_update(
+                profile=profile,
+                tag_id=tag_id,
+                payload={"tagName": desired_name, "tagIcon": desired_icon, "auth": desired_auth},
+            )
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PACKAGE_UPDATE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"tag_id": tag_id},
+                suggested_next_call={"tool_name": "package_update", "arguments": {"profile": profile, **normalized_args}},
+            )
+        verification = self.package_get(profile=profile, tag_id=tag_id)
+        if verification.get("status") != "success":
+            return verification
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "updated package",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": update_result.get("request_id") if isinstance(update_result, dict) else None,
+            "suggested_next_call": None,
+            "noop": False,
+            "warnings": [],
+            "verification": {
+                "package_exists": True,
+                "visibility_verified": verification.get("visibility") == _public_visibility_from_member_auth(desired_auth),
+            },
+            "verified": True,
+            **{
+                key: deepcopy(value)
+                for key, value in verification.items()
+                if key
+                not in {
+                    "status",
+                    "error_code",
+                    "recoverable",
+                    "message",
+                    "normalized_args",
+                    "missing_fields",
+                    "allowed_values",
+                    "details",
+                    "request_id",
+                    "suggested_next_call",
+                    "noop",
+                    "warnings",
+                    "verification",
+                    "verified",
+                }
+            },
         }
 
     def solution_install(
@@ -789,6 +977,294 @@ class AiBuilderFacade:
 
         return {"member_uids": [item["uid"] for item in resolved], "member_entries": resolved, "issues": issues}
 
+    def _resolve_department_references(
+        self,
+        *,
+        profile: str,
+        dept_ids: list[int],
+        dept_names: list[str],
+    ) -> dict[str, Any]:
+        issues: list[dict[str, Any]] = []
+        resolved: list[dict[str, Any]] = []
+        seen_ids: set[int] = set()
+        listed = self.directory.directory_list_all_departments(
+            profile=profile,
+            parent_dept_id=None,
+            max_depth=20,
+            max_items=5000,
+        )
+        items = _extract_directory_items(listed)
+        by_id: dict[int, dict[str, Any]] = {}
+        by_name: dict[str, list[dict[str, Any]]] = {}
+        for item in items:
+            dept_id = _coerce_positive_int(item.get("deptId") or item.get("id"))
+            if dept_id is None:
+                continue
+            by_id[dept_id] = item
+            dept_name = str(item.get("deptName") or item.get("departName") or item.get("name") or "").strip()
+            if dept_name:
+                by_name.setdefault(dept_name, []).append(item)
+
+        def add_department(item: dict[str, Any], *, fallback_name: str | None = None) -> None:
+            dept_id = _coerce_positive_int(item.get("deptId") or item.get("id"))
+            if dept_id is None or dept_id in seen_ids:
+                return
+            resolved.append(
+                {
+                    "deptId": dept_id,
+                    "deptName": str(item.get("deptName") or item.get("departName") or item.get("name") or fallback_name or dept_id),
+                    "deptIcon": item.get("deptIcon"),
+                    "beingFrontendConfig": True,
+                }
+            )
+            seen_ids.add(dept_id)
+
+        for dept_id in dept_ids:
+            normalized = _coerce_positive_int(dept_id)
+            if normalized is None:
+                continue
+            add_department(by_id.get(normalized) or {"deptId": normalized}, fallback_name=str(normalized))
+
+        for dept_name in dept_names:
+            requested = str(dept_name or "").strip()
+            if not requested:
+                continue
+            exact = [item for item in (by_name.get(requested) or []) if isinstance(item, dict)]
+            if len(exact) != 1:
+                issues.append(
+                    {
+                        "kind": "department_name",
+                        "value": requested,
+                        "error_code": "AMBIGUOUS_DEPARTMENT" if len(exact) > 1 else "DEPARTMENT_NOT_FOUND",
+                        "matches": exact,
+                    }
+                )
+                continue
+            add_department(exact[0], fallback_name=requested)
+
+        return {"department_entries": resolved, "issues": issues}
+
+    def _resolve_external_member_references(
+        self,
+        *,
+        profile: str,
+        member_ids: list[int],
+        member_emails: list[str],
+    ) -> dict[str, Any]:
+        issues: list[dict[str, Any]] = []
+        resolved: list[dict[str, Any]] = []
+        seen_ids: set[int] = set()
+
+        def _external_member_id(item: dict[str, Any]) -> int | None:
+            return _coerce_positive_int(item.get("uid") or item.get("memberId") or item.get("id"))
+
+        def add_member(item: dict[str, Any], *, fallback_name: str | None = None) -> None:
+            member_id = _external_member_id(item)
+            if member_id is None or member_id in seen_ids:
+                return
+            resolved.append(
+                {
+                    "uid": member_id,
+                    "remark": item.get("remark") or item.get("nickName") or item.get("name") or fallback_name or str(member_id),
+                    "nickName": item.get("nickName") or item.get("name") or fallback_name or str(member_id),
+                    "email": item.get("email"),
+                    "headImg": item.get("headImg") or item.get("avatar"),
+                    "beingFrontendConfig": True,
+                }
+            )
+            seen_ids.add(member_id)
+
+        for member_id in member_ids:
+            normalized = _coerce_positive_int(member_id)
+            if normalized is not None and normalized not in seen_ids:
+                add_member({"uid": normalized}, fallback_name=str(normalized))
+
+        for member_email in member_emails:
+            requested = str(member_email or "").strip()
+            if not requested:
+                continue
+            listed = self.directory.directory_list_external_members(
+                profile=profile,
+                keyword=requested,
+                page_num=1,
+                page_size=100,
+                simple=True,
+            )
+            items = _extract_directory_items(listed)
+            exact = [
+                item
+                for item in items
+                if isinstance(item, dict) and str(item.get("email") or "").strip().lower() == requested.lower()
+            ]
+            if len(exact) != 1:
+                issues.append(
+                    {
+                        "kind": "external_member_email",
+                        "value": requested,
+                        "error_code": "AMBIGUOUS_EXTERNAL_MEMBER" if len(exact) > 1 else "EXTERNAL_MEMBER_NOT_FOUND",
+                        "matches": exact,
+                    }
+                )
+                continue
+            add_member(exact[0], fallback_name=requested)
+
+        return {"member_entries": resolved, "issues": issues}
+
+    def _raise_visibility_resolution_issues(self, issues: list[dict[str, Any]]) -> None:
+        if not issues:
+            return
+        first_issue = issues[0] if isinstance(issues[0], dict) else {}
+        error_code = str(first_issue.get("error_code") or "VISIBILITY_SUBJECT_NOT_FOUND")
+        raw_value = first_issue.get("value")
+        requested_value = str(raw_value or "").strip()
+        kind = str(first_issue.get("kind") or "subject")
+        if error_code.startswith("AMBIGUOUS_"):
+            public_code = "VISIBILITY_SUBJECT_AMBIGUOUS"
+            message = f"{kind} '{requested_value}' matched multiple visibility subjects"
+        elif error_code.endswith("_NOT_FOUND"):
+            public_code = "VISIBILITY_SUBJECT_NOT_FOUND"
+            message = f"{kind} '{requested_value}' was not found in the visibility directory"
+        else:
+            public_code = "VISIBILITY_SUBJECT_UNSUPPORTED"
+            message = f"{kind} visibility selector is unsupported"
+        raise VisibilityResolutionError(
+            public_code,
+            message,
+            details={"issues": issues},
+        )
+
+    def _compile_visibility_to_member_auth(
+        self,
+        *,
+        profile: str,
+        visibility: VisibilityPatch | None,
+    ) -> dict[str, Any]:
+        if visibility is None:
+            return default_member_auth()
+        if visibility.mode == PublicVisibilityMode.everyone:
+            auth = default_member_auth()
+            auth["type"] = "ALL"
+            auth["contactAuth"]["type"] = "WORKSPACE_ALL"
+            auth["externalMemberAuth"]["type"] = "WORKSPACE_ALL"
+            auth["contactAuth"]["authMembers"]["includeSubDeparts"] = None
+            auth["externalMemberAuth"]["authMembers"]["includeSubDeparts"] = None
+            return auth
+
+        member_resolution = self._resolve_member_references(
+            profile=profile,
+            member_uids=visibility.selectors.member_uids,
+            member_emails=visibility.selectors.member_emails,
+            member_names=visibility.selectors.member_names,
+        )
+        role_resolution = self._resolve_role_references(
+            profile=profile,
+            role_ids=visibility.selectors.role_ids,
+            role_names=visibility.selectors.role_names,
+        )
+        department_resolution = self._resolve_department_references(
+            profile=profile,
+            dept_ids=visibility.selectors.dept_ids,
+            dept_names=visibility.selectors.dept_names,
+        )
+        external_member_resolution = self._resolve_external_member_references(
+            profile=profile,
+            member_ids=visibility.external_selectors.member_ids,
+            member_emails=visibility.external_selectors.member_emails,
+        )
+        self._raise_visibility_resolution_issues(
+            [
+                *member_resolution["issues"],
+                *role_resolution["issues"],
+                *department_resolution["issues"],
+                *external_member_resolution["issues"],
+            ]
+        )
+
+        external_depart_entries: list[dict[str, Any]] = []
+        for dept_id in visibility.external_selectors.dept_ids:
+            normalized = _coerce_positive_int(dept_id)
+            if normalized is None:
+                continue
+            external_depart_entries.append(
+                {
+                    "deptId": normalized,
+                    "deptName": str(normalized),
+                    "beingFrontendConfig": True,
+                }
+            )
+
+        contact_auth_type = "WORKSPACE_ALL"
+        if visibility.mode == PublicVisibilityMode.specific:
+            contact_auth_type = "SPECIFIC"
+        external_auth_type = {
+            PublicExternalVisibilityMode.not_: "NOT",
+            PublicExternalVisibilityMode.workspace: "WORKSPACE_ALL",
+            PublicExternalVisibilityMode.specific: "SPECIFIC",
+        }[visibility.external_mode or PublicExternalVisibilityMode.not_]
+        return {
+            "type": "WORKSPACE",
+            "contactAuth": {
+                "type": contact_auth_type,
+                "authMembers": {
+                    "member": deepcopy(member_resolution["member_entries"]),
+                    "depart": deepcopy(department_resolution["department_entries"]),
+                    "role": deepcopy(role_resolution["role_entries"]),
+                    "dynamic": [],
+                    "includeSubDeparts": visibility.selectors.include_sub_departs,
+                },
+            },
+            "externalMemberAuth": {
+                "type": external_auth_type,
+                "authMembers": {
+                    "member": deepcopy(external_member_resolution["member_entries"]),
+                    "depart": deepcopy(external_depart_entries),
+                    "role": [],
+                    "dynamic": [],
+                    "includeSubDeparts": None,
+                },
+            },
+        }
+
+    def _compile_visibility_to_chart_visible_auth(
+        self,
+        *,
+        profile: str,
+        visibility: VisibilityPatch | None,
+    ) -> dict[str, Any]:
+        if visibility is None:
+            return qingbi_workspace_visible_auth()
+
+        member_auth = self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
+        workspace_type = str(member_auth.get("type") or "").strip().upper()
+        contact_auth = member_auth.get("contactAuth") if isinstance(member_auth.get("contactAuth"), dict) else {}
+        external_auth = member_auth.get("externalMemberAuth") if isinstance(member_auth.get("externalMemberAuth"), dict) else {}
+        contact_members = contact_auth.get("authMembers") if isinstance(contact_auth.get("authMembers"), dict) else {}
+        external_members = external_auth.get("authMembers") if isinstance(external_auth.get("authMembers"), dict) else {}
+        return {
+            "type": "all" if workspace_type == "ALL" else "ws",
+            "contactAuth": {
+                "type": "assign" if str(contact_auth.get("type") or "").strip().upper() == "SPECIFIC" else "all",
+                "authMembers": {
+                    "member": deepcopy(contact_members.get("member") or []),
+                    "depart": deepcopy(contact_members.get("depart") or []),
+                    "role": deepcopy(contact_members.get("role") or []),
+                    "includeSubDeparts": contact_members.get("includeSubDeparts"),
+                },
+            },
+            "externalMemberAuth": {
+                "type": {
+                    "NOT": "not",
+                    "WORKSPACE_ALL": "all",
+                    "SPECIFIC": "assign",
+                }.get(str(external_auth.get("type") or "").strip().upper(), "not"),
+                "authMembers": {
+                    "member": deepcopy(external_members.get("member") or []),
+                    "depart": deepcopy(external_members.get("depart") or []),
+                    "role": [],
+                },
+            },
+        }
+
     def _normalize_flow_nodes(
         self,
         *,
@@ -2117,6 +2593,7 @@ class AiBuilderFacade:
             app_key=app_key,
             title=state["base"].get("formTitle"),
             app_icon=str(state["base"].get("appIcon") or "").strip() or None,
+            visibility=_public_visibility_from_member_auth(state["base"].get("auth")),
             tag_ids=_coerce_int_list(state["base"].get("tagIds")),
             publish_status=state["base"].get("appPublishStatus"),
             field_count=len(parsed["fields"]),
@@ -2655,6 +3132,29 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             )
         charts = _summarize_charts(items)
+        chart_visibility_read_errors: list[dict[str, Any]] = []
+        for chart in charts:
+            chart_id = str(chart.get("chart_id") or "").strip()
+            if not chart_id:
+                continue
+            try:
+                base_info = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                chart_visibility_read_errors.append(
+                    {
+                        "chart_id": chart_id,
+                        "request_id": api_error.request_id,
+                        "http_status": api_error.http_status,
+                        "backend_code": api_error.backend_code,
+                    }
+                )
+                continue
+            chart["visibility_summary"] = _visibility_summary(
+                _public_visibility_from_chart_visible_auth(
+                    base_info.get("visibleAuth") if isinstance(base_info, dict) else None
+                )
+            )
         response = AppChartsReadResponse(
             app_key=resolved_app_key,
             charts=charts,
@@ -2668,12 +3168,24 @@ class AiBuilderFacade:
             "normalized_args": {"app_key": resolved_app_key},
             "missing_fields": [],
             "allowed_values": {},
-            "details": {},
+            "details": {"chart_visibility_read_errors": chart_visibility_read_errors} if chart_visibility_read_errors else {},
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "warnings": [] if list_source == "sorted" else [_warning("CHART_ORDER_UNVERIFIED", "chart summary order uses fallback listing and may not reflect saved chart sort order")],
-            "verification": {"app_exists": True, "chart_order_verified": list_source == "sorted", "chart_list_source": list_source},
+            "warnings": (
+                ([] if list_source == "sorted" else [_warning("CHART_ORDER_UNVERIFIED", "chart summary order uses fallback listing and may not reflect saved chart sort order")])
+                + (
+                    [_warning("CHART_VISIBILITY_READ_PARTIAL", "some chart base infos could not be read back; visibility_summary is incomplete for those charts")]
+                    if chart_visibility_read_errors
+                    else []
+                )
+            ),
+            "verification": {
+                "app_exists": True,
+                "chart_order_verified": list_source == "sorted",
+                "chart_list_source": list_source,
+                "chart_visibility_readback_complete": not chart_visibility_read_errors,
+            },
             "verified": True,
             **response.model_dump(mode="json"),
         }
@@ -2791,6 +3303,7 @@ class AiBuilderFacade:
             ],
             dash_icon=str(result.get("dashIcon") or "").strip() or None,
             hide_copyright=bool(result.get("hideCopyright")) if "hideCopyright" in result else None,
+            visibility=_public_visibility_from_member_auth(result.get("auth")),
             auth=deepcopy(result.get("auth")) if isinstance(result.get("auth"), dict) else {},
             config=deepcopy(result.get("config")) if isinstance(result.get("config"), dict) else {},
             dash_global_config=deepcopy(result.get("dashGlobalConfig")) if isinstance(result.get("dashGlobalConfig"), dict) else {},
@@ -2916,6 +3429,7 @@ class AiBuilderFacade:
         response = ViewGetResponse(
             view_key=view_key,
             base_info=base_info,
+            visibility=_public_visibility_from_member_auth(base_info.get("auth")),
             config=deepcopy(config) if isinstance(config, dict) else {},
             questions=questions,
             associations=associations,
@@ -2993,6 +3507,7 @@ class AiBuilderFacade:
         response = ChartGetResponse(
             chart_id=chart_id,
             base=deepcopy(base) if isinstance(base, dict) else {},
+            visibility=_public_visibility_from_chart_visible_auth(base.get("visibleAuth")),
             config=deepcopy(config) if isinstance(config, dict) else {},
         )
         return {
@@ -3453,6 +3968,7 @@ class AiBuilderFacade:
         app_name: str = "",
         icon: str | None = None,
         color: str | None = None,
+        visibility: VisibilityPatch | None = None,
         create_if_missing: bool = False,
         publish: bool = True,
         add_fields: list[FieldPatch],
@@ -3465,12 +3981,27 @@ class AiBuilderFacade:
             "app_name": app_name,
             "icon": icon,
             "color": color,
+            "visibility": visibility.model_dump(mode="json") if visibility is not None else None,
             "create_if_missing": create_if_missing,
             "publish": publish,
             "add_fields": [patch.model_dump(mode="json") for patch in add_fields],
             "update_fields": [patch.model_dump(mode="json") for patch in update_fields],
             "remove_fields": [patch.model_dump(mode="json") for patch in remove_fields],
         }
+        try:
+            desired_auth = (
+                self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
+                if visibility is not None
+                else None
+            )
+        except VisibilityResolutionError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details=error.details,
+                suggested_next_call=None,
+            )
         permission_outcomes: list[PermissionCheckOutcome] = []
         requested_field_changes = bool(add_fields or update_fields or remove_fields)
         resolved: JSONObject
@@ -3517,6 +4048,7 @@ class AiBuilderFacade:
                 package_tag_id=package_tag_id,
                 icon=icon,
                 color=color,
+                auth=desired_auth,
             )
             if resolved.get("status") == "failed":
                 if not isinstance(resolved.get("normalized_args"), dict) or not resolved.get("normalized_args"):
@@ -3534,7 +4066,7 @@ class AiBuilderFacade:
         requested_rename = requested_app_name if app_key else None
         requested_icon = str(icon or "").strip() or None
         requested_color = str(color or "").strip() or None
-        requested_app_base_update = bool(requested_rename or requested_icon or requested_color)
+        requested_app_base_update = bool(requested_rename or requested_icon or requested_color or desired_auth is not None)
         effective_app_name = target.app_name
         if not bool(resolved.get("created")):
             permission_outcome = self._guard_app_permission(
@@ -3554,6 +4086,7 @@ class AiBuilderFacade:
                     app_name=requested_rename,
                     icon=requested_icon,
                     color=requested_color,
+                    auth_override=desired_auth,
                     normalized_args=normalized_args,
                 )
                 if visual_result.get("status") == "failed":
@@ -4898,6 +5431,20 @@ class AiBuilderFacade:
             created_key: str | None = None
             system_view_list_type = _resolve_system_view_list_type(view_key=existing_key, view_name=patch.name) if existing_key else None
             operation_phase = "view_update" if existing_key else "view_create"
+            try:
+                view_auth_override = (
+                    self._compile_visibility_to_member_auth(profile=profile, visibility=patch.visibility)
+                    if patch.visibility is not None
+                    else None
+                )
+            except VisibilityResolutionError as error:
+                return _failed(
+                    error.error_code,
+                    error.message,
+                    normalized_args=normalized_args,
+                    details={"app_key": app_key, "view_name": patch.name, **error.details},
+                    suggested_next_call=None,
+                )
             try:
                 if existing_key:
                     payload = _build_view_update_payload(
@@ -4908,6 +5455,7 @@ class AiBuilderFacade:
                         patch=patch,
                         view_filters=translated_filters,
                         current_fields_by_name=current_fields_by_name,
+                        auth_override=view_auth_override,
                         explicit_button_dtos=explicit_button_dtos,
                     )
                     self.views.view_update(profile=profile, viewgraph_key=existing_key, payload=payload)
@@ -4976,6 +5524,7 @@ class AiBuilderFacade:
                             patch=patch,
                             view_filters=translated_filters,
                             current_fields_by_name=current_fields_by_name,
+                            auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                         )
                         self.views.view_update(profile=profile, viewgraph_key=created_key, payload=payload)
@@ -4988,6 +5537,7 @@ class AiBuilderFacade:
                             ordinal=ordinal,
                             view_filters=translated_filters,
                             current_fields_by_name=current_fields_by_name,
+                            auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                         )
                         create_result = self.views.view_create(profile=profile, payload=payload)
@@ -5034,6 +5584,7 @@ class AiBuilderFacade:
                                 ordinal=ordinal,
                                 view_filters=translated_filters,
                                 current_fields_by_name=current_fields_by_name,
+                                auth_override=view_auth_override,
                                 explicit_button_dtos=fallback_button_dtos,
                             )
                             self.views.view_update(profile=profile, viewgraph_key=target_key, payload=fallback_payload)
@@ -5118,6 +5669,7 @@ class AiBuilderFacade:
                             ordinal=ordinal,
                             view_filters=translated_filters,
                             current_fields_by_name=current_fields_by_name,
+                            auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                         )
                         self.views.view_create(profile=profile, payload=fallback_payload)
@@ -5691,6 +6243,11 @@ class AiBuilderFacade:
 
         for patch in request.upsert_charts:
             try:
+                chart_visible_auth = (
+                    self._compile_visibility_to_chart_visible_auth(profile=profile, visibility=patch.visibility)
+                    if patch.visibility is not None
+                    else None
+                )
                 existing = None
                 if patch.chart_id:
                     existing = existing_by_id.get(str(patch.chart_id))
@@ -5718,7 +6275,7 @@ class AiBuilderFacade:
                         "tagId": "0",
                         "parentId": "0",
                         "dataSourceId": app_key,
-                        "visibleAuth": qingbi_workspace_visible_auth(),
+                        "visibleAuth": deepcopy(chart_visible_auth if isinstance(chart_visible_auth, dict) else qingbi_workspace_visible_auth()),
                         "editAuthList": [],
                         "editAuthType": "ws",
                         "editAuthIncludeSubDept": True,
@@ -5751,7 +6308,7 @@ class AiBuilderFacade:
                     }
                     existing_by_id[chart_id] = deepcopy(created_chart)
                     existing_by_name.setdefault(patch.name, []).append(deepcopy(created_chart))
-                elif existing_name != patch.name or existing_type != target_type:
+                elif existing_name != patch.name or existing_type != target_type or isinstance(chart_visible_auth, dict):
                     base_info = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
                     self.charts.qingbi_report_update_base(
                         profile=profile,
@@ -5764,7 +6321,11 @@ class AiBuilderFacade:
                             "tagId": "0",
                             "parentId": "0",
                             "dataSourceId": base_info.get("dataSourceId") or app_key,
-                            "visibleAuth": deepcopy(base_info.get("visibleAuth") or qingbi_workspace_visible_auth()),
+                            "visibleAuth": deepcopy(
+                                chart_visible_auth
+                                if isinstance(chart_visible_auth, dict)
+                                else base_info.get("visibleAuth") or qingbi_workspace_visible_auth()
+                            ),
                             "editAuthList": deepcopy(base_info.get("editAuthList") or []),
                             "editAuthType": base_info.get("editAuthType") or "ws",
                             "editAuthIncludeSubDept": bool(base_info.get("editAuthIncludeSubDept", True)),
@@ -5791,6 +6352,10 @@ class AiBuilderFacade:
                     field_lookup=field_lookup,
                     qingbi_fields_by_id=qingbi_fields_by_id,
                 )
+                if isinstance(chart_visible_auth, dict):
+                    raw_data_config = config_payload.get("rawDataConfigDTO")
+                    if isinstance(raw_data_config, dict):
+                        raw_data_config["authInfo"] = deepcopy(chart_visible_auth)
                 self.charts.qingbi_report_update_config(profile=profile, chart_id=chart_id, payload=config_payload)
                 if existing is not None and chart_id not in updated_ids:
                     updated_ids.append(chart_id)
@@ -5816,7 +6381,7 @@ class AiBuilderFacade:
                         "status": "created" if existing is None else "updated",
                     }
                 )
-            except (QingflowApiError, RuntimeError, ValueError) as error:
+            except (QingflowApiError, RuntimeError, ValueError, VisibilityResolutionError) as error:
                 api_error = _coerce_api_error(error) if not isinstance(error, ValueError) else None
                 failure = {
                     "chart_id": str(locals().get("chart_id") or patch.chart_id or ""),
@@ -5966,10 +6531,27 @@ class AiBuilderFacade:
         creating = not dash_key
         verify_dash_name = creating or request.dash_name is not None
         verify_dash_icon = bool(request.icon or request.color)
-        verify_auth = request.auth is not None
+        verify_auth = request.visibility is not None or request.auth is not None
         verify_hide_copyright = request.hide_copyright is not None
         verify_dash_global_config = request.dash_global_config is not None
         verify_tags = creating or request.package_tag_id is not None
+        requested_visibility = request.visibility
+        if requested_visibility is None and isinstance(request.auth, dict) and request.auth:
+            requested_visibility = VisibilityPatch.model_validate(_public_visibility_from_member_auth(request.auth))
+        try:
+            desired_auth = (
+                self._compile_visibility_to_member_auth(profile=profile, visibility=requested_visibility)
+                if requested_visibility is not None
+                else None
+            )
+        except VisibilityResolutionError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details=error.details,
+                suggested_next_call=None,
+            )
         try:
             base_payload = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") if dash_key else {}
         except (QingflowApiError, RuntimeError) as error:
@@ -6035,7 +6617,7 @@ class AiBuilderFacade:
                     package_tag_id=target_package_tag_id,
                     icon=request.icon,
                     color=request.color,
-                    auth=request.auth,
+                    auth=desired_auth,
                     hide_copyright=request.hide_copyright,
                     dash_global_config=request.dash_global_config,
                     config=request.config,
@@ -6059,7 +6641,7 @@ class AiBuilderFacade:
                 package_tag_id=target_package_tag_id,
                 icon=request.icon,
                 color=request.color,
-                auth=request.auth,
+                auth=desired_auth,
                 hide_copyright=request.hide_copyright,
                 dash_global_config=request.dash_global_config,
                 config=request.config,
@@ -6487,6 +7069,7 @@ class AiBuilderFacade:
         package_tag_id: int | None,
         icon: str | None,
         color: str | None,
+        auth: dict[str, Any] | None = None,
     ) -> JSONObject:
         payload: JSONObject = {
             "appName": app_name or "未命名应用",
@@ -6496,7 +7079,7 @@ class AiBuilderFacade:
                 title=app_name or "未命名应用",
                 fallback_icon_name="template",
             ),
-            "auth": default_member_auth(),
+            "auth": deepcopy(auth if isinstance(auth, dict) else default_member_auth()),
             "tagIds": [package_tag_id] if package_tag_id and package_tag_id > 0 else [],
         }
         try:
@@ -6564,8 +7147,9 @@ class AiBuilderFacade:
         raw_base: dict[str, Any],
         form_title: str,
         app_icon: str,
+        auth_override: dict[str, Any] | None = None,
     ) -> JSONObject | None:
-        auth = deepcopy(raw_base.get("auth"))
+        auth = deepcopy(auth_override if isinstance(auth_override, dict) else raw_base.get("auth"))
         if not isinstance(auth, dict):
             return None
         payload: JSONObject = {
@@ -6587,6 +7171,7 @@ class AiBuilderFacade:
         app_name: str | None,
         icon: str | None,
         color: str | None,
+        auth_override: dict[str, Any] | None,
         normalized_args: dict[str, Any],
     ) -> JSONObject:
         try:
@@ -6604,6 +7189,7 @@ class AiBuilderFacade:
         effective_title = str(raw_base.get("formTitle") or fallback_title or "未命名应用").strip() or "未命名应用"
         desired_title = str(app_name or effective_title).strip() or effective_title
         existing_icon = str(raw_base.get("appIcon") or "").strip() or None
+        existing_auth = deepcopy(raw_base.get("auth")) if isinstance(raw_base.get("auth"), dict) else None
         desired_icon = encode_workspace_icon_with_defaults(
             icon=icon,
             color=color,
@@ -6611,7 +7197,8 @@ class AiBuilderFacade:
             fallback_icon_name="template",
             existing_icon=existing_icon,
         )
-        if desired_icon == existing_icon and desired_title == effective_title:
+        auth_changed = isinstance(auth_override, dict) and deepcopy(auth_override) != existing_auth
+        if desired_icon == existing_icon and desired_title == effective_title and not auth_changed:
             return {
                 "status": "success",
                 "updated": False,
@@ -6620,7 +7207,12 @@ class AiBuilderFacade:
                 "app_name_after": desired_title,
                 "request_id": None,
             }
-        payload = self._build_app_base_update_payload(raw_base=raw_base, form_title=desired_title, app_icon=desired_icon)
+        payload = self._build_app_base_update_payload(
+            raw_base=raw_base,
+            form_title=desired_title,
+            app_icon=desired_icon,
+            auth_override=auth_override,
+        )
         if payload is None:
             return _failed(
                 "APP_VISUAL_UPDATE_UNSUPPORTED",
@@ -7951,6 +8543,151 @@ def _verify_portal_readback(
     return not mismatches, mismatches
 
 
+def _empty_public_visibility_selectors(*, include_sub_departs: bool | None = None) -> dict[str, Any]:
+    payload = {
+        "member_uids": [],
+        "member_emails": [],
+        "member_names": [],
+        "dept_ids": [],
+        "dept_names": [],
+        "role_ids": [],
+        "role_names": [],
+    }
+    if include_sub_departs is not None:
+        payload["include_sub_departs"] = bool(include_sub_departs)
+    return payload
+
+
+def _empty_public_external_visibility_selectors() -> dict[str, Any]:
+    return {
+        "member_ids": [],
+        "member_emails": [],
+        "dept_ids": [],
+    }
+
+
+def _public_visibility_from_member_auth(raw_auth: Any) -> dict[str, Any]:
+    auth = raw_auth if isinstance(raw_auth, dict) and raw_auth else default_member_auth()
+    root_type = str(auth.get("type") or "").strip().upper()
+    contact_auth = auth.get("contactAuth") if isinstance(auth.get("contactAuth"), dict) else {}
+    external_auth = auth.get("externalMemberAuth") if isinstance(auth.get("externalMemberAuth"), dict) else {}
+    contact_members = contact_auth.get("authMembers") if isinstance(contact_auth.get("authMembers"), dict) else {}
+    external_members = external_auth.get("authMembers") if isinstance(external_auth.get("authMembers"), dict) else {}
+
+    selectors = _empty_public_visibility_selectors(include_sub_departs=contact_members.get("includeSubDeparts"))
+    for item in contact_members.get("member") or []:
+        if not isinstance(item, dict):
+            continue
+        uid = _coerce_positive_int(item.get("uid") or item.get("id"))
+        if uid is not None:
+            selectors["member_uids"].append(uid)
+        email = str(item.get("email") or "").strip()
+        if email:
+            selectors["member_emails"].append(email)
+        name = str(item.get("nickName") or item.get("remark") or item.get("name") or "").strip()
+        if name:
+            selectors["member_names"].append(name)
+    for item in contact_members.get("depart") or []:
+        if not isinstance(item, dict):
+            continue
+        dept_id = _coerce_positive_int(item.get("deptId") or item.get("id"))
+        if dept_id is not None:
+            selectors["dept_ids"].append(dept_id)
+        dept_name = str(item.get("deptName") or item.get("departName") or item.get("name") or "").strip()
+        if dept_name:
+            selectors["dept_names"].append(dept_name)
+    for item in contact_members.get("role") or []:
+        if not isinstance(item, dict):
+            continue
+        role_id = _coerce_positive_int(item.get("roleId") or item.get("id"))
+        if role_id is not None:
+            selectors["role_ids"].append(role_id)
+        role_name = str(item.get("roleName") or item.get("name") or "").strip()
+        if role_name:
+            selectors["role_names"].append(role_name)
+
+    external_selectors = _empty_public_external_visibility_selectors()
+    for item in external_members.get("member") or []:
+        if not isinstance(item, dict):
+            continue
+        member_id = _coerce_positive_int(item.get("uid") or item.get("memberId") or item.get("id"))
+        if member_id is not None:
+            external_selectors["member_ids"].append(member_id)
+        member_email = str(item.get("email") or "").strip()
+        if member_email:
+            external_selectors["member_emails"].append(member_email)
+    for item in external_members.get("depart") or []:
+        if not isinstance(item, dict):
+            continue
+        dept_id = _coerce_positive_int(item.get("deptId") or item.get("id"))
+        if dept_id is not None:
+            external_selectors["dept_ids"].append(dept_id)
+
+    if root_type == "ALL":
+        mode = PublicVisibilityMode.everyone.value
+        external_mode = PublicExternalVisibilityMode.workspace.value
+    else:
+        contact_type = str(contact_auth.get("type") or "").strip().upper()
+        external_type = str(external_auth.get("type") or "").strip().upper()
+        mode = PublicVisibilityMode.specific.value if contact_type == "SPECIFIC" else PublicVisibilityMode.workspace.value
+        external_mode = {
+            "WORKSPACE_ALL": PublicExternalVisibilityMode.workspace.value,
+            "SPECIFIC": PublicExternalVisibilityMode.specific.value,
+        }.get(external_type, PublicExternalVisibilityMode.not_.value)
+
+    return {
+        "mode": mode,
+        "selectors": selectors,
+        "external_mode": external_mode,
+        "external_selectors": external_selectors,
+    }
+
+
+def _public_visibility_from_chart_visible_auth(raw_auth: Any) -> dict[str, Any]:
+    auth = raw_auth if isinstance(raw_auth, dict) and raw_auth else qingbi_workspace_visible_auth()
+    root_type = str(auth.get("type") or "").strip().lower()
+    contact_auth = auth.get("contactAuth") if isinstance(auth.get("contactAuth"), dict) else {}
+    external_auth = auth.get("externalMemberAuth") if isinstance(auth.get("externalMemberAuth"), dict) else {}
+    contact_members = contact_auth.get("authMembers") if isinstance(contact_auth.get("authMembers"), dict) else {}
+    external_members = external_auth.get("authMembers") if isinstance(external_auth.get("authMembers"), dict) else {}
+    member_auth = {
+        "type": "ALL" if root_type == "all" else "WORKSPACE",
+        "contactAuth": {
+            "type": "SPECIFIC" if str(contact_auth.get("type") or "").strip().lower() == "assign" else "WORKSPACE_ALL",
+            "authMembers": {
+                "member": deepcopy(contact_members.get("member") or []),
+                "depart": deepcopy(contact_members.get("depart") or []),
+                "role": deepcopy(contact_members.get("role") or []),
+                "dynamic": [],
+                "includeSubDeparts": contact_members.get("includeSubDeparts"),
+            },
+        },
+        "externalMemberAuth": {
+            "type": {
+                "assign": "SPECIFIC",
+                "all": "WORKSPACE_ALL",
+            }.get(str(external_auth.get("type") or "").strip().lower(), "NOT"),
+            "authMembers": {
+                "member": deepcopy(external_members.get("member") or []),
+                "depart": deepcopy(external_members.get("depart") or []),
+                "role": [],
+                "dynamic": [],
+                "includeSubDeparts": None,
+            },
+        },
+    }
+    return _public_visibility_from_member_auth(member_auth)
+
+
+def _visibility_summary(visibility: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(visibility, dict):
+        return {}
+    return {
+        "mode": str(visibility.get("mode") or PublicVisibilityMode.workspace.value),
+        "external_mode": str(visibility.get("external_mode") or PublicExternalVisibilityMode.not_.value),
+    }
+
+
 def _mapping_contains(actual: Any, expected: Any) -> bool:
     if isinstance(expected, dict):
         if not isinstance(actual, dict):
@@ -11538,6 +12275,8 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
     summary = deepcopy(base)
     if not isinstance(config, dict) or not config:
         return summary
+    if isinstance(config.get("auth"), dict):
+        summary["visibility_summary"] = _visibility_summary(_public_visibility_from_member_auth(config.get("auth")))
     legacy_columns = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
     question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
     question_entries_by_id = {
@@ -12637,6 +13376,7 @@ def _build_view_create_payload(
     ordinal: int,
     view_filters: list[list[dict[str, Any]]],
     current_fields_by_name: dict[str, dict[str, Any]],
+    auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
 ) -> JSONObject:
     entity = _entity_spec_from_app(base_info=base_info, schema=schema, views=None)
@@ -12663,7 +13403,7 @@ def _build_view_create_payload(
     payload["ordinal"] = ordinal
     payload["viewgraphQueIds"] = visible_que_ids
     payload["viewgraphQuestions"] = _build_viewgraph_questions(schema, visible_que_ids)
-    payload["auth"] = default_member_auth()
+    payload["auth"] = deepcopy(auth_override if isinstance(auth_override, dict) else default_member_auth())
     payload.setdefault("sortType", "defaultSort")
     payload.setdefault("viewgraphSorts", [{"queId": 0, "beingSortAscend": True, "queType": 8}])
     if patch.type.value in {"card", "board", "gantt"}:
@@ -12829,6 +13569,7 @@ def _build_view_update_payload(
     patch: ViewUpsertPatch,
     view_filters: list[list[dict[str, Any]]],
     current_fields_by_name: dict[str, dict[str, Any]],
+    auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
 ) -> JSONObject:
     config_response = views.view_get_config(profile=profile, viewgraph_key=source_viewgraph_key)
@@ -12857,6 +13598,7 @@ def _build_view_update_payload(
     payload.pop("id", None)
 
     payload["viewgraphName"] = patch.name
+    payload["auth"] = deepcopy(auth_override if isinstance(auth_override, dict) else payload.get("auth") or default_member_auth())
     if "viewName" in payload:
         payload["viewName"] = patch.name
     payload["viewgraphQueIds"] = visible_que_id_values
@@ -12931,6 +13673,7 @@ def _build_minimal_view_payload(
     ordinal: int,
     view_filters: list[list[dict[str, Any]]],
     current_fields_by_name: dict[str, dict[str, Any]],
+    auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
 ) -> JSONObject:
     field_map = extract_field_map(schema)
@@ -12950,7 +13693,7 @@ def _build_minimal_view_payload(
         "ordinal": ordinal,
         "viewgraphQueIds": visible_que_id_values,
         "viewgraphQuestions": _build_viewgraph_questions(schema, visible_que_id_values),
-        "auth": default_member_auth(),
+        "auth": deepcopy(auth_override if isinstance(auth_override, dict) else default_member_auth()),
     }
     if patch.type.value in {"card", "board", "gantt"}:
         payload["beingShowTitleQue"] = True