comfyui-mcp 0.52.61 → 0.52.63

package/dist/orchestrator/panel-tools.js

@@ -814,6 +814,10 @@ export const __panelToolsTestHooks = {
     setRunLateAckGraceMs(ms) {
         runLateAckGraceMsOverride = ms;
     },
+    /** Shrink the #2078 save-timeout settle grace so a still-dirty follow-up does not wait 5s. */
+    setSaveTimeoutSettleGraceMs(ms) {
+        saveTimeoutSettleGraceMsOverride = ms;
+    },
     isRetrySafeCmd,
     isTransientReconnectError,
     // CivitAI sample-image gating (#623): the predicate that decides which results'
@@ -3615,30 +3619,87 @@ function saveLandedAfterTimeout(list) {
     const rec = active;
     return rec.modified === false && rec.persisted === true;
 }
+/**
+ * A first save legitimately changes `tmp:<instance>` into `wf:<path>`. The
+ * updated panel publishes the save command's eventual success under its exact
+ * rid, so only that receipt can bridge the identity change. If the receipt field
+ * is absent or does not match, the outcome remains unknown rather than crediting
+ * a clean workflow that may belong to a tab the user switched to.
+ */
+function saveProbeMatchesLateReceipt(saveRid, list) {
+    if (!saveRid || !Array.isArray(list?.late_save_receipts))
+        return false;
+    if (!list?.active || typeof list.active !== "object" || Array.isArray(list.active))
+        return false;
+    const receipt = list.late_save_receipts.find((candidate) => candidate &&
+        typeof candidate === "object" &&
+        !Array.isArray(candidate) &&
+        candidate.rid === saveRid &&
+        candidate.cmd === "workflow_save");
+    if (!receipt || typeof receipt !== "object" || Array.isArray(receipt))
+        return false;
+    const result = receipt.result;
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        return false;
+    if (result.saved !== true)
+        return false;
+    // The panel's receipt is the save command's own eventual success. Still require
+    // its produced workflow identity to match the currently observed active canvas;
+    // a valid late save on A must not be credited after the user switched to B.
+    return identityVerdict(result, list.active) === true;
+}
 const SAVE_TIMEOUT_OUTCOME_UNKNOWN = `\n\nOUTCOME UNKNOWN: the save was already in flight when this budget fired. ` +
     `Confirm by reading the saved file (or panel_list_workflows) before retrying — a re-issue may write twice.`;
 /**
- * #2004 — the panel's 13s budget fired while userdata PUT was still running.
- * A follow-up list that now shows modified:false persisted:true is the save
- * completing; anything else stays outcome-unknown. persisted:true alone is
- * the timeout-time snapshot of a previously-saved dirty tab, not proof.
+ * #2078 — how long to keep reading tab state after the 13s save budget.
+ *
+ * #2004 already listed once. The reporter's PUT landed a moment later: that
+ * snapshot was still dirty, the next panel_list_workflows was already clean.
+ * Paid only on a path that has already spent its full bound. A canvas that
+ * is clean on the first list returns immediately.
+ */
+const SAVE_TIMEOUT_SETTLE_GRACE_MS = 5_000;
+const SAVE_TIMEOUT_SETTLE_POLL_MS = 200;
+let saveTimeoutSettleGraceMsOverride = null;
+function saveTimeoutSettleGraceMs() {
+    return saveTimeoutSettleGraceMsOverride ?? SAVE_TIMEOUT_SETTLE_GRACE_MS;
+}
+function saveAckAfterTimeout(list) {
+    return ok({
+        saved: true,
+        late_ack: true,
+        acknowledged_after_timeout: true,
+        active: list?.active,
+    });
+}
+/**
+ * #2004 / #2078 — the panel's 13s budget fired while userdata PUT was still
+ * running. A list that shows modified:false persisted:true is the save
+ * completing. One snapshot is not enough: the timeout-time canvas is still
+ * dirty, and the PUT can land between that read and the caller's next list.
+ * Keep reading until the grace, then stay outcome-unknown. persisted:true
+ * alone is the timeout-time snapshot of a previously-saved dirty tab, not proof.
  */
-async function settleWorkflowSaveTimeout(res, ctx) {
+async function settleWorkflowSaveTimeout(res, ctx, saveRid) {
     if (!isWorkflowSaveBudgetTimeout(res))
         return res;
-    try {
-        const listRes = await ctx.call({ cmd: "workflow_list" }, 6000);
-        const list = parseToolResultJson(listRes);
-        if (saveLandedAfterTimeout(list)) {
-            return ok({
-                saved: true,
-                acknowledged_after_timeout: true,
-                active: list?.active,
-            });
+    const deadline = Date.now() + saveTimeoutSettleGraceMs();
+    for (;;) {
+        try {
+            const listRes = await ctx.call({ cmd: "workflow_list" }, 6000);
+            const list = parseToolResultJson(listRes);
+            if (saveLandedAfterTimeout(list) &&
+                saveProbeMatchesLateReceipt(saveRid, list)) {
+                return saveAckAfterTimeout(list);
+            }
         }
-    }
-    catch {
-        /* keep the timeout refusal; the note below is the honest remainder */
+        catch {
+            /* keep polling until the grace; the note below is the honest remainder */
+        }
+        const left = deadline - Date.now();
+        if (left <= 0)
+            break;
+        await sleep(Math.max(1, Math.min(SAVE_TIMEOUT_SETTLE_POLL_MS, left)));
     }
     return appendToolResultText(res, SAVE_TIMEOUT_OUTCOME_UNKNOWN);
 }
@@ -8763,13 +8824,20 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets, onRunTicketOpen
         // here is the same recovery, just delayed until a canvas tab exists; it is
         // not a silent re-target.
         if (isScopeAddress(ctx.tabId)) {
-            if (ctx.pendingScopeRecoveryConsent) {
+            const deferredConsent = ctx.pendingScopeRecoveryConsent === true ||
+                (typeof bridge.hasScopeRecoveryConsent === "function" &&
+                    bridge.hasScopeRecoveryConsent(ctx.tabId));
+            if (deferredConsent) {
                 try {
                     const out = rebindToActiveTab({ scopeRecoveryConsent: true });
-                    if (out.rebound)
+                    if (out.rebound) {
                         ctx.pendingScopeRecoveryConsent = false;
-                    else if ((interactiveTabIds() ?? []).length > 0)
+                        bridge.clearScopeRecoveryConsent?.(ctx.tabId);
+                    }
+                    else if ((interactiveTabIds() ?? []).length > 0) {
                         ctx.pendingScopeRecoveryConsent = false;
+                        bridge.clearScopeRecoveryConsent?.(ctx.tabId);
+                    }
                 }
                 catch {
                     // still nothing bindable — keep the consent for the next attempt
@@ -13805,9 +13873,12 @@ export function buildPanelToolDefs() {
             if (ctx.awaitReachable && !(await ctx.awaitReachable())) {
                 return noReachableTabFail(args.name ? "workflow_save_as" : "workflow_save", ctx);
             }
+            let saveRid;
             const saveOnce = () => args.name
                 ? ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)
-                : ctx.call({ cmd: "workflow_save" }, 15000);
+                : ctx.call({ cmd: "workflow_save" }, 15000, (rid) => {
+                    saveRid = rid;
+                });
             let res = await saveOnce();
             // #1710 — dest tab + dest nodes, extra still stamped as the save-as SOURCE.
             // Rebind extra to the confirmed dest, then retry the same save once.
@@ -13823,7 +13894,7 @@ export function buildPanelToolDefs() {
                 }
             }
             if (res.isError && !args.name)
-                res = await settleWorkflowSaveTimeout(res, ctx);
+                res = await settleWorkflowSaveTimeout(res, ctx, saveRid);
             if (res.isError) {
                 // #1873 — named Save-As 409s by contract; the panel's "choose a different
                 // name" is what forced a third file. Keep the 409 and name the rename path.
@@ -14032,10 +14103,12 @@ export function buildPanelToolDefs() {
                     if (recoveringScope)
                         ctx.bridge.endScopeRecovery?.(before);
                 }
-                // panel#1557 — the consent survives a zero-tab DEFER so a graph call
-                // after the canvas reconnects can finish the recovery.
-                if (deferredBind && recoveringScope)
+                // panel#1557 — the consent survives a zero-tab DEFER so a later graph
+                // call (possibly on a fresh HTTP MCP ctx) can finish the recovery.
+                if (deferredBind && recoveringScope) {
                     ctx.pendingScopeRecoveryConsent = true;
+                    ctx.bridge.armScopeRecoveryConsent?.(before);
+                }
                 // Detect the rebind regardless of whether awaitReachable or rebindToActiveTab
                 // performed it (either mutates ctx.tabId), so the note is never swallowed.
                 if (!deferredBind && ctx.tabId !== before) {