pcloudy 0.1.0__py3-none-any.whl

api/__init__.py

@@ -0,0 +1,76 @@
+from .auth import Auth
+from .device import Device
+from .file_management import FileManagement
+from .services import Services
+from .app_management import AppManagement
+from .session import Session
+from .adb import Adb
+from .platform import Platform
+from .device_control import DeviceControl
+from .qpilot_credits import QPilotCredits
+from .qpilot_project import QPilotProject
+from .qpilot_test_suite import QPilotTestSuite
+from .qpilot_test_case import QPilotTestCase
+from .qpilot_steps import QPilotSteps
+from .qpilot_appium_control import QPilotAppiumControl
+from .qpilot_script import QPilotScript
+import os
+import httpx
+from config import Config, logger
+from dotenv import load_dotenv
+
+# Ensure .env is loaded if not already
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+load_dotenv(os.path.join(project_root, '.env'))
+
+class PCloudyAPI(
+    Auth,
+    Device,
+    FileManagement,
+    Services,
+    AppManagement,
+    Session,
+    Adb,
+    Platform,
+    DeviceControl,
+    QPilotCredits,
+    QPilotProject,
+    QPilotTestSuite,
+    QPilotTestCase,
+    QPilotSteps,
+    QPilotAppiumControl,
+    QPilotScript
+):
+    def __init__(self, base_url=None):
+        Auth.__init__(self)
+        Device.__init__(self)
+        FileManagement.__init__(self)
+        Services.__init__(self)
+        AppManagement.__init__(self)
+        Session.__init__(self)
+        Adb.__init__(self)
+        Platform.__init__(self)
+        DeviceControl.__init__(self)
+        QPilotCredits.__init__(self)
+        QPilotProject.__init__(self)
+        QPilotTestSuite.__init__(self)
+        QPilotTestCase.__init__(self)
+        QPilotSteps.__init__(self)
+        QPilotAppiumControl.__init__(self)
+        QPilotScript.__init__(self)
+        self.username = os.environ.get("PCLOUDY_USERNAME") or os.environ.get("PLOUDY_USERNAME")
+        self.api_key = os.environ.get("PCLOUDY_API_KEY") or os.environ.get("PLOUDY_API_KEY")
+        if not self.username or not self.api_key:
+            logger.warning("PCLOUDY_USERNAME or PCLOUDY_API_KEY not set. Check your .env file and environment.")
+        self.base_url = base_url or Config.PCLOUDY_BASE_URL
+        self.client = httpx.AsyncClient(timeout=Config.REQUEST_TIMEOUT)
+        self.rid = None
+        logger.info("PCloudyAPI initialized (modular)")
+
+    async def close(self):
+        """Close the HTTP client."""
+        try:
+            await self.client.aclose()
+            logger.info("HTTP client closed")
+        except Exception as e:
+            logger.error(f"Error closing HTTP client: {str(e)}")

api/adb.py

@@ -0,0 +1,85 @@
+from config import Config, logger
+import httpx
+import json
+from utils import encode_auth, parse_response
+
+class Adb:
+    async def execute_adb_command(self, rid: int, adb_command: str):
+        token = await self.get_token()
+        if not adb_command.strip():
+            raise ValueError("ADB command cannot be empty")
+        original_command = adb_command.strip().strip('"').strip("'")
+        # Ensure 'adb ' prefix is present for backend compatibility
+        if not original_command.lower().startswith('adb '):
+            send_command = f'adb {original_command}'
+            logger.info(f"Added 'adb' prefix: sending '{send_command}' to backend.")
+        else:
+            send_command = original_command
+        logger.info(f"Executing ADB command on RID {rid}: {send_command}")
+        url = f"{self.base_url}/execute_adb"
+        payload = {
+            "token": token,
+            "rid": rid,
+            "adbCommand": send_command
+        }
+        headers = {"Content-Type": "application/json"}
+        timeout_config = httpx.Timeout(connect=30.0, read=120.0, write=30.0, pool=30.0)
+        async with httpx.AsyncClient(timeout=timeout_config) as client:
+            logger.debug(f"Sending ADB request to: {url}")
+            logger.debug(f"Payload: {json.dumps(payload, indent=2)}")
+            response = await client.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+            raw_data = response.json()
+            logger.info(f"Raw ADB response: {json.dumps(raw_data, indent=2)}")
+            if isinstance(raw_data, dict):
+                result = raw_data.get("result", raw_data)
+                status_code = result.get("code", 0)
+                message = result.get("msg", "")
+                output_content = None
+                output_source = None
+                for field_name in ["adbreply", "output", "reply", "response", "data", "result"]:
+                    if field_name in result and result[field_name] is not None:
+                        output_content = result[field_name]
+                        output_source = field_name
+                        break
+                if output_content is not None:
+                    formatted_output = str(output_content)
+                    if "\n" in formatted_output:
+                        formatted_output = formatted_output.replace("\n", "\n")
+                    formatted_output = formatted_output.strip()
+                    if not formatted_output:
+                        formatted_output = "[Command executed successfully but returned empty output]"
+                else:
+                    formatted_output = "[No output returned from device]"
+                    logger.warning(f"No output found in response fields. Available keys: {list(result.keys())}")
+                is_success = status_code == 200 and "Invalid Command" not in formatted_output
+                if is_success:
+                    logger.info(f"ADB command successful. Output source: {output_source}, Length: {len(formatted_output)}")
+                    return {
+                        "success": True,
+                        "output": formatted_output,
+                        "command": send_command,
+                        "rid": rid,
+                        "status_code": status_code,
+                        "message": message,
+                        "output_source": output_source
+                    }
+                else:
+                    error_msg = f"ADB command failed: {formatted_output}"
+                    logger.error(error_msg)
+                    return {
+                        "success": False,
+                        "error": error_msg,
+                        "command": send_command,
+                        "rid": rid,
+                        "status_code": status_code,
+                        "raw_response": raw_data
+                    }
+            else:
+                logger.error(f"Unexpected response format: {type(raw_data)}")
+                return {
+                    "success": False,
+                    "error": f"Unexpected response format: {type(raw_data)}",
+                    "command": send_command,
+                    "rid": rid
+                }

api/app_management.py

@@ -0,0 +1,137 @@
+from config import Config, logger
+from utils import encode_auth, parse_response
+import httpx
+import webbrowser
+
+class AppManagement:
+    async def install_and_launch_app(self, rid: int, filename: str, grant_all_permissions: bool = True, app_package_name: str = None):
+        token = await self.get_token()
+        url = f"{self.base_url}/install_app"
+        payload = {
+            "token": token,
+            "rid": rid,
+            "filename": filename,
+            "grant_all_permissions": grant_all_permissions
+        }
+        headers = {"Content-Type": "application/json"}
+        response = await self.client.post(url, json=payload, headers=headers)
+        response.raise_for_status()
+        result = parse_response(response)
+        if result.get("code") == 200 and result.get("msg") == "success":
+            package = result.get("package", "")
+            logger.info(f"App '{filename}' installed and launched successfully on RID: {rid}")
+            response_content = [
+                {"type": "text", "text": f"✅ App '{filename}' installed and launched successfully on RID: {rid}"}
+            ]
+            if package:
+                response_content.append({"type": "text", "text": f"📱 Package: {package}"})
+            try:
+                logger.info(f"Getting device page URL for RID: {rid}")
+                url_result = await self.get_device_page_url(rid)
+                if not url_result.get("isError", True):
+                    device_url = url_result.get("content", [{}])[0].get("text", "")
+                    if device_url:
+                        webbrowser.open(device_url)
+                        response_content.append({"type": "text", "text": f"🌐 Device page opened in browser: {device_url}"})
+                        logger.info(f"Device page opened in browser: {device_url}")
+                    else:
+                        response_content.append({"type": "text", "text": "⚠️ Could not retrieve device page URL"})
+                else:
+                    response_content.append({"type": "text", "text": "⚠️ Could not retrieve device page URL"})
+            except Exception as url_error:
+                logger.warning(f"Failed to open device page URL: {str(url_error)}")
+                response_content.append({"type": "text", "text": f"⚠️ Could not open device page: {str(url_error)}"})
+            return {
+                "content": response_content,
+                "isError": False
+            }
+        else:
+            logger.error(f"Install and launch failed: {result}")
+            return {
+                "content": [{"type": "text", "text": f"Install and launch failed: {result}"}],
+                "isError": True
+            }
+
+    async def resign_ipa(self, filename: str, force_resign: bool = False):
+        await self.check_token_validity()
+        from security import extract_package_name_hint
+        if not force_resign:
+            logger.info(f"Checking if resigned version of '{filename}' already exists...")
+            try:
+                base_name = filename.rsplit('.', 1)[0]
+                expected_resigned_names = [
+                    f"{base_name}_resign.ipa",
+                    f"{base_name}-resign.ipa",
+                    f"resign_{base_name}.ipa",
+                    f"{filename}_resign",
+                    f"resign_{filename}"
+                ]
+                cloud_apps_result = await self.list_cloud_apps(limit=100, filter_type="all")
+                if not cloud_apps_result.get("isError", True):
+                    cloud_content = cloud_apps_result.get("content", [])
+                    if cloud_content:
+                        cloud_files_text = str(cloud_content[0].get("text", "")).lower()
+                        for resigned_name in expected_resigned_names:
+                            if resigned_name.lower() in cloud_files_text:
+                                logger.warning(f"Resigned version '{resigned_name}' already exists in cloud")
+                                return {
+                                    "content": [
+                                        {"type": "text", "text": f"⚠️ A resigned version of '{filename}' already exists in the cloud drive"},
+                                        {"type": "text", "text": f"🔍 Found existing resigned file: {resigned_name}"},
+                                        {"type": "text", "text": "💡 To resign anyway (replace existing), call: resign_ipa(filename=\"" + filename + "\", force_resign=True)"},
+                                        {"type": "text", "text": "📋 To see all cloud files, use: list_cloud_apps()"}
+                                    ],
+                                    "isError": False,
+                                    "duplicate_detected": True,
+                                    "existing_resigned_file": resigned_name
+                                }
+            except Exception as check_error:
+                logger.warning(f"Could not check for existing resigned files: {str(check_error)}")
+        headers = {"Content-Type": "application/json"}
+        token = await self.get_token()
+        url_initiate = f"{self.base_url}/resign/initiate"
+        payload_initiate = {"token": token, "filename": filename}
+        response = await self.client.post(url_initiate, json=payload_initiate, headers=headers)
+        response.raise_for_status()
+        result = parse_response(response)
+        resign_token = result.get("resign_token")
+        resign_filename = result.get("resign_filename")
+        if not resign_token or not resign_filename:
+            raise Exception(f"Failed to initiate resigning IPA. API response: {result}")
+        logger.info(f"Resigning IPA '{filename}' - this may take up to 60 seconds...")
+        url_progress = f"{self.base_url}/resign/progress"
+        for _ in range(30):
+            payload_progress = {
+                "token": token,
+                "resign_token": resign_token,
+                "filename": filename
+            }
+            response = await self.client.post(url_progress, json=payload_progress, headers=headers)
+            response.raise_for_status()
+            result = parse_response(response)
+            resign_status = result.get("resign_status")
+            if resign_status == 100:
+                break
+            import asyncio
+            await asyncio.sleep(2)
+        url_download = f"{self.base_url}/resign/download"
+        payload_download = {
+            "token": token,
+            "resign_token": resign_token,
+            "filename": filename
+        }
+        response = await self.client.post(url_download, json=payload_download, headers=headers)
+        response.raise_for_status()
+        result = parse_response(response)
+        resigned_file = result.get("resign_file")
+        if not resigned_file:
+            raise Exception(f"Failed to download resigned IPA. API response: {result}")
+        resign_message = f"IPA file '{filename}' has been resigned successfully"
+        if force_resign:
+            resign_message += " (replaced existing resigned version)"
+        logger.info(resign_message)
+        return {
+            "content": [{"type": "text", "text": resign_message}],
+            "isError": False,
+            "resigned_file": resigned_file
+        }

api/auth.py

@@ -0,0 +1,136 @@
+"""
+Authentication Mixin for pCloudy MCP Server
+
+Provides authentication and token management for the PCloudyAPI class.
+- authenticate: Authenticates with pCloudy using username and API key.
+- check_token_validity: Ensures the token is valid and refreshes if expired.
+
+Intended to be used as a mixin in the modular API architecture.
+"""
+
+import time
+import os
+        # ...existing code...
+from utils import encode_auth, parse_response
+from config import Config, logger
+import httpx
+
+class Auth:
+    TOKEN_REFRESH_THRESHOLD = 24 * 60 * 60  # 24 hours in seconds
+
+    def __init__(self):
+        self.username = None
+        self.api_key = None
+        self.base_url = None
+        self._auth_token = None
+        self._token_timestamp = None
+        self.client = None
+        self._db_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "pcloudy_tokens.db")
+        self._init_db()
+
+    def _init_db(self):
+        """Initialize the SQLite database and tokens table"""
+        import sqlite3
+        conn = sqlite3.connect(self._db_path)
+        c = conn.cursor()
+        c.execute("""
+            CREATE TABLE IF NOT EXISTS tokens (
+                username TEXT PRIMARY KEY,
+                token TEXT,
+                timestamp REAL
+            )
+        """)
+        conn.commit()
+        conn.close()
+
+    def _save_token_to_db(self):
+        """Save token to SQLite DB, encoding the token value"""
+        if not self._auth_token or not self._token_timestamp:
+            return
+        import sqlite3, base64
+        try:
+            encoded_token = base64.b64encode(self._auth_token.encode('utf-8')).decode('utf-8')
+            conn = sqlite3.connect(self._db_path)
+            c = conn.cursor()
+            c.execute("REPLACE INTO tokens (username, token, timestamp) VALUES (?, ?, ?)",
+                      (self.username, encoded_token, self._token_timestamp))
+            conn.commit()
+            conn.close()
+            logger.info(f"Token saved to DB for user: {self.username}")
+        except Exception as e:
+            logger.error(f"Failed to save token to DB: {str(e)}")
+
+    def _load_token_from_db(self):
+        """Load token from SQLite DB and decode the token value"""
+        import sqlite3, base64
+        try:
+            conn = sqlite3.connect(self._db_path)
+            c = conn.cursor()
+            c.execute("SELECT token, timestamp FROM tokens WHERE username=?", (self.username,))
+            row = c.fetchone()
+            conn.close()
+            if row:
+                encoded_token, self._token_timestamp = row
+                self._auth_token = base64.b64decode(encoded_token.encode('utf-8')).decode('utf-8')
+                logger.info("Token loaded from DB successfully")
+                return True
+            else:
+                return False
+        except Exception as e:
+            logger.error(f"Failed to load token from DB: {str(e)}")
+            return False
+
+    async def authenticate(self) -> str:
+        """
+        Authenticate with the pCloudy API and store the token.
+        Raises ValueError if credentials are missing or authentication fails.
+        """
+        try:
+            if not self.username or not self.api_key:
+                logger.error("PCLOUDY_USERNAME or PCLOUDY_API_KEY environment variable not set.")
+                raise ValueError("PCLOUDY_USERNAME or PCLOUDY_API_KEY environment variable not set.")
+            logger.info("Authenticating with pCloudy")
+            url = f"{self.base_url}/access"
+            auth = encode_auth(self.username, self.api_key)
+            headers = {"Authorization": f"Basic {auth}"}
+            response = await self.client.get(url, headers=headers)
+            response.raise_for_status()
+            result = parse_response(response)
+            self._auth_token = result.get("token")
+            if not self._auth_token:
+                logger.error("Authentication failed: No token received")
+                raise ValueError("Authentication failed: No token received")
+            self._token_timestamp = time.time()
+            # Save token to DB for persistence
+            self._save_token_to_db()
+            logger.info("Authentication successful")
+            return self._auth_token
+        except httpx.RequestError as e:
+            logger.error(f"Authentication request failed: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Authentication error: {str(e)}")
+            raise
+
+    async def get_token(self) -> str:
+        """
+        Get a valid authentication token, refreshing if expired (every 8 hours).
+        This is the only method that should be used to access the token.
+        """
+        # Try to load token from DB first
+        if not self._auth_token:
+            self._load_token_from_db()
+        # If missing or expired, renew
+        if (not self._auth_token or not self._token_timestamp or
+            (time.time() - float(self._token_timestamp)) > self.TOKEN_REFRESH_THRESHOLD):
+            logger.info("Token missing or expired, generating new token...")
+            await self.authenticate()
+        return self._auth_token
+
+    # Optionally, keep check_token_validity for legacy use
+    async def check_token_validity(self) -> str:
+        """
+        Ensure the authentication token is valid, refreshing if expired.
+        Raises ValueError if not authenticated.
+        """
+        return await self.get_token()

api/device.py

@@ -0,0 +1,168 @@
+"""
+Device Management Mixin for pCloudy MCP Server
+
+Provides device management operations for the PCloudyAPI class:
+- get_devices_list: List available devices for a platform
+- book_device: Book a device by ID
+- release_device: Release a booked device by RID
+
+Intended to be used as a mixin in the modular API architecture.
+"""
+
+from config import Config, logger
+from utils import encode_auth, parse_response
+import httpx
+import asyncio
+
+class Device:
+    async def get_devices_list(self, platform: str = Config.DEFAULT_PLATFORM, duration: int = Config.DEFAULT_DURATION, available_now: bool = True):
+        """
+        List available devices for a given platform and duration.
+        Returns a dict with device models and availability.
+        """
+        try:
+            platform = platform.lower().strip()
+            if platform not in Config.VALID_PLATFORMS:
+                logger.error(f"Invalid platform: {platform}. Must be one of {Config.VALID_PLATFORMS}")
+                raise ValueError(f"Invalid platform: {platform}. Must be one of {Config.VALID_PLATFORMS}")
+            await self.check_token_validity()
+            logger.info(f"Getting device list for platform {platform}")
+            url = f"{self.base_url}/devices"
+            token = await self.get_token()
+            payload = {
+                "token": token,
+                "platform": platform,
+                "duration": duration,
+                "available_now": str(available_now).lower()
+            }
+            headers = {"Content-Type": "application/json"}
+            response = await self.client.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+            result = parse_response(response)
+            logger.info(f"Retrieved {len(result.get('models', []))} devices for {platform}")
+            return result
+        except httpx.RequestError as e:
+            logger.error(f"Device list request failed: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error getting device list: {str(e)}")
+            raise
+
+    async def book_device(self, device_id: str, duration: int = Config.DEFAULT_DURATION, auto_start_services: bool = True):
+        """
+        Book a device by its ID. Optionally auto-starts device services.
+        Returns booking info and optionally enhanced content.
+        """
+        try:
+            await self.check_token_validity()
+            logger.info(f"Booking device with ID {device_id}")
+            url = f"{self.base_url}/book_device"
+            token = await self.get_token()
+            payload = {
+                "token": token,
+                "id": device_id,
+                "duration": duration
+            }
+            headers = {"Content-Type": "application/json"}
+            response = await self.client.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+            result = parse_response(response)
+            rid = result.get('rid')
+            logger.info(f"Device booked successfully. RID: {rid}")
+            response_content = [
+                {"type": "text", "text": f"\u2705 Device booked successfully. RID: {rid}"}
+            ]
+            if auto_start_services and rid:
+                try:
+                    logger.info(f"Auto-starting device services for RID: {rid}")
+                    await asyncio.sleep(2)
+                    services_result = await self.start_device_services(rid)
+                    if not services_result.get("isError", True):
+                        response_content.extend(services_result.get("content", []))
+                        logger.info(f"Device services started successfully for RID: {rid}")
+                    else:
+                        response_content.append({
+                            "type": "text", 
+                            "text": "\u26a0\ufe0f Device services failed to start automatically, but device is booked successfully"
+                        })
+                        response_content.append({
+                            "type": "text", 
+                            "text": "\ud83d\udca1 You can manually start services with: start_device_services(rid=\"" + str(rid) + "\")"
+                        })
+                        logger.warning(f"Failed to auto-start device services: {services_result}")
+                except Exception as service_error:
+                    logger.warning(f"Failed to auto-start device services: {str(service_error)}")
+                    response_content.append({
+                        "type": "text", 
+                        "text": "\u26a0\ufe0f Device services failed to start automatically, but device is booked successfully"
+                    })
+                    response_content.append({
+                        "type": "text", 
+                        "text": "\ud83d\udca1 You can manually start services with: start_device_services(rid=\"" + str(rid) + "\")"
+                    })
+            enhanced_result = result.copy()
+            enhanced_result["enhanced_content"] = response_content
+            return enhanced_result
+        except httpx.RequestError as e:
+            logger.error(f"Device booking request failed: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error booking device: {str(e)}")
+            raise
+
+    async def release_device(self, rid: int, auto_download: bool = False):
+        """
+        Release a booked device by its RID. Optionally auto-downloads session data.
+        Returns a dict with release status and messages.
+        """
+        try:
+            await self.check_token_validity()
+            logger.info(f"Releasing device with RID: {rid} (this may take 10-20 seconds)")
+            url = f"{self.base_url}/release_device"
+            token = await self.get_token()
+            payload = {"token": token, "rid": int(rid)}
+            headers = {"Content-Type": "application/json"}
+            async with httpx.AsyncClient(timeout=30.0) as release_client:
+                response = await release_client.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                result = parse_response(response)
+                if result.get("code") == 200 and result.get("msg") == "success":
+                    logger.info(f"Device {rid} released successfully")
+                    return {
+                        "content": [{"type": "text", "text": f"\u2705 Device {rid} released successfully"}],
+                        "isError": False
+                    }
+                else:
+                    # Handle different error response formats from pCloudy API
+                    def find_error(d):
+                        if isinstance(d, dict):
+                            if 'error' in d and d['error']:
+                                return d['error']
+                            for v in d.values():
+                                found = find_error(v)
+                                if found:
+                                    return found
+                        elif isinstance(d, list):
+                            for item in d:
+                                found = find_error(item)
+                                if found:
+                                    return found
+                        return None
+                    error_msg = find_error(result) or result.get('msg') or "Unknown error"
+                    logger.error(f"Device release failed: {error_msg}")
+                    return {
+                        "content": [{"type": "text", "text": f"Device release failed: {error_msg}"}],
+                        "isError": True
+                    }
+        except httpx.TimeoutException:
+            logger.error(f"Release device request timed out after 30 seconds for RID: {rid}")
+            return {
+                "content": [{"type": "text", "text": f"Release device request timed out. The device may still be released, but the server was slow to respond. Please check device status."}],
+                "isError": True
+            }
+        except Exception as e:
+            logger.error(f"Error releasing device {rid}: {str(e)}")
+            return {
+                "content": [{"type": "text", "text": f"Error releasing device: {str(e)}"}],
+                "isError": True
+            }