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

package/src/qingflow_mcp/server_app_user.py

@@ -0,0 +1,334 @@
+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.approval_tools import ApprovalTools
+from .tools.auth_tools import AuthTools
+from .tools.directory_tools import DirectoryTools
+from .tools.file_tools import FileTools
+from .tools.record_tools import RecordTools
+from .tools.task_tools import TaskTools
+from .tools.workspace_tools import WorkspaceTools
+
+
+def build_user_server() -> FastMCP:
+    server = FastMCP(
+        "Qingflow App User MCP",
+        instructions=(
+            "Use this server for Qingflow record queries, record writes, task center operations, "
+            "directory lookups, and approval actions. Avoid builder-side app or schema changes here."
+        ),
+    )
+    sessions = SessionStore()
+    backend = BackendClient()
+    auth = AuthTools(sessions, backend)
+    workspace = WorkspaceTools(sessions, backend)
+    files = FileTools(sessions, backend)
+    approvals = ApprovalTools(sessions, backend)
+    tasks = TaskTools(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_get_upload_info(
+        profile: str = DEFAULT_PROFILE,
+        upload_kind: str = "attachment",
+        file_name: str = "",
+        file_size: int = 0,
+        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_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()
+    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,
+        )
+
+    RecordTools(sessions, backend).register(server)
+    DirectoryTools(sessions, backend).register(server)
+
+    @server.tool()
+    def record_comment_add(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        payload: dict | None = None,
+    ) -> dict:
+        return approvals.record_comment_add(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+
+    @server.tool()
+    def record_comment_list(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        page_size: int = 20,
+        list_type: int | None = None,
+        page_num: int | None = 1,
+    ) -> dict:
+        return approvals.record_comment_list(
+            profile=profile,
+            app_key=app_key,
+            apply_id=apply_id,
+            page_size=page_size,
+            list_type=list_type,
+            page_num=page_num,
+        )
+
+    @server.tool()
+    def record_comment_mention_candidates(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        page_size: int = 20,
+        page_num: int = 1,
+        list_type: int | None = None,
+        keyword: str | None = None,
+    ) -> dict:
+        return approvals.record_comment_mention_candidates(
+            profile=profile,
+            app_key=app_key,
+            apply_id=apply_id,
+            page_size=page_size,
+            page_num=page_num,
+            list_type=list_type,
+            keyword=keyword,
+        )
+
+    @server.tool()
+    def record_comment_mark_read(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
+        return approvals.record_comment_mark_read(profile=profile, app_key=app_key, apply_id=apply_id)
+
+    @server.tool()
+    def record_comment_stats(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
+        return approvals.record_comment_stats(profile=profile, app_key=app_key, apply_id=apply_id)
+
+    @server.tool()
+    def task_list(
+        profile: str = DEFAULT_PROFILE,
+        type: int = 1,
+        process_status: int = 1,
+        app_key: str | None = None,
+        node_id: int | None = None,
+        search_key: str | None = None,
+        page_num: int = 1,
+        page_size: int = 20,
+        create_time_asc: bool | None = None,
+    ) -> dict:
+        return tasks.task_list(
+            profile=profile,
+            type=type,
+            process_status=process_status,
+            app_key=app_key,
+            node_id=node_id,
+            search_key=search_key,
+            page_num=page_num,
+            page_size=page_size,
+            create_time_asc=create_time_asc,
+        )
+
+    @server.tool()
+    def task_list_grouped(
+        profile: str = DEFAULT_PROFILE,
+        type: int = 1,
+        process_status: int = 1,
+        app_key: str | None = None,
+        node_id: int | None = None,
+        search_key: str | None = None,
+        page_num: int = 1,
+        page_size: int = 20,
+    ) -> dict:
+        return tasks.task_list_grouped(
+            profile=profile,
+            type=type,
+            process_status=process_status,
+            app_key=app_key,
+            node_id=node_id,
+            search_key=search_key,
+            page_num=page_num,
+            page_size=page_size,
+        )
+
+    @server.tool()
+    def task_statistics(profile: str = DEFAULT_PROFILE, app_key: str | None = None) -> dict:
+        return tasks.task_statistics(profile=profile, app_key=app_key)
+
+    @server.tool()
+    def task_urge(profile: str = DEFAULT_PROFILE, app_key: str = "", row_record_id: int = 0) -> dict:
+        return tasks.task_urge(profile=profile, app_key=app_key, row_record_id=row_record_id)
+
+    @server.tool(description=approvals._high_risk_tool_description(operation="approve", target="workflow task"))
+    def task_approve(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        payload: dict | None = None,
+    ) -> dict:
+        return approvals.record_approve(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+
+    @server.tool(description=approvals._high_risk_tool_description(operation="reject", target="workflow task"))
+    def task_reject(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        payload: dict | None = None,
+    ) -> dict:
+        return approvals.record_reject(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+
+    @server.tool()
+    def task_rollback_candidates(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        audit_node_id: int = 0,
+    ) -> dict:
+        return approvals.record_rollback_candidates(
+            profile=profile,
+            app_key=app_key,
+            apply_id=apply_id,
+            audit_node_id=audit_node_id,
+        )
+
+    @server.tool()
+    def task_rollback(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        payload: dict | None = None,
+    ) -> dict:
+        return approvals.record_rollback(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+
+    @server.tool()
+    def task_transfer_candidates(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        page_size: int = 20,
+        page_num: int = 1,
+        audit_node_id: int = 0,
+        keyword: str | None = None,
+    ) -> dict:
+        return approvals.record_transfer_candidates(
+            profile=profile,
+            app_key=app_key,
+            apply_id=apply_id,
+            page_size=page_size,
+            page_num=page_num,
+            audit_node_id=audit_node_id,
+            keyword=keyword,
+        )
+
+    @server.tool()
+    def task_transfer(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        apply_id: int = 0,
+        payload: dict | None = None,
+    ) -> dict:
+        return approvals.record_transfer(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+
+    return server
+
+
+mcp = build_user_server()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

package/src/qingflow_mcp/session_store.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+try:
+    import keyring
+except ImportError:
+    keyring = None
+
+from .config import get_profiles_path, normalize_base_url
+from .json_types import JSONObject, KeyringBackend
+
+
+KEYRING_SERVICE_NAME = "qingflow-mcp"
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass(slots=True)
+class SessionProfile:
+    profile: str
+    base_url: str
+    qf_version: str | None
+    qf_version_source: str | None
+    uid: int
+    email: str | None
+    nick_name: str | None
+    selected_ws_id: int | None
+    selected_ws_name: str | None
+    persisted: bool
+    created_at: str
+    updated_at: str
+
+    @classmethod
+    def from_dict(cls, value: JSONObject) -> "SessionProfile":
+        return cls(
+            profile=value["profile"],
+            base_url=value["base_url"],
+            qf_version=value.get("qf_version"),
+            qf_version_source=value.get("qf_version_source"),
+            uid=value["uid"],
+            email=value.get("email"),
+            nick_name=value.get("nick_name"),
+            selected_ws_id=value.get("selected_ws_id"),
+            selected_ws_name=value.get("selected_ws_name"),
+            persisted=bool(value.get("persisted", False)),
+            created_at=value.get("created_at", _utcnow()),
+            updated_at=value.get("updated_at", _utcnow()),
+        )
+
+
+@dataclass(slots=True)
+class BackendSession:
+    token: str
+    login_token: str | None
+    profile: str
+    base_url: str
+    qf_version: str | None
+    qf_version_source: str | None = None
+
+
+class SessionStore:
+    def __init__(self, base_dir: Path | None = None, keyring_backend: KeyringBackend | None = None) -> None:
+        profiles_path = get_profiles_path() if base_dir is None else Path(base_dir) / "profiles.json"
+        self._profiles_path = profiles_path
+        self._profiles_path.parent.mkdir(parents=True, exist_ok=True)
+        self._keyring = keyring_backend if keyring_backend is not None else keyring
+        self._memory_sessions: dict[str, BackendSession] = {}
+        self._logged_out_profiles: set[str] = set()
+
+    def save_session(
+        self,
+        *,
+        profile: str,
+        base_url: str,
+        qf_version: str | None,
+        qf_version_source: str | None = None,
+        token: str,
+        login_token: str | None,
+        uid: int,
+        email: str | None,
+        nick_name: str | None,
+        persist: bool,
+    ) -> SessionProfile:
+        now = _utcnow()
+        previous = self.get_profile(profile)
+        persisted = False
+        if persist:
+            persisted = self._set_secret(self._token_key(profile), token)
+            if login_token:
+                self._set_secret(self._login_token_key(profile), login_token)
+            else:
+                self._delete_secret(self._login_token_key(profile))
+        else:
+            self._delete_secret(self._token_key(profile))
+            self._delete_secret(self._login_token_key(profile))
+        session_profile = SessionProfile(
+            profile=profile,
+            base_url=normalize_base_url(base_url) or base_url,
+            qf_version=(str(qf_version).strip() or None) if qf_version is not None else None,
+            qf_version_source=(str(qf_version_source).strip() or None) if qf_version_source is not None else None,
+            uid=uid,
+            email=email,
+            nick_name=nick_name,
+            selected_ws_id=None,
+            selected_ws_name=None,
+            persisted=persisted,
+            created_at=previous.created_at if previous else now,
+            updated_at=now,
+        )
+        self._memory_sessions[profile] = BackendSession(
+            token=token,
+            login_token=login_token,
+            profile=profile,
+            base_url=session_profile.base_url,
+            qf_version=session_profile.qf_version,
+            qf_version_source=session_profile.qf_version_source,
+        )
+        self._logged_out_profiles.discard(profile)
+        self._upsert_profile(session_profile)
+        return session_profile
+
+    def get_profile(self, profile: str) -> SessionProfile | None:
+        payload = self._load_profiles()
+        raw_profile = payload.get("profiles", {}).get(profile)
+        if not raw_profile:
+            return None
+        return SessionProfile.from_dict(raw_profile)
+
+    def get_backend_session(self, profile: str) -> BackendSession | None:
+        if profile in self._logged_out_profiles:
+            return None
+        memory_session = self._memory_sessions.get(profile)
+        if memory_session:
+            return memory_session
+        session_profile = self.get_profile(profile)
+        if not session_profile or not session_profile.persisted:
+            return None
+        token = self._get_secret(self._token_key(profile))
+        if not token:
+            return None
+        backend_session = BackendSession(
+            token=token,
+            login_token=self._get_secret(self._login_token_key(profile)),
+            profile=profile,
+            base_url=session_profile.base_url,
+            qf_version=session_profile.qf_version,
+            qf_version_source=session_profile.qf_version_source,
+        )
+        self._memory_sessions[profile] = backend_session
+        return backend_session
+
+    def select_workspace(self, profile: str, ws_id: int, ws_name: str | None) -> SessionProfile:
+        session_profile = self.get_profile(profile)
+        if session_profile is None:
+            raise KeyError(profile)
+        session_profile.selected_ws_id = ws_id
+        session_profile.selected_ws_name = ws_name
+        session_profile.updated_at = _utcnow()
+        self._upsert_profile(session_profile)
+        return session_profile
+
+    def update_route(self, profile: str, *, qf_version: str | None, qf_version_source: str | None) -> SessionProfile:
+        session_profile = self.get_profile(profile)
+        if session_profile is None:
+            raise KeyError(profile)
+        session_profile.qf_version = (str(qf_version).strip() or None) if qf_version is not None else None
+        session_profile.qf_version_source = (str(qf_version_source).strip() or None) if qf_version_source is not None else None
+        session_profile.updated_at = _utcnow()
+        self._upsert_profile(session_profile)
+        backend_session = self._memory_sessions.get(profile)
+        if backend_session is not None:
+            backend_session.qf_version = session_profile.qf_version
+            backend_session.qf_version_source = session_profile.qf_version_source
+        return session_profile
+
+    def logout(self, profile: str, forget_persisted: bool = False) -> None:
+        self._memory_sessions.pop(profile, None)
+        if forget_persisted:
+            self.invalidate(profile)
+            return
+        if self.get_profile(profile):
+            self._logged_out_profiles.add(profile)
+
+    def invalidate(self, profile: str) -> None:
+        self._memory_sessions.pop(profile, None)
+        self._logged_out_profiles.discard(profile)
+        self._delete_secret(self._token_key(profile))
+        self._delete_secret(self._login_token_key(profile))
+        payload = self._load_profiles()
+        profiles = payload.get("profiles", {})
+        if profile in profiles:
+            profiles.pop(profile)
+            self._save_profiles(payload)
+
+    def has_profile(self, profile: str) -> bool:
+        return self.get_profile(profile) is not None
+
+    def _token_key(self, profile: str) -> str:
+        return f"{profile}:token"
+
+    def _login_token_key(self, profile: str) -> str:
+        return f"{profile}:login-token"
+
+    def _upsert_profile(self, profile: SessionProfile) -> None:
+        payload = self._load_profiles()
+        payload.setdefault("profiles", {})[profile.profile] = asdict(profile)
+        self._save_profiles(payload)
+
+    def _load_profiles(self) -> JSONObject:
+        if not self._profiles_path.exists():
+            return {"profiles": {}}
+        with self._profiles_path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+
+    def _save_profiles(self, payload: JSONObject) -> None:
+        self._profiles_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._profiles_path.open("w", encoding="utf-8") as handle:
+            json.dump(payload, handle, ensure_ascii=False, indent=2)
+
+    def _set_secret(self, key: str, value: str) -> bool:
+        if self._keyring is None:
+            return False
+        try:
+            self._keyring.set_password(KEYRING_SERVICE_NAME, key, value)
+            return True
+        except Exception:
+            return False
+
+    def _get_secret(self, key: str) -> str | None:
+        if self._keyring is None:
+            return None
+        try:
+            return self._keyring.get_password(KEYRING_SERVICE_NAME, key)
+        except Exception:
+            return None
+
+    def _delete_secret(self, key: str) -> None:
+        if self._keyring is None:
+            return
+        try:
+            self._keyring.delete_password(KEYRING_SERVICE_NAME, key)
+        except Exception:
+            return

package/src/qingflow_mcp/solution/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .normalizer import normalize_solution_spec
+from .spec_models import SolutionSpec
+
+__all__ = ["SolutionSpec", "normalize_solution_spec"]