@josephyan/qingflow-app-builder-mcp 0.1.0-beta.9

package/src/qingflow_mcp/server.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from .backend_client import BackendClient
+from .session_store import SessionStore
+from .tools.app_tools import AppTools
+from .tools.auth_tools import AuthTools
+from .tools.file_tools import FileTools
+from .tools.package_tools import PackageTools
+from .tools.navigation_tools import NavigationTools
+from .tools.approval_tools import ApprovalTools
+from .tools.directory_tools import DirectoryTools
+from .tools.portal_tools import PortalTools
+from .tools.qingbi_report_tools import QingbiReportTools
+from .tools.record_tools import RecordTools
+from .tools.role_tools import RoleTools
+from .tools.solution_tools import SolutionTools
+from .tools.task_tools import TaskTools
+from .tools.view_tools import ViewTools
+from .tools.workflow_tools import WorkflowTools
+from .tools.workspace_tools import WorkspaceTools
+
+
+def build_server() -> FastMCP:
+    server = FastMCP(
+        "Qingflow MCP",
+        instructions=(
+            "Use auth_login first, then workspace_list and workspace_select. "
+            "All resource tools operate with the logged-in user's Qingflow permissions.\n\n"
+            "Task Center (待办/已办) handling:\n"
+            "- Use task_statistics to get counts of pending tasks (todo_count), timeouts, urged, etc.\n"
+            "- Use task_list to query tasks. Type values: 1=todo (待办), 2=initiated (我发起的), 3=cc (抄送), 5=done (已办).\n"
+            "- Use task_list_grouped to get tasks grouped by form/worksheet.\n"
+            "- Use task_mark_read to mark a specific task as read.\n"
+            "- Use task_urge to send an urgent reminder for a pending task.\n"
+            "- Process status values: 1=all, 2=processing, 3=passed, 4=refused, 5=need_supply, 6=urged, 7=timeout, 8=pre_timeout, 9=unread.\n"
+            "- After identifying the exact task node and record, use record_approve, record_reject, record_rollback, record_transfer, record_reassign, or record_countersign as needed."
+        ),
+    )
+    sessions = SessionStore()
+    backend = BackendClient()
+    AuthTools(sessions, backend).register(server)
+    WorkspaceTools(sessions, backend).register(server)
+    FileTools(sessions, backend).register(server)
+    RecordTools(sessions, backend).register(server)
+    RoleTools(sessions, backend).register(server)
+    AppTools(sessions, backend).register(server)
+    QingbiReportTools(sessions, backend).register(server)
+    PackageTools(sessions, backend).register(server)
+    NavigationTools(sessions, backend).register(server)
+    ApprovalTools(sessions, backend).register(server)
+    PortalTools(sessions, backend).register(server)
+    DirectoryTools(sessions, backend).register(server)
+    WorkflowTools(sessions, backend).register(server)
+    ViewTools(sessions, backend).register(server)
+    SolutionTools(sessions, backend).register(server)
+    TaskTools(sessions, backend).register(server)
+    return server
+
+
+mcp = build_server()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

package/src/qingflow_mcp/server_app_builder.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from .backend_client import BackendClient
+from .config import DEFAULT_PROFILE
+from .session_store import SessionStore
+from .tools.app_tools import AppTools
+from .tools.auth_tools import AuthTools
+from .tools.file_tools import FileTools
+from .tools.navigation_tools import NavigationTools
+from .tools.package_tools import PackageTools
+from .tools.portal_tools import PortalTools
+from .tools.solution_tools import SolutionTools
+from .tools.workspace_tools import WorkspaceTools
+
+
+def build_builder_server() -> FastMCP:
+    server = FastMCP(
+        "Qingflow App Builder MCP",
+        instructions=(
+            "Use this server for high-level Qingflow builder workflows. "
+            "Call solution_schema_example before generating non-trivial builder payloads. "
+            "Prefer solution_build_app for package/entity/field/layout design, then solution_build_flow for workflow, "
+            "then solution_build_views, solution_build_analytics_portal, and solution_build_navigation. "
+            "Avoid handcrafting low-level workflow/view/report payloads."
+        ),
+    )
+    sessions = SessionStore()
+    backend = BackendClient()
+    auth = AuthTools(sessions, backend)
+    workspace = WorkspaceTools(sessions, backend)
+    files = FileTools(sessions, backend)
+    apps = AppTools(sessions, backend)
+    packages = PackageTools(sessions, backend)
+    portals = PortalTools(sessions, backend)
+    navigation = NavigationTools(sessions, backend)
+    solution = SolutionTools(sessions, backend)
+
+    @server.tool()
+    def auth_login(
+        profile: str = DEFAULT_PROFILE,
+        base_url: str | None = None,
+        qf_version: str | None = None,
+        email: str = "",
+        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,
+        )
+
+    @server.tool()
+    def auth_use_token(
+        profile: str = DEFAULT_PROFILE,
+        base_url: str | None = None,
+        qf_version: str | None = None,
+        token: str = "",
+        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,
+        )
+
+    @server.tool()
+    def auth_whoami(profile: str = DEFAULT_PROFILE) -> dict:
+        return auth.auth_whoami(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)
+
+    @server.tool()
+    def workspace_list(
+        profile: str = DEFAULT_PROFILE,
+        page_num: int = 1,
+        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,
+        )
+
+    @server.tool()
+    def workspace_select(profile: str = DEFAULT_PROFILE, ws_id: int = 0) -> dict:
+        return workspace.workspace_select(profile=profile, ws_id=ws_id)
+
+    @server.tool()
+    def file_upload_local(
+        profile: str = DEFAULT_PROFILE,
+        upload_kind: str = "attachment",
+        file_path: str = "",
+        upload_mark: str | None = None,
+        content_type: str | None = None,
+        bucket_type: str | None = None,
+        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,
+        )
+
+    @server.tool()
+    def app_list(profile: str = DEFAULT_PROFILE, ship_auth: bool = False) -> dict:
+        return apps.app_list(profile=profile, ship_auth=ship_auth)
+
+    @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)
+
+    @server.tool()
+    def app_get_base(profile: str = DEFAULT_PROFILE, app_key: str = "", include_raw: bool = False) -> dict:
+        return apps.app_get_base(profile=profile, app_key=app_key, include_raw=include_raw)
+
+    @server.tool()
+    def app_get_form_schema(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        form_type: int = 1,
+        being_draft: bool | None = None,
+        being_apply: bool | None = None,
+        audit_node_id: int | None = None,
+        include_raw: bool = False,
+    ) -> dict:
+        return apps.app_get_form_schema(
+            profile=profile,
+            app_key=app_key,
+            form_type=form_type,
+            being_draft=being_draft,
+            being_apply=being_apply,
+            audit_node_id=audit_node_id,
+            include_raw=include_raw,
+        )
+
+    @server.tool()
+    def app_create(profile: str = DEFAULT_PROFILE, payload: dict | None = None) -> dict:
+        return apps.app_create(profile=profile, payload=payload or {})
+
+    @server.tool()
+    def app_publish(profile: str = DEFAULT_PROFILE, app_key: str = "", payload: dict | None = None) -> dict:
+        return apps.app_publish(profile=profile, app_key=app_key, payload=payload or {})
+
+    @server.tool()
+    def package_list(profile: str = DEFAULT_PROFILE, trial_status: str = "all") -> dict:
+        return packages.package_list(profile=profile, trial_status=trial_status)
+
+    @server.tool()
+    def package_get(profile: str = DEFAULT_PROFILE, tag_id: int = 0) -> dict:
+        return packages.package_get(profile=profile, tag_id=tag_id)
+
+    @server.tool()
+    def portal_list(profile: str = DEFAULT_PROFILE) -> dict:
+        return portals.portal_list(profile=profile)
+
+    @server.tool()
+    def portal_get(profile: str = DEFAULT_PROFILE, dash_key: str = "", being_draft: bool = False) -> dict:
+        return portals.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
+
+    @server.tool()
+    def navigation_list_published(profile: str = DEFAULT_PROFILE, page_num: int = 1, page_size: int = 50) -> dict:
+        return navigation.navigation_list_published(profile=profile, page_num=page_num, page_size=page_size)
+
+    @server.tool()
+    def navigation_list_draft_all(profile: str = DEFAULT_PROFILE, query_key: str | None = None) -> dict:
+        return navigation.navigation_list_draft_all(profile=profile, query_key=query_key)
+
+    @server.tool()
+    def navigation_get_status(profile: str = DEFAULT_PROFILE) -> dict:
+        return navigation.navigation_get_status(profile=profile)
+
+    @server.tool()
+    def solution_design_session(
+        action: str = "get",
+        session_id: str = "",
+        stage: str | None = None,
+        design_patch: dict | None = None,
+        metadata: dict | None = None,
+    ) -> dict:
+        return solution.solution_design_session(
+            action=action,
+            session_id=session_id,
+            stage=stage,
+            design_patch=design_patch or {},
+            metadata=metadata or {},
+        )
+
+    @server.tool()
+    def solution_schema_example(stage: str = "app", intent: str = "minimal") -> dict:
+        return solution.solution_schema_example(stage=stage, intent=intent)
+
+    @server.tool()
+    def solution_build_all(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        solution_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        target: dict | None = None,
+        repair_patch: dict | None = None,
+        verify: bool = False,
+    ) -> dict:
+        return solution.solution_build_all(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            solution_spec=solution_spec or {},
+            publish=publish,
+            run_label=run_label,
+            target=target or {},
+            repair_patch=repair_patch or {},
+            verify=verify,
+        )
+
+    @server.tool()
+    def solution_build_app(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        app_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        target: dict | None = None,
+        repair_patch: dict | None = None,
+    ) -> dict:
+        return solution.solution_build_app(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            app_spec=app_spec or {},
+            publish=publish,
+            run_label=run_label,
+            target=target or {},
+            repair_patch=repair_patch or {},
+        )
+
+    @server.tool()
+    def solution_build_flow(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        flow_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        repair_patch: dict | None = None,
+    ) -> dict:
+        return solution.solution_build_flow(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            flow_spec=flow_spec or {},
+            publish=publish,
+            run_label=run_label,
+            repair_patch=repair_patch or {},
+        )
+
+    @server.tool()
+    def solution_build_views(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        views_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        repair_patch: dict | None = None,
+    ) -> dict:
+        return solution.solution_build_views(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            views_spec=views_spec or {},
+            publish=publish,
+            run_label=run_label,
+            repair_patch=repair_patch or {},
+        )
+
+    @server.tool()
+    def solution_build_analytics_portal(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        analytics_portal_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        repair_patch: dict | None = None,
+    ) -> dict:
+        return solution.solution_build_analytics_portal(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            analytics_portal_spec=analytics_portal_spec or {},
+            publish=publish,
+            run_label=run_label,
+            repair_patch=repair_patch or {},
+        )
+
+    @server.tool()
+    def solution_build_navigation(
+        profile: str = DEFAULT_PROFILE,
+        mode: str = "plan",
+        build_id: str = "",
+        navigation_spec: dict | None = None,
+        publish: bool = True,
+        run_label: str | None = None,
+        repair_patch: dict | None = None,
+    ) -> dict:
+        return solution.solution_build_navigation(
+            profile=profile,
+            mode=mode,
+            build_id=build_id,
+            navigation_spec=navigation_spec or {},
+            publish=publish,
+            run_label=run_label,
+            repair_patch=repair_patch or {},
+        )
+
+    @server.tool()
+    def solution_build_status(build_id: str = "") -> dict:
+        return solution.solution_build_status(build_id=build_id)
+    return server
+
+
+mcp = build_builder_server()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()