comfyui-mcp 0.50.15 → 0.50.17

package/dist/orchestrator/panel-tools.js

@@ -6810,9 +6810,53 @@ export function buildPanelToolDefs() {
             if (ctx.awaitReachable && !(await ctx.awaitReachable())) {
                 return noReachableTabFail(args.name ? "workflow_save_as" : "workflow_save");
             }
-            return args.name
-                ? ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)
-                : ctx.call({ cmd: "workflow_save" }, 15000);
+            const res = args.name
+                ? await ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)
+                : await ctx.call({ cmd: "workflow_save" }, 15000);
+            if (res.isError)
+                return res;
+            // #1045 — a SAVE-AS replaces the active workflow instance: the canvas is
+            // now the NEW file, with its own identity, while this session's command
+            // fence still names the pre-save one. Every graph call afterwards fails
+            // with "workflow instance mismatch" — a reporter lost the session right
+            // after a successful save of ~40 nodes' work.
+            //
+            // Same shape as #932 (panel_new_workflow), and the same fix: re-derive
+            // the fence from the panel's live active record. I closed that path and
+            // missed this one; workflow_new and workflow_save_as both re-point the
+            // active workflow, so both have to re-anchor.
+            //
+            // A plain in-place save is included deliberately. Its identity normally
+            // FOLLOWS the workflow across the save (tmp: -> wf:), so the refresh
+            // re-derives the same value and changes nothing — but "normally" is the
+            // whole problem here, and re-reading costs one round trip against a
+            // session that is otherwise silently unusable.
+            //
+            // NEVER fails the call: the file WAS written. Retracting a completed save
+            // would be the worse lie, so a fence that could not be re-established is
+            // DISCLOSED instead.
+            const fenceRebind = await rebindWorkflowFence(ctx);
+            let canMutateNow;
+            let refusalCause;
+            try {
+                if (ctx.tabGraphMutationCapability) {
+                    const cap = ctx.tabGraphMutationCapability();
+                    canMutateNow = cap.known ? cap.canMutate : undefined;
+                    if (cap.known && !cap.canMutate)
+                        refusalCause = cap.because;
+                }
+                else {
+                    canMutateNow = ctx.tabCanMutateGraph?.();
+                }
+            }
+            catch {
+                canMutateNow = undefined;
+                refusalCause = undefined;
+            }
+            const fence = describeFenceRebind(fenceRebind, canMutateNow, refusalCause);
+            if (!fence || fence.binding === "bound")
+                return res;
+            return appendNote(res, `The workflow WAS saved.${fence.note}`);
         }),
         def("panel_list_workflows", "List the user's OPEN workflow tabs and which one is active (path, filename, modified, persisted). Use this to know what's open before switching/renaming/closing. Read-only.", {}, async (_args, ctx) => ctx.call({ cmd: "workflow_list" })),
         def("panel_get_workflow_target", "Read which workflow this agent is bound to edit. mode 'current' means graph tools follow whatever tab the user is viewing; mode 'pinned' means edits are bound to the pinned workflow (which was the active canvas at pin time) — if the user later switches to another tab, your next graph call FAILS LOUDLY rather than silently editing the wrong graph. Call this when unsure which workflow your panel_* edits will affect.", {}, async (_args, ctx) => {