@josephyan/qingflow-cli 0.2.0-beta.55

package/src/qingflow_mcp/server.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from datetime import date
+
+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.code_block_tools import CodeBlockTools
+from .tools.feedback_tools import FeedbackTools
+from .tools.file_tools import FileTools
+from .tools.import_tools import ImportTools
+from .tools.package_tools import PackageTools
+from .tools.navigation_tools import NavigationTools
+from .tools.directory_tools import DirectoryTools
+from .tools.portal_tools import PortalTools
+from .tools.qingbi_report_tools import QingbiReportTools
+from .tools.role_tools import RoleTools
+from .tools.solution_tools import SolutionTools
+from .tools.task_context_tools import TaskContextTools
+from .tools.view_tools import ViewTools
+from .tools.workflow_tools import WorkflowTools
+from .tools.workspace_tools import WorkspaceTools
+
+
+def build_server() -> FastMCP:
+    today = date.today()
+    current_year = today.year
+    server = FastMCP(
+        "Qingflow MCP",
+        instructions=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
+
+## Authentication
+
+Use `auth_login` first, then `workspace_list` and `workspace_select`.
+All resource tools operate with the logged-in user's Qingflow permissions.
+
+## Shared Helper
+
+`feedback_submit` is always available as a cross-cutting helper.
+
+- Use it when the current MCP capability is unsupported, awkward, or still cannot satisfy the user's need after reasonable use.
+- It does not require Qingflow login or workspace selection.
+- Call it only after the user explicitly confirms submission.
+
+## App Discovery
+
+If `app_key` is unknown, use `app_list` or `app_search` first.
+If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
+If an accessible view has `analysis_supported=false`, do not use it for `record_list` or `record_analyze`. `boardView` and `ganttView` are special UI views, not list/analyze targets.
+
+## Schema-First Rule
+
+Call `record_insert_schema_get` before `record_insert`.
+Call `record_update_schema_get` before `record_update`.
+Call `record_code_block_schema_get` before `record_code_block_run`.
+Call `app_get` first when the data range is unclear, then use `record_browse_schema_get(view_id=...)` before `record_list`, `record_get`, or `record_analyze`.
+Call `record_import_schema_get` when the import field mapping is unclear before template download or verify.
+
+- All `field_id` values must come from the schema response.
+- Never guess field names or ids.
+
+## Schema Scope
+
+`record_insert_schema_get` returns the current user's insert-ready applicant schema; read `required_fields`, `optional_fields`, `runtime_linked_required_fields`, and `payload_template`.
+`record_update_schema_get` returns the current record's overall update-ready writable field set across matched accessible views; read `writable_fields` and `payload_template`.
+`record_browse_schema_get(view_id=...)` returns browse-schema fields for the selected accessible view.
+`record_code_block_schema_get` returns code-block-ready schema for exact code block field selection.
+`record_import_schema_get` returns import-ready column metadata.
+
+- Hidden fields are omitted.
+- Missing fields mean the field is not visible in the current permission scope.
+- Read the top-level schema payload directly; do not guess missing writable fields.
+
+## Analytics Path
+
+`app_get -> record_browse_schema_get(view_id=...) -> record_analyze`
+
+Prefer `view_id` entries from `accessible_views` where `analysis_supported=true`.
+
+Use this DSL shape:
+
+- `dimensions`: `{{field_id, alias, bucket}}`
+- `metrics`: `{{op, field_id, alias}}`
+- `filters`: `{{field_id, op, value}}`
+- `sort`: `{{by, order}}`
+
+Important key rules:
+
+- Use `op`
+- Do **not** use `type`
+- Do **not** use `agg`
+- Do **not** use `aggregation`
+- Do **not** use `operator`
+
+Analysis answers must include concrete numbers. When applicable, include percentages based on the returned totals.
+
+## Record CRUD Path
+
+`app_get -> record_browse_schema_get(view_id=...) -> record_list / record_get`
+`record_insert_schema_get -> record_insert`
+`record_update_schema_get -> record_update`
+`record_list / record_get -> record_delete`
+`record_code_block_schema_get -> record_code_block_run`
+
+- Use `columns` as `[{{field_id}}]`
+- Use `where` items as `{{field_id, op, value}}`
+- Use `order_by` items as `{{field_id, direction}}`
+- Legacy forms such as bare integer `field_id`, `fieldId`, `operator`, `values`, or `order` may still parse, but they are compatibility-only and not the canonical DSL
+
+- `record_insert` uses an applicant-node `fields` map keyed by field title.
+- `record_update` uses a field-title keyed `fields` map and internally selects the first accessible view that can execute the current payload.
+- For insert, `runtime_linked_required_fields` means required-but-not-directly-writable fields that are usually supplied by runtime linkage or upstream context.
+- For insert, fields marked `may_become_required=true` stay in `optional_fields`; they are still directly writable, but linked visibility or option-driven rules can make them required at runtime.
+- Read field-level `linkage` whenever present on `record_insert_schema_get` or `record_update_schema_get`; it is the static hint for linked visibility, reference-driven auto fill, and formula/default auto-fill behavior.
+- `linkage.sources` lists upstream field titles that influence the current field; `linkage.affects_fields` lists downstream fields that may change when the current field changes.
+- `linkage.kind=logic_visibility` means linked visibility or option-driven rules are involved; `linkage.kind=reference_fill` means reference/default matching logic is involved; `linkage.kind=formula_fill` means formula/default auto-fill logic is involved.
+- `record_update_schema_get` exposes the overall writable field set for the record, but not every field combination is guaranteed; `record_update` still needs one single matched accessible view that can cover the payload.
+- `record_delete` deletes by `record_id` or `record_ids`.
+- When readback shape matters after insert or update, prefer `record_get(..., output_profile="normalized")` or `record_list(..., output_profile="normalized")`.
+
+- Read relation targets from `record_insert_schema_get` / `record_update_schema_get` relation metadata before preparing relation writes.
+- Member and department fields may be written with natural strings directly on `record_insert` / `record_update`; only fall back to `record_member_candidates` or `record_department_candidates` when the user wants explicit candidate browsing or the write returns ambiguity that needs confirmation.
+- If explicit candidate browsing is needed for default-all member or department fields, prefer those field candidate tools instead of starting with `directory_*`.
+
+## Code Block Path
+
+Use `record_code_block_run` when the user wants to execute a form code-block field against an existing record.
+
+- Always resolve the exact code-block field from `record_code_block_schema_get` first.
+- Treat code-block execution as write-capable, not read-only.
+- If the code block is bound to relation outputs, Qingflow may calculate target answers and write them back automatically.
+- In workflow context, pass `role=3` and the exact `workflow_node_id`.
+- After execution, inspect `outputs.alias_results`, `relation.target_fields`, and `writeback.verification` before claiming success.
+
+## Import Path
+
+`app_get -> record_import_schema_get -> record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+
+- Check `app_get.data.import_capability` before doing import work.
+- If `import_capability.can_import=false`, stop before template download, file repair, or import start.
+- Import must go through `verify -> start`; do not start directly from a raw file path.
+- `record_import_start` requires an explicit `being_enter_auditing` choice. Do not assume a default.
+- Do not modify user-uploaded files unless the user explicitly authorizes repair.
+- If repair is authorized, keep the original file and repair a copy, then run `record_import_verify` again before `record_import_start`.
+
+## Task Workflow Path
+
+`task_list -> task_get -> task_action_execute`
+
+- Use `task_associated_report_detail_get` for associated view or report details.
+- Use `task_workflow_log_get` for full workflow log history.
+- Task actions operate on `app_key + record_id + workflow_node_id`, not `task_id`.
+
+## Time Handling
+
+Normalize relative dates before building DSL.
+
+- If the user says `3月` without a year, use the current year: `{current_year}`
+- Convert month-only phrases into explicit legal date ranges
+- Never send impossible dates such as `2026-02-29`
+
+## Environment
+
+Default to `prod` unless the user explicitly specifies `test`.
+
+## Constraints
+
+Avoid builder-side app or schema changes here.
+
+## Feedback Path
+
+If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, offer to submit product feedback.
+
+- First summarize what is still not working
+- Ask the user whether to submit feedback
+- Call `feedback_submit` only after explicit user confirmation""",
+    )
+    sessions = SessionStore()
+    backend = BackendClient()
+    AuthTools(sessions, backend).register(server)
+    FeedbackTools(backend, mcp_side="通用").register(server)
+    WorkspaceTools(sessions, backend).register(server)
+    FileTools(sessions, backend).register(server)
+    ImportTools(sessions, backend).register(server)
+    CodeBlockTools(sessions, backend).register(server)
+    TaskContextTools(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)
+    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)
+    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,387 @@
+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.ai_builder_tools import AiBuilderTools
+from .tools.auth_tools import AuthTools
+from .tools.feedback_tools import FeedbackTools
+from .tools.file_tools import FileTools
+from .tools.workspace_tools import WorkspaceTools
+
+
+def build_builder_server() -> FastMCP:
+    server = FastMCP(
+        "Qingflow App Builder MCP",
+        instructions=(
+            "Use this server for AI-native Qingflow builder workflows. "
+            "`feedback_submit` is always available as a cross-cutting helper when the current capability is unsupported, awkward, or still cannot satisfy the user's need after reasonable use; it does not require Qingflow login or workspace selection, and it should be called only after explicit user confirmation. "
+            "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, "
+            "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. "
+            "For workflow edits, keep the public builder surface on stable linear flows only: start/approve/fill/copy/webhook/end. Branch and condition nodes are intentionally disabled because the backend workflow route is not front-end stable for those node types. Declare node assignees and editable fields explicitly. "
+            "If builder writes are blocked by the current user's own edit lock, use app_release_edit_lock_if_mine with the lock owner details from the failed result. "
+            "Do not handcraft internal solution payloads or rely on build_id/stage/repair. "
+            "If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, first summarize the gap, ask whether to submit feedback, and call feedback_submit only after explicit user confirmation."
+        ),
+    )
+    sessions = SessionStore()
+    backend = BackendClient()
+    auth = AuthTools(sessions, backend)
+    workspace = WorkspaceTools(sessions, backend)
+    files = FileTools(sessions, backend)
+    ai_builder = AiBuilderTools(sessions, backend)
+    feedback = FeedbackTools(backend, mcp_side="App Builder MCP")
+
+    @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,
+        )
+
+    feedback.register(server)
+
+    @server.tool()
+    def package_list(profile: str = DEFAULT_PROFILE, trial_status: str = "all") -> dict:
+        return ai_builder.package_list(profile=profile, trial_status=trial_status)
+
+    @server.tool()
+    def package_resolve(profile: str = DEFAULT_PROFILE, package_name: str = "") -> dict:
+        return ai_builder.package_resolve(profile=profile, package_name=package_name)
+
+    @server.tool()
+    def builder_tool_contract(tool_name: str = "") -> dict:
+        return ai_builder.builder_tool_contract(tool_name=tool_name)
+
+    @server.tool()
+    def package_create(profile: str = DEFAULT_PROFILE, package_name: str = "") -> dict:
+        return ai_builder.package_create(profile=profile, package_name=package_name)
+
+    @server.tool()
+    def member_search(
+        profile: str = DEFAULT_PROFILE,
+        query: str = "",
+        page_num: int = 1,
+        page_size: int = 20,
+        contain_disable: bool = False,
+    ) -> dict:
+        return ai_builder.member_search(
+            profile=profile,
+            query=query,
+            page_num=page_num,
+            page_size=page_size,
+            contain_disable=contain_disable,
+        )
+
+    @server.tool()
+    def role_search(
+        profile: str = DEFAULT_PROFILE,
+        keyword: str = "",
+        page_num: int = 1,
+        page_size: int = 20,
+    ) -> dict:
+        return ai_builder.role_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+
+    @server.tool()
+    def role_create(
+        profile: str = DEFAULT_PROFILE,
+        role_name: str = "",
+        member_uids: list[int] | None = None,
+        member_emails: list[str] | None = None,
+        member_names: list[str] | None = None,
+        role_icon: str = "ex-user-outlined",
+    ) -> dict:
+        return ai_builder.role_create(
+            profile=profile,
+            role_name=role_name,
+            member_uids=member_uids or [],
+            member_emails=member_emails or [],
+            member_names=member_names or [],
+            role_icon=role_icon,
+        )
+
+    @server.tool()
+    def package_attach_app(
+        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)
+
+    @server.tool()
+    def app_release_edit_lock_if_mine(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        lock_owner_email: str = "",
+        lock_owner_name: str = "",
+    ) -> dict:
+        return ai_builder.app_release_edit_lock_if_mine(
+            profile=profile,
+            app_key=app_key,
+            lock_owner_email=lock_owner_email,
+            lock_owner_name=lock_owner_name,
+        )
+
+    @server.tool()
+    def app_resolve(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        app_name: str = "",
+        package_tag_id: int | None = None,
+    ) -> dict:
+        return ai_builder.app_resolve(profile=profile, app_key=app_key, app_name=app_name, package_tag_id=package_tag_id)
+
+    @server.tool()
+    def app_read_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_summary(profile=profile, app_key=app_key)
+
+    @server.tool()
+    def app_read_fields(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_fields(profile=profile, app_key=app_key)
+
+    @server.tool()
+    def app_read_layout_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_layout_summary(profile=profile, app_key=app_key)
+
+    @server.tool()
+    def app_read_views_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_views_summary(profile=profile, app_key=app_key)
+
+    @server.tool()
+    def app_read_flow_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_flow_summary(profile=profile, app_key=app_key)
+
+    @server.tool()
+    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_read_summary(
+        profile: str = DEFAULT_PROFILE,
+        dash_key: str = "",
+        being_draft: bool = True,
+    ) -> dict:
+        return ai_builder.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft)
+
+    @server.tool()
+    def app_schema_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        package_tag_id: int | None = None,
+        app_name: str = "",
+        app_title: str = "",
+        create_if_missing: bool = False,
+        publish: bool = True,
+        add_fields: list[dict] | None = None,
+        update_fields: list[dict] | None = None,
+        remove_fields: list[dict] | None = None,
+    ) -> dict:
+        return ai_builder.app_schema_apply(
+            profile=profile,
+            app_key=app_key,
+            package_tag_id=package_tag_id,
+            app_name=app_name,
+            app_title=app_title,
+            create_if_missing=create_if_missing,
+            publish=publish,
+            add_fields=add_fields or [],
+            update_fields=update_fields or [],
+            remove_fields=remove_fields or [],
+        )
+
+    @server.tool()
+    def app_layout_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        mode: str = "merge",
+        publish: bool = True,
+        sections: list[dict] | None = None,
+    ) -> dict:
+        return ai_builder.app_layout_apply(profile=profile, app_key=app_key, mode=mode, publish=publish, sections=sections or [])
+
+    @server.tool()
+    def app_flow_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        mode: str = "replace",
+        publish: bool = True,
+        nodes: list[dict] | None = None,
+        transitions: list[dict] | None = None,
+    ) -> dict:
+        return ai_builder.app_flow_apply(
+            profile=profile,
+            app_key=app_key,
+            mode=mode,
+            publish=publish,
+            nodes=nodes or [],
+            transitions=transitions or [],
+        )
+
+    @server.tool()
+    def app_views_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        publish: bool = True,
+        upsert_views: list[dict] | None = None,
+        remove_views: list[str] | None = None,
+    ) -> dict:
+        return ai_builder.app_views_apply(
+            profile=profile,
+            app_key=app_key,
+            publish=publish,
+            upsert_views=upsert_views or [],
+            remove_views=remove_views or [],
+        )
+
+    @server.tool()
+    def app_charts_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        upsert_charts: list[dict] | None = None,
+        remove_chart_ids: list[str] | None = None,
+        reorder_chart_ids: list[str] | None = None,
+    ) -> dict:
+        return ai_builder.app_charts_apply(
+            profile=profile,
+            app_key=app_key,
+            upsert_charts=upsert_charts or [],
+            remove_chart_ids=remove_chart_ids or [],
+            reorder_chart_ids=reorder_chart_ids or [],
+        )
+
+    @server.tool()
+    def portal_apply(
+        profile: str = DEFAULT_PROFILE,
+        dash_key: str = "",
+        dash_name: str = "",
+        package_tag_id: int | None = None,
+        publish: bool = True,
+        sections: list[dict] | None = None,
+        auth: dict | None = None,
+        icon: str | None = None,
+        color: str | None = None,
+        hide_copyright: bool | None = None,
+        dash_global_config: dict | None = None,
+        config: dict | None = None,
+    ) -> dict:
+        return ai_builder.portal_apply(
+            profile=profile,
+            dash_key=dash_key,
+            dash_name=dash_name,
+            package_tag_id=package_tag_id,
+            publish=publish,
+            sections=sections or [],
+            auth=auth,
+            icon=icon,
+            color=color,
+            hide_copyright=hide_copyright,
+            dash_global_config=dash_global_config,
+            config=config or {},
+        )
+
+    @server.tool()
+    def app_publish_verify(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        expected_package_tag_id: int | None = None,
+    ) -> dict:
+        return ai_builder.app_publish_verify(
+            profile=profile,
+            app_key=app_key,
+            expected_package_tag_id=expected_package_tag_id,
+        )
+
+    return server
+
+
+def main() -> None:
+    build_builder_server().run()
+
+
+if __name__ == "__main__":
+    main()