iflow-mcp_orion4d-comfyui_mcp 1.0.0__py3-none-any.whl

iflow_mcp_orion4d_comfyui_mcp/__init__.py

@@ -0,0 +1,9 @@
+"""
+iflow-mcp_orion4d-comfyui_mcp - MCP server for ComfyUI
+"""
+
+__version__ = "1.0.0"
+
+from .server import main
+
+__all__ = ["main"]

iflow_mcp_orion4d_comfyui_mcp/__main__.py

@@ -0,0 +1,8 @@
+"""
+Main entry point for iflow-mcp_orion4d_comfyui_mcp package
+"""
+
+from .server import main
+
+if __name__ == "__main__":
+    main()

iflow_mcp_orion4d_comfyui_mcp/browser_controller.py

@@ -0,0 +1,123 @@
+"""
+Contrôleur pour envoyer des commandes à l'extension Chrome via WebSocket.
+Compatible avec le ConnectionManager du serveur MCP.
+"""
+
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class BrowserController:
+    """
+    Contrôleur pour envoyer des commandes à l'extension Chrome.
+    Utilise le WebSocket ConnectionManager au lieu de Playwright.
+    """
+    
+    def __init__(self, manager):
+        """
+        Initialise le contrôleur avec le WebSocket manager.
+        
+        Args:
+            manager: Instance de ConnectionManager pour WebSocket
+        """
+        self.manager = manager
+        logger.info("BrowserController initialisé avec WebSocket manager")
+    
+    async def click_element(self, selector: str) -> Dict[str, Any]:
+        """
+        Envoie une commande de clic à l'extension Chrome.
+        
+        Args:
+            selector: Sélecteur CSS de l'élément
+            
+        Returns:
+            dict: Confirmation de l'envoi
+        """
+        command = {
+            "action": "click",
+            "selector": selector
+        }
+        
+        await self.manager.send_command(command)
+        logger.info(f"Commande click envoyée: {selector}")
+        
+        return {
+            "status": "sent",
+            "action": "click",
+            "selector": selector,
+            "message": f"Commande envoyée à {len(self.manager.active_connections)} extension(s)"
+        }
+    
+    async def fill_input(self, selector: str, text: str) -> Dict[str, Any]:
+        """
+        Envoie une commande pour remplir un champ texte.
+        
+        Args:
+            selector: Sélecteur CSS du champ
+            text: Texte à insérer
+            
+        Returns:
+            dict: Confirmation de l'envoi
+        """
+        command = {
+            "action": "fill",
+            "selector": selector,
+            "text": text
+        }
+        
+        await self.manager.send_command(command)
+        logger.info(f"Commande fill envoyée: {selector} = '{text[:50]}'")
+        
+        return {
+            "status": "sent",
+            "action": "fill",
+            "selector": selector,
+            "text": text,
+            "message": f"Commande envoyée à {len(self.manager.active_connections)} extension(s)"
+        }
+    
+    async def get_workflow(self) -> Dict[str, Any]:
+        """
+        Demande à l'extension de récupérer le workflow actuel.
+        
+        Returns:
+            dict: Confirmation (workflow sera affiché dans la console de l'extension)
+        """
+        command = {
+            "action": "get_workflow"
+        }
+        
+        await self.manager.send_command(command)
+        logger.info("Commande get_workflow envoyée")
+        
+        return {
+            "status": "sent",
+            "action": "get_workflow",
+            "message": "Le workflow sera affiché dans la console de l'extension Chrome (F12)",
+            "connections": len(self.manager.active_connections)
+        }
+    
+    async def execute_script(self, script: str) -> Dict[str, Any]:
+        """
+        Envoie du JavaScript arbitraire à exécuter.
+        
+        Args:
+            script: Code JavaScript à exécuter
+            
+        Returns:
+            dict: Confirmation de l'envoi
+        """
+        command = {
+            "action": "execute_js",
+            "script": script
+        }
+        
+        await self.manager.send_command(command)
+        logger.info(f"Script JS envoyé: {script[:100]}")
+        
+        return {
+            "status": "sent",
+            "action": "execute_js",
+            "message": f"Script envoyé à {len(self.manager.active_connections)} extension(s)"
+        }

iflow_mcp_orion4d_comfyui_mcp/comfyui_client.py

@@ -0,0 +1,301 @@
+import requests
+import json
+import time
+import logging
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("ComfyUIClient")
+
+DEFAULT_MAPPING = {
+    "prompt": ("6", "text"),
+    "width": ("5", "width"),
+    "height": ("5", "height"),
+    "model": ("4", "ckpt_name")
+}
+
+class ComfyUIClient:
+    def __init__(self, base_url="http://127.0.0.1:8188", workflows_dir="workflows"):
+        self.base_url = base_url
+        self.workflows_dir = Path(workflows_dir)
+        self.available_models = self._get_available_models()
+    
+    def _get_available_models(self):
+        """Fetch list of available checkpoint models from ComfyUI"""
+        try:
+            response = requests.get(f"{self.base_url}/object_info/CheckpointLoaderSimple")
+            if response.status_code != 200:
+                logger.warning("Failed to fetch model list; using default handling")
+                return []
+            data = response.json()
+            models = data["CheckpointLoaderSimple"]["input"]["required"]["ckpt_name"][0]
+            logger.info(f"Available models: {len(models)} models found")
+            return models
+        except Exception as e:
+            logger.warning(f"Error fetching models: {e}")
+            return []
+    
+    def list_workflows(self):
+        """Liste tous les workflows disponibles (récursif avec sous-dossiers)"""
+        if not self.workflows_dir.exists():
+            return []
+        workflows = []
+        for json_file in self.workflows_dir.rglob("*.json"):
+            relative_path = json_file.relative_to(self.workflows_dir)
+            workflow_id = str(relative_path.with_suffix('')).replace('\\', '/')
+            workflows.append(workflow_id)
+        return sorted(workflows)
+    
+    def _is_ui_format(self, workflow: dict) -> bool:
+        """Détecte si le workflow est au format UI ou API"""
+        return "nodes" in workflow and "links" in workflow
+    
+    def _convert_ui_to_api(self, ui_workflow: dict) -> dict:
+        """
+        Convertit un workflow UI ComfyUI en format API.
+        Version améliorée qui gère correctement les widgets.
+        """
+        logger.info("Converting workflow from UI format to API format")
+        api_workflow = {}
+        nodes = ui_workflow.get("nodes", [])
+        links = ui_workflow.get("links", [])
+        
+        # Créer un mapping link_id -> (source_node_id, source_slot)
+        link_map = {}
+        for link in links:
+            if len(link) >= 5:
+                link_id = link[0]
+                source_node_id = str(link[1])
+                source_slot = link[2]
+                link_map[link_id] = (source_node_id, source_slot)
+        
+        # Convertir chaque node
+        for node in nodes:
+            node_id = str(node["id"])
+            node_type = node.get("type")
+            if not node_type:
+                logger.warning(f"Node {node_id} has no type, skipping")
+                continue
+            
+            inputs = {}
+            
+            # Récupérer la définition des inputs du node
+            node_inputs = node.get("inputs", [])
+            
+            # 1. D'ABORD : Traiter les connections (links)
+            for input_def in node_inputs:
+                link_id = input_def.get("link")
+                if link_id is not None and link_id in link_map:
+                    source_node_id, source_slot = link_map[link_id]
+                    input_name = input_def.get("name")
+                    if input_name:
+                        inputs[input_name] = [source_node_id, source_slot]
+            
+            # 2. ENSUITE : Traiter les widgets_values
+            if "widgets_values" in node and node["widgets_values"]:
+                widgets = node["widgets_values"]
+                widget_inputs = []
+                for input_def in node_inputs:
+                    has_widget = input_def.get("widget") is not None
+                    has_link = input_def.get("link") is not None
+                    if has_widget and not has_link:
+                        widget_inputs.append(input_def["name"])
+                
+                for i, value in enumerate(widgets):
+                    if i < len(widget_inputs):
+                        input_name = widget_inputs[i]
+                        inputs[input_name] = value
+                    else:
+                        logger.warning(f"Node {node_id}: Extra widget value at index {i}: {value}")
+            
+            # Créer le node au format API
+            api_workflow[node_id] = {
+                "inputs": inputs,
+                "class_type": node_type
+            }
+            
+            logger.debug(f"Node {node_id} ({node_type}): {len(inputs)} inputs converted")
+        
+        logger.info(f"Converted {len(api_workflow)} nodes from UI to API format")
+        return api_workflow
+    
+    def load_workflow(self, workflow_id: str) -> dict:
+        """
+        Charge un workflow et le convertit automatiquement si nécessaire.
+        Supporte les sous-dossiers (ex: "flux/upscale")
+        """
+        workflow_path = self.workflows_dir / f"{workflow_id}.json"
+        if not workflow_path.exists():
+            raise FileNotFoundError(f"Workflow '{workflow_id}' not found at {workflow_path}")
+        
+        with open(workflow_path, 'r', encoding='utf-8') as f:
+            workflow = json.load(f)
+        
+        # Détection et conversion automatique
+        if self._is_ui_format(workflow):
+            logger.info(f"Workflow '{workflow_id}' is in UI format, converting to API format")
+            return self._convert_ui_to_api(workflow)
+        else:
+            logger.info(f"Workflow '{workflow_id}' is already in API format")
+            return workflow
+    
+    def generate_image(self, prompt, width=512, height=512, workflow_id="basic_api_test", model=None):
+        """
+        Generate an image using ComfyUI with a predefined workflow.
+        Automatically converts UI format workflows to API format.
+        """
+        # Load workflow (with automatic conversion)
+        workflow = self.load_workflow(workflow_id)
+        
+        # Apply parameters using mapping
+        mapping = DEFAULT_MAPPING
+        
+        # Update prompt
+        if "prompt" in mapping:
+            node_id, field = mapping["prompt"]
+            if node_id in workflow:
+                workflow[node_id]["inputs"][field] = prompt
+        
+        # Update dimensions
+        if "width" in mapping:
+            node_id, field = mapping["width"]
+            if node_id in workflow:
+                workflow[node_id]["inputs"][field] = width
+        
+        if "height" in mapping:
+            node_id, field = mapping["height"]
+            if node_id in workflow:
+                workflow[node_id]["inputs"][field] = height
+        
+        # Update model if specified
+        if model and "model" in mapping:
+            node_id, field = mapping["model"]
+            if node_id in workflow:
+                if self.available_models and model not in self.available_models:
+                    logger.warning(f"Model '{model}' not found. Using workflow default.")
+                else:
+                    workflow[node_id]["inputs"][field] = model
+        
+        # Submit workflow
+        payload = {"prompt": workflow}
+        response = requests.post(f"{self.base_url}/prompt", json=payload)
+        response.raise_for_status()
+        result = response.json()
+        prompt_id = result.get("prompt_id")
+        
+        if not prompt_id:
+            raise ValueError("No prompt_id returned from ComfyUI")
+        
+        logger.info(f"Workflow submitted. Prompt ID: {prompt_id}")
+        
+        # Poll for completion
+        max_wait = 120
+        start_time = time.time()
+        
+        while time.time() - start_time < max_wait:
+            history_response = requests.get(f"{self.base_url}/history/{prompt_id}")
+            history_response.raise_for_status()
+            history = history_response.json()
+            
+            if prompt_id in history:
+                outputs = history[prompt_id].get("outputs", {})
+                for node_output in outputs.values():
+                    if "images" in node_output:
+                        images = node_output["images"]
+                        if images:
+                            img = images[0]
+                            filename = img["filename"]
+                            subfolder = img.get("subfolder", "")
+                            img_type = img.get("type", "output")
+                            
+                            url = f"{self.base_url}/view?filename={filename}"
+                            if subfolder:
+                                url += f"&subfolder={subfolder}"
+                            url += f"&type={img_type}"
+                            
+                            logger.info(f"Image generated: {url}")
+                            return url
+            
+            time.sleep(1)
+        
+        raise TimeoutError(f"Image generation timed out after {max_wait} seconds")
+    
+    def get_queue_info(self) -> dict:
+        """
+        Récupère les informations de la file d'attente ComfyUI
+        
+        Returns:
+            dict: État de la queue avec running et pending
+        """
+        try:
+            response = requests.get(f"{self.base_url}/queue")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Erreur lors de la récupération de la queue: {e}")
+            return {"queue_running": [], "queue_pending": []}
+    
+    def get_object_info(self, node_class: str = None) -> dict:
+        """
+        Récupère les informations des nodes ComfyUI
+        
+        Args:
+            node_class: Classe spécifique à récupérer (optionnel)
+        
+        Returns:
+            dict: Informations sur les nodes disponibles
+        """
+        try:
+            if node_class:
+                response = requests.get(f"{self.base_url}/object_info/{node_class}")
+            else:
+                response = requests.get(f"{self.base_url}/object_info")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Erreur lors de la récupération de object_info: {e}")
+            return {}
+    
+    def queue_prompt(self, workflow: dict) -> dict:
+        """Envoie un workflow à ComfyUI pour exécution"""
+        try:
+            payload = {"prompt": workflow}
+            response = requests.post(f"{self.base_url}/prompt", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Erreur lors de l'envoi du workflow: {e}")
+            return {"status": "error", "message": str(e)}
+    
+    def get_history(self, prompt_id: str) -> dict:
+        """Récupère l'historique d'un prompt (outputs, status)"""
+        try:
+            resp = requests.get(f"{self.base_url}/history/{prompt_id}")
+            resp.raise_for_status()
+            return resp.json()
+        except Exception as e:
+            logger.error(f"Erreur get_history({prompt_id}): {e}")
+            return {"status": "error", "message": str(e)}
+   
+    def interrupt(self) -> dict:
+        """Sends an interrupt request to ComfyUI"""
+        try:
+            response = requests.post(f"{self.base_url}/interrupt")
+            response.raise_for_status()
+            logger.info("Interrupt request sent to ComfyUI.")
+            return {"status": "success", "message": "Interrupt request sent"}
+        except Exception as e:
+            logger.error(f"Error sending interrupt request: {e}")
+            return {"status": "error", "message": str(e)}
+   
+    async def get_system_stats(self) -> dict:
+        """Récupère les stats CPU, RAM, GPU du backend ComfyUI"""
+        import aiohttp
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"{self.base_url}/system_stats") as response:
+                    response.raise_for_status()
+                    return await response.json()
+        except Exception as e:
+            logger.error(f"Erreur lors de la récupération des stats système: {e}")
+            return {"status": "error", "message": str(e)}

iflow_mcp_orion4d_comfyui_mcp/generate_key.py

@@ -0,0 +1,158 @@
+"""
+Générateur de clés sécurisées pour le serveur MCP ComfyUI.
+Génère MCP_API_KEY (pour ChatGPT) et WEBSOCKET_TOKEN (pour Extension Chrome).
+"""
+
+import secrets
+from datetime import datetime
+from pathlib import Path
+
+def generate_api_key(length: int = 32) -> str:
+    """
+    Génère une clé API cryptographiquement sécurisée.
+    
+    Args:
+        length: Longueur de la clé (par défaut 32 caractères)
+    
+    Returns:
+        Clé API URL-safe
+    """
+    return secrets.token_urlsafe(length)
+
+if __name__ == "__main__":
+    print("\n" + "="*70)
+    print("🔑 Générateur de Clés Sécurisées - Serveur MCP ComfyUI")
+    print("="*70 + "\n")
+    
+    # Générer les clés
+    mcp_api_key = generate_api_key(32)
+    websocket_token = generate_api_key(32)
+    date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    print(f"📅 Date de génération : {date}\n")
+    
+    print("🔐 Vos clés générées :")
+    print("-" * 70)
+    print(f"\n1️⃣  MCP_API_KEY (pour ChatGPT via API HTTP):")
+    print(f"   {mcp_api_key}\n")
+    print(f"2️⃣  WEBSOCKET_TOKEN (pour Extension Chrome):")
+    print(f"   {websocket_token}\n")
+    
+    print("="*70)
+    print("📋 CONFIGURATION .env")
+    print("="*70)
+    print("\nAjoutez ces lignes dans votre fichier .env :\n")
+    print(f"MCP_API_KEY={mcp_api_key}")
+    print(f"WEBSOCKET_TOKEN={websocket_token}\n")
+    
+    print("="*70)
+    print("📋 CONFIGURATION CHATGPT")
+    print("="*70)
+    print("\nCustom Action / GPT Configuration:")
+    print("  • Authentication Type: API Key")
+    print("  • Custom Header Name: X-API-Key")
+    print(f"  • API Key: {mcp_api_key}\n")
+    
+    print("="*70)
+    print("📋 CONFIGURATION EXTENSION CHROME")
+    print("="*70)
+    print("\nDans le popup de l'extension :")
+    print("  • URL: ws://127.0.0.1:8000/ws")
+    print(f"  • Token: {websocket_token}\n")
+    
+    print("="*70)
+    print("\n⚠️  SÉCURITÉ - IMPORTANT :")
+    print("="*70)
+    print("  • Ne partagez JAMAIS ces clés")
+    print("  • Conservez-les uniquement dans .env (git ignoré)")
+    print("  • Regénérez-les si elles sont compromises")
+    print("  • Utilisez des clés différentes pour chaque environnement")
+    print("\n" + "="*70 + "\n")
+    
+    # Proposer de sauvegarder
+    save = input("💾 Voulez-vous créer/mettre à jour le fichier .env ? (o/n) : ")
+    
+    if save.lower() in ['o', 'oui', 'y', 'yes']:
+        env_path = Path('.env')
+        
+        # Vérifier si .env existe déjà
+        if env_path.exists():
+            backup = input("\n⚠️  Le fichier .env existe déjà. Créer une sauvegarde ? (o/n) : ")
+            if backup.lower() in ['o', 'oui', 'y', 'yes']:
+                backup_path = Path(f'.env.backup.{datetime.now().strftime("%Y%m%d_%H%M%S")}')
+                env_path.rename(backup_path)
+                print(f"✅ Sauvegarde créée : {backup_path}")
+        
+        env_content = f"""# Configuration Serveur MCP ComfyUI
+# Généré le {date}
+
+# ComfyUI
+COMFYUI_BASE_URL=http://127.0.0.1:8188
+WORKFLOWS_DIR=workflows
+COMFYUI_PATH=D:\\ComfyUI_dev\\ComfyUI
+
+# Sécurité - API Key pour ChatGPT (via HTTP/HTTPS)
+MCP_API_KEY={mcp_api_key}
+
+# Sécurité - Token WebSocket pour Extension Chrome
+ENABLE_BROWSER_CONTROL=true
+WEBSOCKET_TOKEN={websocket_token}
+
+# Timeouts (en secondes)
+HTTP_TIMEOUT=60
+GENERATION_TIMEOUT=300
+
+# Options navigateur (non utilisé avec Extension Chrome)
+BROWSER_HEADLESS=false
+"""
+        
+        with open('.env', 'w', encoding='utf-8') as f:
+            f.write(env_content)
+        
+        print(f"\n✅ Fichier .env créé avec succès !")
+        print(f"   Emplacement : {env_path.absolute()}")
+        
+        # Créer aussi un .env.example (sans les vraies clés)
+        env_example_content = f"""# Configuration Serveur MCP ComfyUI
+# Exemple de configuration - Générez vos propres clés avec generate_api_key.py
+
+# ComfyUI
+COMFYUI_BASE_URL=http://127.0.0.1:8188
+WORKFLOWS_DIR=workflows
+COMFYUI_PATH=D:\\ComfyUI_dev\\ComfyUI
+
+# Sécurité - API Key pour ChatGPT (via HTTP/HTTPS)
+# Générez avec : python generate_api_key.py
+MCP_API_KEY=votre_cle_api_ici
+
+# Sécurité - Token WebSocket pour Extension Chrome
+ENABLE_BROWSER_CONTROL=true
+# Générez avec : python generate_api_key.py
+WEBSOCKET_TOKEN=votre_token_websocket_ici
+
+# Timeouts (en secondes)
+HTTP_TIMEOUT=60
+GENERATION_TIMEOUT=300
+
+# Options navigateur
+BROWSER_HEADLESS=false
+"""
+        
+        with open('.env.example', 'w', encoding='utf-8') as f:
+            f.write(env_example_content)
+        
+        print(f"✅ Fichier .env.example créé (template pour Git)")
+        
+        print("\n" + "="*70)
+        print("🎉 CONFIGURATION TERMINÉE")
+        print("="*70)
+        print("\n✅ Prochaines étapes :")
+        print("   1. Redémarrez le serveur MCP : python server.py")
+        print("   2. Configurez l'extension Chrome avec le WEBSOCKET_TOKEN")
+        print("   3. Configurez ChatGPT avec le MCP_API_KEY")
+        print("\n" + "="*70 + "\n")
+        
+    else:
+        print("\n✅ Copiez manuellement les clés dans votre .env")
+        print("   N'oubliez pas les deux clés : MCP_API_KEY et WEBSOCKET_TOKEN\n")
+