@josephyan/qingflow-cli 0.2.0-beta.58 → 0.2.0-beta.60

package/src/qingflow_mcp/server_app_user.py

@@ -1,16 +1,21 @@
 from __future__ import annotations
 
 from datetime import date
-from typing import Any
 
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .config import DEFAULT_PROFILE
-from .ops.base import mcp_result_from_operation
-from .ops.context import build_operations_runtime
 from .session_store import SessionStore
+from .tools.app_tools import AppTools
+from .tools.auth_tools import AuthTools
+from .tools.code_block_tools import CodeBlockTools
+from .tools.directory_tools import DirectoryTools
+from .tools.feedback_tools import FeedbackTools
+from .tools.file_tools import FileTools
+from .tools.import_tools import ImportTools
 from .tools.task_context_tools import TaskContextTools
+from .tools.workspace_tools import WorkspaceTools
 
 
 def build_user_server() -> FastMCP:
@@ -164,11 +169,12 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     )
     sessions = SessionStore()
     backend = BackendClient()
-    runtime = build_operations_runtime(sessions=sessions, backend=backend, feedback_mcp_side="App User MCP")
-    high_risk_desc = TaskContextTools(sessions, backend)._high_risk_tool_description(
-        operation="execute",
-        target="workflow task action",
-    )
+    auth = AuthTools(sessions, backend)
+    apps = AppTools(sessions, backend)
+    workspace = WorkspaceTools(sessions, backend)
+    files = FileTools(sessions, backend)
+    imports = ImportTools(sessions, backend)
+    feedback = FeedbackTools(backend, mcp_side="App User MCP")
 
     @server.tool()
     def auth_login(
@@ -179,15 +185,13 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         password: str = "",
         persist: bool = True,
     ) -> dict:
-        return mcp_result_from_operation(
-            runtime.auth.login(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                email=email,
-                password=password,
-                persist=persist,
-            )
+        return auth.auth_login(
+            profile=profile,
+            base_url=base_url,
+            qf_version=qf_version,
+            email=email,
+            password=password,
+            persist=persist,
         )
 
     @server.tool()
@@ -199,24 +203,22 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         ws_id: int | None = None,
         persist: bool = False,
     ) -> dict:
-        return mcp_result_from_operation(
-            runtime.auth.use_token(
-                profile=profile,
-                base_url=base_url,
-                qf_version=qf_version,
-                token=token,
-                ws_id=ws_id,
-                persist=persist,
-            )
+        return auth.auth_use_token(
+            profile=profile,
+            base_url=base_url,
+            qf_version=qf_version,
+            token=token,
+            ws_id=ws_id,
+            persist=persist,
         )
 
     @server.tool()
     def auth_whoami(profile: str = DEFAULT_PROFILE) -> dict:
-        return mcp_result_from_operation(runtime.auth.me(profile=profile))
+        return auth.auth_whoami(profile=profile)
 
     @server.tool()
     def auth_logout(profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict:
-        return mcp_result_from_operation(runtime.auth.logout(profile=profile, forget_persisted=forget_persisted))
+        return auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
 
     @server.tool()
     def workspace_list(
@@ -225,32 +227,28 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         page_size: int = 20,
         include_external: bool = False,
     ) -> dict:
-        return mcp_result_from_operation(
-            runtime.workspace.list(
-                profile=profile,
-                page_num=page_num,
-                page_size=page_size,
-                include_external=include_external,
-            )
+        return workspace.workspace_list(
+            profile=profile,
+            page_num=page_num,
+            page_size=page_size,
+            include_external=include_external,
         )
 
     @server.tool()
     def workspace_select(profile: str = DEFAULT_PROFILE, ws_id: int = 0) -> dict:
-        return mcp_result_from_operation(runtime.workspace.use(profile=profile, ws_id=ws_id))
+        return workspace.workspace_select(profile=profile, ws_id=ws_id)
 
     @server.tool()
     def app_list(profile: str = DEFAULT_PROFILE) -> dict:
-        return mcp_result_from_operation(runtime.apps.list(profile=profile))
+        return apps.app_list(profile=profile)
 
     @server.tool()
     def app_search(profile: str = DEFAULT_PROFILE, keyword: str = "", page_num: int = 1, page_size: int = 50) -> dict:
-        return mcp_result_from_operation(
-            runtime.apps.find(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
-        )
+        return apps.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
 
     @server.tool()
     def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
-        return mcp_result_from_operation(runtime.apps.show(profile=profile, app_key=app_key))
+        return apps.app_get(profile=profile, app_key=app_key)
 
     @server.tool()
     def file_get_upload_info(
@@ -264,18 +262,16 @@ 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 mcp_result_from_operation(
-            runtime.files.get_upload_info(
-                profile=profile,
-                upload_kind=upload_kind,
-                file_name=file_name,
-                file_size=file_size,
-                upload_mark=upload_mark,
-                content_type=content_type,
-                bucket_type=bucket_type,
-                path_id=path_id,
-                file_related_url=file_related_url,
-            )
+        return files.file_get_upload_info(
+            profile=profile,
+            upload_kind=upload_kind,
+            file_name=file_name,
+            file_size=file_size,
+            upload_mark=upload_mark,
+            content_type=content_type,
+            bucket_type=bucket_type,
+            path_id=path_id,
+            file_related_url=file_related_url,
         )
 
     @server.tool()
@@ -289,618 +285,23 @@ 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 mcp_result_from_operation(
-            runtime.files.upload_local(
-                profile=profile,
-                upload_kind=upload_kind,
-                file_path=file_path,
-                upload_mark=upload_mark,
-                content_type=content_type,
-                bucket_type=bucket_type,
-                path_id=path_id,
-                file_related_url=file_related_url,
-            )
-        )
-
-    @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:
-        return mcp_result_from_operation(
-            runtime.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,
-            )
-        )
-
-    @server.tool()
-    def record_import_schema_get(
-        app_key: str = "",
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.imports.schema(profile=DEFAULT_PROFILE, app_key=app_key, output_profile=output_profile)
-        )
-
-    @server.tool(description="Get the official app import template and the expected applicant import columns.")
-    def record_import_template_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        download_to_path: str | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.imports.template(profile=profile, app_key=app_key, download_to_path=download_to_path)
-        )
-
-    @server.tool(description="Verify a local Excel import file and produce the only verification_id allowed for import start.")
-    def record_import_verify(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        file_path: str = "",
-    ) -> dict:
-        return mcp_result_from_operation(runtime.imports.verify(profile=profile, app_key=app_key, file_path=file_path))
-
-    @server.tool(description="Repair a local .xlsx import file after explicit user authorization, then re-verify it.")
-    def record_import_repair_local(
-        profile: str = DEFAULT_PROFILE,
-        verification_id: str = "",
-        authorized_file_modification: bool = False,
-        output_path: str | None = None,
-        selected_repairs: list[str] | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.imports.repair(
-                profile=profile,
-                verification_id=verification_id,
-                authorized_file_modification=authorized_file_modification,
-                output_path=output_path,
-                selected_repairs=selected_repairs or [],
-            )
-        )
-
-    @server.tool(description="Start import from a successful verification_id. being_enter_auditing must be passed explicitly.")
-    def record_import_start(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        verification_id: str = "",
-        being_enter_auditing: bool | None = None,
-        view_key: str | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.imports.start(
-                profile=profile,
-                app_key=app_key,
-                verification_id=verification_id,
-                being_enter_auditing=being_enter_auditing,
-                view_key=view_key,
-            )
-        )
-
-    @server.tool()
-    def record_import_status_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        import_id: str | None = None,
-        process_id_str: str | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.imports.status(
-                profile=profile,
-                app_key=app_key,
-                import_id=import_id,
-                process_id_str=process_id_str,
-            )
-        )
-
-    @server.tool()
-    def record_insert_schema_get(app_key: str = "", output_profile: str = "normal") -> dict:
-        return mcp_result_from_operation(
-            runtime.records.schema(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                mode="insert",
-                view_id=None,
-                record_id=None,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_update_schema_get(app_key: str = "", record_id: int = 0, output_profile: str = "normal") -> dict:
-        return mcp_result_from_operation(
-            runtime.records.schema(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                mode="update",
-                view_id=None,
-                record_id=record_id,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_browse_schema_get(app_key: str = "", view_id: str = "", output_profile: str = "normal") -> dict:
-        return mcp_result_from_operation(
-            runtime.records.schema(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                mode="browse",
-                view_id=view_id,
-                record_id=None,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_member_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        field_id: int = 0,
-        keyword: str = "",
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.member_candidates(
-                profile=profile,
-                app_key=app_key,
-                field_id=field_id,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def record_department_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        field_id: int = 0,
-        keyword: str = "",
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.department_candidates(
-                profile=profile,
-                app_key=app_key,
-                field_id=field_id,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def record_analyze(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        dimensions: list[dict[str, Any]] | None = None,
-        metrics: list[dict[str, Any]] | None = None,
-        filters: list[dict[str, Any]] | None = None,
-        sort: list[dict[str, Any]] | None = None,
-        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",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.analyze(
-                profile=profile,
-                app_key=app_key,
-                dimensions=dimensions or [],
-                metrics=metrics or [],
-                filters=filters or [],
-                sort=sort or [],
-                limit=limit,
-                strict_full=strict_full,
-                view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_list(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        columns: list[dict[str, Any] | int] | None = None,
-        where: list[dict[str, Any]] | None = None,
-        order_by: list[dict[str, Any]] | None = None,
-        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",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.list(
-                profile=profile,
-                app_key=app_key,
-                columns=columns or [],
-                where=where or [],
-                order_by=order_by or [],
-                limit=limit,
-                page=page,
-                view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        columns: list[dict[str, Any] | int] | None = None,
-        view_id: str | None = None,
-        workflow_node_id: int | None = None,
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.get(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                columns=columns or [],
-                view_id=view_id,
-                workflow_node_id=workflow_node_id,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_insert(
-        app_key: str = "",
-        fields: dict[str, Any] | None = None,
-        verify_write: bool = True,
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.create(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                fields=fields or {},
-                verify_write=verify_write,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_update(
-        app_key: str = "",
-        record_id: int | None = None,
-        fields: dict[str, Any] | None = None,
-        verify_write: bool = True,
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.update(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                record_id=record_id,
-                fields=fields or {},
-                verify_write=verify_write,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_delete(
-        app_key: str = "",
-        record_id: int | None = None,
-        record_ids: list[int] | None = None,
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.delete(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                record_id=record_id,
-                record_ids=record_ids or [],
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_code_block_schema_get(app_key: str = "", output_profile: str = "normal") -> dict:
-        return mcp_result_from_operation(
-            runtime.records.schema(
-                profile=DEFAULT_PROFILE,
-                app_key=app_key,
-                mode="code-block",
-                view_id=None,
-                record_id=None,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def record_code_block_run(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        code_block_field: str = "",
-        role: int = 1,
-        workflow_node_id: int | None = None,
-        answers: list[dict[str, Any]] | None = None,
-        fields: dict[str, Any] | None = None,
-        manual: bool = True,
-        verify_writeback: bool = True,
-        force_refresh_form: bool = False,
-        output_profile: str = "normal",
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.records.run_code(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                code_block_field=code_block_field,
-                role=role,
-                workflow_node_id=workflow_node_id,
-                answers=answers or [],
-                fields=fields or {},
-                manual=manual,
-                verify_writeback=verify_writeback,
-                force_refresh_form=force_refresh_form,
-                output_profile=output_profile,
-            )
-        )
-
-    @server.tool()
-    def task_list(
-        profile: str = DEFAULT_PROFILE,
-        task_box: str = "todo",
-        flow_status: str = "all",
-        app_key: str | None = None,
-        workflow_node_id: int | None = None,
-        query: str | None = None,
-        page: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.tasks.list(
-                profile=profile,
-                task_box=task_box,
-                flow_status=flow_status,
-                app_key=app_key,
-                workflow_node_id=workflow_node_id,
-                query=query,
-                page=page,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def task_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        workflow_node_id: int = 0,
-        include_candidates: bool = True,
-        include_associated_reports: bool = True,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.tasks.show(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                include_candidates=include_candidates,
-                include_associated_reports=include_associated_reports,
-            )
-        )
-
-    @server.tool(description=high_risk_desc)
-    def task_action_execute(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        workflow_node_id: int = 0,
-        action: str = "",
-        payload: dict[str, Any] | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.tasks.act(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                action=action,
-                payload=payload or {},
-            )
-        )
-
-    @server.tool()
-    def task_associated_report_detail_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        workflow_node_id: int = 0,
-        report_id: int = 0,
-        page: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.tasks.associated_report_detail(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                report_id=report_id,
-                page=page,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def task_workflow_log_get(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        record_id: int = 0,
-        workflow_node_id: int = 0,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.tasks.log(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-            )
-        )
-
-    @server.tool()
-    def directory_search(
-        profile: str = DEFAULT_PROFILE,
-        query: str = "",
-        scopes: list[str] | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.search(
-                profile=profile,
-                query=query,
-                scopes=scopes,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def directory_list_internal_users(
-        profile: str = DEFAULT_PROFILE,
-        keyword: str | None = None,
-        department_id: int | None = None,
-        role_id: int | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-        include_disabled: bool = False,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_internal_users(
-                profile=profile,
-                keyword=keyword,
-                department_id=department_id,
-                role_id=role_id,
-                page_num=page_num,
-                page_size=page_size,
-                include_disabled=include_disabled,
-            )
+        return files.file_upload_local(
+            profile=profile,
+            upload_kind=upload_kind,
+            file_path=file_path,
+            upload_mark=upload_mark,
+            content_type=content_type,
+            bucket_type=bucket_type,
+            path_id=path_id,
+            file_related_url=file_related_url,
         )
 
-    @server.tool()
-    def directory_list_all_internal_users(
-        profile: str = DEFAULT_PROFILE,
-        keyword: str | None = None,
-        department_id: int | None = None,
-        role_id: int | None = None,
-        page_size: int = 200,
-        include_disabled: bool = False,
-        max_pages: int = 100,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_all_internal_users(
-                profile=profile,
-                keyword=keyword,
-                department_id=department_id,
-                role_id=role_id,
-                page_size=page_size,
-                include_disabled=include_disabled,
-                max_pages=max_pages,
-            )
-        )
+    imports.register(server)
 
-    @server.tool()
-    def directory_list_internal_departments(
-        profile: str = DEFAULT_PROFILE,
-        keyword: str = "",
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_internal_departments(
-                profile=profile,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        )
-
-    @server.tool()
-    def directory_list_all_departments(
-        profile: str = DEFAULT_PROFILE,
-        parent_department_id: int | None = None,
-        max_depth: int = 20,
-        max_items: int = 2000,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_all_departments(
-                profile=profile,
-                parent_department_id=parent_department_id,
-                max_depth=max_depth,
-                max_items=max_items,
-            )
-        )
-
-    @server.tool()
-    def directory_list_sub_departments(
-        profile: str = DEFAULT_PROFILE,
-        parent_department_id: int | None = None,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_sub_departments(
-                profile=profile,
-                parent_department_id=parent_department_id,
-            )
-        )
-
-    @server.tool()
-    def directory_list_external_members(
-        profile: str = DEFAULT_PROFILE,
-        keyword: str | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-        simple: bool = False,
-    ) -> dict:
-        return mcp_result_from_operation(
-            runtime.directory.list_external_members(
-                profile=profile,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-                simple=simple,
-            )
-        )
+    feedback.register(server)
+    CodeBlockTools(sessions, backend).register(server)
+    TaskContextTools(sessions, backend).register(server)
+    DirectoryTools(sessions, backend).register(server)
 
     return server