iflow-mcp_orion4d-comfyui_mcp 1.0.0__tar.gz

iflow_mcp_orion4d_comfyui_mcp-1.0.0/.env

@@ -0,0 +1,12 @@
+# MCP API Key for testing
+MCP_API_KEY=test_key_123
+
+# WebSocket Token for Chrome extension
+WEBSOCKET_TOKEN=test_ws_token_123
+
+# Browser control disabled for testing
+ENABLE_BROWSER_CONTROL=false
+
+# ComfyUI configuration (not needed for MCP protocol test)
+# COMFYUI_BASE_URL=http://127.0.0.1:8188
+# COMFYUI_ROOT=/path/to/comfyui

iflow_mcp_orion4d_comfyui_mcp-1.0.0/.env.exampleforGPT

@@ -0,0 +1,30 @@
+# ============================================================================
+# Configuration Cloudflare Tunnel (avec Extension Chrome)
+# ============================================================================
+
+# ----- ComfyUI Local -----
+COMFYUI_BASE_URL=http://127.0.0.1:8188
+WORKFLOWS_DIR=workflows
+
+# Chemin de votre comfyUI, Exemple D:\ComfyUI_dev\ComfyUI
+COMFYUI_ROOT=
+
+# ----- Sécurité API -----
+# Décommente si tu veux activer l'authentification
+# pour le moment les connecteurs ChatGPT personnalisés ne proposent pas d'API key
+# Clé API à genérer (generate_key.py)
+# MCP_API_KEY=ta_cle_api_forte_ici
+
+# ----- Extension Chrome (via Cloudflare) -----
+ENABLE_BROWSER_CONTROL=true
+
+# Clé Websoket à genérer (generate_key.py)
+WEBSOCKET_TOKEN=
+
+# ----- Timeouts (augmentés pour Cloudflare) -----
+HTTP_TIMEOUT=120
+GENERATION_TIMEOUT=600
+
+# Votre adresse URL tunnel sécurisé, attention garder cette adresse privée
+# Toute personne avec l'URL peut accéder à votre serveur MCP
+PUBLIC_URL=

iflow_mcp_orion4d_comfyui_mcp-1.0.0/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

iflow_mcp_orion4d_comfyui_mcp-1.0.0/3017_process.log

@@ -0,0 +1,3 @@
+[2026-02-04 05:38:16] [SUCCESS] 步骤1-获取项目: 成功fork并克隆项目 orion4d/ComfyUI_mcp
+[2026-02-04 05:38:55] [SUCCESS] 步骤2-阅读代码: 项目类型=Python, MCP服务端=是, 传输协议=stdio+HTTP
+[2026-02-04 05:49:17] [SUCCESS] 步骤3-本地测试: 成功检测到28个工具, 无需额外环境变量

iflow_mcp_orion4d_comfyui_mcp-1.0.0/Extension_Chrome/background.js

@@ -0,0 +1,328 @@
+// =============================
+// MCP ComfyUI Controller - background.js (MV3) - Version Corrigée
+// =============================
+
+// ---------- Configuration par défaut ----------
+let MCP_WEBSOCKET_URL = "ws://127.0.0.1:8000/ws";
+let WEBSOCKET_TOKEN = "";
+let BROWSER_CONTROL_ENABLED = true;
+
+// ---------- État WS ----------
+let ws = null;
+let reconnectTimeout = null;
+let isConnecting = false;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 5;
+
+// ---------- Journal partagé (popup <-> bg) ----------
+const LOG_BUFFER = [];
+const LOG_MAX = 200;
+
+function pushLog(entry) {
+  const stamp = new Date().toISOString().slice(11, 19); // HH:MM:SS
+  const row = { t: stamp, level: "info", ...entry };
+  LOG_BUFFER.push(row);
+  if (LOG_BUFFER.length > LOG_MAX) LOG_BUFFER.shift();
+
+  chrome.runtime.sendMessage({ action: "log_update", rows: [row] }, () => {
+    if (chrome.runtime.lastError) { /* Popup fermé, c'est normal */ }
+  });
+}
+
+// ---------- Chargement config depuis storage ----------
+let CONFIG_READY = false;
+const waitConfig = new Promise((resolve) => {
+  chrome.storage.sync.get(
+    ["mcpServerUrl", "mcpWebSocketToken", "mcpBrowserControlEnabled"],
+    (result) => {
+      if (result.mcpServerUrl) MCP_WEBSOCKET_URL = result.mcpServerUrl;
+      if (result.mcpWebSocketToken) WEBSOCKET_TOKEN = result.mcpWebSocketToken;
+      if (typeof result.mcpBrowserControlEnabled === "boolean") {
+        BROWSER_CONTROL_ENABLED = result.mcpBrowserControlEnabled;
+      }
+      pushLog({ level: "info", msg: "Config chargée" });
+      CONFIG_READY = true;
+      resolve();
+
+      if (BROWSER_CONTROL_ENABLED) {
+        pushLog({ level: "info", msg: "Connexion auto dans 3s…" });
+        setTimeout(connect, 3000);
+      } else {
+        pushLog({ level: "info", msg: "Contrôle navigateur désactivé" });
+      }
+    }
+  );
+});
+
+// ---------- Handlers messages (popup -> bg) ----------
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  // ... (Le reste de ce listener est parfait, pas de changement nécessaire) ...
+  if (message.action === "updateConfig") {
+    MCP_WEBSOCKET_URL = message.url ?? MCP_WEBSOCKET_URL;
+    WEBSOCKET_TOKEN = message.token ?? WEBSOCKET_TOKEN;
+    pushLog({ level: "info", msg: "Config mise à jour depuis popup" });
+    disconnect();
+    if (BROWSER_CONTROL_ENABLED) {
+      reconnectAttempts = 0;
+      connect();
+    }
+    sendResponse({ success: true });
+    return true;
+  }
+  if (message.action === "toggleBrowserControl") {
+    BROWSER_CONTROL_ENABLED = !!message.enabled;
+    pushLog({ level: "info", msg: `Contrôle ${BROWSER_CONTROL_ENABLED ? "activé" : "désactivé"}` });
+    if (BROWSER_CONTROL_ENABLED) {
+      reconnectAttempts = 0;
+      connect();
+    } else {
+      disconnect();
+    }
+    sendResponse({ success: true });
+    return true;
+  }
+  if (message.action === "reconnect") {
+    if (BROWSER_CONTROL_ENABLED) {
+      disconnect();
+      reconnectAttempts = 0;
+      connect();
+    }
+    sendResponse({ success: true });
+    return true;
+  }
+  if (message.action === "getConnectionStatus") {
+    sendResponse({
+      connected: ws && ws.readyState === WebSocket.OPEN,
+      connecting: isConnecting,
+      enabled: BROWSER_CONTROL_ENABLED,
+    });
+    return true;
+  }
+  if (message.action === "getLog") {
+    sendResponse({ rows: LOG_BUFFER });
+    return true;
+  }
+  if (message.action === "execAndReturn" && message.cmd) {
+    executeCommandAndReturn(message.cmd)
+      .then((data) => sendResponse({ ok: true, data }))
+      .catch((e) => sendResponse({ ok: false, error: String(e) }));
+    return true;
+  }
+  // Action non reconnue (implicite)
+});
+
+// ---------- Connexion WebSocket sécurisée ----------
+async function connect() {
+  // ... (Cette fonction est parfaite, pas de changement nécessaire) ...
+  if (!CONFIG_READY) await waitConfig;
+  if (!BROWSER_CONTROL_ENABLED) {
+    pushLog({ level: "info", msg: "Connexion annulée (contrôle désactivé)" });
+    return;
+  }
+  if (!WEBSOCKET_TOKEN) {
+    pushLog({ level: "warn", msg: "Token absent → pas de tentative WS (évite 403)" });
+    return;
+  }
+  if (isConnecting || (ws && ws.readyState === WebSocket.OPEN)) return;
+  if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+    pushLog({ level: "error", msg: "Max reconnexions atteint" });
+    reconnectAttempts = 0;
+    return;
+  }
+  isConnecting = true;
+  reconnectAttempts++;
+  const urlWithToken = `${MCP_WEBSOCKET_URL}?token=${encodeURIComponent(WEBSOCKET_TOKEN)}`;
+  pushLog({ level: "info", msg: `Connexion WS (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})` });
+  try {
+    ws = new WebSocket(urlWithToken);
+    ws.onopen = () => {
+      isConnecting = false;
+      reconnectAttempts = 0;
+      pushLog({ level: "info", msg: "WS connecté" });
+      const pingInterval = setInterval(() => {
+        if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "ping" }));
+        else clearInterval(pingInterval);
+      }, 30000);
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "pong") return;
+        if (data.error) {
+          pushLog({ level: "error", msg: `Erreur serveur: ${data.error}` });
+          if (data.message) pushLog({ level: "error", msg: data.message });
+          return;
+        }
+        pushLog({ level: "debug", msg: `Commande reçue: ${data.action || data.type || "—"}` });
+        executeCommand(data);
+      } catch (e) {
+        pushLog({ level: "error", msg: `JSON parse error: ${String(e)}` });
+      }
+    };
+    ws.onclose = (event) => {
+      isConnecting = false;
+      if (event.code === 1008) {
+        pushLog({ level: "error", msg: "Auth refusée (token invalide/manquant)" });
+        reconnectAttempts = MAX_RECONNECT_ATTEMPTS;
+        return;
+      }
+      pushLog({ level: "warn", msg: `WS fermé (${event.code})` });
+      if (BROWSER_CONTROL_ENABLED && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        const delay = Math.min(5000 * reconnectAttempts, 30000);
+        pushLog({ level: "info", msg: `Reconnexion dans ${delay / 1000}s…` });
+        reconnectTimeout = setTimeout(connect, delay);
+      }
+    };
+    ws.onerror = () => {
+      isConnecting = false;
+      pushLog({ level: "warn", msg: "WS error (handshake/403 ?)" });
+    };
+  } catch (error) {
+    isConnecting = false;
+    pushLog({ level: "error", msg: `Création WS: ${String(error)}` });
+    if (BROWSER_CONTROL_ENABLED && reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+      reconnectTimeout = setTimeout(connect, 5000);
+    }
+  }
+}
+
+function disconnect() {
+  // ... (Cette fonction est parfaite, pas de changement nécessaire) ...
+  if (reconnectTimeout) {
+    clearTimeout(reconnectTimeout);
+    reconnectTimeout = null;
+  }
+  if (ws) {
+    try { ws.close(); } catch {}
+    ws = null;
+  }
+  isConnecting = false;
+  pushLog({ level: "info", msg: "WS déconnecté" });
+}
+
+// ---------- Utilitaires ----------
+function isValidSelector(selector) { /* ... parfait, pas de changement ... */ return true; }
+async function getComfyTab() { /* ... parfait, pas de changement ... */ const tabs = await chrome.tabs.query({url: ["http://127.0.0.1:8188/*", "http://localhost:8188/*"]}); return tabs[0];}
+
+// ---------- Exécution des commandes (reçues du WS) ----------
+async function executeCommand(command) {
+  try {
+    const data = await executeCommandAndReturn(command);
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      // CORRECTION : On construit la réponse pour le serveur MCP ici
+      // Le type de la réponse est dérivé de l'action de la commande
+      const responseType = {
+        "dump_dom": "dom_dump",
+        "get_nodes_map": "nodes_map",
+        "get_workflow": "workflow"
+      }[command.action];
+
+      if (responseType) {
+        // On envoie directement les données, sans le wrapper {ok: true}
+        ws.send(JSON.stringify({ type: responseType, data: data }));
+        pushLog({ level: "info", msg: `Réponse '${responseType}' envoyée au serveur` });
+      }
+    }
+  } catch (err) {
+    pushLog({ level: "error", msg: `Erreur exécution commande: ${String(err)}` });
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "error", message: `Erreur côté extension: ${String(err)}` }));
+    }
+  }
+}
+
+
+// ---------- Exécution de commande avec RETOUR de données (pour popup et WS) ----------
+async function executeCommandAndReturn(command) {
+  const comfyTab = await getComfyTab();
+  if (!comfyTab) throw new Error("Aucun onglet ComfyUI (8188) trouvé");
+
+  const [res] = await chrome.scripting.executeScript({
+    target: { tabId: comfyTab.id },
+    world: 'MAIN',
+    func: injectedLogic, // AMÉLIORATION: On utilise une seule fonction d'injection
+    args: [command]
+  });
+
+  if (res && res.result) {
+    if (res.result.error) {
+      throw new Error(res.result.error + (res.result.message ? `: ${res.result.message}` : ''));
+    }
+    return res.result; // Retourne directement les données (ex: {count: ..., items: ...})
+  }
+  throw new Error("Aucun résultat du script injecté.");
+}
+
+
+// ========== Fonctions injectées dans la page ComfyUI ==========
+// AMÉLIORATION: Toute la logique est maintenant dans une seule fonction pour la propreté.
+function injectedLogic(command) {
+  
+  // -- Fonctions utilitaires dans la page --
+  const waitForGraph = (ms = 5000) => new Promise((resolve) => {
+    const start = performance.now();
+    const tick = () => {
+      const g = (window.app && window.app.graph) || null;
+      if (g && (g._nodes || g.nodes) && typeof g.serialize === 'function') return resolve(g);
+      if (performance.now() - start > ms) return resolve(null);
+      requestAnimationFrame(tick);
+    };
+    tick();
+  });
+
+  // -- Logique principale --
+  switch (command.action) {
+    case "click": {
+      const el = document.querySelector(command.selector);
+      if (el) el.click();
+      return { ok: true };
+    }
+    case "fill": {
+      const el = document.querySelector(command.selector);
+      if (el) {
+        el.value = command.text ?? "";
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      return { ok: true };
+    }
+    case "dump_dom": {
+      // ... la fonction runInPageDump est déplacée ici ...
+      const maxItems = command.maxItems || 100;
+      const uniquePath = el => { /* ... (code de uniquePath inchangé) ... */ if(!el)return"";let path=[],n=5;while(el&&el.nodeType===1&&n-->0){let t=(e=>{if(!e)return"";if(e.id)return`#${e.id}`;let l=(e.className||"").toString().split(/\s+/).filter(Boolean).slice(0,3).join("."),r=(e.tagName||"div").toLowerCase();return l?`${r}.${l}`:r})(el);const o=el.parentElement;o&&Array.from(o.children).filter(t=>t.tagName===el.tagName).length>1&&(t+=`:nth-of-type(${Array.from(o.children).filter(t=>t.tagName===el.tagName).indexOf(el)+1})`),path.unshift(t),el=o}return path.join(" > ")};
+      const pick = (selector) => Array.from(document.querySelectorAll(selector));
+      const buttons = pick("button, [role='button'], .btn, .comfy-btn");
+      const inputs = pick("input, textarea, [contenteditable='true']");
+      const serialize = (el) => ({
+        tag: (el.tagName || "").toLowerCase(), id: el.id || null, classes: (el.className || "").toString().trim() || null,
+        selector: uniquePath(el), text: (el.innerText || el.value || "").trim().replace(/\s+/g, " ").slice(0, 120),
+      });
+      const items = [...buttons, ...inputs].slice(0, maxItems).map(serialize);
+      return { url: location.href, count: items.length, items };
+    }
+    case "get_nodes_map": {
+      return waitForGraph().then(g => {
+        if (!g) return { error: "graph_not_ready" };
+        const list = (g._nodes || g.nodes || []);
+        const nodes = Array.from(list).map(n => ({
+          id: n.id, type: n.type || n.constructor?.name || "Unknown",
+          title: n.title || n.type || `Node ${n.id}`, pos: n.pos || null
+        }));
+        return { url: location.href, count: nodes.length, nodes };
+      });
+    }
+    case "get_workflow": {
+      return waitForGraph().then(g => {
+        if (!g) return { error: "graph_not_ready" };
+        try {
+          const wf = g.serialize();
+          return { url: location.href, node_count: (wf.nodes || []).length, workflow: wf };
+        } catch (e) {
+          return { error: "serialize_failed", message: String(e) };
+        }
+      });
+    }
+    default:
+      return { error: `Action inconnue: ${command.action}` };
+  }
+}

iflow_mcp_orion4d_comfyui_mcp-1.0.0/Extension_Chrome/manifest.json

@@ -0,0 +1,35 @@
+{
+  "manifest_version": 3,
+  "name": "MCP ComfyUI Controller",
+  "version": "1.0",
+  "description": "Connecte ComfyUI au serveur MCP local via WebSocket sécurisé.",
+  "minimum_chrome_version": "116",
+  "permissions": [
+    "scripting",
+    "tabs",
+    "storage"
+  ],
+  "host_permissions": [
+    "http://127.0.0.1:8188/*",
+    "http://localhost:8188/*"
+  ],
+  "content_security_policy": {
+    "extension_pages": "script-src 'self'; object-src 'self'; connect-src ws://127.0.0.1:* ws://localhost:* wss://*.trycloudflare.com wss://*.ngrok.io wss://*.loca.lt;"
+  },
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "icon16.png",
+      "48": "icon48.png",
+      "128": "icon128.png"
+    }
+  },
+  "icons": {
+    "16": "icon16.png",
+    "48": "icon48.png",
+    "128": "icon128.png"
+  }
+}

iflow_mcp_orion4d_comfyui_mcp-1.0.0/Extension_Chrome/popup.html

@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <title>MCP ComfyUI Controller</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { width: 500px; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: #fff; padding: 16px; }
+    h2 { font-size: 18px; margin-bottom: 12px; text-align: center; }
+    h3 { font-size: 14px; margin: 12px 0 8px; border-bottom: 1px solid rgba(255,255,255,0.3); padding-bottom: 4px; }
+    .status { display: flex; align-items: center; gap: 12px; padding: 12px; background: rgba(255,255,255,0.1); border-radius: 8px; margin-bottom: 16px; }
+    .status-indicator { width: 12px; height: 12px; border-radius: 50%; }
+    .status.connected .status-indicator { background: #4ade80; box-shadow: 0 0 8px #4ade80; }
+    .status.connecting .status-indicator { background: #fbbf24; animation: pulse 1.5s infinite; }
+    .status.disconnected .status-indicator { background: #f87171; }
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }
+    .toggle-btn { width: 60px; height: 30px; background: rgba(255,255,255,0.2); border-radius: 15px; cursor: pointer; position: relative; transition: background 0.3s; }
+    .toggle-btn::after { content: ""; position: absolute; width: 26px; height: 26px; border-radius: 50%; background: #fff; top: 2px; left: 2px; transition: left 0.3s; }
+    .toggle-btn.active { background: #4ade80; }
+    .toggle-btn.active::after { left: 32px; }
+    .config-panel { background: rgba(255,255,255,0.15); padding: 12px; border-radius: 8px; margin-bottom: 12px; }
+    input[type="text"], input[type="password"] { width: 100%; padding: 8px; margin-top: 6px; border: none; border-radius: 4px; background: rgba(255,255,255,0.9); color: #333; }
+    button { padding: 8px 16px; margin: 4px; border: none; border-radius: 6px; cursor: pointer; font-weight: 600; transition: all 0.2s; }
+    .btn-primary { background: #4ade80; color: #000; }
+    .btn-primary:hover { background: #22c55e; transform: translateY(-2px); }
+    .btn-secondary { background: rgba(255,255,255,0.2); color: #fff; }
+    .btn-secondary:hover { background: rgba(255,255,255,0.3); }
+    textarea { width: 100%; height: 300px; background: #1a1a2e; color: #eee; padding: 10px; border: none; border-radius: 6px; font-family: 'Consolas', 'Monaco', monospace; font-size: 11px; resize: vertical; }
+    .btn-group { display: flex; gap: 8px; margin-top: 8px; flex-wrap: wrap; }
+  </style>
+</head>
+<body>
+  <h2>🎨 MCP ComfyUI Controller</h2>
+  
+  <div class="status" id="status">
+    <div class="status-indicator"></div>
+    <span id="statusText">Déconnecté du serveur MCP</span>
+  </div>
+
+  <div style="display: flex; align-items: center; gap: 12px; margin-bottom: 12px;">
+    <span>Contrôle du navigateur</span>
+    <div class="toggle-btn" id="enableToggle"></div>
+  </div>
+
+  <div class="config-panel" id="configPanel">
+    <label>🔗 URL du serveur WebSocket</label>
+    <input type="text" id="serverUrl" placeholder="ws://127.0.0.1:8000/ws">
+    
+    <label style="display: block; margin-top: 12px;">🔑 Token d'authentification</label>
+    <input type="password" id="authToken" placeholder="Optionnel">
+    
+    <div style="margin-top: 12px;">
+      <button class="btn-primary" id="saveBtn">💾 Sauvegarder</button>
+      <button class="btn-secondary" id="testBtn">🔌 Tester</button>
+    </div>
+  </div>
+
+  <h3>📦 Sortie JSON</h3>
+  <textarea id="jsonOutput" placeholder="Les résultats JSON apparaîtront ici..."></textarea>
+  
+  <div class="btn-group">
+    <button class="btn-primary" id="dumpDomBtn">🔍 Inspecter DOM</button>
+    <button class="btn-primary" id="nodesMapBtn">🧩 Nodes Map</button>
+    <button class="btn-primary" id="workflowBtn">📄 Workflow JSON</button>
+    <button class="btn-secondary" id="downloadJsonBtn">💾 Télécharger</button>
+  </div>
+
+  <div style="margin-top: 16px; text-align: center; font-size: 11px; opacity: 0.7;">
+    Développé pour ComfyUI • Connexion sécurisée par token
+  </div>
+
+  <script src="popup.js"></script>
+</body>
+</html>

iflow_mcp_orion4d_comfyui_mcp-1.0.0/Extension_Chrome/popup.js

@@ -0,0 +1,149 @@
+// =============================
+// MCP ComfyUI Controller - popup.js
+// =============================
+
+const $ = (id) => document.getElementById(id);
+const statusEl = $("status");
+const statusText = $("statusText");
+const enableToggle = $("enableToggle");
+const configPanel = $("configPanel");
+const serverUrl = $("serverUrl");
+const authToken = $("authToken");
+const jsonOutput = $("jsonOutput");
+
+function setStatus({ connected, connecting }) {
+  statusEl.classList.remove("connected", "connecting", "disconnected");
+  if (connected) {
+    statusEl.classList.add("connected");
+    statusText.textContent = "Connecté au serveur MCP";
+  } else if (connecting) {
+    statusEl.classList.add("connecting");
+    statusText.textContent = "Connexion au serveur MCP…";
+  } else {
+    statusEl.classList.add("disconnected");
+    statusText.textContent = "Déconnecté du serveur MCP";
+  }
+}
+
+function setToggle(enabled) {
+  enableToggle.classList.toggle("active", enabled);
+  configPanel.style.display = enabled ? "block" : "none";
+}
+
+function initPopup() {
+  chrome.storage.sync.get(
+    ["mcpServerUrl", "mcpWebSocketToken", "mcpBrowserControlEnabled"],
+    (res) => {
+      serverUrl.value = res.mcpServerUrl || "ws://127.0.0.1:8000/ws";
+      authToken.value = res.mcpWebSocketToken || "";
+      const enabled = typeof res.mcpBrowserControlEnabled === "boolean" ? res.mcpBrowserControlEnabled : true;
+      setToggle(enabled);
+      
+      chrome.runtime.sendMessage({ action: "getConnectionStatus" }, (st) => {
+        if (!chrome.runtime.lastError) {
+          setStatus(st || { connected: false, connecting: false });
+        }
+      });
+    }
+  );
+
+  // Toggle activation
+  enableToggle.addEventListener("click", () => {
+    const enabled = !enableToggle.classList.contains("active");
+    setToggle(enabled);
+    chrome.storage.sync.set({ mcpBrowserControlEnabled: enabled }, () => {
+      chrome.runtime.sendMessage({ action: "toggleBrowserControl", enabled });
+    });
+  });
+
+  // Sauvegarder la configuration
+  $("saveBtn").addEventListener("click", () => {
+    const url = serverUrl.value.trim();
+    const token = authToken.value.trim();
+    chrome.storage.sync.set({ mcpServerUrl: url, mcpWebSocketToken: token }, () => {
+      chrome.runtime.sendMessage({ action: "updateConfig", url, token });
+    });
+  });
+
+  // Test de connexion
+  $("testBtn").addEventListener("click", () => {
+    chrome.runtime.sendMessage({ action: "getConnectionStatus" }, (st) => {
+      if (!chrome.runtime.lastError) {
+        setStatus(st || { connected: false, connecting: false });
+      }
+    });
+  });
+
+  // Inspecter DOM
+  $("dumpDomBtn").addEventListener("click", () => {
+    chrome.runtime.sendMessage(
+      { action: "execAndReturn", cmd: { action: "dump_dom", maxItems: 200 } },
+      (resp) => {
+        if (chrome.runtime.lastError) {
+          jsonOutput.value = `Erreur: ${chrome.runtime.lastError.message}`;
+          return;
+        }
+        jsonOutput.value = resp?.ok ? JSON.stringify(resp.data, null, 2) : `Erreur: ${resp?.error || "inconnue"}`;
+        jsonOutput.scrollTop = 0;
+      }
+    );
+  });
+
+  // Nodes Map
+  $("nodesMapBtn").addEventListener("click", () => {
+    chrome.runtime.sendMessage({ action: "execAndReturn", cmd: { action: "get_nodes_map" } }, (resp) => {
+      if (chrome.runtime.lastError) {
+        jsonOutput.value = `Erreur: ${chrome.runtime.lastError.message}`;
+        return;
+      }
+      jsonOutput.value = resp?.ok ? JSON.stringify(resp.data, null, 2) : `Erreur: ${resp?.error || "inconnue"}`;
+      jsonOutput.scrollTop = 0;
+    });
+  });
+
+  // Workflow JSON
+  $("workflowBtn").addEventListener("click", () => {
+    chrome.runtime.sendMessage({ action: "execAndReturn", cmd: { action: "get_workflow" } }, (resp) => {
+      if (chrome.runtime.lastError) {
+        jsonOutput.value = `Erreur: ${chrome.runtime.lastError.message}`;
+        return;
+      }
+      jsonOutput.value = resp?.ok ? JSON.stringify(resp.data, null, 2) : `Erreur: ${resp?.error || "inconnue"}`;
+      jsonOutput.scrollTop = 0;
+    });
+  });
+
+  // Télécharger JSON
+  $("downloadJsonBtn").addEventListener("click", () => {
+    const txt = jsonOutput.value || "";
+    if (!txt.trim()) return;
+    const blob = new Blob([txt], { type: "application/json;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    const now = new Date().toISOString().replace(/[:.]/g, "-");
+    a.download = `mcp-comfyui-${now}.json`;
+    document.body.appendChild(a);
+    a.click();
+    setTimeout(() => {
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    }, 100);
+  });
+
+  // Rafraîchissement du statut de connexion toutes les 5 secondes
+  setInterval(() => {
+    chrome.runtime.sendMessage({ action: "getConnectionStatus" }, (st) => {
+      if (!chrome.runtime.lastError && st) {
+        setStatus(st);
+      }
+    });
+  }, 5000);
+}
+
+// Initialisation
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initPopup);
+} else {
+  initPopup();
+}

iflow_mcp_orion4d_comfyui_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Philippe Joye (Orion4D)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.