@josephyan/qingflow-app-builder-mcp 0.2.0-beta.4 → 0.2.0-beta.41

package/src/qingflow_mcp/backend_client.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from threading import Event
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
 from uuid import uuid4
 
 import httpx
@@ -201,6 +204,182 @@ class BackendClient:
             "body": body,
         }
 
+    def download_binary(self, url: str, *, headers: dict[str, str] | None = None) -> bytes:
+        try:
+            response = self._client.get(url, headers=headers or None)
+        except httpx.RequestError as exc:
+            raise QingflowApiError(category="network", message=str(exc))
+        if response.status_code >= 400:
+            raise QingflowApiError(
+                category="http",
+                message=self._extract_message(response.text) or f"HTTP {response.status_code}",
+                http_status=response.status_code,
+            )
+        return response.content
+
+    def request_multipart(
+        self,
+        method: str,
+        context: BackendRequestContext,
+        path: str,
+        *,
+        data: dict[str, Any] | None = None,
+        files: dict[str, tuple[str, bytes, str | None]] | None = None,
+        unwrap: bool = True,
+    ) -> JSONValue:
+        return self.request_multipart_with_meta(
+            method,
+            context,
+            path,
+            data=data,
+            files=files,
+            unwrap=unwrap,
+        ).data
+
+    def request_multipart_with_meta(
+        self,
+        method: str,
+        context: BackendRequestContext,
+        path: str,
+        *,
+        data: dict[str, Any] | None = None,
+        files: dict[str, tuple[str, bytes, str | None]] | None = None,
+        unwrap: bool = True,
+    ) -> BackendResponse:
+        headers = self._base_headers(
+            context.token,
+            context.ws_id,
+            context.qf_request_id,
+            qf_version=context.qf_version,
+        )
+        request_files: dict[str, tuple[str, bytes, str | None]] | None = None
+        if files:
+            request_files = {key: value for key, value in files.items()}
+        try:
+            response = self._client.request(
+                method.upper(),
+                self._build_url(context.base_url, path),
+                data=data,
+                files=request_files,
+                headers=headers,
+            )
+        except httpx.RequestError as exc:
+            raise QingflowApiError(category="network", message=str(exc), request_id=headers["Qf-Request-Id"])
+        parsed = self._parse_response(response, headers["Qf-Request-Id"], unwrap=unwrap)
+        return BackendResponse(
+            data=parsed,
+            headers=dict(response.headers),
+            request_id=headers["Qf-Request-Id"],
+            http_status=response.status_code,
+            qf_response_version=self._extract_response_qf_version(response.headers),
+        )
+
+    def start_socket_data_import(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        being_enter_auditing: bool,
+        view_key: str | None,
+        excel_url: str,
+        excel_name: str,
+        ack_timeout_seconds: float = 8.0,
+        initial_wait_seconds: float = 4.0,
+    ) -> dict[str, Any]:
+        try:
+            import socketio  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise QingflowApiError(
+                category="config",
+                message=f"socket.io client dependency is missing: {exc}",
+            )
+
+        socket_base_url = self._build_socket_base_url(context.base_url)
+        import_result: dict[str, Any] = {
+            "import_id": None,
+            "process_id_str": None,
+            "status": "accepted",
+            "warnings": [],
+            "initial_event": None,
+            "failure_event": None,
+        }
+        initial_event_received = Event()
+        failure_event_received = Event()
+        sio = socketio.Client(reconnection=False, logger=False, engineio_logger=False)
+
+        def _handle_initial(payload: Any) -> None:
+            if isinstance(payload, dict):
+                import_result["initial_event"] = payload
+                process_id = payload.get("processIdStr") or payload.get("process_id_str") or payload.get("processId")
+                if process_id is not None:
+                    import_result["process_id_str"] = str(process_id)
+            initial_event_received.set()
+
+        def _handle_failure(payload: Any) -> None:
+            if isinstance(payload, dict):
+                import_result["failure_event"] = payload
+                process_id = payload.get("processIdStr") or payload.get("process_id_str") or payload.get("processId")
+                if process_id is not None:
+                    import_result["process_id_str"] = str(process_id)
+            failure_event_received.set()
+
+        try:
+            sio.connect(
+                socket_base_url,
+                transports=["polling", "websocket"],
+                socketio_path="socket.io",
+                headers=self._base_headers(
+                    context.token,
+                    context.ws_id,
+                    qf_version=context.qf_version,
+                ),
+                wait_timeout=ack_timeout_seconds,
+            )
+            ack = sio.call(
+                "dataImport",
+                [
+                    context.token,
+                    app_key,
+                    bool(being_enter_auditing),
+                    view_key,
+                    False,
+                    excel_url,
+                    excel_name,
+                ],
+                timeout=ack_timeout_seconds,
+            )
+            import_id = ack[0] if isinstance(ack, list) and ack else ack
+            if not import_id:
+                raise QingflowApiError(category="backend", message="socket import ack did not return import_id")
+            import_result["import_id"] = str(import_id)
+            sio.on(f"dataImportRes_{import_result['import_id']}", _handle_initial)
+            sio.on(f"dataImportFail_{import_result['import_id']}", _handle_failure)
+            if not initial_event_received.wait(timeout=initial_wait_seconds) and not failure_event_received.wait(timeout=0.1):
+                import_result["warnings"].append(
+                    {
+                        "code": "IMPORT_SOCKET_INITIAL_EVENT_PENDING",
+                        "message": "Import ack received, but no initial progress payload arrived within the initial wait window.",
+                    }
+                )
+        except Exception as exc:
+            message = str(exc)
+            if "timeout" in message.lower():
+                raise QingflowApiError(
+                    category="network",
+                    message="socket import ack timed out",
+                    details={"error_code": "IMPORT_SOCKET_ACK_TIMEOUT"},
+                )
+            if isinstance(exc, QingflowApiError):
+                raise
+            raise QingflowApiError(category="network", message=message or "socket import failed")
+        finally:
+            try:
+                if sio.connected:
+                    sio.disconnect()
+            except Exception:
+                pass
+        return import_result
+
     def _request_with_meta(
         self,
         method: str,
@@ -334,3 +513,13 @@ class BackendClient:
         if not normalized:
             raise QingflowApiError.config_error("base_url is required")
         return f"{normalized}/{path.lstrip('/')}"
+
+    def _build_socket_base_url(self, base_url: str) -> str:
+        normalized = normalize_base_url(base_url)
+        if not normalized:
+            raise QingflowApiError.config_error("base_url is required")
+        parsed = urlsplit(normalized)
+        path = parsed.path.rstrip("/")
+        if path.endswith("/api"):
+            path = path[:-4]
+        return urlunsplit((parsed.scheme, parsed.netloc, path or "", "", ""))