Add custom nodes, Civitai loras (LFS), and vast.ai setup script

Includes 30 custom nodes committed directly, 7 Civitai-exclusive
loras stored via Git LFS, and a setup script that installs all
dependencies and downloads HuggingFace-hosted models on vast.ai.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

custom_nodes/comfyui-custom-scripts/web/js/workflows.js

@@ -0,0 +1,343 @@
+import { app } from "../../../scripts/app.js";
+import { api } from "../../../scripts/api.js";
+import { $el } from "../../../scripts/ui.js";
+
+// Adds workflow management
+// Original implementation by https://github.com/i-h4x
+// Thanks for permission to reimplement as an extension
+
+const style = `
+#comfy-save-button, #comfy-load-button {
+   position: relative;
+   overflow: hidden;
+}
+.pysssss-workflow-arrow {
+   position: absolute;
+   top: 0;
+   bottom: 0;
+   right: 0;
+   font-size: 12px;
+   display: flex;
+   align-items: center;
+   width: 24px;
+   justify-content: center;
+   background: rgba(255,255,255,0.1);
+}
+.pysssss-workflow-arrow:after {
+   content: "▼";
+}
+.pysssss-workflow-arrow:hover {
+   filter: brightness(1.6);
+   background-color: var(--comfy-menu-bg);
+}
+.pysssss-workflow-load .litemenu-entry:not(.has_submenu):before,
+.pysssss-workflow-load ~ .litecontextmenu .litemenu-entry:not(.has_submenu):before {
+	content: "🎛️";
+	padding-right: 5px;
+}
+.pysssss-workflow-load .litemenu-entry.has_submenu:before,
+.pysssss-workflow-load ~ .litecontextmenu .litemenu-entry.has_submenu:before {
+	content: "📂";
+	padding-right: 5px;
+	position: relative;
+	top: -1px;
+}
+.pysssss-workflow-popup ~ .litecontextmenu {
+	transform: scale(1.3);
+}
+`;
+
+async function getWorkflows() {
+	const response = await api.fetchApi("/pysssss/workflows", { cache: "no-store" });
+	return await response.json();
+}
+
+async function getWorkflow(name) {
+	const response = await api.fetchApi(`/pysssss/workflows/${encodeURIComponent(name)}`, { cache: "no-store" });
+	return await response.json();
+}
+
+async function saveWorkflow(name, workflow, overwrite) {
+	try {
+		const response = await api.fetchApi("/pysssss/workflows", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ name, workflow, overwrite }),
+		});
+		if (response.status === 201) {
+			return true;
+		}
+		if (response.status === 409) {
+			return false;
+		}
+		throw new Error(response.statusText);
+	} catch (error) {
+		console.error(error);
+	}
+}
+
+class PysssssWorkflows {
+	async load() {
+		this.workflows = await getWorkflows();
+		if(this.workflows.length) {
+			this.workflows.sort();
+		}
+		this.loadMenu.style.display = this.workflows.length ? "flex" : "none";
+	}
+
+	getMenuOptions(callback) {
+		const menu = [];
+		const directories = new Map();
+		for (const workflow of this.workflows || []) {
+			const path = workflow.split("/");
+			let parent = menu;
+			let currentPath = "";
+			for (let i = 0; i < path.length - 1; i++) {
+				currentPath += "/" + path[i];
+				let newParent = directories.get(currentPath);
+				if (!newParent) {
+					newParent = {
+						title: path[i],
+						has_submenu: true,
+						submenu: {
+							options: [],
+						},
+					};
+					parent.push(newParent);
+					newParent = newParent.submenu.options;
+					directories.set(currentPath, newParent);
+				}
+				parent = newParent;
+			}
+			parent.push({
+				title: path[path.length - 1],
+				callback: () => callback(workflow),
+			});
+		}
+		return menu;
+	}
+
+	constructor() {
+		function addWorkflowMenu(type, getOptions) {
+			return $el("div.pysssss-workflow-arrow", {
+				parent: document.getElementById(`comfy-${type}-button`),
+				onclick: (e) => {
+					e.preventDefault();
+					e.stopPropagation();
+
+					LiteGraph.closeAllContextMenus();
+					const menu = new LiteGraph.ContextMenu(
+						getOptions(),
+						{
+							event: e,
+							scale: 1.3,
+						},
+						window
+					);
+					menu.root.classList.add("pysssss-workflow-popup");
+					menu.root.classList.add(`pysssss-workflow-${type}`);
+				},
+			});
+		}
+
+		this.loadMenu = addWorkflowMenu("load", () =>
+			this.getMenuOptions(async (workflow) => {
+				const json = await getWorkflow(workflow);
+				app.loadGraphData(json);
+			})
+		);
+		addWorkflowMenu("save", () => {
+			return [
+				{
+					title: "Save as",
+					callback: () => {
+						let filename = prompt("Enter filename", this.workflowName || "workflow");
+						if (filename) {
+							if (!filename.toLowerCase().endsWith(".json")) {
+								filename += ".json";
+							}
+
+							this.workflowName = filename;
+
+							const json = JSON.stringify(app.graph.serialize(), null, 2); // convert the data to a JSON string
+							const blob = new Blob([json], { type: "application/json" });
+							const url = URL.createObjectURL(blob);
+							const a = $el("a", {
+								href: url,
+								download: filename,
+								style: { display: "none" },
+								parent: document.body,
+							});
+							a.click();
+							setTimeout(function () {
+								a.remove();
+								window.URL.revokeObjectURL(url);
+							}, 0);
+						}
+					},
+				},
+				{
+					title: "Save to workflows",
+					callback: async () => {
+						const name = prompt("Enter filename", this.workflowName || "workflow");
+						if (name) {
+							this.workflowName = name;
+
+							const data = app.graph.serialize();
+							if (!(await saveWorkflow(name, data))) {
+								if (confirm("A workspace with this name already exists, do you want to overwrite it?")) {
+									await saveWorkflow(name, app.graph.serialize(), true);
+								} else {
+									return;
+								}
+							}
+							await this.load();
+						}
+					},
+				},
+			];
+		});
+		this.load();
+
+		const handleFile = app.handleFile;
+		const self = this;
+		app.handleFile = function (file) {
+			if (file?.name?.endsWith(".json")) {
+				self.workflowName = file.name;
+			} else {
+				self.workflowName = null;
+			}
+			return handleFile.apply(this, arguments);
+		};
+	}
+}
+
+const refreshComboInNodes = app.refreshComboInNodes;
+let workflows;
+
+async function sendToWorkflow(img, workflow) {
+	const graph = !workflow ? app.graph.serialize() : await getWorkflow(workflow);
+	const nodes = graph.nodes.filter((n) => n.type === "LoadImage");
+	let targetNode;
+	if (nodes.length === 0) {
+		alert("To send the image to another workflow, that workflow must have a LoadImage node.");
+		return;
+	} else if (nodes.length > 1) {
+		targetNode = nodes.find((n) => n.title?.toLowerCase().includes("input"));
+		if (!targetNode) {
+			targetNode = nodes[0];
+			alert(
+				"The target workflow has multiple LoadImage nodes, include 'input' in the name of the one you want to use. The first one will be used here."
+			);
+		}
+	} else {
+		targetNode = nodes[0];
+	}
+
+	const blob = await (await fetch(img.src)).blob();
+	const name =
+		(workflow || "sendtoworkflow").replace(/\//g, "_") +
+		"-" +
+		+new Date() +
+		new URLSearchParams(img.src.split("?")[1]).get("filename");
+	const body = new FormData();
+	body.append("image", new File([blob], name));
+
+	const resp = await api.fetchApi("/upload/image", {
+		method: "POST",
+		body,
+	});
+
+	if (resp.status === 200) {
+		await refreshComboInNodes.call(app);
+		targetNode.widgets_values[0] = name;
+		app.loadGraphData(graph);
+		app.graph.getNodeById(targetNode.id);
+	} else {
+		alert(resp.status + " - " + resp.statusText);
+	}
+}
+
+app.registerExtension({
+	name: "pysssss.Workflows",
+	init() {
+		$el("style", {
+			textContent: style,
+			parent: document.head,
+		});
+	},
+
+	async refreshComboInNodes() {
+		workflows.load()
+	},
+	
+	async setup() {
+		workflows = new PysssssWorkflows();
+
+		const comfyDefault = "[ComfyUI Default]";
+		const defaultWorkflow = app.ui.settings.addSetting({
+			id: "pysssss.Workflows.Default",
+			name: "🐍 Default Workflow",
+			defaultValue: comfyDefault,
+			type: "combo",
+			options: (value) =>
+				[comfyDefault, ...workflows.workflows].map((m) => ({
+					value: m,
+					text: m,
+					selected: m === value,
+				})),
+		});
+
+		document.getElementById("comfy-load-default-button").onclick = async function () {
+			if (
+				localStorage["Comfy.Settings.Comfy.ConfirmClear"] === "false" ||
+				confirm(`Load default workflow (${defaultWorkflow.value})?`)
+			) {
+				if (defaultWorkflow.value === comfyDefault) {
+					app.loadGraphData();
+				} else {
+					const json = await getWorkflow(defaultWorkflow.value);
+					app.loadGraphData(json);
+				}
+			}
+		};
+	},
+	async beforeRegisterNodeDef(nodeType, nodeData, app) {
+		const getExtraMenuOptions = nodeType.prototype.getExtraMenuOptions;
+		nodeType.prototype.getExtraMenuOptions = function (_, options) {
+			const r = getExtraMenuOptions?.apply?.(this, arguments);
+			let img;
+			if (this.imageIndex != null) {
+				// An image is selected so select that
+				img = this.imgs[this.imageIndex];
+			} else if (this.overIndex != null) {
+				// No image is selected but one is hovered
+				img = this.imgs[this.overIndex];
+			}
+
+			if (img) {
+				let pos = options.findIndex((o) => o.content === "Save Image");
+				if (pos === -1) {
+					pos = 0;
+				} else {
+					pos++;
+				}
+
+				options.splice(pos, 0, {
+					content: "Send to workflow",
+					has_submenu: true,
+					submenu: {
+						options: [
+							{ callback: () => sendToWorkflow(img), title: "[Current workflow]" },
+							...workflows.getMenuOptions(sendToWorkflow.bind(null, img)),
+						],
+					},
+				});
+			}
+
+			return r;
+		};
+	},
+});