Merge pull request #20 from Kosinkadink/update-support

Update Support: Commit-based, Copy, Migration, and Release-based Updates for Standalone

Author: Kosinkadink

.github/workflows/build-release.yml

@@ -35,7 +35,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 22
           cache: npm
 
       - name: Set version from tag

README.md

@@ -36,7 +36,18 @@ chmod +x ComfyUI-Launcher-*.AppImage
 
 ### Prerequisites
 
-- [Node.js](https://nodejs.org/) (v18+)
+- [Node.js](https://nodejs.org/) **v22 LTS** or later
+
+We recommend using [nvm](https://github.com/nvm-sh/nvm) (or [nvm-windows](https://github.com/coreybutler/nvm-windows)) to manage Node versions:
+
+```bash
+# Install and use Node 22
+nvm install 22
+nvm use 22
+
+# Verify
+node --version   # should print v22.x.x
+```
 
 ### Setup
 

docs/migration-parity.md

@@ -0,0 +1,118 @@
+# Migration Feature Parity with ComfyUI-Manager v4
+
+## Current Implementation (Step 3)
+
+Our migration copies custom node directories and installs `requirements.txt`
+via `uv pip install`, filtering out PyTorch packages. This covers the basic
+case but misses several things Manager does.
+
+## What We're Missing
+
+### 1. `install.py` Execution (High Priority)
+
+Many custom nodes ship an `install.py` that runs arbitrary setup: downloading
+models, compiling C/CUDA extensions, creating config files, etc. Manager runs
+this **after** `requirements.txt` with `cwd` set to the node directory and two
+environment variables:
+
+- `COMFYUI_PATH` — path to the ComfyUI root
+- `COMFYUI_FOLDERS_BASE_PATH` — base path for ComfyUI folders
+
+### 2. pip Blacklist / Downgrade Protection (Medium Priority)
+
+Manager maintains:
+
+- **Blacklist** (never install): `torch`, `torchaudio`, `torchsde`,
+  `torchvision`
+- **Downgrade blacklist** (never downgrade): `transformers`, `safetensors`,
+  `kornia`, plus all of the above
+
+We currently only filter `torch`, `torchvision`, `torchaudio` from
+requirements. Missing `torchsde`. No downgrade protection.
+
+### 3. `--index-url` Parsing (Low Priority)
+
+Manager parses `--index-url` / `--extra-index-url` directives inline in
+`requirements.txt` and forwards them to pip. We currently pass the entire
+filtered file to `uv pip install` which may not handle these correctly.
+
+### 4. `pip_fixer.fix_broken()` (Low Priority)
+
+After installing requirements, Manager runs a broken-package repair pass.
+We don't do this.
+
+### 5. `pip_overrides.json` (Low Priority)
+
+Manager supports user-configured package name remapping. Not relevant for
+migration but worth noting for completeness.
+
+## Delegating to ComfyUI-Manager
+
+If Manager is installed in the **destination** installation, we can delegate
+the entire post-copy dependency process to it instead of doing it ourselves.
+This gets us full feature parity for free.
+
+### Option A: `cm-cli.py restore-dependencies` (Recommended)
+
+Run after copying node directories, before the user launches ComfyUI:
+
+```
+python <ComfyUI>/custom_nodes/ComfyUI-Manager/cm-cli.py restore-dependencies
+```
+
+- Iterates every non-disabled directory in `custom_nodes/`
+- Calls `execute_install_script` for each (requirements + install.py)
+- No running server needed, no knowledge of node IDs required
+- Works for all node types (git, CNR, unknown)
+
+### Option B: `cm-cli.py post-install <path>`
+
+For a single node:
+
+```
+python <ComfyUI>/custom_nodes/ComfyUI-Manager/cm-cli.py post-install /path/to/node
+```
+
+### Option C: Write `#LAZY-INSTALL-SCRIPT` entries
+
+Append entries to `<user_dir>/ComfyUI-Manager/startup-scripts/install-scripts.txt`:
+
+```python
+['/path/to/custom_nodes/MyNode', '#LAZY-INSTALL-SCRIPT', '/path/to/python']
+```
+
+Manager processes these on next boot, then auto-restarts ComfyUI. This is the
+deferred approach — no extra subprocess needed during migration, but deps
+aren't installed until next launch.
+
+### Detection
+
+Check if Manager is present:
+
+```javascript
+const managerCli = path.join(comfyUIDir, "custom_nodes", "ComfyUI-Manager", "cm-cli.py");
+const hasManager = fs.existsSync(managerCli);
+```
+
+### Hybrid Strategy
+
+1. Check if Manager exists in the destination installation
+2. If yes: use Option A (`restore-dependencies`) or Option C (lazy scripts)
+   and skip our own `uv pip install` phase entirely
+3. If no: fall back to our current `uv pip install` approach (sans install.py)
+
+Option C (lazy scripts) is attractive because:
+- Zero extra time during migration
+- Manager handles everything on next boot including restart
+- Consistent with how Manager itself queues installs on Windows
+
+Option A is better when:
+- User wants deps ready before first launch
+- We want to show progress/output during migration
+
+## TODO
+
+- [x] Add `torchsde` to our PyTorch filter regex
+- [ ] Add `install.py` execution to our fallback (no-Manager) path
+- [ ] Detect Manager in destination and delegate when available
+- [ ] Add `--index-url` passthrough for requirements files

installations.js

@@ -21,8 +21,17 @@ async function list() {
   return load();
 }
 
+function uniqueName(baseName, existing, excludeId) {
+  const names = new Set(existing.filter((i) => i.id !== excludeId).map((i) => i.name));
+  if (!names.has(baseName)) return baseName;
+  let suffix = 2;
+  while (names.has(`${baseName} (${suffix})`)) suffix++;
+  return `${baseName} (${suffix})`;
+}
+
 async function add(installation) {
   const installations = await load();
+  installation.name = uniqueName(installation.name, installations);
   const entry = {
     id: `inst-${Date.now()}`,
     createdAt: new Date().toISOString(),
@@ -76,4 +85,4 @@ async function seedDefaults(defaults) {
   if (installations.length > 0) await save(installations);
 }
 
-module.exports = { list, add, remove, update, get, reorder, seedDefaults };
+module.exports = { list, add, remove, update, get, reorder, seedDefaults, uniqueName };

lib/comfyui-releases.js

@@ -0,0 +1,48 @@
+const { fetchJSON } = require("./fetch");
+
+async function fetchLatestRelease(track) {
+  if (track === "latest") {
+    const REPO = "Comfy-Org/ComfyUI";
+    const [commit, releases] = await Promise.all([
+      fetchJSON(`https://api.github.com/repos/${REPO}/commits/master`),
+      fetchJSON(`https://api.github.com/repos/${REPO}/releases?per_page=10`).catch(() => []),
+    ]);
+    if (!commit) return null;
+    const sha = commit.sha.slice(0, 7);
+    const date = commit.commit?.committer?.date;
+    const msg = commit.commit?.message?.split("\n")[0] || "";
+    const stable = releases.find((r) => !r.draft && !r.prerelease);
+    let label = sha;
+    if (stable) {
+      try {
+        const cmp = await fetchJSON(`https://api.github.com/repos/${REPO}/compare/${stable.tag_name}...master`);
+        const ahead = cmp.ahead_by;
+        label = ahead > 0
+          ? `${stable.tag_name} + ${ahead} commit${ahead !== 1 ? "s" : ""} (${sha})`
+          : stable.tag_name;
+      } catch {
+        label = `${stable.tag_name}+ (${sha})`;
+      }
+    }
+    return {
+      tag_name: sha,
+      name: label,
+      body: msg || "",
+      html_url: commit.html_url,
+      published_at: date,
+      _commit: true,
+    };
+  }
+  const releases = await fetchJSON(
+    "https://api.github.com/repos/Comfy-Org/ComfyUI/releases?per_page=30"
+  );
+  return releases.find((r) => !r.draft && !r.prerelease) || null;
+}
+
+function truncateNotes(text, maxLen) {
+  if (!text) return "";
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\n… (truncated)";
+}
+
+module.exports = { fetchLatestRelease, truncateNotes };

lib/copy.js

@@ -0,0 +1,84 @@
+const fs = require("fs");
+const path = require("path");
+
+async function collectFiles(dir) {
+  const files = [];
+  const symlinks = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const items = await fs.promises.readdir(current, { withFileTypes: true });
+    for (const item of items) {
+      const full = path.join(current, item.name);
+      if (item.isSymbolicLink()) {
+        symlinks.push(path.relative(dir, full));
+      } else if (item.isDirectory()) {
+        stack.push(full);
+      } else {
+        files.push(path.relative(dir, full));
+      }
+    }
+  }
+  return { files, symlinks };
+}
+
+async function copyDirWithProgress(src, dest, onProgress, { signal } = {}) {
+  const { files, symlinks } = await collectFiles(src);
+  const total = files.length + symlinks.length;
+  let copied = 0;
+  const step = Math.max(1, Math.floor(total / 100));
+  const concurrency = 50;
+  const dirPromises = new Map();
+  const startTime = Date.now();
+
+  const ensureDir = (dir) => {
+    if (dirPromises.has(dir)) return dirPromises.get(dir);
+    const p = fs.promises.mkdir(dir, { recursive: true });
+    dirPromises.set(dir, p);
+    return p;
+  };
+
+  const reportProgress = () => {
+    if (onProgress && (copied % step === 0 || copied === total)) {
+      const elapsedSecs = (Date.now() - startTime) / 1000;
+      const etaSecs = copied > 0 ? elapsedSecs * ((total - copied) / copied) : -1;
+      onProgress(copied, total, elapsedSecs, etaSecs);
+    }
+  };
+
+  let i = 0;
+  while (i < files.length) {
+    if (signal?.aborted) throw new Error("Cancelled");
+    const batch = files.slice(i, i + concurrency);
+    await Promise.all(batch.map(async (rel) => {
+      const destPath = path.join(dest, rel);
+      await ensureDir(path.dirname(destPath));
+      await fs.promises.copyFile(path.join(src, rel), destPath);
+      copied++;
+      reportProgress();
+    }));
+    i += concurrency;
+  }
+
+  // Recreate symlinks, rewriting absolute targets that point inside src
+  for (const rel of symlinks) {
+    if (signal?.aborted) throw new Error("Cancelled");
+    const srcLink = path.join(src, rel);
+    const destLink = path.join(dest, rel);
+    await ensureDir(path.dirname(destLink));
+    let target = await fs.promises.readlink(srcLink);
+    if (path.isAbsolute(target)) {
+      const relToSrc = path.relative(src, target);
+      if (!relToSrc.startsWith("..") && !path.isAbsolute(relToSrc)) {
+        target = path.join(dest, relToSrc);
+      }
+    }
+    try {
+      await fs.promises.symlink(target, destLink);
+    } catch {}
+    copied++;
+    reportProgress();
+  }
+}
+
+module.exports = { collectFiles, copyDirWithProgress };