@josephyan/qingflow-cli 0.2.0-beta.55 → 0.2.0-beta.57

package/src/qingflow_mcp/server_app_user.py

@@ -1,21 +1,16 @@
 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:
@@ -169,12 +164,11 @@ 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)
-    feedback = FeedbackTools(backend, mcp_side="App User MCP")
+    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",
+    )
 
     @server.tool()
     def auth_login(
@@ -185,13 +179,15 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         password: str = "",
         persist: bool = True,
     ) -> dict:
-        return auth.auth_login(
-            profile=profile,
-            base_url=base_url,
-            qf_version=qf_version,
-            email=email,
-            password=password,
-            persist=persist,
+        return mcp_result_from_operation(
+            runtime.auth.login(
+                profile=profile,
+                base_url=base_url,
+                qf_version=qf_version,
+                email=email,
+                password=password,
+                persist=persist,
+            )
         )
 
     @server.tool()
@@ -203,22 +199,24 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         ws_id: int | None = None,
         persist: bool = False,
     ) -> dict:
-        return auth.auth_use_token(
-            profile=profile,
-            base_url=base_url,
-            qf_version=qf_version,
-            token=token,
-            ws_id=ws_id,
-            persist=persist,
+        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,
+            )
         )
 
     @server.tool()
     def auth_whoami(profile: str = DEFAULT_PROFILE) -> dict:
-        return auth.auth_whoami(profile=profile)
+        return mcp_result_from_operation(runtime.auth.me(profile=profile))
 
     @server.tool()
     def auth_logout(profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict:
-        return auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
+        return mcp_result_from_operation(runtime.auth.logout(profile=profile, forget_persisted=forget_persisted))
 
     @server.tool()
     def workspace_list(
@@ -227,28 +225,32 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         page_size: int = 20,
         include_external: bool = False,
     ) -> dict:
-        return workspace.workspace_list(
-            profile=profile,
-            page_num=page_num,
-            page_size=page_size,
-            include_external=include_external,
+        return mcp_result_from_operation(
+            runtime.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 workspace.workspace_select(profile=profile, ws_id=ws_id)
+        return mcp_result_from_operation(runtime.workspace.use(profile=profile, ws_id=ws_id))
 
     @server.tool()
     def app_list(profile: str = DEFAULT_PROFILE) -> dict:
-        return apps.app_list(profile=profile)
+        return mcp_result_from_operation(runtime.apps.list(profile=profile))
 
     @server.tool()
     def app_search(profile: str = DEFAULT_PROFILE, keyword: str = "", page_num: int = 1, page_size: int = 50) -> dict:
-        return apps.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+        return mcp_result_from_operation(
+            runtime.apps.find(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 apps.app_get(profile=profile, app_key=app_key)
+        return mcp_result_from_operation(runtime.apps.show(profile=profile, app_key=app_key))
 
     @server.tool()
     def file_get_upload_info(
@@ -262,16 +264,18 @@ 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(
-            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 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,
+            )
         )
 
     @server.tool()
@@ -285,23 +289,618 @@ 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(
-            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,
+        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,
+            )
         )
 
-    imports.register(server)
+    @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,
+            )
+        )
 
-    feedback.register(server)
-    CodeBlockTools(sessions, backend).register(server)
-    TaskContextTools(sessions, backend).register(server)
-    DirectoryTools(sessions, backend).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,
+            )
+        )
 
     return server