Merge e04ed0eda7 into c8dce94c03

* Update custom-node-list.json

* Update custom-node-list.json

* Update custom-node-list.json

---------

Co-authored-by: Dr.Lt.Data <128333288+ltdrdata@users.noreply.github.com>

glob/manager_core.py

@@ -43,7 +43,7 @@ import manager_downloader
 from node_package import InstalledNodePackage
 
 
-version_code = [3, 37]
+version_code = [3, 37, 2]
 version_str = f"V{version_code[0]}.{version_code[1]}" + (f'.{version_code[2]}' if len(version_code) > 2 else '')
 
 
@@ -2533,6 +2533,7 @@ def update_to_stable_comfyui(repo_path):
         else:
             logging.info(f"[ComfyUI-Manager] Updating ComfyUI: {current_tag} -> {latest_tag}")
             repo.git.checkout(latest_tag)
+            execute_install_script("ComfyUI", repo_path, instant_execution=False, no_deps=False)
             return 'updated', latest_tag
     except:
         traceback.print_exc()
@@ -2664,9 +2665,13 @@ def check_state_of_git_node_pack_single(item, do_fetch=False, do_update_check=Tr
 
 
 def get_installed_pip_packages():
-    # extract pip package infos
-    cmd = manager_util.make_pip_cmd(['freeze'])
-    pips = subprocess.check_output(cmd, text=True).split('\n')
+    try:
+        # extract pip package infos
+        cmd = manager_util.make_pip_cmd(['freeze'])
+        pips = subprocess.check_output(cmd, text=True).split('\n')
+    except Exception as e:
+        logging.warning("[ComfyUI-Manager] Could not enumerate pip packages for snapshot: %s", e)
+        return {}
 
     res = {}
     for x in pips:

glob/manager_server.py

@@ -11,7 +11,10 @@ import threading
 import re
 import shutil
 import git
+import glob
+import json
 from datetime import datetime
+from contextlib import contextmanager
 
 from server import PromptServer
 import manager_core as core
@@ -726,6 +729,86 @@ async def fetch_updates(request):
     except:
         traceback.print_exc()
         return web.Response(status=400)
+    
+@routes.get("/customnode/get_node_types_in_workflows")
+async def get_node_types_in_workflows(request):
+    try:
+        # get our username from the request header
+        user_id = PromptServer.instance.user_manager.get_request_user_id(request)
+
+        # get the base workflow directory (TODO: figure out if non-standard directories are possible, and how to find them)
+        workflow_files_base_path = os.path.abspath(os.path.join(folder_paths.get_user_directory(), user_id, "workflows"))
+
+        logging.debug(f"workflows base path: {workflow_files_base_path}")
+
+        # workflow directory doesn't actually exist, return 204 (No Content)
+        if not os.path.isdir(workflow_files_base_path):
+            logging.debug("workflows base path doesn't exist - nothing to do...")
+            return web.Response(status=204)
+        
+        # get all JSON files under the workflow directory
+        workflow_file_relative_paths: list[str] = glob.glob(pathname="**/*.json", root_dir=workflow_files_base_path, recursive=True)
+
+        logging.debug(f"found the following workflows: {workflow_file_relative_paths}")
+
+        # set up our list of workflow/node-lists
+        workflow_node_mappings: list[dict[str, str | list[str]]] = []
+
+        # iterate over each found JSON file
+        for workflow_file_path in workflow_file_relative_paths:
+
+            try:
+                workflow_file_absolute_path = os.path.abspath(os.path.join(workflow_files_base_path, workflow_file_path))
+                logging.debug(f"starting work on {workflow_file_absolute_path}")
+                # load the JSON file
+                workflow_file_data = json.load(open(workflow_file_absolute_path, "r"))
+
+                # make sure there's a nodes key (otherwise this might not actually be a workflow file)
+                if "nodes" not in workflow_file_data:
+                    logging.warning(f"{workflow_file_path} has no 'nodes' key (possibly invalid?) - skipping...")
+                    # skip to next file
+                    continue
+
+                # now this looks like a valid file, so let's get to work
+                new_mapping = {"workflow_file_name": workflow_file_path}
+                # we can't use an actual set, because you can't use dicts as set members
+                node_set = []
+
+                # iterate over each node in the workflow
+                for node in workflow_file_data["nodes"]:
+                    if "id" not in node:
+                        logging.warning(f"Found a node with no ID - possibly corrupt/invalid workflow?")
+                        continue
+                    # if there's no type, throw a warning
+                    if "type" not in node:
+                        logging.warning(f"Node type not found in {workflow_file_path} for node ID {node['id']}")
+                        # skip to next node
+                        continue
+
+                    node_data_to_return = {"type": node["type"]}
+                    if "properties" not in node:
+                        logging.warning(f"Node ${node['id']} has no properties field - can't determine cnr_id")
+                    else:
+                        for property_key in ["cnr_id", "ver"]:
+                            if property_key in node["properties"]:
+                                node_data_to_return[property_key] = node["properties"][property_key]                  
+                    
+                    # add it to the list for this workflow
+                    if not node_data_to_return in node_set:
+                        node_set.append(node_data_to_return)
+
+                # annoyingly, Python can't serialize sets to JSON
+                new_mapping["node_types"] = list(node_set)
+                workflow_node_mappings.append(new_mapping)            
+
+            except Exception as e:
+                logging.warning(f"Couldn't open {workflow_file_path}: {e}")
+
+        return web.json_response(workflow_node_mappings, content_type='application/json')
+    
+    except:
+        traceback.print_exc()
+        return web.Response(status=500)
 
 
 @routes.get("/manager/queue/update_all")

js/README.md

@@ -9,6 +9,7 @@ This directory contains the JavaScript frontend implementation for ComfyUI-Manag
 - **model-manager.js**: Handles the model management interface for downloading and organizing AI models.
 - **components-manager.js**: Manages reusable workflow components system.
 - **snapshot.js**: Implements the snapshot system for backing up and restoring installations.
+- **node-usage-analyzer.js**: Implements the UI for analyzing node usage in workflows.
 
 ## Sharing Components
 
@@ -46,5 +47,6 @@ The frontend follows a modular component-based architecture:
 CSS files are included for specific components:
 - **custom-nodes-manager.css**: Styling for the node management UI
 - **model-manager.css**: Styling for the model management UI
+- **node-usage-analyzer.css**: Styling for the node usage analyzer UI
 
 This frontend implementation provides a comprehensive yet user-friendly interface for managing the ComfyUI ecosystem.

js/comfyui-manager.js

@@ -18,6 +18,7 @@ import {
 } from "./common.js";
 import { ComponentBuilderDialog, getPureName, load_components, set_component_policy } from "./components-manager.js";
 import { CustomNodesManager } from "./custom-nodes-manager.js";
+import { NodeUsageAnalyzer } from "./node-usage-analyzer.js";
 import { ModelManager } from "./model-manager.js";
 import { SnapshotManager } from "./snapshot.js";
 
@@ -910,6 +911,17 @@ class ManagerMenuDialog extends ComfyDialog {
 							CustomNodesManager.instance.show(CustomNodesManager.ShowMode.IN_WORKFLOW);
 						}
 				}),
+				$el("button.cm-button", {
+					type: "button",
+					textContent: "Node Usage Analyzer",
+					onclick:
+						() => {
+							if(!NodeUsageAnalyzer.instance) {
+								NodeUsageAnalyzer.instance = new NodeUsageAnalyzer(app, self);
+							}
+							NodeUsageAnalyzer.instance.show(NodeUsageAnalyzer.SortMode.BY_PACKAGE);
+						}
+				}),
 				
 				$el("br", {}, []),
 				$el("button.cm-button", {

js/common.js

@@ -109,9 +109,9 @@ export async function customConfirm(message) {
 		let res = await
 			window['app'].extensionManager.dialog
 			.confirm({
-				title: 'Confirm',
-				message: message
-			});
+			title: 'Confirm',
+			message: message
+		});
 
 		return res;
 	}
@@ -151,9 +151,9 @@ export async function customPrompt(title, message) {
 		let res = await
 				window['app'].extensionManager.dialog
 				.prompt({
-					title: title,
-					message: message
-				});
+			title: title,
+			message: message
+		});
 
 		return res;
 	}
@@ -651,4 +651,449 @@ function initTooltip () {
     document.body.addEventListener('mouseleave', mouseleaveHandler, true);
 }
 
+export async function uninstallNodes(nodeList, options = {}) {
+	const {
+		title = `${nodeList.length} custom nodes`,
+		onProgress = () => {},
+		onError = () => {},
+		onSuccess = () => {},
+		channel = 'default',
+		mode = 'default'
+	} = options;
+
+	// Check if queue is busy
+	let stats = await api.fetchApi('/manager/queue/status');
+	stats = await stats.json();
+	if (stats.is_processing) {
+		customAlert(`[ComfyUI-Manager] There are already tasks in progress. Please try again after it is completed. (${stats.done_count}/${stats.total_count})`);
+		return { success: false, error: 'Queue is busy' };
+	}
+
+	// Confirmation dialog for uninstall
+	const confirmed = await customConfirm(`Are you sure uninstall ${title}?`);
+	if (!confirmed) {
+		return { success: false, error: 'User cancelled' };
+	}
+
+	let errorMsg = "";
+	let target_items = [];
+
+	await api.fetchApi('/manager/queue/reset');
+
+	for (const nodeItem of nodeList) {
+		target_items.push(nodeItem);
+
+		onProgress(`Uninstall ${nodeItem.title || nodeItem.name} ...`);
+
+		const data = nodeItem.originalData || nodeItem;
+		data.channel = channel;
+		data.mode = mode;
+		data.ui_id = nodeItem.hash || md5(nodeItem.name || nodeItem.title);
+
+		const res = await api.fetchApi(`/manager/queue/uninstall`, {
+			method: 'POST',
+			body: JSON.stringify(data)
+		});
+
+		if (res.status != 200) {
+			errorMsg = `'${nodeItem.title || nodeItem.name}': `;
+
+			if (res.status == 403) {
+				errorMsg += `This action is not allowed with this security level configuration.\n`;
+			} else if (res.status == 404) {
+				errorMsg += `With the current security level configuration, only custom nodes from the <B>"default channel"</B> can be uninstalled.\n`;
+			} else {
+				errorMsg += await res.text() + '\n';
+			}
+
+			break;
+		}
+	}
+
+	if (errorMsg) {
+		onError(errorMsg);
+		show_message("[Uninstall Errors]\n" + errorMsg);
+		return { success: false, error: errorMsg, targets: target_items };
+	} else {
+		await api.fetchApi('/manager/queue/start');
+		onSuccess(target_items);
+		showTerminal();
+		return { success: true, targets: target_items };
+	}
+}
+
+// ===========================================================================================
+// Workflow Utilities Consolidation
+
+export async function getWorkflowNodeTypes() {
+	try {
+		const res = await fetchData('/customnode/get_node_types_in_workflows');
+		
+		if (res.status === 200) {
+			return { success: true, data: res.data };
+		} else if (res.status === 204) {
+			// No workflows found - return empty list
+			return { success: true, data: [] };
+		} else {
+			return { success: false, error: res.error };
+		}
+	} catch (error) {
+		return { success: false, error: error };
+	}
+}
+
+export function findPackageByCnrId(cnrId, nodePackages, installedOnly = true) {
+	if (!cnrId || !nodePackages) {
+		return null;
+	}
+	
+	// Tier 1: Direct key match
+	if (nodePackages[cnrId]) {
+		const pack = nodePackages[cnrId];
+		if (!installedOnly || pack.state !== "not-installed") {
+			return { key: cnrId, pack: pack };
+		}
+	}
+	
+	// Tier 2: Case-insensitive match
+	const cnrIdLower = cnrId.toLowerCase();
+	for (const packKey of Object.keys(nodePackages)) {
+		if (packKey.toLowerCase() === cnrIdLower) {
+			const pack = nodePackages[packKey];
+			if (!installedOnly || pack.state !== "not-installed") {
+				return { key: packKey, pack: pack };
+			}
+		}
+	}
+	
+	// Tier 3: URL/reference contains match
+	for (const packKey of Object.keys(nodePackages)) {
+		const pack = nodePackages[packKey];
+		
+		// Skip non-installed packages if installedOnly is true
+		if (installedOnly && pack.state === "not-installed") {
+			continue;
+		}
+		
+		// Check if reference URL contains cnr_id
+		if (pack.reference && pack.reference.includes(cnrId)) {
+			return { key: packKey, pack: pack };
+		}
+		
+		// Check if any file URL contains cnr_id
+		if (pack.files && Array.isArray(pack.files)) {
+			for (const fileUrl of pack.files) {
+				if (fileUrl.includes(cnrId)) {
+					return { key: packKey, pack: pack };
+				}
+			}
+		}
+	}
+	
+	return null;
+}
+
+export async function analyzeWorkflowUsage(nodePackages) {
+	const result = await getWorkflowNodeTypes();
+	
+	if (!result.success) {
+		return { success: false, error: result.error };
+	}
+	
+	const workflowNodeList = result.data;
+	const usageMap = new Map();
+	const workflowDetailsMap = new Map();
+	
+	if (workflowNodeList && Array.isArray(workflowNodeList)) {
+		const cnrIdCounts = new Map();
+		const cnrIdToWorkflows = new Map();
+		
+		// Process each workflow
+		workflowNodeList.forEach((workflowObj, workflowIndex) => {
+			if (workflowObj.node_types && Array.isArray(workflowObj.node_types)) {
+				const workflowCnrIds = new Set();
+				
+				// Get workflow filename
+				const workflowFilename = workflowObj.workflow_file_name ||
+										 workflowObj.filename ||
+										 workflowObj.file ||
+										 workflowObj.name ||
+										 workflowObj.path ||
+										 `Workflow ${workflowIndex + 1}`;
+				
+				// Count nodes per cnr_id in this workflow
+				const workflowCnrIdCounts = new Map();
+				workflowObj.node_types.forEach(nodeTypeObj => {
+					const cnrId = nodeTypeObj.cnr_id;
+					
+					if (cnrId && cnrId !== "comfy-core") {
+						// Track unique cnr_ids per workflow
+						workflowCnrIds.add(cnrId);
+						
+						// Count nodes per cnr_id in this specific workflow
+						const workflowNodeCount = workflowCnrIdCounts.get(cnrId) || 0;
+						workflowCnrIdCounts.set(cnrId, workflowNodeCount + 1);
+					}
+				});
+				
+				// Record workflow details for each unique cnr_id found in this workflow
+				workflowCnrIds.forEach(cnrId => {
+					// Count occurrences of this cnr_id across all workflows
+					const currentCount = cnrIdCounts.get(cnrId) || 0;
+					cnrIdCounts.set(cnrId, currentCount + 1);
+					
+					// Track workflow details
+					if (!cnrIdToWorkflows.has(cnrId)) {
+						cnrIdToWorkflows.set(cnrId, []);
+					}
+					cnrIdToWorkflows.get(cnrId).push({
+						filename: workflowFilename,
+						nodeCount: workflowCnrIdCounts.get(cnrId) || 0
+					});
+				});
+			}
+		});
+		
+		// Map cnr_id to installed packages with workflow details
+		cnrIdCounts.forEach((count, cnrId) => {
+			const workflowDetails = cnrIdToWorkflows.get(cnrId) || [];
+			
+			const foundPackage = findPackageByCnrId(cnrId, nodePackages, true);
+			if (foundPackage) {
+				usageMap.set(foundPackage.key, count);
+				workflowDetailsMap.set(foundPackage.key, workflowDetails);
+			}
+		});
+	}
+	
+	return {
+		success: true,
+		usageMap: usageMap,
+		workflowDetailsMap: workflowDetailsMap
+	};
+}
+
+// Size formatting utilities - consolidated from model-manager.js and node-usage-analyzer.js
+export function formatSize(v) {
+	const base = 1000;
+	const units = ['', 'K', 'M', 'G', 'T', 'P'];
+	const space = '';
+	const postfix = 'B';
+	if (v <= 0) {
+		return `0${space}${postfix}`;
+	}
+	for (let i = 0, l = units.length; i < l; i++) {
+		const min = Math.pow(base, i);
+		const max = Math.pow(base, i + 1);
+		if (v > min && v <= max) {
+			const unit = units[i];
+			if (unit) {
+				const n = v / min;
+				const nl = n.toString().split('.')[0].length;
+				const fl = Math.max(3 - nl, 1);
+				v = n.toFixed(fl);
+			}
+			v = v + space + unit + postfix;
+			break;
+		}
+	}
+	return v;
+}
+
+// for size sort
+export function sizeToBytes(v) {
+	if (typeof v === "number") {
+		return v;
+	}
+	if (typeof v === "string") {
+		const n = parseFloat(v);
+		const unit = v.replace(/[0-9.B]+/g, "").trim().toUpperCase();
+		if (unit === "K") {
+			return n * 1000;
+		}
+		if (unit === "M") {
+			return n * 1000 * 1000;
+		}
+		if (unit === "G") {
+			return n * 1000 * 1000 * 1000;
+		}
+		if (unit === "T") {
+			return n * 1000 * 1000 * 1000 * 1000;
+		}
+	}
+	return v;
+}
+
+// Flyover component - consolidated from custom-nodes-manager.js and node-usage-analyzer.js
+export function createFlyover(container, options = {}) {
+	const {
+		enableHover = false,
+		hoverHandler = null,
+		context = null
+	} = options;
+
+	const $flyover = document.createElement("div");
+	$flyover.className = "cn-flyover";
+	$flyover.innerHTML = `<div class="cn-flyover-header">
+		<div class="cn-flyover-close">${icons.arrowRight}</div>
+		<div class="cn-flyover-title"></div>
+		<div class="cn-flyover-close">${icons.close}</div>
+		</div>
+		<div class="cn-flyover-body"></div>`
+	container.appendChild($flyover);
+
+	const $flyoverTitle = $flyover.querySelector(".cn-flyover-title");
+	const $flyoverBody = $flyover.querySelector(".cn-flyover-body");
+	
+	let width = '50%';
+	let visible = false;
+
+	let timeHide;
+	const closeHandler = (e) => {
+		if ($flyover === e.target || $flyover.contains(e.target)) {
+			return;
+		}
+		clearTimeout(timeHide);
+		timeHide = setTimeout(() => {
+			flyover.hide();
+		}, 100);
+	}
+
+	const displayHandler = () => {
+		if (visible) {
+			$flyover.classList.remove("cn-slide-in-right");
+		} else {
+			$flyover.classList.remove("cn-slide-out-right");
+			$flyover.style.width = '0px';
+			$flyover.style.display = "none";
+		}
+	}
+
+	const flyover = {
+		show: (titleHtml, bodyHtml) => {
+			clearTimeout(timeHide);
+			if (context && context.element) {
+				context.element.removeEventListener("click", closeHandler);
+			}
+			$flyoverTitle.innerHTML = titleHtml;
+			$flyoverBody.innerHTML = bodyHtml;
+			$flyover.style.display = "block";
+			$flyover.style.width = width;
+			if(!visible) {
+				$flyover.classList.add("cn-slide-in-right");
+			}
+			visible = true;
+			setTimeout(() => {
+				if (context && context.element) {
+					context.element.addEventListener("click", closeHandler);
+				}
+			}, 100);
+		},
+		hide: (now) => {
+			visible = false;
+			if (context && context.element) {
+				context.element.removeEventListener("click", closeHandler);
+			}
+			if(now) {
+				displayHandler();
+				return;
+			}
+			$flyover.classList.add("cn-slide-out-right");
+		}
+	}
+
+	$flyover.addEventListener("animationend", (e) => {
+		displayHandler();
+	});
+
+	// Add hover handlers if enabled
+	if (enableHover && hoverHandler) {
+		$flyover.addEventListener("mouseenter", hoverHandler, true);
+		$flyover.addEventListener("mouseleave", hoverHandler, true);
+	}
+
+	$flyover.addEventListener("click", (e) => {
+		if(e.target.classList.contains("cn-flyover-close")) {
+			flyover.hide();
+			return;
+		}
+		
+		// Forward other click events to the provided handler or context
+		if (context && context.handleFlyoverClick) {
+			context.handleFlyoverClick(e);
+		}
+	});
+
+	return flyover;
+}
+
+// Shared UI State Methods - consolidated from multiple managers
+export function createUIStateManager(element, selectors) {
+	return {
+		showSelection: (msg) => {
+			const el = element.querySelector(selectors.selection);
+			if (el) el.innerHTML = msg;
+		},
+		
+		showError: (err) => {
+			const el = element.querySelector(selectors.message);
+			if (el) {
+				const msg = err ? `<font color="red">${err}</font>` : "";
+				el.innerHTML = msg;
+			}
+		},
+		
+		showMessage: (msg, color) => {
+			const el = element.querySelector(selectors.message);
+			if (el) {
+				if (color) {
+					msg = `<font color="${color}">${msg}</font>`;
+				}
+				el.innerHTML = msg;
+			}
+		},
+		
+		showStatus: (msg, color) => {
+			const el = element.querySelector(selectors.status);
+			if (el) {
+				if (color) {
+					msg = `<font color="${color}">${msg}</font>`;
+				}
+				el.innerHTML = msg;
+			}
+		},
+		
+		showLoading: (grid) => {
+			if (grid) {
+				grid.showLoading();
+				grid.showMask({
+					opacity: 0.05
+				});
+			}
+		},
+		
+		hideLoading: (grid) => {
+			if (grid) {
+				grid.hideLoading();
+				grid.hideMask();
+			}
+		},
+		
+		showRefresh: () => {
+			const el = element.querySelector(selectors.refresh);
+			if (el) el.style.display = "block";
+		},
+		
+		showStop: () => {
+			const el = element.querySelector(selectors.stop);
+			if (el) el.style.display = "block";
+		},
+		
+		hideStop: () => {
+			const el = element.querySelector(selectors.stop);
+			if (el) el.style.display = "none";
+		}
+	};
+}
+
 initTooltip();

js/custom-nodes-manager.js

@@ -7,7 +7,7 @@ import {
 	fetchData, md5, icons, show_message, customConfirm, customAlert, customPrompt,
 	sanitizeHTML, infoToast, showTerminal, setNeedRestart,
 	storeColumnWidth, restoreColumnWidth, getTimeAgo, copyText, loadCss,
-	showPopover, hidePopover
+	showPopover, hidePopover, getWorkflowNodeTypes, findPackageByCnrId, analyzeWorkflowUsage, createFlyover
 } from  "./common.js";
 
 // https://cenfun.github.io/turbogrid/api.html
@@ -54,6 +54,8 @@ const ShowMode = {
 	FAVORITES: "Favorites",
 	ALTERNATIVES: "Alternatives",
 	IN_WORKFLOW: "In Workflow",
+	USED_IN_ANY_WORKFLOW: "Used In Any Workflow",
+	NOT_USED_IN_ANY_WORKFLOW: "Installed and Unused",
 };
 
 export class CustomNodesManager {
@@ -268,6 +270,14 @@ export class CustomNodesManager {
 			label: "In Workflow",
 			value: ShowMode.IN_WORKFLOW,
 			hasData: false
+		}, {
+			label: "Used In Any Workflow",
+			value: ShowMode.USED_IN_ANY_WORKFLOW,
+			hasData: false
+		}, {
+			label: "Installed and Unused",
+			value: ShowMode.NOT_USED_IN_ANY_WORKFLOW,
+			hasData: false
 		}, {
 			label: "Missing",
 			value: ShowMode.MISSING,
@@ -518,7 +528,11 @@ export class CustomNodesManager {
 		const grid = new TG.Grid(container);
 		this.grid = grid;
 
-		this.flyover = this.createFlyover(container);
+		this.flyover = createFlyover(container, {
+			enableHover: true,
+			hoverHandler: this.handleFlyoverHover.bind(this),
+			context: this
+		});
 		
 		let prevViewRowsLength = -1;
 		grid.bind('onUpdated', (e, d) => {
@@ -1061,143 +1075,63 @@ export class CustomNodesManager {
 		hidePopover();
 	}
 
-	createFlyover(container) {
-		const $flyover = document.createElement("div");
-		$flyover.className = "cn-flyover";
-		$flyover.innerHTML = `<div class="cn-flyover-header">
-			<div class="cn-flyover-close">${icons.arrowRight}</div>
-			<div class="cn-flyover-title"></div>
-			<div class="cn-flyover-close">${icons.close}</div>
-			</div>
-			<div class="cn-flyover-body"></div>`
-		container.appendChild($flyover);
-
-		const $flyoverTitle = $flyover.querySelector(".cn-flyover-title");
-		const $flyoverBody = $flyover.querySelector(".cn-flyover-body");
-		
-		let width = '50%';
-		let visible = false;
-
-		let timeHide;
-		const closeHandler = (e) => {
-            if ($flyover === e.target || $flyover.contains(e.target)) {
-                return;
-            }
-			clearTimeout(timeHide);
-			timeHide = setTimeout(() => {
-				flyover.hide();
-			}, 100);
-		}
-
-		const hoverHandler = (e) => {
-			if(e.type === "mouseenter") {
-				if(e.target.classList.contains("cn-nodes-name")) {
-					this.showNodePreview(e.target);
-				}
-				return;
-			}
-			this.hideNodePreview();
-		}
-
-		const displayHandler = () => {
-			if (visible) {
-				$flyover.classList.remove("cn-slide-in-right");
-			} else {
-				$flyover.classList.remove("cn-slide-out-right");
-				$flyover.style.width = '0px';
-				$flyover.style.display = "none";
-			}
-		}
-
-		const flyover = {
-			show: (titleHtml, bodyHtml) => {
-				clearTimeout(timeHide);
-				this.element.removeEventListener("click", closeHandler);
-				$flyoverTitle.innerHTML = titleHtml;
-				$flyoverBody.innerHTML = bodyHtml;
-				$flyover.style.display = "block";
-				$flyover.style.width = width;
-				if(!visible) {
-					$flyover.classList.add("cn-slide-in-right");
-				}
-				visible = true;
-				setTimeout(() => {
-					this.element.addEventListener("click", closeHandler);
-				}, 100);
-			},
-			hide: (now) => {
-				visible = false;
-				this.element.removeEventListener("click", closeHandler);
-				if(now) {
-					displayHandler();
-					return;
-				}
-				$flyover.classList.add("cn-slide-out-right");
-			}
-		}
-
-		$flyover.addEventListener("animationend", (e) => {
-			displayHandler();
-		});
-
-		$flyover.addEventListener("mouseenter", hoverHandler, true);
-		$flyover.addEventListener("mouseleave", hoverHandler, true);
-
-		$flyover.addEventListener("click", (e) => {
-
+	handleFlyoverHover(e) {
+		if(e.type === "mouseenter") {
 			if(e.target.classList.contains("cn-nodes-name")) {
-				const nodeName = e.target.innerText;
-				const nodeItem = this.nodeMap[nodeName];
-				if (!nodeItem) {
-					copyText(nodeName).then((res) => {
-						if (res) {
-							e.target.setAttribute("action", "Copied");
-							e.target.classList.add("action");
-							setTimeout(() => {
-								e.target.classList.remove("action");
-								e.target.removeAttribute("action");
-							}, 1000);
-						}
-					});
-					return;
-				}
+				this.showNodePreview(e.target);
+			}
+			return;
+		}
+		this.hideNodePreview();
+	}
 
-				const [x, y, w, h] = app.canvas.ds.visible_area;
-				const dpi = Math.max(window.devicePixelRatio ?? 1, 1);
-				const node = window.LiteGraph?.createNode(
-					nodeItem.name,
-					nodeItem.display_name,
-					{
-						pos: [x + (w-300) / dpi / 2, y]
+	handleFlyoverClick(e) {
+		if(e.target.classList.contains("cn-nodes-name")) {
+			const nodeName = e.target.innerText;
+			const nodeItem = this.nodeMap[nodeName];
+			if (!nodeItem) {
+				copyText(nodeName).then((res) => {
+					if (res) {
+						e.target.setAttribute("action", "Copied");
+						e.target.classList.add("action");
+						setTimeout(() => {
+							e.target.classList.remove("action");
+							e.target.removeAttribute("action");
+						}, 1000);
 					}
-				);
-				if (node) {
-					app.graph.add(node);
-					e.target.setAttribute("action", "Added to Workflow");
-					e.target.classList.add("action");
-					setTimeout(() => {
-						e.target.classList.remove("action");
-						e.target.removeAttribute("action");
-					}, 1000);
-				}
-				
+				});
 				return;
 			}
-			if(e.target.classList.contains("cn-nodes-pack")) {
-				const hash = e.target.getAttribute("hash");
-				const rowItem = this.grid.getRowItemBy("hash", hash);
-				//console.log(rowItem);
-				this.grid.scrollToRow(rowItem);
-				this.addHighlight(rowItem);
-				return;
-			}
-			if(e.target.classList.contains("cn-flyover-close")) {
-				flyover.hide();
-				return;
-			}
-		});
 
-		return flyover;
+			const [x, y, w, h] = app.canvas.ds.visible_area;
+			const dpi = Math.max(window.devicePixelRatio ?? 1, 1);
+			const node = window.LiteGraph?.createNode(
+				nodeItem.name,
+				nodeItem.display_name,
+				{
+					pos: [x + (w-300) / dpi / 2, y]
+				}
+			);
+			if (node) {
+				app.graph.add(node);
+				e.target.setAttribute("action", "Added to Workflow");
+				e.target.classList.add("action");
+				setTimeout(() => {
+					e.target.classList.remove("action");
+					e.target.removeAttribute("action");
+				}, 1000);
+			}
+			
+			return;
+		}
+		if(e.target.classList.contains("cn-nodes-pack")) {
+			const hash = e.target.getAttribute("hash");
+			const rowItem = this.grid.getRowItemBy("hash", hash);
+				//console.log(rowItem);
+			this.grid.scrollToRow(rowItem);
+			this.addHighlight(rowItem);
+			return;
+		}
 	}
 
 	showNodes(d) {
@@ -1863,7 +1797,10 @@ export class CustomNodesManager {
 		for(let k in allUsedNodes) {
 			var item;
 			if(allUsedNodes[k].properties.cnr_id) {
-				item = this.custom_nodes[allUsedNodes[k].properties.cnr_id];
+				const foundPackage = findPackageByCnrId(allUsedNodes[k].properties.cnr_id, this.custom_nodes, false);
+				if (foundPackage) {
+					item = foundPackage.pack;
+				}
 			}
 			else if(allUsedNodes[k].properties.aux_id) {
 				item = aux_id_to_pack[allUsedNodes[k].properties.aux_id];
@@ -1910,6 +1847,48 @@ export class CustomNodesManager {
 		return hashMap;
 	}
 
+	async getUsedInAnyWorkflow() {
+		this.showStatus(`Loading workflow usage analysis ...`);
+		
+		const result = await analyzeWorkflowUsage(this.custom_nodes);
+		
+		if (!result.success) {
+			this.showError(`Failed to get workflow data: ${result.error}`);
+			return {};
+		}
+		
+		const hashMap = {};
+		
+		// Convert usage map keys to hash map
+		result.usageMap.forEach((count, packageKey) => {
+			const pack = this.custom_nodes[packageKey];
+			if (pack && pack.hash) {
+				hashMap[pack.hash] = true;
+			}
+		});
+		
+		return hashMap;
+	}
+
+	async getNotUsedInAnyWorkflow() {
+		this.showStatus(`Loading workflow usage analysis ...`);
+		
+		// Get the used packages first using common utility
+		const usedHashMap = await this.getUsedInAnyWorkflow();
+		const notUsedHashMap = {};
+		
+		// Find all installed packages that are NOT in the used list
+		for(let k in this.custom_nodes) {
+			let nodepack = this.custom_nodes[k];
+			// Only consider installed packages
+			if (nodepack.state !== "not-installed" && !usedHashMap[nodepack.hash]) {
+				notUsedHashMap[nodepack.hash] = true;
+			}
+		}
+		
+		return notUsedHashMap;
+	}
+
 	async loadData(show_mode = ShowMode.NORMAL) {
 		const isElectron = 'electronAPI' in window;
 
@@ -1979,6 +1958,10 @@ export class CustomNodesManager {
 				hashMap = await this.getFavorites();
 			} else if(this.show_mode == ShowMode.IN_WORKFLOW) {
 				hashMap = await this.getNodepackInWorkflow();
+			} else if(this.show_mode == ShowMode.USED_IN_ANY_WORKFLOW) {
+				hashMap = await this.getUsedInAnyWorkflow();
+			} else if(this.show_mode == ShowMode.NOT_USED_IN_ANY_WORKFLOW) {
+				hashMap = await this.getNotUsedInAnyWorkflow();
 			}
 			filterItem.hashMap = hashMap;
 

js/model-manager.js

@@ -1,9 +1,9 @@
 import { app } from "../../scripts/app.js";
 import { $el } from "../../scripts/ui.js";
-import { 
-	manager_instance, rebootAPI, 
+import {
+	manager_instance, rebootAPI,
 	fetchData, md5, icons, show_message, customAlert, infoToast, showTerminal,
-	storeColumnWidth, restoreColumnWidth, loadCss
+	storeColumnWidth, restoreColumnWidth, loadCss, formatSize, sizeToBytes
 } from  "./common.js";
 import { api } from "../../scripts/api.js";
 
@@ -364,7 +364,7 @@ export class ModelManager {
 			width: 100,
 			formatter: (size) => {
 				if (typeof size === "number") {
-					return this.formatSize(size);
+					return formatSize(size);
 				}
 				return size;
 			}
@@ -578,7 +578,7 @@ export class ModelManager {
 		models.forEach((item, i) => {
 			const { type, base, name, reference, installed } = item;
 			item.originalData = JSON.parse(JSON.stringify(item));
-			item.size = this.sizeToBytes(item.size);
+			item.size = sizeToBytes(item.size);
 			item.hash = md5(name + reference);
 			item.id = i + 1;
 
@@ -655,7 +655,6 @@ export class ModelManager {
 		const { models } = res.data;
 
 		this.modelList = this.getModelList(models);
-		// console.log("models", this.modelList);
 
 		this.updateFilter();
 		
@@ -667,56 +666,6 @@ export class ModelManager {
 
 	// ===========================================================================================
 
-	formatSize(v) {
-		const base = 1000;
-        const units = ['', 'K', 'M', 'G', 'T', 'P'];
-        const space = '';
-        const postfix = 'B';
-		if (v <= 0) {
-			return `0${space}${postfix}`;
-		}
-		for (let i = 0, l = units.length; i < l; i++) {
-			const min = Math.pow(base, i);
-			const max = Math.pow(base, i + 1);
-			if (v > min && v <= max) {
-				const unit = units[i];
-				if (unit) {
-					const n = v / min;
-					const nl = n.toString().split('.')[0].length;
-					const fl = Math.max(3 - nl, 1);
-					v = n.toFixed(fl);
-				}
-				v = v + space + unit + postfix;
-				break;
-			}
-		}
-		return v;
-	}
-
-	// for size sort
-	sizeToBytes(v) {
-		if (typeof v === "number") {
-			return v;
-		}
-		if (typeof v === "string") {
-			const n = parseFloat(v);
-			const unit = v.replace(/[0-9.B]+/g, "").trim().toUpperCase();
-			if (unit === "K") {
-				return n * 1000;
-			}
-			if (unit === "M") {
-				return n * 1000 * 1000;
-			}
-			if (unit === "G") {
-				return n * 1000 * 1000 * 1000;
-			}
-			if (unit === "T") {
-				return n * 1000 * 1000 * 1000 * 1000;
-			}
-		}
-		return v;
-	}
-
 	showSelection(msg) {
 		this.element.querySelector(".cmm-manager-selection").innerHTML = msg;
 	}

js/node-usage-analyzer.css

@@ -0,0 +1,699 @@
+.nu-manager {
+	--grid-font: -apple-system, BlinkMacSystemFont, "Segue UI", "Noto Sans", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+	z-index: 1099;
+	width: 80%;
+	height: 80%;
+	display: flex;
+	flex-direction: column;
+	gap: 10px;
+	color: var(--fg-color);
+	font-family: arial, sans-serif;
+	text-underline-offset: 3px;
+	outline: none;
+}
+
+.nu-manager .nu-flex-auto {
+	flex: auto;
+}
+
+.nu-manager button {
+	font-size: 16px;
+	color: var(--input-text);
+	background-color: var(--comfy-input-bg);
+	border-radius: 8px;
+	border-color: var(--border-color);
+	border-style: solid;
+	margin: 0;
+	padding: 4px 8px;
+	min-width: 100px;
+}
+
+.nu-manager button:disabled,
+.nu-manager input:disabled,
+.nu-manager select:disabled {
+	color: gray;
+}
+
+.nu-manager button:disabled {
+	background-color: var(--comfy-input-bg);
+}
+
+.nu-manager .nu-manager-restart {
+	display: none;
+	background-color: #500000;
+	color: white;
+}
+
+.nu-manager .nu-manager-stop {
+	display: none;
+	background-color: #500000;
+	color: white;
+}
+
+.nu-manager .nu-manager-back {
+	align-items: center;
+	justify-content: center;
+}
+
+.arrow-icon {
+	height: 1em;
+	width: 1em;
+	margin-right: 5px;
+	transform: translateY(2px);
+}
+
+.cn-icon {
+	display: block;
+	width: 16px;
+	height: 16px;
+}
+
+.cn-icon svg {
+	display: block;
+	margin: 0;
+	pointer-events: none;
+}
+
+.nu-manager-header {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 5px;
+	align-items: center;
+	padding: 0 5px;
+}
+
+.nu-manager-header label {
+	display: flex;
+	gap: 5px;
+	align-items: center;
+}
+
+.nu-manager-filter {
+	height: 28px;
+	line-height: 28px;
+}
+
+.nu-manager-keywords {
+	height: 28px;
+	line-height: 28px;
+	padding: 0 5px 0 26px;
+	background-size: 16px;
+	background-position: 5px center;
+	background-repeat: no-repeat;
+	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20width%3D%22100%25%22%20height%3D%22100%25%22%20pointer-events%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20fill%3D%22none%22%20stroke%3D%22%23888%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke-width%3D%222%22%20d%3D%22m21%2021-4.486-4.494M19%2010.5a8.5%208.5%200%201%201-17%200%208.5%208.5%200%200%201%2017%200%22%2F%3E%3C%2Fsvg%3E");
+}
+
+.nu-manager-status {
+	padding-left: 10px;
+}
+
+.nu-manager-grid {
+	flex: auto;
+	border: 1px solid var(--border-color);
+	overflow: hidden;
+	position: relative;
+}
+
+.nu-manager-selection {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 10px;
+	align-items: center;
+}
+
+.nu-manager-message {
+	position: relative;
+}
+
+.nu-manager-footer {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 10px;
+	align-items: center;
+}
+
+.nu-manager-grid .tg-turbogrid {
+	font-family: var(--grid-font);
+	font-size: 15px;
+	background: var(--bg-color);
+}
+
+.nu-manager-grid .tg-turbogrid .tg-highlight::after {
+	position: absolute;
+	top: 0;
+	left: 0;
+	content: "";
+	display: block;
+	width: 100%;
+	height: 100%;
+	box-sizing: border-box;
+	background-color: #80bdff11;
+	pointer-events: none;
+}
+
+.nu-manager-grid .nu-pack-name a {
+	color: skyblue;
+	text-decoration: none;
+	word-break: break-word;
+}
+
+.nu-manager-grid .cn-pack-desc a {
+	color: #5555FF;
+	font-weight: bold;
+	text-decoration: none;
+}
+
+.nu-manager-grid .tg-cell a:hover {
+	text-decoration: underline;
+}
+
+.nu-manager-grid .cn-pack-version {
+	line-height: 100%;
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	height: 100%;
+	gap: 5px;
+}
+
+.nu-manager-grid .cn-pack-nodes {
+	line-height: 100%;
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	gap: 5px;
+	cursor: pointer;
+	height: 100%;
+}
+
+.nu-manager-grid .cn-pack-nodes:hover {
+	text-decoration: underline;
+}
+
+.nu-manager-grid .cn-pack-conflicts {
+	color: orange;
+}
+
+.cn-popover {
+	position: fixed;
+	z-index: 10000;
+	padding: 20px;
+	color: #1e1e1e;
+	filter: drop-shadow(1px 5px 5px rgb(0 0 0 / 30%));
+	overflow: hidden;
+}
+
+.cn-flyover {
+	position: absolute;
+    top: 0;
+	right: 0;
+    z-index: 1000;
+    display: none;
+    width: 50%;
+    height: 100%;
+    background-color: var(--comfy-menu-bg);
+    animation-duration: 0.2s;
+    animation-fill-mode: both;
+	flex-direction: column;
+}
+
+.cn-flyover::before {
+    position: absolute;
+    top: 0;
+    content: "";
+    z-index: 10;
+    display: block;
+    width: 10px;
+    height: 100%;
+    pointer-events: none;
+	left: -10px;
+    background-image: linear-gradient(to left, rgb(0 0 0 / 20%), rgb(0 0 0 / 0%));
+}
+
+.cn-flyover-header {
+	height: 45px;
+	display: flex;
+	align-items: center;
+	gap: 5px;
+	border-bottom: 1px solid var(--border-color);
+}
+
+.cn-flyover-close {
+	display: flex;
+	align-items: center;
+	padding: 0 10px;
+	justify-content: center;
+	cursor: pointer;
+	opacity: 0.8;
+	height: 100%;
+}
+
+.cn-flyover-close:hover {
+	opacity: 1;
+}
+
+.cn-flyover-close svg {
+	display: block;
+	margin: 0;
+	pointer-events: none;
+	width: 20px;
+	height: 20px;
+}
+
+.cn-flyover-title {
+	display: flex;
+	align-items: center;
+	font-weight: bold;
+	gap: 10px;
+	flex: auto;
+}
+
+.cn-flyover-body {
+	height: calc(100% - 45px);
+	overflow-y: auto;
+	position: relative;
+	background-color: var(--comfy-menu-secondary-bg);
+}
+
+@keyframes cn-slide-in-right {
+    from {
+        visibility: visible;
+        transform: translate3d(100%, 0, 0);
+    }
+
+    to {
+        transform: translate3d(0, 0, 0);
+    }
+}
+
+.cn-slide-in-right {
+    animation-name: cn-slide-in-right;
+}
+
+@keyframes cn-slide-out-right {
+    from {
+        transform: translate3d(0, 0, 0);
+    }
+
+    to {
+        visibility: hidden;
+        transform: translate3d(100%, 0, 0);
+    }
+}
+
+.cn-slide-out-right {
+    animation-name: cn-slide-out-right;
+}
+
+.cn-nodes-list {
+	width: 100%;
+}
+
+.cn-nodes-row {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+}
+
+.cn-nodes-row:nth-child(odd) {
+	background-color: rgb(0 0 0 / 5%);
+}
+
+.cn-nodes-row:hover {
+    background-color: rgb(0 0 0 / 10%);
+}
+
+.cn-nodes-sn {
+	text-align: right;
+	min-width: 35px;
+	color: var(--drag-text);
+	flex-shrink: 0;
+	font-size: 12px;
+	padding: 8px 5px;
+}
+
+.cn-nodes-name {
+	cursor: pointer;
+	white-space: nowrap;
+	flex-shrink: 0;
+	position: relative;
+	padding: 8px 5px;
+}
+
+.cn-nodes-name::after {
+	content: attr(action);
+	position: absolute;
+	pointer-events: none;
+	top: 50%;
+	left: 100%;
+	transform: translate(5px, -50%);
+	font-size: 12px;
+	color: var(--drag-text);
+	background-color: var(--comfy-input-bg);
+	border-radius: 10px;
+	border: 1px solid var(--border-color);
+	padding: 3px 8px;
+	display: none;
+}
+
+.cn-nodes-name.action::after {
+	display: block;
+}
+
+.cn-nodes-name:hover {
+	text-decoration: underline;
+}
+
+.cn-nodes-conflict .cn-nodes-name,
+.cn-nodes-conflict .cn-icon {
+	color: orange;
+}
+
+.cn-conflicts-list {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 5px;
+	align-items: center;
+	padding: 5px 0;
+}
+
+.cn-conflicts-list b {
+	font-weight: normal;
+	color: var(--descrip-text);
+}
+
+.cn-nodes-pack {
+	cursor: pointer;
+	color: skyblue;
+}
+
+.cn-nodes-pack:hover {
+	text-decoration: underline;
+}
+
+.cn-pack-badge {
+	font-size: 12px;
+	font-weight: normal;
+	background-color: var(--comfy-input-bg);
+	border-radius: 10px;
+	border: 1px solid var(--border-color);
+	padding: 3px 8px;
+	color: var(--error-text);
+}
+
+.cn-preview {
+	min-width: 300px;
+	max-width: 500px;
+	min-height: 120px;
+	overflow: hidden;
+  	font-size: 12px;
+	pointer-events: none;
+	padding: 12px;
+	color: var(--fg-color);
+}
+
+.cn-preview-header {
+	display: flex;
+	gap: 8px;
+	align-items: center;
+	border-bottom: 1px solid var(--comfy-input-bg);
+	padding: 5px 10px;
+}
+
+.cn-preview-dot {
+	width: 8px;
+	height: 8px;
+	border-radius: 50%;
+	background-color: grey;
+	position: relative;
+	filter: drop-shadow(1px 2px 3px rgb(0 0 0 / 30%));
+}
+
+.cn-preview-dot.cn-preview-optional::after {
+	content: "";
+	position: absolute;
+	pointer-events: none;
+	top: 50%;
+	left: 50%;
+	transform: translate(-50%, -50%);
+	background-color: var(--comfy-input-bg);
+	border-radius: 50%;
+	width: 3px;
+  	height: 3px;
+}
+
+.cn-preview-dot.cn-preview-grid {
+	border-radius: 0;
+}
+
+.cn-preview-dot.cn-preview-grid::before {
+	content: '';
+	position: absolute;
+	border-left: 1px solid var(--comfy-input-bg);
+	border-right: 1px solid var(--comfy-input-bg);
+	width: 4px;
+	height: 100%;
+	left: 2px;
+	top: 0;
+	z-index: 1;
+}
+
+.cn-preview-dot.cn-preview-grid::after {
+	content: '';
+	position: absolute;
+	border-top: 1px solid var(--comfy-input-bg);
+	border-bottom: 1px solid var(--comfy-input-bg);
+	width: 100%;
+	height: 4px;
+	left: 0;
+	top: 2px;
+	z-index: 1;
+}
+
+.cn-preview-name {
+	flex: auto;
+	font-size: 14px;
+}
+
+.cn-preview-io {
+	display: flex;
+	justify-content: space-between;
+	padding: 10px 10px;
+}
+
+.cn-preview-column > div {
+	display: flex;
+	gap: 10px;
+	align-items: center;
+	height: 18px;
+	overflow: hidden;
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.cn-preview-input {
+	justify-content: flex-start;
+}
+
+.cn-preview-output {
+	justify-content: flex-end;
+}
+
+.cn-preview-list {
+	display: flex;
+	flex-direction: column;
+	gap: 3px;
+	padding: 0 10px 10px 10px;
+}
+
+.cn-preview-switch {
+	position: relative;
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	background: var(--bg-color);
+	border: 2px solid var(--border-color);
+	border-radius: 10px;
+	text-wrap: nowrap;
+	padding: 2px 20px;
+	gap: 10px;
+}
+
+.cn-preview-switch::before,
+.cn-preview-switch::after {
+	position: absolute;
+	pointer-events: none;
+	top: 50%;
+	transform: translate(0, -50%);
+	color: var(--fg-color);
+	opacity: 0.8;
+}
+
+.cn-preview-switch::before {
+	content: "◀";
+	left: 5px;
+}
+
+.cn-preview-switch::after {
+	content: "▶";
+	right: 5px;
+}
+
+.cn-preview-value {
+	color: var(--descrip-text);
+}
+
+.cn-preview-string {
+	min-height: 30px;
+	max-height: 300px;
+	background: var(--bg-color);
+	color: var(--descrip-text);
+	border-radius: 3px;
+	padding: 3px 5px;
+	overflow-y: auto;
+	overflow-x: hidden;
+}
+
+.cn-preview-description {
+	margin: 0px 10px 10px 10px;
+	padding: 6px;
+	background: var(--border-color);
+	color: var(--descrip-text);
+	border-radius: 5px;
+	font-style: italic;
+	word-break: break-word;
+}
+
+.cn-tag-list {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 5px;
+	align-items: center;
+	margin-bottom: 5px;
+}
+
+.cn-tag-list > div {
+	background-color: var(--border-color);
+	border-radius: 5px;
+	padding: 0 5px;
+}
+
+.cn-install-buttons {
+	display: flex;
+	flex-direction: column;
+	gap: 3px;
+	padding: 3px;
+	align-items: center;
+	justify-content: center;
+	height: 100%;
+}
+
+.cn-selected-buttons {
+	display: flex;
+	gap: 5px;
+	align-items: center;
+	padding-right: 20px;
+}
+
+.nu-manager .cn-btn-enable {
+	background-color: #333399;
+	color: white;
+}
+
+.nu-manager .cn-btn-disable {
+	background-color: #442277;
+	color: white;
+}
+
+.nu-manager .cn-btn-update {
+	background-color: #1155AA;
+	color: white;
+}
+
+.nu-manager .cn-btn-try-update {
+	background-color: Gray;
+	color: white;
+}
+
+.nu-manager .cn-btn-try-fix {
+	background-color: #6495ED;
+	color: white;
+}
+
+.nu-manager .cn-btn-import-failed {
+	background-color: #AA1111;
+    font-size: 10px;
+	font-weight: bold;
+	color: white;
+}
+
+.nu-manager .cn-btn-install {
+	background-color: black;
+	color: white;
+}
+
+.nu-manager .cn-btn-try-install {
+	background-color: Gray;
+	color: white;
+}
+
+.nu-manager .cn-btn-uninstall {
+	background-color: #993333;
+	color: white;
+}
+
+.nu-manager .cn-btn-reinstall {
+	background-color: #993333;
+	color: white;
+}
+
+.nu-manager .cn-btn-switch {
+	background-color: #448833;
+	color: white;
+
+}
+
+@keyframes nu-btn-loading-bg {
+	0% {
+		left: 0;
+	}
+	100% {
+		left: -105px;
+	}
+}
+
+.nu-manager button.nu-btn-loading {
+	position: relative;
+	overflow: hidden;
+	border-color: rgb(0 119 207 / 80%);
+	background-color: var(--comfy-input-bg);
+}
+
+.nu-manager button.nu-btn-loading::after {
+	position: absolute;
+	top: 0;
+	left: 0;
+	content: "";
+	width: 500px;
+	height: 100%;
+	background-image: repeating-linear-gradient(
+		-45deg,
+		rgb(0 119 207 / 30%),
+		rgb(0 119 207 / 30%) 10px,
+		transparent 10px,
+		transparent 15px
+	);
+	animation: nu-btn-loading-bg 2s linear infinite;
+}
+
+.nu-manager-light .nu-pack-name a {
+	color: blue;
+}
+
+.nu-manager-light .cm-warn-note {
+	background-color: #ccc !important;
+}
+
+.nu-manager-light .cn-btn-install {
+	background-color: #333;
+}

js/node-usage-analyzer.js

@@ -0,0 +1,742 @@
+import { app } from "../../scripts/app.js";
+import { $el } from "../../scripts/ui.js";
+import {
+	manager_instance,
+	fetchData, md5, show_message, customAlert, infoToast, showTerminal,
+	storeColumnWidth, restoreColumnWidth, loadCss, uninstallNodes,
+	analyzeWorkflowUsage, sizeToBytes, createFlyover, createUIStateManager
+} from "./common.js";
+import { api } from "../../scripts/api.js";
+
+// https://cenfun.github.io/turbogrid/api.html
+import TG from "./turbogrid.esm.js";
+
+loadCss("./node-usage-analyzer.css");
+
+const gridId = "model";
+
+const pageHtml = `
+<div class="nu-manager-header">
+	<div class="nu-manager-status"></div>
+	<input type="text" class="nu-manager-keywords" placeholder="Filter keywords..." />
+	<div class="nu-flex-auto"></div>
+</div>
+<div class="nu-manager-grid"></div>
+<div class="nu-manager-selection"></div>
+<div class="nu-manager-message"></div>
+<div class="nu-manager-footer">
+	<button class="nu-manager-back">
+		<svg class="arrow-icon" width="14" height="14" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+			<path d="M2 8H18M2 8L8 2M2 8L8 14" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+		</svg>
+		Back
+	</button>
+	<button class="nu-manager-refresh">Refresh</button>
+	<button class="nu-manager-stop">Stop</button>
+	<div class="nu-flex-auto"></div>
+</div>
+`;
+
+export class NodeUsageAnalyzer {
+	static instance = null;
+
+	static SortMode = {
+		BY_PACKAGE: 'by_package'
+	};
+
+	constructor(app, manager_dialog) {
+		this.app = app;
+		this.manager_dialog = manager_dialog;
+		this.id = "nu-manager";
+
+		this.filter = '';
+		this.type = '';
+		this.base = '';
+		this.keywords = '';
+
+		this.init();
+
+		// Initialize shared UI state manager
+		this.ui = createUIStateManager(this.element, {
+			selection: ".nu-manager-selection",
+			message: ".nu-manager-message",
+			status: ".nu-manager-status",
+			refresh: ".nu-manager-refresh",
+			stop: ".nu-manager-stop"
+		});
+
+		api.addEventListener("cm-queue-status", this.onQueueStatus);
+	}
+
+	init() {
+		this.element = $el("div", {
+			parent: document.body,
+			className: "comfy-modal nu-manager"
+		});
+		this.element.innerHTML = pageHtml;
+		this.bindEvents();
+		this.initGrid();
+	}
+
+	bindEvents() {
+		const eventsMap = {
+			".nu-manager-selection": {
+				click: (e) => {
+					const target = e.target;
+					const mode = target.getAttribute("mode");
+					if (mode === "install") {
+						this.installModels(this.selectedModels, target);
+					} else if (mode === "uninstall") {
+						this.uninstallModels(this.selectedModels, target);
+					}
+				}
+			},
+
+			".nu-manager-refresh": {
+				click: () => {
+					app.refreshComboInNodes();
+				}
+			},
+
+			".nu-manager-stop": {
+				click: () => {
+					api.fetchApi('/manager/queue/reset');
+					infoToast('Cancel', 'Remaining tasks will stop after completing the current task.');
+				}
+			},
+
+			".nu-manager-back": {
+				click: (e) => {
+					this.close()
+					manager_instance.show();
+				}
+			}
+		};
+		Object.keys(eventsMap).forEach(selector => {
+			const target = this.element.querySelector(selector);
+			if (target) {
+				const events = eventsMap[selector];
+				if (events) {
+					Object.keys(events).forEach(type => {
+						target.addEventListener(type, events[type]);
+					});
+				}
+			}
+		});
+	}
+
+	// ===========================================================================================
+
+	initGrid() {
+		const container = this.element.querySelector(".nu-manager-grid");
+		const grid = new TG.Grid(container);
+		this.grid = grid;
+
+		this.flyover = createFlyover(container, { context: this });
+
+		grid.bind('onUpdated', (e, d) => {
+			this.ui.showStatus(`${grid.viewRows.length.toLocaleString()} installed packages`);
+
+		});
+
+		grid.bind('onSelectChanged', (e, changes) => {
+			this.renderSelected();
+		});
+
+		grid.bind("onColumnWidthChanged", (e, columnItem) => {
+			storeColumnWidth(gridId, columnItem)
+		});
+
+		grid.bind('onClick', (e, d) => {
+			const { rowItem } = d;
+			const target = d.e.target;
+			const mode = target.getAttribute("mode");
+
+			if (mode === "install") {
+				this.installModels([rowItem], target);
+				return;
+			}
+
+			if (mode === "uninstall") {
+				this.uninstallModels([rowItem], target);
+				return;
+			}
+
+			// Handle click on usage count
+			if (d.columnItem.id === "used_in_count" && rowItem.used_in_count > 0) {
+				this.showUsageDetails(rowItem);
+				return;
+			}
+
+		});
+
+		grid.setOption({
+			theme: 'dark',
+
+			selectVisible: true,
+			selectMultiple: true,
+			selectAllVisible: true,
+
+			textSelectable: true,
+			scrollbarRound: true,
+
+			frozenColumn: 1,
+			rowNotFound: "No Results",
+
+			rowHeight: 40,
+			bindWindowResize: true,
+			bindContainerResize: true,
+
+			cellResizeObserver: (rowItem, columnItem) => {
+				const autoHeightColumns = ['name', 'description'];
+				return autoHeightColumns.includes(columnItem.id)
+			}
+		});
+
+	}
+
+	renderGrid() {
+
+		// update theme
+		const colorPalette = this.app.ui.settings.settingsValues['Comfy.ColorPalette'];
+		Array.from(this.element.classList).forEach(cn => {
+			if (cn.startsWith("nu-manager-")) {
+				this.element.classList.remove(cn);
+			}
+		});
+		this.element.classList.add(`nu-manager-${colorPalette}`);
+
+		const options = {
+			theme: colorPalette === "light" ? "" : "dark"
+		};
+
+		const rows = this.modelList || [];
+
+		const columns = [{
+			id: 'title',
+			name: 'Title',
+			width: 200,
+			minWidth: 100,
+			maxWidth: 500,
+			classMap: 'nu-pack-name',
+			formatter: function (name, rowItem, columnItem, cellNode) {
+				return `<a href=${rowItem.reference} target="_blank"><b>${name}</b></a>`;
+			}
+		}, {
+			id: 'used_in_count',
+			name: 'Used in',
+			width: 100,
+			formatter: function (usedCount, rowItem, columnItem) {
+				if (!usedCount || usedCount === 0) {
+					return '0';
+				}
+				const plural = usedCount > 1 ? 's' : '';
+				return `<div class="cn-pack-nodes" style="cursor: pointer;">${usedCount} workflow${plural}</div>`;
+			}
+		}, {
+			id: 'action',
+			name: 'Action',
+			width: 160,
+			minWidth: 140,
+			maxWidth: 200,
+			sortable: false,
+			align: 'center',
+			formatter: function (action, rowItem, columnItem) {
+				// Only show uninstall button for installed packages
+				if (rowItem.originalData && rowItem.originalData.state && rowItem.originalData.state !== "not-installed") {
+					return `<div class="cn-install-buttons"><button class="nu-btn-uninstall" mode="uninstall">Uninstall</button></div>`;
+				}
+				return '';
+			}
+		}];
+
+		restoreColumnWidth(gridId, columns);
+
+		this.grid.setData({
+			options,
+			rows,
+			columns
+		});
+
+		this.grid.render();
+
+	}
+
+	updateGrid() {
+		if (this.grid) {
+			this.grid.update();
+		}
+	}
+
+
+	showUsageDetails(rowItem) {
+		const workflowList = rowItem.workflowDetails;
+		if (!workflowList || workflowList.length === 0) {
+			return;
+		}
+
+		let titleHtml = `<div class="cn-nodes-pack">${rowItem.title}</div>`;
+
+		const list = [];
+		list.push(`<div class="cn-nodes-list">`);
+
+		workflowList.forEach((workflow, i) => {
+			list.push(`<div class="cn-nodes-row">`);
+			list.push(`<div class="cn-nodes-sn">${i + 1}</div>`);
+			list.push(`<div class="cn-nodes-name">${workflow.filename}</div>`);
+			list.push(`<div class="cn-nodes-details">${workflow.nodeCount} node${workflow.nodeCount > 1 ? 's' : ''}</div>`);
+			list.push(`</div>`);
+		});
+
+		list.push("</div>");
+		const bodyHtml = list.join("");
+
+		this.flyover.show(titleHtml, bodyHtml);
+	}
+
+	renderSelected() {
+		const selectedList = this.grid.getSelectedRows();
+		if (!selectedList.length) {
+			this.ui.showSelection("");
+			return;
+		}
+
+		const installedSelected = selectedList.filter(item =>
+			item.originalData && item.originalData.state && item.originalData.state !== "not-installed"
+		);
+
+		if (installedSelected.length === 0) {
+			this.ui.showSelection(`<span>Selected <b>${selectedList.length}</b> packages (none can be uninstalled)</span>`);
+			return;
+		}
+
+		this.selectedModels = installedSelected;
+
+		this.ui.showSelection(`
+			<div class="nu-selected-buttons">
+				<span>Selected <b>${installedSelected.length}</b> installed packages</span>
+				<button class="nu-btn-uninstall" mode="uninstall">Uninstall Selected</button>
+			</div>
+		`);
+	}
+
+	// ===========================================================================================
+
+	async installModels(list, btn) {
+		let stats = await api.fetchApi('/manager/queue/status');
+
+		stats = await stats.json();
+		if (stats.is_processing) {
+			customAlert(`[ComfyUI-Manager] There are already tasks in progress. Please try again after it is completed. (${stats.done_count}/${stats.total_count})`);
+			return;
+		}
+
+		btn.classList.add("nu-btn-loading");
+		this.ui.showError("");
+
+		let needRefresh = false;
+		let errorMsg = "";
+
+		await api.fetchApi('/manager/queue/reset');
+
+		let target_items = [];
+
+		for (const item of list) {
+			this.grid.scrollRowIntoView(item);
+			target_items.push(item);
+
+
+			this.ui.showStatus(`Install ${item.name} ...`);
+
+			const data = item.originalData;
+			data.ui_id = item.hash;
+
+			const res = await api.fetchApi(`/manager/queue/install_model`, {
+				method: 'POST',
+				body: JSON.stringify(data)
+			});
+
+			if (res.status != 200) {
+				errorMsg = `'${item.name}': `;
+
+				if (res.status == 403) {
+					errorMsg += `This action is not allowed with this security level configuration.\n`;
+				} else {
+					errorMsg += await res.text() + '\n';
+				}
+
+				break;
+			}
+		}
+
+		this.install_context = { btn: btn, targets: target_items };
+
+		if (errorMsg) {
+			this.ui.showError(errorMsg);
+			show_message("[Installation Errors]\n" + errorMsg);
+
+			// reset
+			for (let k in target_items) {
+				const item = target_items[k];
+				this.grid.updateCell(item, "installed");
+			}
+		}
+		else {
+			await api.fetchApi('/manager/queue/start');
+			this.ui.showStop();
+			showTerminal();
+		}
+	}
+
+	async uninstallModels(list, btn) {
+		btn.classList.add("nu-btn-loading");
+		this.ui.showError("");
+
+		const result = await uninstallNodes(list, {
+			title: list.length === 1 ? list[0].title || list[0].name : `${list.length} custom nodes`,
+			channel: 'default',
+			mode: 'default',
+			onProgress: (msg) => {
+				this.showStatus(msg);
+			},
+			onError: (errorMsg) => {
+				this.showError(errorMsg);
+			},
+			onSuccess: (targets) => {
+				this.showStatus(`Uninstalled ${targets.length} custom node(s) successfully`);
+				this.showMessage(`To apply the uninstalled custom nodes, please restart ComfyUI and refresh browser.`, "red");
+				// Update the grid to reflect changes
+				for (let item of targets) {
+					if (item.originalData) {
+						item.originalData.state = "not-installed";
+					}
+					this.grid.updateRow(item);
+				}
+			}
+		});
+
+		if (result.success) {
+			this.showStop();
+		}
+
+		btn.classList.remove("nu-btn-loading");
+	}
+
+	async onQueueStatus(event) {
+		let self = NodeUsageAnalyzer.instance;
+
+		if (event.detail.status == 'in_progress' && (event.detail.ui_target == 'model_manager' || event.detail.ui_target == 'nodepack_manager')) {
+			const hash = event.detail.target;
+
+			const item = self.grid.getRowItemBy("hash", hash);
+
+			if (item) {
+				item.refresh = true;
+				self.grid.setRowSelected(item, false);
+				item.selectable = false;
+				self.grid.updateRow(item);
+			}
+		}
+		else if (event.detail.status == 'done') {
+			self.hideStop();
+			self.onQueueCompleted(event.detail);
+		}
+	}
+
+	async onQueueCompleted(info) {
+		let result = info.model_result || info.nodepack_result;
+
+		if (!result || result.length == 0) {
+			return;
+		}
+
+		let self = NodeUsageAnalyzer.instance;
+
+		if (!self.install_context) {
+			return;
+		}
+
+		let btn = self.install_context.btn;
+
+		self.hideLoading();
+		btn.classList.remove("nu-btn-loading");
+
+		let errorMsg = "";
+
+		for (let hash in result) {
+			let v = result[hash];
+
+			if (v != 'success' && v != 'skip')
+				errorMsg += v + '\n';
+		}
+
+		for (let k in self.install_context.targets) {
+			let item = self.install_context.targets[k];
+			if (info.model_result) {
+				self.grid.updateCell(item, "installed");
+			} else if (info.nodepack_result) {
+				// Handle uninstall completion
+				if (item.originalData) {
+					item.originalData.state = "not-installed";
+				}
+				self.grid.updateRow(item);
+			}
+		}
+
+		if (errorMsg) {
+			self.showError(errorMsg);
+			show_message("Operation Error:\n" + errorMsg);
+		} else {
+			if (info.model_result) {
+				self.showStatus(`Install ${Object.keys(result).length} models successfully`);
+				self.showRefresh();
+				self.showMessage(`To apply the installed model, please click the 'Refresh' button.`, "red");
+			} else if (info.nodepack_result) {
+				self.showStatus(`Uninstall ${Object.keys(result).length} custom node(s) successfully`);
+				self.showMessage(`To apply the uninstalled custom nodes, please restart ComfyUI and refresh browser.`, "red");
+			}
+		}
+
+		infoToast('Tasks done', `[ComfyUI-Manager] All tasks in the queue have been completed.\n${info.done_count}/${info.total_count}`);
+		self.install_context = undefined;
+	}
+
+	getModelList(models) {
+		const typeMap = new Map();
+		const baseMap = new Map();
+
+		models.forEach((item, i) => {
+			const { type, base, name, reference, installed } = item;
+			// CRITICAL FIX: Do NOT overwrite originalData - it contains the needed state field!
+			item.size = sizeToBytes(item.size);
+			item.hash = md5(name + reference);
+
+			if (installed === "True") {
+				item.selectable = false;
+			}
+
+			typeMap.set(type, type);
+			baseMap.set(base, base);
+
+		});
+
+		const typeList = [];
+		typeMap.forEach(type => {
+			typeList.push({
+				label: type,
+				value: type
+			});
+		});
+		typeList.sort((a, b) => {
+			const au = a.label.toUpperCase();
+			const bu = b.label.toUpperCase();
+			if (au !== bu) {
+				return au > bu ? 1 : -1;
+			}
+			return 0;
+		});
+		this.typeList = [{
+			label: "All",
+			value: ""
+		}].concat(typeList);
+
+
+		const baseList = [];
+		baseMap.forEach(base => {
+			baseList.push({
+				label: base,
+				value: base
+			});
+		});
+		baseList.sort((a, b) => {
+			const au = a.label.toUpperCase();
+			const bu = b.label.toUpperCase();
+			if (au !== bu) {
+				return au > bu ? 1 : -1;
+			}
+			return 0;
+		});
+		this.baseList = [{
+			label: "All",
+			value: ""
+		}].concat(baseList);
+
+		return models;
+	}
+
+	// ===========================================================================================
+
+	async loadData() {
+
+		this.showLoading();
+		this.showStatus(`Analyzing node usage ...`);
+
+		const mode = manager_instance.datasrc_combo.value;
+
+		const nodeListRes = await fetchData(`/customnode/getlist?mode=${mode}&skip_update=true`);
+		if (nodeListRes.error) {
+			this.showError("Failed to get custom node list.");
+			this.hideLoading();
+			return;
+		}
+
+		const { channel, node_packs } = nodeListRes.data;
+		delete node_packs['comfyui-manager'];
+		this.installed_custom_node_packs = node_packs;
+
+		// Use the consolidated workflow analysis utility
+		const result = await analyzeWorkflowUsage(node_packs);
+
+		if (!result.success) {
+			if (result.error.toString().includes('204')) {
+				this.showMessage("No workflows were found for analysis.");
+			} else {
+				this.showError(result.error);
+				this.hideLoading();
+				return;
+			}
+		}
+
+		// Transform node_packs into models format - ONLY INSTALLED PACKAGES
+		const models = [];
+
+		Object.keys(node_packs).forEach((packKey, index) => {
+			const pack = node_packs[packKey];
+
+			// Only include installed packages (filter out "not-installed" packages)
+			if (pack.state === "not-installed") {
+				return; // Skip non-installed packages
+			}
+
+			const usedCount = result.usageMap?.get(packKey) || 0;
+			const workflowDetails = result.workflowDetailsMap?.get(packKey) || [];
+
+			models.push({
+				title: pack.title || packKey,
+				reference: pack.reference || pack.files?.[0] || '#',
+				used_in_count: usedCount,
+				workflowDetails: workflowDetails,
+				name: packKey,
+				originalData: pack
+			});
+		});
+
+		// Sort by usage count (descending) then by title
+		models.sort((a, b) => {
+			if (b.used_in_count !== a.used_in_count) {
+				return b.used_in_count - a.used_in_count;
+			}
+			return a.title.localeCompare(b.title);
+		});
+
+		this.modelList = this.getModelList(models);
+
+		this.renderGrid();
+
+		this.hideLoading();
+
+	}
+
+	// ===========================================================================================
+
+	showSelection(msg) {
+		this.element.querySelector(".nu-manager-selection").innerHTML = msg;
+	}
+
+	showError(err) {
+		this.showMessage(err, "red");
+	}
+
+	showMessage(msg, color) {
+		if (color) {
+			msg = `<font color="${color}">${msg}</font>`;
+		}
+		this.element.querySelector(".nu-manager-message").innerHTML = msg;
+	}
+
+	showStatus(msg, color) {
+		if (color) {
+			msg = `<font color="${color}">${msg}</font>`;
+		}
+		this.element.querySelector(".nu-manager-status").innerHTML = msg;
+	}
+
+	showLoading() {
+		//		this.setDisabled(true);
+		if (this.grid) {
+			this.grid.showLoading();
+			this.grid.showMask({
+				opacity: 0.05
+			});
+		}
+	}
+
+	hideLoading() {
+		//		this.setDisabled(false);
+		if (this.grid) {
+			this.grid.hideLoading();
+			this.grid.hideMask();
+		}
+	}
+
+	setDisabled(disabled) {
+		const $close = this.element.querySelector(".nu-manager-close");
+		const $refresh = this.element.querySelector(".nu-manager-refresh");
+		const $stop = this.element.querySelector(".nu-manager-stop");
+
+		const list = [
+			".nu-manager-header input",
+			".nu-manager-header select",
+			".nu-manager-footer button",
+			".nu-manager-selection button"
+		].map(s => {
+			return Array.from(this.element.querySelectorAll(s));
+		})
+			.flat()
+			.filter(it => {
+				return it !== $close && it !== $refresh && it !== $stop;
+			});
+
+		list.forEach($elem => {
+			if (disabled) {
+				$elem.setAttribute("disabled", "disabled");
+			} else {
+				$elem.removeAttribute("disabled");
+			}
+		});
+
+		Array.from(this.element.querySelectorAll(".nu-btn-loading")).forEach($elem => {
+			$elem.classList.remove("nu-btn-loading");
+		});
+
+	}
+
+	showRefresh() {
+		this.element.querySelector(".nu-manager-refresh").style.display = "block";
+	}
+
+	showStop() {
+		this.element.querySelector(".nu-manager-stop").style.display = "block";
+	}
+
+	hideStop() {
+		this.element.querySelector(".nu-manager-stop").style.display = "none";
+	}
+
+	setKeywords(keywords = "") {
+		this.keywords = keywords;
+		this.element.querySelector(".nu-manager-keywords").value = keywords;
+	}
+
+	show(sortMode) {
+		this.element.style.display = "flex";
+		this.setKeywords("");
+		this.showSelection("");
+		this.showMessage("");
+		this.loadData();
+	}
+
+	close() {
+		this.element.style.display = "none";
+	}
+}

node_db/forked/custom-node-list.json

@@ -169,6 +169,16 @@
             ],
             "install_type": "git-clone",
             "description": "A fork of KJNodes for ComfyUI.\nVarious quality of life -nodes for ComfyUI, mostly just visual stuff to improve usability"
+        },
+        {
+            "author": "huixingyun",
+            "title": "ComfyUI-SoundFlow",
+            "reference": "https://github.com/huixingyun/ComfyUI-SoundFlow",
+            "files": [
+                "https://github.com/huixingyun/ComfyUI-SoundFlow"
+            ],
+            "install_type": "git-clone",
+            "description": "forked from https://github.com/fredconex/ComfyUI-SoundFlow (removed)"
         }
     ]
 }

node_db/legacy/custom-node-list.json

@@ -1,15 +1,204 @@
 {
     "custom_nodes": [
         {
-            "author": "Lorenzo Mercugliano",
-            "title": "Multiple-Angle-Camera-Control [REMOVED]",
-            "id": "multiple-angle-camera-control",
-            "reference": "https://github.com/mercu-lore/-Multiple-Angle-Camera-Control",
+            "author": "PozzettiAndrea",
+            "title": "ComfyUI-CameraAnalysis [REMOVED]",
+            "reference": "https://github.com/PozzettiAndrea/ComfyUI-CameraAnalysis",
             "files": [
-                "https://github.com/mercu-lore/-Multiple-Angle-Camera-Control.git"
+                "https://github.com/PozzettiAndrea/ComfyUI-CameraAnalysis"
             ],
             "install_type": "git-clone",
-            "description": "Advanced camera control prompt generator for ComfyUI, optimized for dx8152's MultiAngle LoRA. Simplifies multi-directional movements, rotations, and special views with bilingual output."
+            "description": "Extracts camera intrinsic parameters from image EXIF data."
+        },
+        {
+            "author": "fuzr0dah",
+            "title": "comfyui-sceneassembly [REMOVED]",
+            "reference": "https://github.com/fuzr0dah/comfyui-sceneassembly",
+            "files": [
+                "https://github.com/fuzr0dah/comfyui-sceneassembly"
+            ],
+            "install_type": "git-clone",
+            "description": "A bunch of nodes I created that I also find useful."
+        },
+        {
+            "author": "rslosch",
+            "title": "ComfyUI-EZ_Prompts [REMOVED]",
+            "reference": "https://github.com/rslosch/ComfyUI-EZ_Prompts",
+            "files": [
+                "https://github.com/rslosch/ComfyUI-EZ_Prompts"
+            ],
+            "install_type": "git-clone",
+            "description": "A ComfyUI custom node extension that provides easy-to-use prompt templates and wildcards for AI image generation."
+        },
+        {
+            "author": "hvppycoding",
+            "title": "hvppyflow [REMOVED]",
+            "reference": "https://github.com/hvppycoding/hvppyflow",
+            "files": [
+                "https://github.com/hvppycoding/hvppyflow"
+            ],
+            "install_type": "git-clone",
+            "description": "ComfyUI nodes for Automated Workflow"
+        },        
+        {
+            "author": "cedarconnor",
+            "title": "ComfyUI-GEN3C-Gsplat [REMOVED]",
+            "reference": "https://github.com/cedarconnor/ComfyUI-GEN3C-Gsplat",
+            "files": [
+                "https://github.com/cedarconnor/ComfyUI-GEN3C-Gsplat"
+            ],
+            "install_type": "git-clone",
+            "description": "A custom ComfyUI node pack that bridges Cosmos/GEN3C video generation with in-graph Gaussian Splat (3DGS) training. It adds camera/trajectory tooling, dataset exporters, and two training backends (Nerfstudio CLI wrapper and an in-process gsplat optimizer) so artists can go from prompt to splat entirely inside ComfyUI.\nNOTE: The files in the repo are not organized."
+        },
+        {
+            "author": "dowa-git",
+            "title": "comfyui-dowa [REMOVED]",
+            "reference": "https://github.com/dowa-git/comfyui-dowa",
+            "files": [
+                "https://github.com/dowa-git/comfyui-dowa"
+            ],
+            "install_type": "git-clone",
+            "description": "Professional navigation bar widget for ComfyUI with JWT-based user authentication, workflow templates, and team collaboration features in a purple gradient design."
+        },
+        {
+            "author": "Fablestarexpanse",
+            "title": "Timer-Node-Comfyui [REMOVED]",
+            "reference": "https://github.com/Fablestarexpanse/Timer-Node-Comfyui",
+            "files": [
+                "https://github.com/Fablestarexpanse/Timer-Node-Comfyui"
+            ],
+            "install_type": "git-clone",
+            "description": "A custom ComfyUI node that displays live processing time in a red digital countdown clock format, perfect for monitoring image generation times and tracking performance between workflow nodes."
+        },
+        {
+            "author": "cedarconnor",
+            "title": "ComfyUI-OmniX [REMOVED]",
+            "reference": "https://github.com/cedarconnor/ComfyUI-OmniX",
+            "files": [
+                "https://github.com/cedarconnor/ComfyUI-OmniX"
+            ],
+            "install_type": "git-clone",
+            "description": "Extract comprehensive scene properties from 360-degree equirectangular panoramas, including depth, normals, and PBR materials, using OmniX adapters with Flux."
+        },
+        {
+            "author": "cedarconnor",
+            "title": "ComfyUI-DiT360 [REMOVED]",
+            "reference": "https://github.com/cedarconnor/ComfyUI-DiT360",
+            "files": [
+                "https://github.com/cedarconnor/ComfyUI-DiT360"
+            ],
+            "install_type": "git-clone",
+            "description": "Generate high-fidelity 360-degree panoramic images using the DiT360 diffusion transformer model in ComfyUI."
+        },
+        {
+            "author": "PozzettiAndrea",
+            "title": "ComfyUI-AnyTop [REMOVED]",
+            "reference": "https://github.com/PozzettiAndrea/ComfyUI-AnyTop",
+            "files": [
+                "https://github.com/PozzettiAndrea/ComfyUI-AnyTop"
+            ],
+            "install_type": "git-clone",
+            "description": "Standalone ComfyUI custom nodes for AnyTop - Universal Motion Generation for Any Skeleton Topology."
+        },
+        {
+            "author": "penposs",
+            "title": "ComfyUI-Banana-Node [REMOVED]",
+            "reference": "https://github.com/penposs/ComfyUI-Banana-Node",
+            "files": [
+                "https://github.com/penposs/ComfyUI-Banana-Node"
+            ],
+            "install_type": "git-clone",
+            "description": "A custom node for ComfyUI that generates images using Google’s Gemini 2.5 Flash Image Preview API."
+        },
+        {
+            "author": "spiralmountain",
+            "title": "ComfyUI_HDNodes [REMOVED]",
+            "reference": "https://github.com/spiralmountain/ComfyUI_HDNodes",
+            "files": [
+                "https://github.com/spiralmountain/ComfyUI_HDNodes"
+            ],
+            "install_type": "git-clone",
+            "description": "Custom nodes for ComfyUI that enable video generation using ByteDance's Seedance model via [a/Fal.ai](https://fal.ai/)."
+        },
+        {
+            "author": "fredconex",
+            "title": "Sync Edit [REMOVED]",
+            "reference": "https://github.com/fredconex/ComfyUI-SyncEdit",
+            "files": [
+                "https://github.com/fredconex/ComfyUI-SyncEdit"
+            ],
+            "install_type": "git-clone",
+            "description": "This node allow to intercept changes on the input string and choose between use the current one or sync with incoming new one."
+        },
+        {
+            "author": "fredconex",
+            "title": "ComfyUI-SoundFlow [REMOVED]",
+            "reference": "https://github.com/fredconex/ComfyUI-SoundFlow",
+            "files": [
+                "https://github.com/fredconex/ComfyUI-SoundFlow"
+            ],
+            "install_type": "git-clone",
+            "description": "This is a bunch of nodes for ComfyUI to help with sound work."
+        },
+        {
+            "author": "fredconex",
+            "title": "SongBloom [REMOVED]",
+            "reference": "https://github.com/fredconex/ComfyUI-SongBloom",
+            "files": [
+                "https://github.com/fredconex/ComfyUI-SongBloom"
+            ],
+            "install_type": "git-clone",
+            "description": "ComfyUI Nodes for SongBloom"
+        },
+        {
+            "author": "EQXai",
+            "title": "ComfyUI_EQX [REMOVED]",
+            "reference": "https://github.com/EQXai/ComfyUI_EQX",
+            "files": [
+                "https://github.com/EQXai/ComfyUI_EQX"
+            ],
+            "install_type": "git-clone",
+            "description": "NODES: SaveImage_EQX, File Image Selector, Load Prompt From File - EQX, LoraStackEQX_random, Extract Filename - EQX, Extract LORA name - EQX, NSFW Detector EQX, NSFW Detector Advanced EQX"
+        },
+        {
+            "author": "wizdroid",
+            "title": "Wizdroid ComfyUI Outfit Selection [REMOVED]",
+            "reference": "https://github.com/wizdroid/wizdroid-fashionista",
+            "files": [
+                "https://github.com/wizdroid/wizdroid-fashionista"
+            ],
+            "install_type": "git-clone",
+            "description": "A comprehensive outfit generation system for ComfyUI with AI-powered prompt enhancement and dynamic outfit composition."
+        },
+        {
+            "author": "enternalsaga",
+            "title": "NBA-ComfyUINode [REMOVED]",
+            "reference": "https://github.com/enternalsaga/NBA-ComfyUINode-public",
+            "files": [
+                "https://github.com/enternalsaga/NBA-ComfyUINode-public"
+            ],
+            "install_type": "git-clone",
+            "description": "Version 1.2.1 - Dependency cleanup and archived LineSelector node\nA comprehensive collection of custom nodes for ComfyUI, providing advanced image processing, workflow control, and utility functions to enhance your AI image generation workflows."
+        },
+        {
+            "author": "sselpah",
+            "title": "ComfyUI-sselpah-nodes [REMOVED]",
+            "reference": "https://github.com/sselpah/ComfyUI-sselpah-nodes",
+            "files": [
+                "https://github.com/sselpah/ComfyUI-sselpah-nodes"
+            ],
+            "install_type": "git-clone",
+            "description": "Extension of IPAdapter implementation by cubiq and whoever contributed to that repository"
+        },
+        {
+            "author": "vsaan212",
+            "title": "ComfyUI Text Split Node [REMOVED]",
+            "reference": "https://github.com/vsaan212/Comfy-ui-textsplit",
+            "files": [
+                "https://github.com/vsaan212/Comfy-ui-textsplit"
+            ],
+            "install_type": "git-clone",
+            "description": "A custom ComfyUI node that splits text into multiple outputs for feeding complex multi-scene renders. This node allows you to dynamically control the number of splits and use custom separators."
         },
         {
             "author": "EnragedAntelope",
@@ -1208,16 +1397,6 @@
             "install_type": "git-clone",
             "description": "This node provides advanced text-to-speech functionality powered by KokoroTTS. Follow the instructions below to install, configure, and use the node within your portable ComfyUI installation."
         },
-        {
-            "author": "MushroomFleet",
-            "title": "DJZ-Pedalboard [REMOVED]",
-            "reference": "https://github.com/MushroomFleet/DJZ-Pedalboard",
-            "files": [
-                "https://github.com/MushroomFleet/DJZ-Pedalboard"
-            ],
-            "install_type": "git-clone",
-            "description": "This project provides a collection of custom nodes designed for enhanced audio effects in ComfyUI. With an intuitive pedalboard interface, users can easily integrate and manipulate various audio effects within their workflows."
-        },
         {
             "author": "MushroomFleet",
             "title": "SVG Suite for ComfyUI [REMOVED]",

openapi.yaml

@@ -250,6 +250,30 @@ paths:
                     type: object
                     additionalProperties:
                       $ref: '#/components/schemas/NodePackageMetadata'
+
+  /customnode/get_node_types_in_workflows:
+    get:
+      summary: List node types used by all user workflows
+      description: Scan through all workflows in the Comfy user directory, and return a list of all node types used in each one.
+      responses:
+        '200':
+          description: Successful operation
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    workflow_file_name:
+                      type: string
+                    node_types:
+                      type: array
+                      items:
+                        type: string
+                    
+        '500':
+          description: Error occurred
                       
   /customnode/alternatives:
     get:

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-manager"
 description = "ComfyUI-Manager provides features to install and manage custom nodes for ComfyUI, as well as various functionalities to assist with ComfyUI."
-version = "3.37"
+version = "3.37.2"
 license = { file = "LICENSE.txt" }
 dependencies = ["GitPython", "PyGithub", "matrix-nio", "transformers", "huggingface-hub>0.20", "typer", "rich", "typing-extensions", "toml", "uv", "chardet"]
 

scanner.py

@@ -7,6 +7,8 @@ import concurrent
 import datetime
 import concurrent.futures
 import requests
+import warnings
+import argparse
 
 builtin_nodes = set()
 
@@ -39,27 +41,51 @@ def download_url(url, dest_folder, filename=None):
         raise Exception(f"Failed to download file from {url}")
 
 
-# prepare temp dir
-if len(sys.argv) > 1:
-    temp_dir = sys.argv[1]
-else:
-    temp_dir = os.path.join(os.getcwd(), ".tmp")
+def parse_arguments():
+    """Parse command-line arguments"""
+    parser = argparse.ArgumentParser(
+        description='ComfyUI Manager Node Scanner',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  # Standard mode
+  python3 scanner.py
+  python3 scanner.py --skip-update
 
-if not os.path.exists(temp_dir):
-    os.makedirs(temp_dir)
+  # Scan-only mode
+  python3 scanner.py --scan-only temp-urls-clean.list
+  python3 scanner.py --scan-only urls.list --temp-dir /custom/temp
+  python3 scanner.py --scan-only urls.list --skip-update
+        '''
+    )
+
+    parser.add_argument('--scan-only', type=str, metavar='URL_LIST_FILE',
+                       help='Scan-only mode: provide URL list file (one URL per line)')
+    parser.add_argument('--temp-dir', type=str, metavar='DIR',
+                       help='Temporary directory for cloned repositories')
+    parser.add_argument('--skip-update', action='store_true',
+                       help='Skip git clone/pull operations')
+    parser.add_argument('--skip-stat-update', action='store_true',
+                       help='Skip GitHub stats collection')
+    parser.add_argument('--skip-all', action='store_true',
+                       help='Skip all update operations')
+
+    # Backward compatibility: positional argument for temp_dir
+    parser.add_argument('temp_dir_positional', nargs='?', metavar='TEMP_DIR',
+                       help='(Legacy) Temporary directory path')
+
+    args = parser.parse_args()
+    return args
 
 
-skip_update = '--skip-update' in sys.argv or '--skip-all' in sys.argv
-skip_stat_update = '--skip-stat-update' in sys.argv or '--skip-all' in sys.argv
-
-if not skip_stat_update:
-    auth = Auth.Token(os.environ.get('GITHUB_TOKEN'))
-    g = Github(auth=auth)
-else:
-    g = None
-
-
-print(f"TEMP DIR: {temp_dir}")
+# Module-level variables (will be set in main if running as script)
+args = None
+scan_only_mode = False
+url_list_file = None
+temp_dir = None
+skip_update = False
+skip_stat_update = True
+g = None
 
 
 parse_cnt = 0
@@ -74,12 +100,22 @@ def extract_nodes(code_text):
         parse_cnt += 1
 
         code_text = re.sub(r'\\[^"\']', '', code_text)
-        parsed_code = ast.parse(code_text)
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', category=SyntaxWarning)
+            warnings.filterwarnings('ignore', category=DeprecationWarning)
+            parsed_code = ast.parse(code_text)
+
+        # Support both ast.Assign and ast.AnnAssign (for type-annotated assignments)
+        assignments = (node for node in parsed_code.body if isinstance(node, (ast.Assign, ast.AnnAssign)))
 
-        assignments = (node for node in parsed_code.body if isinstance(node, ast.Assign))
-        
         for assignment in assignments:
-            if isinstance(assignment.targets[0], ast.Name) and assignment.targets[0].id in ['NODE_CONFIG', 'NODE_CLASS_MAPPINGS']:
+            # Handle ast.AnnAssign (e.g., NODE_CLASS_MAPPINGS: Type = {...})
+            if isinstance(assignment, ast.AnnAssign):
+                if isinstance(assignment.target, ast.Name) and assignment.target.id in ['NODE_CONFIG', 'NODE_CLASS_MAPPINGS']:
+                    node_class_mappings = assignment.value
+                    break
+            # Handle ast.Assign (e.g., NODE_CLASS_MAPPINGS = {...})
+            elif isinstance(assignment.targets[0], ast.Name) and assignment.targets[0].id in ['NODE_CONFIG', 'NODE_CLASS_MAPPINGS']:
                 node_class_mappings = assignment.value
                 break
         else:
@@ -91,7 +127,7 @@ def extract_nodes(code_text):
             for key in node_class_mappings.keys:
                     if key is not None and isinstance(key.value, str):
                         s.add(key.value.strip())
-                    
+
             return s
         else:
             return set()
@@ -99,6 +135,99 @@ def extract_nodes(code_text):
         return set()
 
 
+def has_comfy_node_base(class_node):
+    """Check if class inherits from io.ComfyNode or ComfyNode"""
+    for base in class_node.bases:
+        # Case 1: ComfyNode
+        if isinstance(base, ast.Name) and base.id == 'ComfyNode':
+            return True
+        # Case 2: io.ComfyNode
+        elif isinstance(base, ast.Attribute):
+            if base.attr == 'ComfyNode':
+                return True
+    return False
+
+
+def extract_keyword_value(call_node, keyword):
+    """
+    Extract string value of keyword argument
+    Schema(node_id="MyNode") -> "MyNode"
+    """
+    for kw in call_node.keywords:
+        if kw.arg == keyword:
+            # ast.Constant (Python 3.8+)
+            if isinstance(kw.value, ast.Constant):
+                if isinstance(kw.value.value, str):
+                    return kw.value.value
+            # ast.Str (Python 3.7-) - suppress deprecation warning
+            else:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', category=DeprecationWarning)
+                    if hasattr(ast, 'Str') and isinstance(kw.value, ast.Str):
+                        return kw.value.s
+    return None
+
+
+def is_schema_call(call_node):
+    """Check if ast.Call is io.Schema() or Schema()"""
+    func = call_node.func
+    if isinstance(func, ast.Name) and func.id == 'Schema':
+        return True
+    elif isinstance(func, ast.Attribute) and func.attr == 'Schema':
+        return True
+    return False
+
+
+def extract_node_id_from_schema(class_node):
+    """
+    Extract node_id from define_schema() method
+    """
+    for item in class_node.body:
+        if isinstance(item, ast.FunctionDef) and item.name == 'define_schema':
+            # Walk through function body
+            for stmt in ast.walk(item):
+                if isinstance(stmt, ast.Call):
+                    # Check if it's Schema() call
+                    if is_schema_call(stmt):
+                        node_id = extract_keyword_value(stmt, 'node_id')
+                        if node_id:
+                            return node_id
+    return None
+
+
+def extract_v3_nodes(code_text):
+    """
+    Extract V3 node IDs using AST parsing
+    Returns: set of node_id strings
+    """
+    global parse_cnt
+
+    try:
+        if parse_cnt % 100 == 0:
+            print(".", end="", flush=True)
+        parse_cnt += 1
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', category=SyntaxWarning)
+            warnings.filterwarnings('ignore', category=DeprecationWarning)
+            tree = ast.parse(code_text)
+    except (SyntaxError, UnicodeDecodeError):
+        return set()
+
+    nodes = set()
+
+    # Find io.ComfyNode subclasses
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            # Check if inherits from ComfyNode
+            if has_comfy_node_base(node):
+                node_id = extract_node_id_from_schema(node)
+                if node_id:
+                    nodes.add(node_id)
+
+    return nodes
+
+
 # scan
 def scan_in_file(filename, is_builtin=False):
     global builtin_nodes
@@ -106,13 +235,18 @@ def scan_in_file(filename, is_builtin=False):
     with open(filename, encoding='utf-8', errors='ignore') as file:
         code = file.read()
 
-    pattern = r"_CLASS_MAPPINGS\s*=\s*{([^}]*)}"
+    # Support type annotations (e.g., NODE_CLASS_MAPPINGS: Type = {...}) and line continuations (\)
+    pattern = r"_CLASS_MAPPINGS\s*(?::\s*\w+\s*)?=\s*(?:\\\s*)?{([^}]*)}"
     regex = re.compile(pattern, re.MULTILINE | re.DOTALL)
 
     nodes = set()
     class_dict = {}
 
+    # V1 nodes detection
     nodes |= extract_nodes(code)
+
+    # V3 nodes detection
+    nodes |= extract_v3_nodes(code)
     code = re.sub(r'^#.*?$', '', code, flags=re.MULTILINE)
 
     def extract_keys(pattern, code):
@@ -209,6 +343,53 @@ def get_nodes(target_dir):
     return py_files, directories
 
 
+def get_urls_from_list_file(list_file):
+    """
+    Read URLs from list file for scan-only mode
+
+    Args:
+        list_file (str): Path to URL list file (one URL per line)
+
+    Returns:
+        list of tuples: [(url, "", None, None), ...]
+        Format: (url, title, preemptions, nodename_pattern)
+        - title: Empty string
+        - preemptions: None
+        - nodename_pattern: None
+
+    File format:
+        https://github.com/owner/repo1
+        https://github.com/owner/repo2
+        # Comments starting with # are ignored
+
+    Raises:
+        FileNotFoundError: If list_file does not exist
+    """
+    if not os.path.exists(list_file):
+        raise FileNotFoundError(f"URL list file not found: {list_file}")
+
+    urls = []
+    with open(list_file, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            line = line.strip()
+
+            # Skip empty lines and comments
+            if not line or line.startswith('#'):
+                continue
+
+            # Validate URL format (basic check)
+            if not (line.startswith('http://') or line.startswith('https://')):
+                print(f"WARNING: Line {line_num} is not a valid URL: {line}")
+                continue
+
+            # Add URL with empty metadata
+            # (url, title, preemptions, nodename_pattern)
+            urls.append((line, "", None, None))
+
+    print(f"Loaded {len(urls)} URLs from {list_file}")
+    return urls
+
+
 def get_git_urls_from_json(json_file):
     with open(json_file, encoding='utf-8') as file:
         data = json.load(file)
@@ -265,13 +446,43 @@ def clone_or_pull_git_repository(git_url):
             print(f"Failed to clone '{repo_name}': {e}")
 
 
-def update_custom_nodes():
+def update_custom_nodes(scan_only_mode=False, url_list_file=None):
+    """
+    Update custom nodes by cloning/pulling repositories
+
+    Args:
+        scan_only_mode (bool): If True, use URL list file instead of custom-node-list.json
+        url_list_file (str): Path to URL list file (required if scan_only_mode=True)
+
+    Returns:
+        dict: node_info mapping {repo_name: (url, title, preemptions, node_pattern)}
+    """
     if not os.path.exists(temp_dir):
         os.makedirs(temp_dir)
 
     node_info = {}
 
-    git_url_titles_preemptions = get_git_urls_from_json('custom-node-list.json')
+    # Select URL source based on mode
+    if scan_only_mode:
+        if not url_list_file:
+            raise ValueError("url_list_file is required in scan-only mode")
+
+        git_url_titles_preemptions = get_urls_from_list_file(url_list_file)
+        print("\n[Scan-Only Mode]")
+        print(f"  - URL source: {url_list_file}")
+        print("  - GitHub stats: DISABLED")
+        print(f"  - Git clone/pull: {'ENABLED' if not skip_update else 'DISABLED'}")
+        print("  - Metadata: EMPTY")
+    else:
+        if not os.path.exists('custom-node-list.json'):
+            raise FileNotFoundError("custom-node-list.json not found")
+
+        git_url_titles_preemptions = get_git_urls_from_json('custom-node-list.json')
+        print("\n[Standard Mode]")
+        print("  - URL source: custom-node-list.json")
+        print(f"  - GitHub stats: {'ENABLED' if not skip_stat_update else 'DISABLED'}")
+        print(f"  - Git clone/pull: {'ENABLED' if not skip_update else 'DISABLED'}")
+        print("  - Metadata: FULL")
 
     def process_git_url_title(url, title, preemptions, node_pattern):
         name = os.path.basename(url)
@@ -383,46 +594,59 @@ def update_custom_nodes():
     if not skip_stat_update:
         process_git_stats(git_url_titles_preemptions)
 
+    # Git clone/pull for all repositories
     with concurrent.futures.ThreadPoolExecutor(11) as executor:
         for url, title, preemptions, node_pattern in git_url_titles_preemptions:
             executor.submit(process_git_url_title, url, title, preemptions, node_pattern)
 
-    py_url_titles_and_pattern = get_py_urls_from_json('custom-node-list.json')
+    # .py file download (skip in scan-only mode - only process git repos)
+    if not scan_only_mode:
+        py_url_titles_and_pattern = get_py_urls_from_json('custom-node-list.json')
 
-    def download_and_store_info(url_title_preemptions_and_pattern):
-        url, title, preemptions, node_pattern = url_title_preemptions_and_pattern
-        name = os.path.basename(url)
-        if name.endswith(".py"):
-            node_info[name] = (url, title, preemptions, node_pattern)
+        def download_and_store_info(url_title_preemptions_and_pattern):
+            url, title, preemptions, node_pattern = url_title_preemptions_and_pattern
+            name = os.path.basename(url)
+            if name.endswith(".py"):
+                node_info[name] = (url, title, preemptions, node_pattern)
 
-        try:
-            download_url(url, temp_dir)
-        except:
-            print(f"[ERROR] Cannot download '{url}'")
+            try:
+                download_url(url, temp_dir)
+            except:
+                print(f"[ERROR] Cannot download '{url}'")
 
-    with concurrent.futures.ThreadPoolExecutor(10) as executor:
-        executor.map(download_and_store_info, py_url_titles_and_pattern)
+        with concurrent.futures.ThreadPoolExecutor(10) as executor:
+            executor.map(download_and_store_info, py_url_titles_and_pattern)
 
     return node_info
 
 
-def gen_json(node_info):
+def gen_json(node_info, scan_only_mode=False):
+    """
+    Generate extension-node-map.json from scanned node information
+
+    Args:
+        node_info (dict): Repository metadata mapping
+        scan_only_mode (bool): If True, exclude metadata from output
+    """
     # scan from .py file
     node_files, node_dirs = get_nodes(temp_dir)
 
     comfyui_path = os.path.abspath(os.path.join(temp_dir, "ComfyUI"))
-    node_dirs.remove(comfyui_path)
-    node_dirs = [comfyui_path] + node_dirs
+    # Only reorder if ComfyUI exists in the list
+    if comfyui_path in node_dirs:
+        node_dirs.remove(comfyui_path)
+        node_dirs = [comfyui_path] + node_dirs
 
     data = {}
     for dirname in node_dirs:
         py_files = get_py_file_paths(dirname)
         metadata = {}
-        
+
         nodes = set()
         for py in py_files:
             nodes_in_file, metadata_in_file = scan_in_file(py, dirname == "ComfyUI")
             nodes.update(nodes_in_file)
+            # Include metadata from .py files in both modes
             metadata.update(metadata_in_file)
         
         dirname = os.path.basename(dirname)
@@ -437,17 +661,28 @@ def gen_json(node_info):
             if dirname in node_info:
                 git_url, title, preemptions, node_pattern = node_info[dirname]
 
-                metadata['title_aux'] = title
+                # Conditionally add metadata based on mode
+                if not scan_only_mode:
+                    # Standard mode: include all metadata
+                    metadata['title_aux'] = title
 
-                if preemptions is not None:
-                    metadata['preemptions'] = preemptions
+                    if preemptions is not None:
+                        metadata['preemptions'] = preemptions
 
-                if node_pattern is not None:
-                    metadata['nodename_pattern'] = node_pattern
+                    if node_pattern is not None:
+                        metadata['nodename_pattern'] = node_pattern
+                # Scan-only mode: metadata remains empty
 
                 data[git_url] = (nodes, metadata)
             else:
-                print(f"WARN: {dirname} is removed from custom-node-list.json")
+                # Scan-only mode: Repository not in node_info (expected behavior)
+                # Construct URL from dirname (author_repo format)
+                if '_' in dirname:
+                    parts = dirname.split('_', 1)
+                    git_url = f"https://github.com/{parts[0]}/{parts[1]}"
+                    data[git_url] = (nodes, metadata)
+                else:
+                    print(f"WARN: {dirname} is removed from custom-node-list.json")
 
     for file in node_files:
         nodes, metadata = scan_in_file(file)
@@ -460,13 +695,16 @@ def gen_json(node_info):
 
             if file in node_info:
                 url, title, preemptions, node_pattern = node_info[file]
-                metadata['title_aux'] = title
 
-                if preemptions is not None:
-                    metadata['preemptions'] = preemptions
-                
-                if node_pattern is not None:
-                    metadata['nodename_pattern'] = node_pattern
+                # Conditionally add metadata based on mode
+                if not scan_only_mode:
+                    metadata['title_aux'] = title
+
+                    if preemptions is not None:
+                        metadata['preemptions'] = preemptions
+
+                    if node_pattern is not None:
+                        metadata['nodename_pattern'] = node_pattern
 
                 data[url] = (nodes, metadata)
             else:
@@ -478,6 +716,10 @@ def gen_json(node_info):
     for extension in extensions:
         node_list_json_path = os.path.join(temp_dir, extension, 'node_list.json')
         if os.path.exists(node_list_json_path):
+            # Skip if extension not in node_info (scan-only mode with limited URLs)
+            if extension not in node_info:
+                continue
+
             git_url, title, preemptions, node_pattern = node_info[extension]
 
             with open(node_list_json_path, 'r', encoding='utf-8') as f:
@@ -507,14 +749,16 @@ def gen_json(node_info):
                 print("------------------------------------------------------")
                 node_list_json = {}
 
-            metadata_in_url['title_aux'] = title
+            # Conditionally add metadata based on mode
+            if not scan_only_mode:
+                metadata_in_url['title_aux'] = title
 
-            if preemptions is not None:
-                metadata['preemptions'] = preemptions
+                if preemptions is not None:
+                    metadata_in_url['preemptions'] = preemptions
+
+                if node_pattern is not None:
+                    metadata_in_url['nodename_pattern'] = node_pattern
 
-            if node_pattern is not None:
-                metadata_in_url['nodename_pattern'] = node_pattern
-                
             nodes = list(nodes)
             nodes.sort()
             data[git_url] = (nodes, metadata_in_url)
@@ -524,12 +768,53 @@ def gen_json(node_info):
         json.dump(data, file, indent=4, sort_keys=True)
 
 
-print("### ComfyUI Manager Node Scanner ###")
+if __name__ == "__main__":
+    # Parse arguments
+    args = parse_arguments()
 
-print("\n# Updating extensions\n")
-updated_node_info = update_custom_nodes()
+    # Determine mode
+    scan_only_mode = args.scan_only is not None
+    url_list_file = args.scan_only if scan_only_mode else None
 
-print("\n# 'extension-node-map.json' file is generated.\n")
-gen_json(updated_node_info)
+    # Determine temp_dir
+    if args.temp_dir:
+        temp_dir = args.temp_dir
+    elif args.temp_dir_positional:
+        temp_dir = args.temp_dir_positional
+    else:
+        temp_dir = os.path.join(os.getcwd(), ".tmp")
 
-print("\nDONE.\n")
+    if not os.path.exists(temp_dir):
+        os.makedirs(temp_dir)
+
+    # Determine skip flags
+    skip_update = args.skip_update or args.skip_all
+    skip_stat_update = args.skip_stat_update or args.skip_all or scan_only_mode
+
+    if not skip_stat_update:
+        auth = Auth.Token(os.environ.get('GITHUB_TOKEN'))
+        g = Github(auth=auth)
+    else:
+        g = None
+
+    print("### ComfyUI Manager Node Scanner ###")
+
+    if scan_only_mode:
+        print(f"\n# [Scan-Only Mode] Processing URL list: {url_list_file}\n")
+    else:
+        print("\n# [Standard Mode] Updating extensions\n")
+
+    # Update/clone repositories and collect node info
+    updated_node_info = update_custom_nodes(scan_only_mode, url_list_file)
+
+    print("\n# Generating 'extension-node-map.json'...\n")
+
+    # Generate extension-node-map.json
+    gen_json(updated_node_info, scan_only_mode)
+
+    print("\n✅ DONE.\n")
+
+    if scan_only_mode:
+        print("Output: extension-node-map.json (node mappings only)")
+    else:
+        print("Output: extension-node-map.json (full metadata)")