feat: add a folder picker to the Save workflow dialog

ComfyUI's Save and Save As dialogs are a single text prompt, so saving into a
subfolder means typing the full path relative to the workflows directory.

A frontend extension now injects a collapsible tree of the workflow folders
into that dialog. Clicking a folder rewrites the path in the dialog's own
input, keeping the typed name and selecting it for overtyping; "+ New folder"
adds a level that the backend creates on save. The tree opens on the current
workflow's folder.

The native dialog is augmented rather than replaced, so ComfyUI still performs
the save and its tab tracking and overwrite confirmation are unchanged. The
picker appears only while Comfy.SaveWorkflow or Comfy.SaveWorkflowAs is
running, which keeps it out of the Rename and Export prompts that share the
same dialog component. Folders come from /api/v2/userdata, which unlike the
v1 listing includes empty directories. Can be switched off in Settings.

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

README.md

@@ -2,7 +2,32 @@
 
 ![Stillfront](assets/logo.png)
 
-A collection of custom ComfyUI nodes developed by [Stillfront](https://www.stillfront.com). All nodes are prefixed with **SF** for easy searching in ComfyUI.
+**63 custom ComfyUI nodes** from [Stillfront](https://www.stillfront.com), covering AI image and
+video generation, LLM integration, and tooling for working with large game asset libraries. Every
+node is prefixed **SF** so they're easy to find in the node search.
+
+| | |
+|---|---|
+| [**Stillfront/WaveSpeed**](#stillfrontwavespeed) | 45 nodes — image, video and 3D generation through [WaveSpeed AI](https://wavespeed.ai): VEO 3.1, Sora 2, Nano Banana, Qwen, Flux Kontext, Seedream, WAN 2.5, InfiniteTalk, Tripo P2, upscalers |
+| [**Stillfront/VertexAI**](#stillfrontvertexai) | 7 nodes — Imagen 3/4, VEO 3.1 and Nano Banana Pro via Google Cloud Vertex AI |
+| [**Stillfront/Utils**](#stillfrontutils) | 7 nodes — Google Sheets integration, prompt batching, resolution presets |
+| [**Stillfront/LLM**](#stillfrontllm) | 4 nodes — Claude, Gemini and GPT in your graph, plus the asset library tooling below |
+
+### Worth a look
+
+**[The asset library workflow](#the-asset-library-workflow)** — point Claude at a folder of game
+assets and it writes a searchable manifest describing every one. After that, any workflow can ask
+for *"the character art that suits a boss-fight poster"* and get back the right reference images
+**plus a generated prompt that already matches your project's art style** — without a single image
+being opened at generation time.
+
+Two nodes do this: **SF Claude Library Builder** catalogues once, **SF Claude Asset Director**
+searches on every run. Both run on your existing Claude Code login, so there's no API key and no
+per-token billing.
+
+**[SF Google Sheet Prompt Queue](#using-sf-google-sheet-prompt-queue)** — drive a batch of
+generations straight from a Google Sheet, marking rows done as you go and resuming where you left
+off.
 
 ---
 
@@ -61,7 +86,6 @@ Chat with large language models directly inside your ComfyUI workflows, with opt
 | **SF Text Analyzer** | Analyze and process text strings within workflows. |
 | **SF Claude Code** | Send text and images to Claude through the Claude Code CLI on your own machine, using your existing Claude login instead of an API key. Image slots appear as you fill them. |
 | **SF Claude Asset Director** | Point Claude at an asset library and it chooses which references suit the brief and writes the image prompt to go with them. Outputs an IMAGE batch plus the prompt, ready to wire into any generation node. |
-
 | **SF Claude Library Builder** | Point Claude at a folder of game assets and it writes a searchable manifest describing each one. Can also reorganise and rename the files. Feeds **SF Claude Asset Director**. |
 
 #### The asset library workflow
@@ -130,9 +154,23 @@ blow up in turns and cost on libraries of 100+ assets, with nothing produced at
 batch now only reads its own assets and replies with JSON; the node assembles and writes the
 manifest itself, so no file-writing tool is ever handed to Claude for this.
 
-A hidden checkpoint (`.sf_library_builder_checkpoint.json`, removed automatically on success)
-tracks which assets are already catalogued. If a run fails or times out partway, rerunning with
-the same settings **resumes** — finished batches are skipped, not re-paid for.
+**Reruns are incremental.** With `update_existing` on (the default), the node reads the manifest
+already in the library and only catalogues files it doesn't yet describe. So the normal workflow
+is: drop new assets into the folder, run the same node against the same path, and only the new
+ones cost anything. Entries whose file has since been deleted are dropped automatically. Turn
+`update_existing` off to re-describe everything from scratch.
+
+*(Not available in `organise into a copy` mode, where the manifest holds post-rename paths that
+can't be matched against the untouched source folder.)*
+
+Separately, a hidden checkpoint (`.sf_library_builder_checkpoint.json`, removed automatically on
+success) covers a run that dies partway. Rerunning **resumes** — finished batches are skipped,
+not re-paid for.
+
+If a batch's reply comes back **cut off** — the model ran past its reply length limit partway
+through describing a wordy set of assets — that batch is automatically **retried as two smaller
+halves**, repeatedly if needed, rather than failing the run. You'll see it in the log as
+`Batch 7/7: the reply was cut off… Retrying as two batches of 5 and 6`.
 
 #### Using SF Claude Asset Director
 
@@ -273,6 +311,20 @@ Connect an **SF WaveSpeed Client** node (enter your WaveSpeed API key) to any Wa
 | **SF WaveSpeed Flux Kontext Max** | Flux Kontext Max — highest quality variant. |
 | **SF WaveSpeed Flux ControlNet Union Pro 2** | Flux image generation with ControlNet guidance. |
 
+#### 3D Generation
+
+| Node | Description |
+|---|---|
+| **SF WaveSpeed Tripo P2 Image to 3D** | Tripo's P2 model — the same one behind ComfyUI's *Tripo P2: Image to Model* partner node — billed to your WaveSpeed account instead of ComfyUI credits. Quad or triangle topology, a target face count, texture quality from none to extreme, PBR, delighting, UVs, and seeds. |
+
+Outputs mirror the partner node, so they plug into **Preview 3D** and **Save 3D** directly: Tripo
+returns **FBX when `quad` is on and GLB when it's off**, so the matching output is populated and
+the other is empty. The file is also saved to `output/3d/`, with its path and CDN URL as strings.
+
+`face_limit` runs 48–50,000 for triangles or 48–25,000 for quads; `-1` lets Tripo decide. It's a
+target, not a hard cap. Leave `export_orientation` unset if the model is headed for rigging or
+retexturing — Tripo warns those steps can come out mis-rotated without reporting an error.
+
 #### Upscalers
 
 | Node | Description |
@@ -323,6 +375,25 @@ and skips row 2. Each prompt triggers a separate pass through the downstream gra
 
 ---
 
+## Interface improvements
+
+Not nodes — small fixes to ComfyUI's own interface that come with the pack.
+
+### Folder picker in the Save workflow dialog
+
+ComfyUI's **Save** / **Save As** dialog normally wants the whole path typed by hand —
+`Stillfront/NewMoon/My Workflow` — to save into a subfolder. With this pack installed, the dialog
+also shows your workflow folders as a tree: click a folder, type just the name, confirm.
+
+- **+ New folder** adds a folder at the selected level; it's created on disk when you save into it
+- The dialog opens on the folder of the workflow you're editing, already selected
+- Only the Save dialogs get the picker — Rename and Export, which reuse the same prompt, are left alone
+- ComfyUI still does the actual saving, so tab tracking and overwrite warnings behave exactly as before
+
+Turn it off under **Settings → Stillfront → Workflows**.
+
+---
+
 ## Requirements
 
 - Python 3.10+

py/sf_claude_library_builder.py

@@ -55,16 +55,25 @@ def chunk(items, size):
         yield items[i : i + size]
 
 
+class BatchParseError(RuntimeError):
+    """Claude's reply was not usable JSON.
+
+    Nearly always a reply that ran past its length limit and stopped partway,
+    which a smaller batch fixes — so the caller retries by splitting rather than
+    giving up.
+    """
+
+
 def extract_json(text):
     """The JSON object out of a reply that may be fenced or prefaced."""
     start, end = text.find("{"), text.rfind("}")
     if start == -1 or end <= start:
-        raise RuntimeError(f"Claude did not return JSON. It said: {text.strip()[:300]}")
+        raise BatchParseError("the reply stopped before any complete JSON object")
     body = text[start : end + 1]
     try:
         return json.loads(body)
     except json.JSONDecodeError as e:
-        raise RuntimeError(f"Claude's JSON could not be parsed ({e}): {body[:300]}")
+        raise BatchParseError(f"the reply was cut off or malformed ({e})")
 
 
 def canonicalize(claude_path, expected):
@@ -80,21 +89,47 @@ def canonicalize(claude_path, expected):
     return cleaned
 
 
-def checkpoint_key(mode, manifest_name, system_prompt, project_notes, all_files):
-    """A fingerprint of this exact job, so a checkpoint only resumes a matching rerun."""
+def checkpoint_key(mode, manifest_name, system_prompt, project_notes):
+    """A fingerprint of this job's settings, so a checkpoint only resumes a
+    matching rerun.
+
+    Deliberately excludes the file list: adding or removing an asset should not
+    throw away a half-finished run, and entries are keyed by path anyway, so
+    stale ones are filtered out when the manifest is assembled.
+    """
     payload = json.dumps(
         {
             "mode": mode,
             "manifest_name": manifest_name,
             "system_prompt": system_prompt,
             "project_notes": project_notes,
-            "files": all_files,
         },
         sort_keys=True,
     )
     return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:16]
 
 
+def load_existing_manifest(path):
+    """A previously written manifest, as (entries by file, project, art_style).
+
+    This is what makes a rerun incremental: anything already described here is
+    not sent to Claude again.
+    """
+    if not os.path.isfile(path):
+        return {}, None, None
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}, None, None
+
+    entries = {}
+    for entry in data.get("assets") or []:
+        if isinstance(entry, dict) and entry.get("file"):
+            entries[entry["file"]] = entry
+    return entries, data.get("project"), data.get("art_style")
+
+
 def load_checkpoint(root, key):
     path = os.path.join(root, CHECKPOINT_NAME)
     if not os.path.isfile(path):
@@ -267,6 +302,18 @@ class SFClaudeLibraryBuilder:
                         ),
                     },
                 ),
+                "update_existing": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": (
+                            "On: reuse descriptions already in the manifest and only "
+                            "catalogue files that are new, so adding assets costs only "
+                            "those assets. Entries whose file has since been deleted are "
+                            "dropped. Off: describe every asset again from scratch."
+                        ),
+                    },
+                ),
                 "batch_size": (
                     "INT",
                     {
@@ -324,6 +371,10 @@ once, and tracks progress in a hidden checkpoint file. If a run fails partway,
 rerunning with the same settings resumes from where it stopped instead of
 re-paying for batches already done.
 
+With **update_existing** on (the default), rerunning against a library that
+already has a manifest only catalogues files that are new — so adding assets
+costs just those assets. Entries whose file has since been deleted are dropped.
+
 Defaults to **manifest only**, which touches nothing: you get the JSON as text to
 read and save yourself. Switch `write_manifest` on to have it saved into the
 library, or change `mode` to let Claude reorganise and rename the files too.
@@ -340,6 +391,7 @@ Budget about 5 seconds per asset — it opens every image.
         system_prompt,
         manifest_name,
         write_manifest,
+        update_existing,
         batch_size,
         model,
         timeout_seconds,
@@ -368,21 +420,51 @@ Budget about 5 seconds per asset — it opens every image.
         if not assets:
             raise ValueError(f"No image files found in {root}")
 
-        key = checkpoint_key(mode, manifest_name, system_prompt, project_notes, assets)
-        checkpoint = load_checkpoint(root, key)
+        manifest_root = out_dir if mode == MODE_COPY else root
+        manifest_path = os.path.join(manifest_root, manifest_name)
+
         done_by_file = {}
         project = art_style = None
+
+        # An existing manifest is the durable record of what is already described,
+        # so a rerun only pays for assets that are genuinely new. Skipped for the
+        # copy mode, where the manifest holds post-rename paths that cannot be
+        # matched against a scan of the untouched source folder.
+        reused = 0
+        if update_existing and mode != MODE_COPY:
+            existing, prev_project, prev_style = load_existing_manifest(manifest_path)
+            if existing:
+                done_by_file.update(existing)
+                project, art_style = prev_project, prev_style
+                reused = sum(1 for f in assets if f in existing)
+                gone = len(existing) - reused
+                print(
+                    f"[SF Claude Library Builder] Found {manifest_name}: reusing "
+                    f"{reused} existing description(s)"
+                    + (f", dropping {gone} for deleted file(s)" if gone else "")
+                    + "."
+                )
+
+        # A checkpoint from an interrupted run is newer than the manifest, so it wins.
+        key = checkpoint_key(mode, manifest_name, system_prompt, project_notes)
+        checkpoint = load_checkpoint(root, key)
         if checkpoint:
-            project = checkpoint.get("project")
-            art_style = checkpoint.get("art_style")
             for entry in checkpoint.get("done_assets", []):
                 if entry.get("file"):
                     done_by_file[entry["file"]] = entry
+            project = checkpoint.get("project") or project
+            art_style = checkpoint.get("art_style") or art_style
             print(
-                f"[SF Claude Library Builder] Resuming — {len(done_by_file)}/{len(assets)} "
-                f"asset(s) already catalogued from a previous run."
+                f"[SF Claude Library Builder] Resuming an interrupted run — "
+                f"{len(done_by_file)}/{len(assets)} asset(s) already catalogued."
             )
 
+        todo = sum(1 for f in assets if f not in done_by_file)
+        if todo == 0:
+            print("[SF Claude Library Builder] Nothing new to catalogue.")
+        else:
+            print(f"[SF Claude Library Builder] {todo} asset(s) to catalogue.")
+
         # Claude only ever reads images and replies with JSON; the node writes the
         # manifest itself, and the Write tool is never offered. Bash is needed
         # only to move/rename files in the organise modes.
@@ -392,35 +474,34 @@ Budget about 5 seconds per asset — it opens every image.
         total_cost = 0.0
         started = time.time()
 
-        for batch_num, batch_files in enumerate(batches, start=1):
-            remaining = [f for f in batch_files if f not in done_by_file]
-            if not remaining:
-                continue  # fully covered by the checkpoint already
-
-            established = (project, art_style) if project and art_style else None
-            instruction = build_batch_instruction(
-                mode, remaining, len(assets), project_notes, established, out_dir
+        def fail(message):
+            """Stop the run, leaving finished batches safely checkpointed."""
+            save_checkpoint(root, key, project, art_style, list(done_by_file.values()))
+            raise RuntimeError(
+                f"{message} {len(done_by_file)}/{len(assets)} asset(s) are saved in a "
+                f"checkpoint — rerun with the same settings to resume rather than "
+                f"start over."
             )
 
-            command = [binary, "-p", instruction, "--output-format", "json", "--allowedTools", tools]
+        def run_batch(files, label):
+            """One Claude call. Returns (parsed reply, cost, turns)."""
+            established = (project, art_style) if project and art_style else None
+            command = [
+                binary,
+                "-p",
+                build_batch_instruction(
+                    mode, files, len(assets), project_notes, established, out_dir
+                ),
+                "--output-format",
+                "json",
+                "--allowedTools",
+                tools,
+            ]
             if system_prompt.strip():
                 command += ["--append-system-prompt", system_prompt.strip()]
             if model != "default":
                 command += ["--model", model]
 
-            print(
-                f"[SF Claude Library Builder] Batch {batch_num}/{len(batches)} "
-                f"({len(remaining)} asset(s))..."
-            )
-
-            def _fail(message):
-                save_checkpoint(root, key, project, art_style, list(done_by_file.values()))
-                raise RuntimeError(
-                    f"{message} {len(done_by_file)}/{len(assets)} asset(s) are saved in a "
-                    f"checkpoint — rerun with the same settings to resume rather than "
-                    f"start over."
-                )
-
             try:
                 completed = subprocess.run(
                     command,
@@ -431,39 +512,55 @@ Budget about 5 seconds per asset — it opens every image.
                     stdin=subprocess.DEVNULL,
                 )
             except subprocess.TimeoutExpired:
-                _fail(
-                    f"Batch {batch_num}/{len(batches)} did not finish within "
-                    f"{timeout_seconds}s."
-                )
+                fail(f"Batch {label} did not finish within {timeout_seconds}s.")
 
             if completed.returncode != 0:
                 detail = (completed.stderr or completed.stdout or "").strip()[:500]
-                _fail(f"Batch {batch_num}/{len(batches)} failed (exit {completed.returncode}). {detail}")
+                fail(f"Batch {label} failed (exit {completed.returncode}). {detail}")
 
             try:
                 payload = json.loads(completed.stdout)
             except json.JSONDecodeError:
-                _fail(
-                    f"Batch {batch_num}/{len(batches)}: unreadable response: "
-                    f"{completed.stdout.strip()[:300]}"
-                )
+                fail(f"Batch {label}: unreadable response: {completed.stdout.strip()[:300]}")
 
             if payload.get("is_error"):
-                _fail(
-                    f"Batch {batch_num}/{len(batches)} reported an error: "
-                    f"{payload.get('result', 'unknown')}."
-                )
-
-            cost = payload.get("total_cost_usd") or 0.0
-            total_cost += cost
-            turns = payload.get("num_turns", "?")
+                fail(f"Batch {label} reported an error: {payload.get('result', 'unknown')}.")
 
+            # May raise BatchParseError, which catalogue() retries by splitting.
             data = extract_json(payload.get("result", ""))
+            return data, payload.get("total_cost_usd") or 0.0, payload.get("num_turns", "?")
+
+        def catalogue(files, label):
+            """Catalogue `files`, halving and retrying if the reply comes back cut off.
+
+            Each piece that succeeds is merged and checkpointed immediately, so a
+            later failure never costs work already paid for.
+            """
+            nonlocal project, art_style, total_cost
+
+            try:
+                data, cost, turns = run_batch(files, label)
+            except BatchParseError as exc:
+                if len(files) == 1:
+                    fail(
+                        f"Batch {label}: {exc}. This is a single asset "
+                        f"({files[0]}), so it cannot be split any further."
+                    )
+                half = len(files) // 2
+                print(
+                    f"[SF Claude Library Builder] Batch {label}: {exc}. "
+                    f"Retrying as two batches of {half} and {len(files) - half}."
+                )
+                catalogue(files[:half], f"{label}a")
+                catalogue(files[half:], f"{label}b")
+                return
+
+            total_cost += cost
             if project is None:
                 project = data.get("project", "Untitled project")
                 art_style = data.get("art_style", "")
 
-            expected = set(remaining)
+            expected = set(files)
             for entry in data.get("assets") or []:
                 raw = entry.get("file")
                 if not raw:
@@ -474,11 +571,29 @@ Budget about 5 seconds per asset — it opens every image.
             save_checkpoint(root, key, project, art_style, list(done_by_file.values()))
 
             print(
-                f"[SF Claude Library Builder] Batch {batch_num}/{len(batches)} done: "
-                f"{turns} turns, ${cost:.2f}. Running total: "
-                f"{len(done_by_file)}/{len(assets)} asset(s), ${total_cost:.2f}."
+                f"[SF Claude Library Builder] Batch {label} done: {turns} turns, "
+                f"${cost:.2f}. Running total: {len(done_by_file)}/{len(assets)} "
+                f"asset(s), ${total_cost:.2f}."
             )
 
+            skipped = [f for f in files if f not in done_by_file]
+            if skipped:
+                print(
+                    f"[SF Claude Library Builder] Batch {label}: {len(skipped)} file(s) "
+                    f"came back undescribed; a rerun will pick them up."
+                )
+
+        for batch_num, batch_files in enumerate(batches, start=1):
+            remaining = [f for f in batch_files if f not in done_by_file]
+            if not remaining:
+                continue  # fully covered by the checkpoint already
+
+            print(
+                f"[SF Claude Library Builder] Batch {batch_num}/{len(batches)} "
+                f"({len(remaining)} asset(s))..."
+            )
+            catalogue(remaining, f"{batch_num}/{len(batches)}")
+
         elapsed = time.time() - started
 
         # Assemble the final manifest in the library's original scan order.
@@ -492,8 +607,6 @@ Budget about 5 seconds per asset — it opens every image.
         }
         manifest_text = json.dumps(manifest_data, indent=2)
 
-        manifest_root = out_dir if mode == MODE_COPY else root
-        manifest_path = os.path.join(manifest_root, manifest_name)
         if write_manifest:
             os.makedirs(manifest_root, exist_ok=True)
             with open(manifest_path, "w", encoding="utf-8") as f:
@@ -505,11 +618,13 @@ Budget about 5 seconds per asset — it opens every image.
         for entry in final_assets:
             counts[entry.get("category", "?")] = counts.get(entry.get("category", "?"), 0) + 1
 
+        newly_done = max(0, len(final_assets) - reused)
         report = "\n".join(
             [
                 f"mode:        {mode}",
                 f"scanned:     {len(assets)} file(s) in {root}",
-                f"catalogued:  {len(final_assets)} asset(s) across {len(batches)} batch(es)",
+                f"in manifest: {len(final_assets)} asset(s)",
+                f"reused:      {reused} already described, {newly_done} newly catalogued",
                 "categories:  " + (", ".join(f"{k} x{v}" for k, v in sorted(counts.items())) or "none"),
                 f"art style:   {manifest_data['art_style'] or '(not set)'}",
                 "manifest:    " + (manifest_path if write_manifest else "returned as text, not saved"),

py/wavespeed_tripo_p2_image_to_3d.py

@@ -0,0 +1,235 @@
+# ABOUTME: Tripo P2 image-to-3D through the WaveSpeed API, billed to a WaveSpeed account
+# ABOUTME: Emits GLB/FBX File3D outputs compatible with ComfyUI's Preview 3D and Save nodes
+
+import os
+import time
+from urllib.parse import urlparse
+
+import requests
+
+from .wavespeed_api.client import WaveSpeedClient
+from .wavespeed_api.utils import tensor2images
+
+try:
+    from comfy_api.latest import Types
+
+    File3D = Types.File3D
+except ImportError:  # older ComfyUI without 3D file types
+    File3D = None
+
+ENDPOINT = "/api/v3/tripo3d/p2/image-to-3d"
+RESULT_PATH = "/api/v3/predictions/{id}/result"
+
+TEXTURE_LEVELS = ["standard", "fast", "detailed", "extreme", "none"]
+TEXTURE_VERSIONS = ["v3.5-20260815", "v3.0-20250812", "v2.5-20250123"]
+ORIENTATION_UNSET = "unset (recommended)"
+ORIENTATIONS = [ORIENTATION_UNSET, "+x", "-x", "+y", "-y"]
+TERMINAL_FAILURES = {"failed", "cancelled", "timeout", "deleted"}
+
+
+def build_payload(image_url, quad, face_limit, texture, pbr, texture_version,
+                  delight, auto_size, export_uv, export_orientation, model_seed, texture_seed):
+    """The request body. Unused options are omitted rather than sent as null,
+    as WaveSpeed's documentation asks."""
+    if face_limit != -1:
+        ceiling = 25000 if quad else 50000
+        if not 48 <= face_limit <= ceiling:
+            raise ValueError(
+                f"face_limit must be -1 (adaptive) or between 48 and {ceiling}"
+                f"{' — quad meshes cap at 25,000' if quad else ''}."
+            )
+    if texture == "fast" and texture_version != "v3.5-20260815":
+        raise ValueError("texture 'fast' requires texture_version v3.5-20260815.")
+
+    textured = texture != "none"
+    payload = {
+        "image": image_url,
+        "quad": quad,
+        "texture": textured,
+        # PBR implies textures, so it is switched off along with them.
+        "pbr": bool(pbr and textured),
+        "auto_size": auto_size,
+        "export_uv": export_uv,
+    }
+    if textured:
+        payload["texture_quality"] = texture
+        payload["texture_version"] = texture_version
+        payload["delight"] = delight
+    if face_limit != -1:
+        payload["face_limit"] = face_limit
+    if export_orientation != ORIENTATION_UNSET:
+        payload["export_orientation"] = export_orientation
+    if model_seed != -1:
+        payload["model_seed"] = model_seed
+    if texture_seed != -1 and textured:
+        payload["texture_seed"] = texture_seed
+    return payload
+
+
+def pick_model_url(outputs):
+    """The model file URL out of a result's `outputs`, which may be a list or a string."""
+    candidates = outputs if isinstance(outputs, list) else [outputs]
+    urls = [u for u in candidates if isinstance(u, str) and u.startswith("http")]
+    for url in urls:
+        if urlparse(url).path.lower().endswith((".glb", ".fbx")):
+            return url
+    if urls:
+        return urls[0]
+    raise RuntimeError(f"No model URL in the result: {outputs!r}")
+
+
+def check_interrupted():
+    try:
+        import comfy.model_management as mm
+    except ImportError:
+        return
+    mm.throw_exception_if_processing_interrupted()
+
+
+def output_dir():
+    try:
+        import folder_paths
+
+        base = folder_paths.get_output_directory()
+    except ImportError:
+        base = os.getcwd()
+    path = os.path.join(base, "3d")
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+class SFWaveSpeedTripoP2ImageTo3D:
+    """
+    Tripo P2 image-to-3D via WaveSpeed — the same model as ComfyUI's partner
+    node, billed to your WaveSpeed account instead of ComfyUI credits.
+
+    Tripo returns FBX when quad topology is on and GLB when it is off, so the
+    matching output is populated and the other is empty.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "client": ("WAVESPEED_AI_API_CLIENT",),
+                "image": ("IMAGE", {"tooltip": "Reference image. Only the first frame of a batch is used."}),
+                "quad": (
+                    "BOOLEAN",
+                    {"default": False, "tooltip": "Quad topology instead of triangles. Output becomes FBX."},
+                ),
+                "face_limit": (
+                    "INT",
+                    {
+                        "default": -1,
+                        "min": -1,
+                        "max": 50000,
+                        "step": 100,
+                        "tooltip": "Target face count. -1 lets Tripo choose. 48-50,000, or up to 25,000 with quad.",
+                    },
+                ),
+                "texture": (
+                    TEXTURE_LEVELS,
+                    {"default": "standard", "tooltip": "'none' gives untextured geometry. Higher levels cost more."},
+                ),
+                "pbr": ("BOOLEAN", {"default": True, "tooltip": "PBR material maps. Ignored when texture is 'none'."}),
+            },
+            "optional": {
+                "texture_version": (
+                    TEXTURE_VERSIONS,
+                    {"default": TEXTURE_VERSIONS[0], "tooltip": "'fast' texture requires v3.5."},
+                ),
+                "delight": (
+                    "BOOLEAN",
+                    {"default": True, "tooltip": "Strip lighting baked into the source image before texturing."},
+                ),
+                "auto_size": ("BOOLEAN", {"default": False, "tooltip": "Scale the model to real-world metres."}),
+                "export_uv": ("BOOLEAN", {"default": True, "tooltip": "Generate UVs. Off is faster and smaller."}),
+                "export_orientation": (
+                    ORIENTATIONS,
+                    {
+                        "default": ORIENTATION_UNSET,
+                        "tooltip": (
+                            "Forward axis. Leave unset if you will rig, retexture or convert the "
+                            "model — Tripo warns those steps can silently come out mis-rotated."
+                        ),
+                    },
+                ),
+                "model_seed": (
+                    "INT",
+                    {"default": -1, "min": -1, "max": 2147483647, "tooltip": "-1 for random geometry."},
+                ),
+                "texture_seed": (
+                    "INT",
+                    {"default": -1, "min": -1, "max": 2147483647, "tooltip": "-1 for random texturing."},
+                ),
+                "timeout_seconds": (
+                    "INT",
+                    {"default": 900, "min": 60, "max": 3600, "step": 30},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("FILE_3D_GLB", "FILE_3D_FBX", "STRING", "STRING")
+    RETURN_NAMES = ("GLB", "FBX", "model_file", "model_url")
+    OUTPUT_TOOLTIPS = (
+        "Populated when quad is off.",
+        "Populated when quad is on.",
+        "Absolute path of the downloaded model in ComfyUI's output/3d folder.",
+        "WaveSpeed CDN link to the model.",
+    )
+    FUNCTION = "generate"
+    CATEGORY = "Stillfront/WaveSpeed"
+    OUTPUT_NODE = True
+
+    def generate(self, client, image, quad, face_limit, texture, pbr,
+                 texture_version=TEXTURE_VERSIONS[0], delight=True, auto_size=False,
+                 export_uv=True, export_orientation=ORIENTATION_UNSET,
+                 model_seed=-1, texture_seed=-1, timeout_seconds=900):
+        api = WaveSpeedClient(api_key=client["api_key"])
+
+        image_url = api.upload_file(tensor2images(image)[0])
+        payload = build_payload(
+            image_url, quad, face_limit, texture, pbr, texture_version, delight,
+            auto_size, export_uv, export_orientation, model_seed, texture_seed,
+        )
+
+        task = api.post(ENDPOINT, payload)
+        task_id = task.get("id")
+        if not task_id:
+            raise RuntimeError(f"WaveSpeed did not return a task id: {task}")
+        print(f"[SF Tripo P2] Submitted {task_id} (quad={quad}, faces={face_limit}, texture={texture}).")
+
+        started = time.time()
+        while True:
+            check_interrupted()
+            result = api.get(RESULT_PATH.format(id=task_id))
+            status = result.get("status")
+            if status == "completed":
+                break
+            if status in TERMINAL_FAILURES:
+                raise RuntimeError(f"Tripo P2 task {status}: {result.get('error') or result}")
+            if time.time() - started > timeout_seconds:
+                raise RuntimeError(f"Tripo P2 task {task_id} still '{status}' after {timeout_seconds}s.")
+            time.sleep(3)
+
+        url = pick_model_url(result.get("outputs"))
+        ext = os.path.splitext(urlparse(url).path)[1].lower() or (".fbx" if quad else ".glb")
+        path = os.path.join(output_dir(), f"sf_tripo_p2_{task_id}{ext}")
+
+        response = requests.get(url, timeout=300)
+        response.raise_for_status()
+        with open(path, "wb") as f:
+            f.write(response.content)
+
+        print(f"[SF Tripo P2] Done in {time.time() - started:.0f}s -> {path}")
+
+        glb = fbx = None
+        if File3D is not None:
+            model = File3D(path)
+            glb = model if ext == ".glb" else None
+            fbx = model if ext == ".fbx" else None
+        return (glb, fbx, path, url)
+
+
+NODE_CLASS_MAPPINGS = {"SFWaveSpeedTripoP2ImageTo3D": SFWaveSpeedTripoP2ImageTo3D}
+NODE_DISPLAY_NAME_MAPPINGS = {"SFWaveSpeedTripoP2ImageTo3D": "SF WaveSpeed Tripo P2 Image to 3D"}

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-sf-nodes"
 description = "Custom nodes for ComfyUI including LLM Chat with support for Claude, Gemini, and OpenAI models, WaveSpeed AI image/video generation, VertexAI integration, and workflow utilities"
-version = "1.3.1"
+version = "1.6.0"
 license = { file = "LICENSE" }
 dependencies = [
     "requests>=2.31.0",

web/js/sf_save_folder_picker.js

@@ -0,0 +1,221 @@
+/**
+ * SF Save Folder Picker — adds a folder browser to ComfyUI's "Save workflow"
+ * dialog, so a workflow can be saved into a subfolder by clicking the folder
+ * and typing only the name, instead of typing the whole path.
+ *
+ * It augments the native dialog rather than replacing it: ComfyUI still does
+ * the actual saving, so tab tracking and overwrite confirmation are unchanged.
+ * Picking a folder only rewrites the path in the dialog's own input.
+ */
+
+import { app } from "../../../scripts/app.js";
+import { api } from "../../../scripts/api.js";
+
+const SETTING_ID = "Stillfront.SaveFolderPicker";
+const SAVE_COMMANDS = ["Comfy.SaveWorkflow", "Comfy.SaveWorkflowAs"];
+const ROOT = "workflows";
+
+// True only while a Save command is running, so the same prompt dialog used
+// for renaming or exporting is left alone.
+let savePending = false;
+
+function enabled() {
+    try {
+        return app.extensionManager?.setting?.get(SETTING_ID) !== false;
+    } catch {
+        return true;
+    }
+}
+
+async function fetchFolders() {
+    const res = await api.fetchApi(`/v2/userdata?path=${encodeURIComponent(ROOT)}`);
+    if (!res.ok) {
+        throw new Error(`folder list failed (${res.status})`);
+    }
+    const entries = await res.json();
+    return entries
+        .filter((e) => e.type === "directory")
+        .map((e) => e.path.replace(/^workflows\/?/, ""))
+        .filter((p) => p && !p.split("/").some((part) => part.startsWith(".")))
+        .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
+}
+
+function el(tag, style = "", text = "") {
+    const node = document.createElement(tag);
+    if (style) node.style.cssText = style;
+    if (text) node.textContent = text;
+    return node;
+}
+
+function splitPath(value) {
+    const i = value.lastIndexOf("/");
+    return i === -1 ? { folder: "", name: value } : { folder: value.slice(0, i), name: value.slice(i + 1) };
+}
+
+function setInput(input, folder) {
+    const { name } = splitPath(input.value);
+    input.value = folder ? `${folder}/${name}` : name;
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    input.focus();
+    // Select just the name, ready to be typed over.
+    const start = input.value.length - name.length;
+    input.setSelectionRange(start, input.value.length);
+}
+
+function buildPicker(input, folders) {
+    const expanded = new Set();
+    let selected = splitPath(input.value).folder;
+
+    // Open the branch leading to the folder the dialog started in.
+    selected.split("/").reduce((acc, part) => {
+        const path = acc ? `${acc}/${part}` : part;
+        if (part) expanded.add(path);
+        return path;
+    }, "");
+
+    const box = el(
+        "div",
+        "border:1px solid rgba(128,128,128,.35);border-radius:6px;margin:4px 0 8px;"
+    );
+    const header = el(
+        "div",
+        "display:flex;align-items:center;justify-content:space-between;padding:6px 8px;" +
+            "font-size:12px;opacity:.75;border-bottom:1px solid rgba(128,128,128,.25);"
+    );
+    header.appendChild(el("span", "", "Save into folder"));
+    const newBtn = el(
+        "button",
+        "background:none;border:1px solid rgba(128,128,128,.4);border-radius:4px;" +
+            "padding:2px 8px;font-size:12px;color:inherit;cursor:pointer;",
+        "+ New folder"
+    );
+    newBtn.type = "button";
+    header.appendChild(newBtn);
+    box.appendChild(header);
+
+    const list = el("div", "max-height:260px;overflow-y:auto;padding:4px 0;font-size:13px;");
+    box.appendChild(list);
+
+    const hasChildren = (path) => folders.some((f) => f.startsWith(`${path}/`));
+    const childrenOf = (parent) =>
+        folders.filter((f) => {
+            const { folder } = splitPath(f);
+            return folder === parent;
+        });
+
+    function row(path, depth) {
+        const label = path ? splitPath(path).name : `${ROOT} (top level)`;
+        const r = el(
+            "div",
+            `display:flex;align-items:center;gap:4px;padding:3px 8px 3px ${8 + depth * 16}px;` +
+                "cursor:pointer;border-radius:4px;user-select:none;" +
+                (path === selected ? "background:rgba(66,133,244,.28);" : "")
+        );
+        const caret = el("span", "width:14px;display:inline-block;text-align:center;opacity:.7;");
+        if (path && hasChildren(path)) {
+            caret.textContent = expanded.has(path) ? "▾" : "▸";
+            caret.addEventListener("click", (e) => {
+                e.stopPropagation();
+                expanded.has(path) ? expanded.delete(path) : expanded.add(path);
+                render();
+            });
+        }
+        r.appendChild(caret);
+        r.appendChild(el("span", "", `📁 ${label}`));
+        r.addEventListener("mouseenter", () => {
+            if (path !== selected) r.style.background = "rgba(128,128,128,.15)";
+        });
+        r.addEventListener("mouseleave", () => {
+            if (path !== selected) r.style.background = "";
+        });
+        r.addEventListener("click", () => {
+            selected = path;
+            setInput(input, path);
+            render();
+        });
+        return r;
+    }
+
+    function addBranch(parent, depth) {
+        for (const child of childrenOf(parent)) {
+            list.appendChild(row(child, depth));
+            if (expanded.has(child)) addBranch(child, depth + 1);
+        }
+    }
+
+    function render() {
+        list.replaceChildren(row("", 0));
+        addBranch("", 1);
+    }
+
+    newBtn.addEventListener("click", () => {
+        const where = selected ? `inside "${selected}"` : "at the top level";
+        const name = window.prompt(`New folder name (${where}):`);
+        const clean = (name || "").trim().replace(/[\\/]+/g, "-");
+        if (!clean) return;
+        const path = selected ? `${selected}/${clean}` : clean;
+        // The folder is created on disk when the workflow is saved into it.
+        if (!folders.includes(path)) folders.push(path);
+        folders.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
+        if (selected) expanded.add(selected);
+        selected = path;
+        setInput(input, path);
+        render();
+    });
+
+    render();
+    return box;
+}
+
+async function inject(dialog) {
+    if (dialog.dataset.sfFolderPicker) return;
+    dialog.dataset.sfFolderPicker = "1";
+
+    const input = dialog.querySelector("input");
+    if (!input) return;
+
+    let picker;
+    try {
+        picker = buildPicker(input, await fetchFolders());
+    } catch (e) {
+        picker = el("div", "font-size:12px;opacity:.7;margin:4px 0;", `Folder list unavailable: ${e.message}`);
+    }
+    input.parentElement.insertBefore(picker, input);
+}
+
+app.registerExtension({
+    name: "Stillfront.SaveFolderPicker",
+
+    settings: [
+        {
+            id: SETTING_ID,
+            category: ["Stillfront", "Workflows", "Folder picker in Save dialog"],
+            name: "Show a folder browser in the Save workflow dialog",
+            type: "boolean",
+            defaultValue: true,
+        },
+    ],
+
+    async setup() {
+        const commands = app.extensionManager?.command?.commands || [];
+        for (const id of SAVE_COMMANDS) {
+            const command = commands.find((c) => c.id === id);
+            if (!command) continue;
+            const original = command.function;
+            command.function = async function () {
+                savePending = true;
+                try {
+                    return await original.apply(this, arguments);
+                } finally {
+                    savePending = false;
+                }
+            };
+        }
+
+        new MutationObserver(() => {
+            if (!savePending || !enabled()) return;
+            const dialog = document.querySelector(".prompt-dialog-content:not([data-sf-folder-picker])");
+            if (dialog) inject(dialog);
+        }).observe(document.body, { childList: true, subtree: true });
+    },
+});