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

package/src/qingflow_mcp/server_app_builder.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import json
+
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .config import DEFAULT_PROFILE
+from .response_trim import BUILDER_SERVER_METHOD_MAP, trim_error_response, trim_public_response, wrap_trimmed_methods
 from .session_store import SessionStore
 from .tools.ai_builder_tools import AiBuilderTools
 from .tools.auth_tools import AuthTools
@@ -12,6 +15,17 @@ from .tools.file_tools import FileTools
 from .tools.workspace_tools import WorkspaceTools
 
 
+def _config_failure(message: str, *, fix_hint: str) -> dict:
+    return {
+        "status": "failed",
+        "error_code": "CONFIG_ERROR",
+        "recoverable": True,
+        "message": message,
+        "details": {"fix_hint": fix_hint},
+        "verification": {},
+    }
+
+
 def build_builder_server() -> FastMCP:
     server = FastMCP(
         "Qingflow App Builder MCP",
@@ -21,7 +35,7 @@ def build_builder_server() -> FastMCP:
             "Follow the resource path resolve -> summary read -> apply -> attach -> publish_verify. "
             "Use builder_tool_contract when you need a machine-readable contract, aliases, allowed enums, or a minimal valid example for a public builder tool. "
             "If creating a new package may be appropriate, ask the user to confirm package creation before calling package_create; otherwise use package_resolve/package_list and app_resolve to locate resources, "
-            "app_read_summary/app_read_fields/app_read_layout_summary/app_read_views_summary/app_read_flow_summary/app_read_charts_summary/portal_read_summary for compact reads, "
+            "app_read_summary/app_read_fields/app_read_layout_summary/app_read_views_summary/app_read_flow_summary/app_read_charts_summary/portal_list/portal_get/portal_read_summary/view_get/chart_get for reads, "
             "member_search/role_search/role_create when workflow assignees must come from the directory or role catalog, preferring roles over explicit members unless the user explicitly names members, "
             "then app_schema_apply/app_layout_apply/app_flow_apply/app_views_apply/app_charts_apply/portal_apply to execute normalized patches; these apply tools perform planning, normalization, and dependency checks internally where applicable. Schema/layout/views noop requests skip publish, charts are immediate-live without publish and resolve targets by chart_id first then exact unique chart name, portal updates are replace-only and publish=false only guarantees draft/base-info updates, and flow should use publish=false whenever you only want draft/precheck behavior. "
             "Use package_attach_app to attach apps to packages, and app_publish_verify for explicit final publish verification. "
@@ -33,10 +47,10 @@ def build_builder_server() -> FastMCP:
     )
     sessions = SessionStore()
     backend = BackendClient()
-    auth = AuthTools(sessions, backend)
-    workspace = WorkspaceTools(sessions, backend)
-    files = FileTools(sessions, backend)
-    ai_builder = AiBuilderTools(sessions, backend)
+    auth = wrap_trimmed_methods(AuthTools(sessions, backend), BUILDER_SERVER_METHOD_MAP)
+    workspace = wrap_trimmed_methods(WorkspaceTools(sessions, backend), BUILDER_SERVER_METHOD_MAP)
+    files = wrap_trimmed_methods(FileTools(sessions, backend), BUILDER_SERVER_METHOD_MAP)
+    ai_builder = wrap_trimmed_methods(AiBuilderTools(sessions, backend), BUILDER_SERVER_METHOD_MAP)
     feedback = FeedbackTools(backend, mcp_side="App Builder MCP")
 
     @server.tool()
@@ -123,7 +137,45 @@ def build_builder_server() -> FastMCP:
             file_related_url=file_related_url,
         )
 
-    feedback.register(server)
+    @server.tool()
+    def feedback_submit(
+        category: str = "",
+        title: str = "",
+        description: str = "",
+        expected_behavior: str | None = None,
+        actual_behavior: str | None = None,
+        impact_scope: str | None = None,
+        tool_name: str | None = None,
+        app_key: str | None = None,
+        record_id: str | int | None = None,
+        workflow_node_id: str | int | None = None,
+        note: str | None = None,
+    ) -> dict:
+        try:
+            return trim_public_response(
+                "feedback_submit",
+                feedback.feedback_submit(
+                    category=category,
+                    title=title,
+                    description=description,
+                    expected_behavior=expected_behavior,
+                    actual_behavior=actual_behavior,
+                    impact_scope=impact_scope,
+                    tool_name=tool_name,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    note=note,
+                ),
+            )
+        except RuntimeError as exc:
+            try:
+                payload = json.loads(str(exc))
+            except json.JSONDecodeError:
+                raise
+            if isinstance(payload, dict):
+                raise RuntimeError(json.dumps(trim_error_response(payload), ensure_ascii=False)) from None
+            raise
 
     @server.tool()
     def package_list(profile: str = DEFAULT_PROFILE, trial_status: str = "all") -> dict:
@@ -194,9 +246,8 @@ def build_builder_server() -> FastMCP:
         profile: str = DEFAULT_PROFILE,
         tag_id: int = 0,
         app_key: str = "",
-        app_title: str = "",
     ) -> dict:
-        return ai_builder.package_attach_app(profile=profile, tag_id=tag_id, app_key=app_key, app_title=app_title)
+        return ai_builder.package_attach_app(profile=profile, tag_id=tag_id, app_key=app_key)
 
     @server.tool()
     def app_release_edit_lock_if_mine(
@@ -219,6 +270,19 @@ def build_builder_server() -> FastMCP:
         app_name: str = "",
         package_tag_id: int | None = None,
     ) -> dict:
+        has_app_key = bool((app_key or "").strip())
+        has_app_name = bool((app_name or "").strip())
+        has_package_tag_id = package_tag_id is not None
+        if has_app_key and (has_app_name or has_package_tag_id):
+            return _config_failure(
+                "app_resolve accepts exactly one selector mode.",
+                fix_hint="Use only `app_key`, or use `app_name` together with `package_tag_id`.",
+            )
+        if not has_app_key and not (has_app_name and has_package_tag_id):
+            return _config_failure(
+                "app_resolve requires either app_key, or app_name together with package_tag_id.",
+                fix_hint="For an existing known app, pass `app_key`. For package-scoped lookup, pass both `app_name` and `package_tag_id`.",
+            )
         return ai_builder.app_resolve(profile=profile, app_key=app_key, app_name=app_name, package_tag_id=package_tag_id)
 
     @server.tool()
@@ -270,6 +334,18 @@ def build_builder_server() -> FastMCP:
     def app_read_charts_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
         return ai_builder.app_read_charts_summary(profile=profile, app_key=app_key)
 
+    @server.tool()
+    def portal_list(profile: str = DEFAULT_PROFILE) -> dict:
+        return ai_builder.portal_list(profile=profile)
+
+    @server.tool()
+    def portal_get(
+        profile: str = DEFAULT_PROFILE,
+        dash_key: str = "",
+        being_draft: bool = True,
+    ) -> dict:
+        return ai_builder.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
+
     @server.tool()
     def portal_read_summary(
         profile: str = DEFAULT_PROFILE,
@@ -278,6 +354,30 @@ def build_builder_server() -> FastMCP:
     ) -> dict:
         return ai_builder.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft)
 
+    @server.tool()
+    def view_get(profile: str = DEFAULT_PROFILE, viewgraph_key: str = "") -> dict:
+        return ai_builder.view_get(profile=profile, viewgraph_key=viewgraph_key)
+
+    @server.tool()
+    def chart_get(
+        profile: str = DEFAULT_PROFILE,
+        chart_id: str = "",
+        data_payload: dict | None = None,
+        page_num: int | None = None,
+        page_size: int | None = None,
+        page_num_y: int | None = None,
+        page_size_y: int | None = None,
+    ) -> dict:
+        return ai_builder.chart_get(
+            profile=profile,
+            chart_id=chart_id,
+            data_payload=data_payload or {},
+            page_num=page_num,
+            page_size=page_size,
+            page_num_y=page_num_y,
+            page_size_y=page_size_y,
+        )
+
     @server.tool()
     def app_schema_apply(
         profile: str = DEFAULT_PROFILE,
@@ -293,6 +393,21 @@ def build_builder_server() -> FastMCP:
         update_fields: list[dict] | None = None,
         remove_fields: list[dict] | None = None,
     ) -> dict:
+        has_app_key = bool((app_key or "").strip())
+        has_app_name = bool((app_name or "").strip())
+        has_app_title = bool((app_title or "").strip())
+        has_package_tag_id = package_tag_id is not None
+        if has_app_key:
+            if create_if_missing or has_app_name or has_package_tag_id or has_app_title:
+                return _config_failure(
+                    "app_schema_apply edit mode only accepts app_key as the resource selector.",
+                    fix_hint="For existing apps, pass `app_key` only. For create mode, use `package_tag_id + app_name + create_if_missing=true`.",
+                )
+        elif not (create_if_missing and has_package_tag_id and has_app_name):
+            return _config_failure(
+                "app_schema_apply create mode requires package_tag_id, app_name, and create_if_missing=true.",
+                fix_hint="Use `app_key` for existing apps, or pass `package_tag_id + app_name + create_if_missing=true` to create a new app.",
+            )
         return ai_builder.app_schema_apply(
             profile=profile,
             app_key=app_key,
@@ -383,6 +498,19 @@ def build_builder_server() -> FastMCP:
         dash_global_config: dict | None = None,
         config: dict | None = None,
     ) -> dict:
+        has_dash_key = bool((dash_key or "").strip())
+        has_dash_name = bool((dash_name or "").strip())
+        has_package_tag_id = package_tag_id is not None
+        if has_dash_key and has_package_tag_id:
+            return _config_failure(
+                "portal_apply accepts exactly one selector mode.",
+                fix_hint="Use `dash_key` to update an existing portal, or use `package_tag_id + dash_name` to create a new portal.",
+            )
+        if not has_dash_key and not (has_package_tag_id and has_dash_name):
+            return _config_failure(
+                "portal_apply requires either dash_key, or package_tag_id together with dash_name.",
+                fix_hint="Use `dash_key` for an existing portal. For create mode, pass `package_tag_id + dash_name`.",
+            )
         return ai_builder.portal_apply(
             profile=profile,
             dash_key=dash_key,

package/src/qingflow_mcp/server_app_user.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import json
 from datetime import date
 
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .config import DEFAULT_PROFILE
+from .response_trim import USER_SERVER_METHOD_MAP, trim_error_response, trim_public_response, wrap_trimmed_methods
 from .session_store import SessionStore
 from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
@@ -170,12 +172,15 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     )
     sessions = SessionStore()
     backend = BackendClient()
-    auth = AuthTools(sessions, backend)
-    apps = AppTools(sessions, backend)
-    workspace = WorkspaceTools(sessions, backend)
-    files = FileTools(sessions, backend)
-    imports = ImportTools(sessions, backend)
+    auth = wrap_trimmed_methods(AuthTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    apps = wrap_trimmed_methods(AppTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    workspace = wrap_trimmed_methods(WorkspaceTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    file_tools = wrap_trimmed_methods(FileTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    imports = wrap_trimmed_methods(ImportTools(sessions, backend), USER_SERVER_METHOD_MAP)
     feedback = FeedbackTools(backend, mcp_side="App User MCP")
+    code_block_tools = wrap_trimmed_methods(CodeBlockTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    task_context_tools = wrap_trimmed_methods(TaskContextTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    directory_tools = wrap_trimmed_methods(DirectoryTools(sessions, backend), USER_SERVER_METHOD_MAP)
 
     @server.tool()
     def auth_login(
@@ -263,7 +268,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         path_id: int | None = None,
         file_related_url: str | None = None,
     ) -> dict:
-        return files.file_get_upload_info(
+        return file_tools.file_get_upload_info(
             profile=profile,
             upload_kind=upload_kind,
             file_name=file_name,
@@ -286,7 +291,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         path_id: int | None = None,
         file_related_url: str | None = None,
     ) -> dict:
-        return files.file_upload_local(
+        return file_tools.file_upload_local(
             profile=profile,
             upload_kind=upload_kind,
             file_path=file_path,
@@ -299,10 +304,49 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
 
     imports.register(server)
 
-    feedback.register(server)
-    CodeBlockTools(sessions, backend).register(server)
-    TaskContextTools(sessions, backend).register(server)
-    DirectoryTools(sessions, backend).register(server)
+    @server.tool()
+    def feedback_submit(
+        category: str = "",
+        title: str = "",
+        description: str = "",
+        expected_behavior: str | None = None,
+        actual_behavior: str | None = None,
+        impact_scope: str | None = None,
+        tool_name: str | None = None,
+        app_key: str | None = None,
+        record_id: str | int | None = None,
+        workflow_node_id: str | int | None = None,
+        note: str | None = None,
+    ) -> dict:
+        try:
+            return trim_public_response(
+                "feedback_submit",
+                feedback.feedback_submit(
+                    category=category,
+                    title=title,
+                    description=description,
+                    expected_behavior=expected_behavior,
+                    actual_behavior=actual_behavior,
+                    impact_scope=impact_scope,
+                    tool_name=tool_name,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    note=note,
+                ),
+            )
+        except RuntimeError as exc:
+            try:
+                payload = json.loads(str(exc))
+            except json.JSONDecodeError:
+                raise
+            if isinstance(payload, dict):
+                raise RuntimeError(json.dumps(trim_error_response(payload), ensure_ascii=False)) from None
+            raise
+
+    code_block_tools.register(server)
+    task_context_tools.register(server)
+    directory_tools.register(server)
 
     return server