dsh-comfyui-rp 0.2.2 → 0.2.4

package/README.md

@@ -40,7 +40,7 @@ dsh plugin --profile web add git+https://github.com/bmhty123/dsh-comfyui-rp.git
 
 ## 能做什么
 
-- **自动出图**：捕获正文 → 解析提示词 → 出图 → 归档，全自动；投递和出图可分开开关。
+- **自动出图**：捕获正文 → 解析提示词 → 出图 → 归档，全自动；投递和出图可分开开关。纯黑图会自动换种子重生成，进行中可以随时点「停止自动补图」。
 - **投递**：正文来源和提示词来源分开，可指到另一个会话甚至另一台 DSH；附加消息放正文最上面或最下面，投递成功后自动留空。
 - **看图**：右侧栏面板、全屏、悬浮球、悬浮图片框。翻页、下载、收藏、刷新、删除、圆角；自己拖过 / 缩过之后，切图不再改回初始大小。
 - **跟图**：滚动正文自动切图，连续图按段落比例拆位置，可切光标跟图、手动偏移、清空定位。

package/docs/CHANGELOG.md

@@ -1,5 +1,22 @@
 # 更新记录
 
+## 0.2.4
+
+- **纯黑图误判修复**：判定前先看体积——真·纯黑 PNG 只有 20 多 KB，超过 **120 KB** 的图直接不参与判定。之前有正常图（约 1 MB）在「原地替换后立刻复查」时被判成黑图，导致同一张图被连续替换 3 次。
+- **判黑要两次都黑**：第一次判黑后会隔 0.9 秒、绕过浏览器缓存再验一次，两次都黑才自动替换，避免一次绘制的偶发全黑。
+- **判定可追溯**：每次判定都会把统计（体积、暗像素比例、平均亮度、亮点比例、不透明覆盖）写进 Host 日志，「日志」页能直接看到；出现误判时能一眼定位是哪条规则触发。
+
+## 0.2.3
+
+- **自动补图可以随时停下**：补图进行中，图片框左下菜单的按钮会变成「终止」（之前因为补图是内部任务，菜单里根本看不到它），点一下清空队列并中止正在跑的那一单；全屏和工作台的「终止」也一样。右侧栏顶部还有一条「停止自动补图」。下一次新任务开始时自动复位。
+- **黑图自动替换开关**：工作流页 →「图片输出相关」→「额外设置」里新增开关，关掉后不再检测纯黑图，待补队列也会清空。
+- **纯黑判定更严，修掉误判**：以前只要求「暗像素 ≥ 99%」就会判黑，夜景、黑底小主体这类图会被误伤。现在必须同时满足：暗像素 ≥ 99.5%、平均亮度 ≤ 8、亮点（亮度 > 110）占比 < 0.1%，并且不透明像素要占到一半以上（透明底的小图不算黑）。
+- **固定种子可手填**：工作流页「每次换随机种子」下面多了一个「固定种子」输入框。
+  - 勾着自动时它是灰的，显示**上一轮实际用的种子**（方便看到满意的一张后直接固定下来）；
+  - 取消勾选后解锁，填的整数会立刻存进工作流，出图时覆盖每一处字面量 seed；取消的那一刻会把上一轮的种子自动带进来。
+  - 这些开关改完直接生效，不用再点「保存」。
+
+
 ## 0.2.2
 
 - **LoRA 强度可以填负数**：工作台「连续图」的档位、LoRA 页每条的强度都允许 `-5 ~ 5`（反相 LoRA 用）。

package/lib/api.js

@@ -358,7 +358,7 @@ export function createApi({ store, jobs, hub, getConfig, ctx, sc, routePath, ver
       workflows: compact ? [] : store.listWorkflows(),
       activeWorkflowId: cfg.workflowId,
       activeWorkflow: activeWf
-        ? { id: activeWf.id, name: activeWf.name, size: activeWf.size || null, sizeMode: activeWf.sizeMode || 'manual', randomSeed: activeWf.randomSeed !== false, nodeCount: Object.keys(activeWf.json || {}).length }
+        ? { id: activeWf.id, name: activeWf.name, size: activeWf.size || null, sizeMode: activeWf.sizeMode || 'manual', randomSeed: activeWf.randomSeed !== false, blackRetry: activeWf.blackRetry !== false, nodeCount: Object.keys(activeWf.json || {}).length }
         : null,
       jobs: jobsList,
       images: imageItems,
@@ -604,6 +604,9 @@ export function createApi({ store, jobs, hub, getConfig, ctx, sc, routePath, ver
       size: wf.size || null,
       sizeMode: wf.sizeMode || 'manual',
       randomSeed: wf.randomSeed !== false,
+      seed: wf.seed === null || wf.seed === undefined ? null : Number(wf.seed),
+      lastSeed: wf.lastSeed === null || wf.lastSeed === undefined ? null : Number(wf.lastSeed),
+      blackRetry: wf.blackRetry !== false,
       pruneOutputs: wf.pruneOutputs !== false,
       onlyFirst: wf.onlyFirst === true,
       loraState: wf.loraState || null,
@@ -662,12 +665,15 @@ export function createApi({ store, jobs, hub, getConfig, ctx, sc, routePath, ver
     const sizeMode = body.sizeMode || wf?.sizeMode || 'manual';
     const loraState = body.loraState !== undefined ? body.loraState : resolveLoraState(wf || {});
     const loraScan = scanLoraStacks(json);
+    // 固定种子：干跑也要按工作流页填的那个值算，否则「干跑」和真出一张的结果对不上。
+    const seed = body.seed !== undefined ? body.seed : (wf && wf.seed !== undefined ? wf.seed : null);
     const { workflow, report } = applyOverrides(json, {
       positive: String(body.positive ?? ''),
       negative: String(body.negative ?? ''),
       mapping,
       tokenEmpty: 'blank',
       randomSeed: body.randomSeed === true,
+      seed,
       loraState,
       size,
       sizeSource: sizeMode,
@@ -1287,6 +1293,21 @@ export function createApi({ store, jobs, hub, getConfig, ctx, sc, routePath, ver
       }));
     }
 
+    if (action === 'black-check' && method === 'POST') {
+      const b = body || {};
+      const stats = [
+        b.darkRatio !== undefined ? `暗 ${(Number(b.darkRatio) * 100).toFixed(2)}%` : '',
+        b.meanLum !== undefined ? `平均亮度 ${Number(b.meanLum).toFixed(1)}` : '',
+        b.brightRatio !== undefined ? `亮点 ${(Number(b.brightRatio) * 100).toFixed(2)}%` : '',
+        b.coverage !== undefined ? `不透明 ${Math.round(Number(b.coverage) * 100)}%` : '',
+      ].filter(Boolean).join(' · ');
+      const skippedText = b.skipped === 'bytes' ? '跳过（体积太大，不可能是纯黑）' : (b.skipped ? `跳过（${b.skipped}）` : '');
+      const head = b.black === true ? '判为纯黑图' : (skippedText || '不是黑图');
+      hub.pushLog(b.black === true ? 'warn' : 'info',
+        `黑图检测：${head} · ${b.fileName || b.imageId || '?'}${b.bytes ? ` · ${b.bytes} B` : ''}${stats ? ` · ${stats}` : ''}`);
+      return sendJson(res, 200, ok({ logged: true }));
+    }
+
     if (action === 'logs' && method === 'GET') {
       return sendJson(res, 200, ok({ logs: hub.logs.slice(-300) }));
     }

package/lib/client.js

@@ -221,6 +221,30 @@ window.__ModuleLoader__.load({
 
       function clamp(v, lo, hi) { return Math.max(lo, Math.min(hi, Number(v) || 0)); }
 
+      /**
+       * 自动补图的全局状态：逻辑在 FloatBall 里跑（它一直在，负责检测纯黑图），
+       * 但「停止」按钮要能出现在右侧栏面板里，所以两边共享这一份。
+       * pending = 队列里的 + 正在跑的；stop = FloatBall 注册过来的停止函数。
+       */
+      var BLACK_UI = { pending: 0, stop: null, subs: new Set() };
+      function setBlackPendingGlobal(n) {
+        var value = Math.max(0, Number(n) || 0);
+        if (BLACK_UI.pending === value) return;
+        BLACK_UI.pending = value;
+        BLACK_UI.subs.forEach(function (fn) { try { fn(value); } catch (e) { /* ignore */ } });
+      }
+      function useBlackPending() {
+        var [pending, setPending] = useState(BLACK_UI.pending);
+        useEffect(function () {
+          var fn = function (n) { setPending(n); };
+          BLACK_UI.subs.add(fn);
+          setPending(BLACK_UI.pending);
+          return function () { BLACK_UI.subs.delete(fn); };
+        }, []);
+        return pending;
+      }
+
+
       function loadTheme() {
         try { return localStorage.getItem(LS_THEME) === "light" ? "light" : "dark"; } catch (e) { return "dark"; }
       }
@@ -423,6 +447,7 @@ window.__ModuleLoader__.load({
         jobs: function (limit) { return req("GET", "jobs?limit=" + (limit || 30)); },
         job: function (id) { return req("GET", "jobs/" + encodeURIComponent(id)); },
         abort: function (id) { return req("POST", "jobs/" + encodeURIComponent(id) + "/abort", {}); },
+        blackCheck: function (body) { return req("POST", "black-check", body || {}); },
         delJob: function (id) { return req("DELETE", "jobs/" + encodeURIComponent(id)); },
         clearJobs: function (keepActive) { return req("POST", "jobs/clear", { keepActive: keepActive !== false }); },
         images: function (q) { return req("GET", "images" + (q ? "?" + q : "")); },
@@ -504,6 +529,8 @@ window.__ModuleLoader__.load({
 :root{--ac-bg:#151517;--ac-bg2:#1b1b1d;--ac-card:#1b1b1d;--ac-raised:#2a2a2c;--ac-line:#303033;--ac-line2:#3a3a3d;--ac-text:#ececee;--ac-text2:#c6c6ca;--ac-muted:#a8a8ad;--ac-dim:#8a8a90;--ac-accent:#b3bfd0;--ac-accent2:#dbe1ea;--ac-ok:#6fbf8f;--ac-warn:#d1ac72;--ac-err:#d18a8a;--ac-fs:12.5px;--ac-fs-s:11.5px;--ac-fs-l:11px;}
 .ac-root{--ac-bg:#151517;--ac-bg2:#1b1b1d;--ac-card:#1b1b1d;--ac-raised:#2a2a2c;--ac-line:#303033;--ac-line2:#3a3a3d;--ac-text:#ececee;--ac-text2:#c6c6ca;--ac-muted:#a8a8ad;--ac-dim:#8a8a90;--ac-accent:#b3bfd0;--ac-accent2:#dbe1ea;--ac-ok:#6fbf8f;--ac-warn:#d1ac72;--ac-err:#d18a8a;--ac-fs:12.5px;--ac-fs-s:11.5px;--ac-fs-l:11px;box-sizing:border-box;height:100%;min-height:0;display:flex;flex-direction:column;background:var(--ac-bg);color:var(--ac-text);font-size:var(--ac-fs);line-height:1.5;font-family:var(--ac-font,inherit);color-scheme:dark;}
 .ac-root *{box-sizing:border-box;}
+.ac-blackbar{display:flex;align-items:center;gap:8px;padding:7px 10px;background:rgba(96,72,30,.5);border-bottom:1px solid var(--ac-line);color:var(--ac-text);font-size:var(--ac-fs-s);flex:0 0 auto;}
+.ac-blackbar .ac-blackbar-txt{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
 .ac-ballroot,.ac-ballroot *,.ac-overlay,.ac-overlay *{box-sizing:border-box;}
 .ac-root ::selection{background:rgba(130,150,180,.35);}
 .ac-root ::-webkit-scrollbar{width:8px;height:8px;}
@@ -1758,7 +1785,10 @@ window.__ModuleLoader__.load({
           var shown = view || img || null;
           if (shown && shown.id) lastFrameView = shown;
         }, [view && view.id, view && view.url, img && img.id, img && img.url]);
-        var live = !!(job && (job.status === "delivering" || job.status === "parsing" || job.status === "running" || job.status === "queued"));
+        // 黑图补图是 internal 任务，不在 visibleJobs 里，所以「有没有在跑」要单看这个计数：
+        // 补图进行中也要能把菜单里的「请求生成」换成「终止」。
+        var blackActive = useBlackPending() > 0;
+        var live = blackActive || !!(job && (job.status === "delivering" || job.status === "parsing" || job.status === "running" || job.status === "queued"));
         // anchor / turn 也进 key：旧图回填锚点后 id 不变，但跟随逻辑必须重建，
         // 否则监听器里还是“没有锚点”的旧 imgs。
         var imgKey = imgs.map(function (x) {
@@ -3693,36 +3723,114 @@ window.__ModuleLoader__.load({
             });
           }, "重新生成");
         };
-        var isNearlyBlack = function (url) {
+        /**
+         * 纯黑判定（纯函数，便于自检）：从缩放后的 RGBA 采样里算，三条同时满足才算黑：
+         *   ① 暗像素（亮度 < 14）占比 ≥ 99.5%
+         *   ② 平均亮度 ≤ 8
+         *   ③ 亮点（亮度 > 110）占比 < 0.1%
+         * 只满足 ① 会误伤夜景 / 黑底小主体——之前就是这么误判的。
+         * 另外要求不透明像素覆盖 ≥ 50%：透明底的小图不是“黑图”，是透明图。
+         */
+        function judgeNearlyBlack(d) {
+          var pixels = d.length / 4;
+          var opaque = 0;
+          var dark = 0;
+          var bright = 0;
+          var lumSum = 0;
+          for (var i = 0; i < d.length; i += 4) {
+            if (d[i + 3] < 16) continue; // 透明像素不算
+            opaque += 1;
+            var lum = 0.2126 * d[i] + 0.7152 * d[i + 1] + 0.0722 * d[i + 2];
+            lumSum += lum;
+            if (lum < 14) dark += 1;
+            else if (lum > 110) bright += 1;
+          }
+          var darkRatio = opaque ? dark / opaque : 0;
+          var brightRatio = opaque ? bright / opaque : 0;
+          var meanLum = opaque ? lumSum / opaque : 0;
+          var coverage = pixels ? opaque / pixels : 0;
+          var black = opaque >= 8 && coverage >= 0.5
+            && darkRatio >= 0.995 && meanLum <= 8 && brightRatio < 0.001;
+          return { black: black, darkRatio: darkRatio, brightRatio: brightRatio, meanLum: meanLum, coverage: coverage, opaque: opaque };
+        }
+        // 纯黑图 PNG 压缩后极小（832×1216 的真黑图 ≈ 25 KB），超过这个体积不可能是纯黑。
+        // 这条是硬保险：就算画布绘制 / 解码出了岔子，也不会把一张有内容的图当成黑图。
+        var BLACK_MAX_BYTES = 120000;
+        // 返回 judgeNearlyBlack 的统计对象；bust=true 时加个 nc 参数绕过浏览器缓存（确认二次判定用）。
+        var isNearlyBlack = function (url, bust) {
           return new Promise(function (resolve) {
-            if (!url || typeof document === "undefined" || typeof Image === "undefined") return resolve(false);
+            if (!url || typeof document === "undefined" || typeof Image === "undefined") return resolve({ black: false });
             var probe = new Image();
             probe.onload = function () {
               try {
-                var w = Math.max(1, Math.min(256, probe.naturalWidth || 1));
-                var h = Math.max(1, Math.min(256, probe.naturalHeight || 1));
+                if (!probe.naturalWidth || !probe.naturalHeight) return resolve({ black: false });
+                var w = Math.max(1, Math.min(256, probe.naturalWidth));
+                var h = Math.max(1, Math.min(256, probe.naturalHeight));
                 var canvas = document.createElement("canvas");
                 canvas.width = w;
                 canvas.height = h;
                 var g = canvas.getContext("2d");
-                if (!g) return resolve(false);
+                if (!g) return resolve({ black: false });
                 g.drawImage(probe, 0, 0, w, h);
                 var d = g.getImageData(0, 0, w, h).data;
-                var total = 0;
-                var black = 0;
-                for (var i = 0; i < d.length; i += 4) {
-                  if (d[i + 3] < 16) continue; // 透明像素不算黑
-                  total += 1;
-                  if (d[i] < 16 && d[i + 1] < 16 && d[i + 2] < 16) black += 1;
-                }
-                resolve(total > 0 && black / total >= 0.99);
-              } catch (e) { resolve(false); }
+                resolve(judgeNearlyBlack(d));
+              } catch (e) { resolve({ black: false }); }
             };
-            probe.onerror = function () { resolve(false); };
-            probe.src = url;
+            probe.onerror = function () { resolve({ black: false }); };
+            probe.src = url + (bust ? (url.indexOf("?") >= 0 ? "&" : "?") + "nc=" + Date.now() : "");
+          });
+        };
+        // 判定入口：先看体积，再验像素；判黑要**两次都黑**才算数（第二次绕过缓存）。
+        var probeBlackImage = function (im) {
+          var url = im && im.url ? String(im.url) : "";
+          var bytes = im && im.bytes ? Number(im.bytes) : 0;
+          if (!url) return Promise.resolve({ black: false, skipped: "no-url" });
+          if (bytes > BLACK_MAX_BYTES) return Promise.resolve({ black: false, skipped: "bytes", bytes: bytes, url: url });
+          return isNearlyBlack(url).then(function (first) {
+            if (!first.black) return { black: false, stats: first, url: url, bytes: bytes };
+            return new Promise(function (resolve) { setTimeout(resolve, 900); })
+              .then(function () { return isNearlyBlack(url, true); })
+              .then(function (second) {
+                return { black: !!second.black, stats: second, first: first, url: url, bytes: bytes, confirmed: true };
+              });
           });
         };
+        // 把判定结果写进 Host 日志（日志页可见），误判时能直接看到当时的统计。
+        var reportBlackCheck = function (im, verdict) {
+          try {
+            var s = verdict && verdict.stats ? verdict.stats : {};
+            api.blackCheck({
+              imageId: im && im.id ? String(im.id) : "",
+              fileName: im && im.fileName ? String(im.fileName) : "",
+              bytes: verdict && verdict.bytes ? verdict.bytes : (im && im.bytes) || 0,
+              black: !!(verdict && verdict.black),
+              skipped: (verdict && verdict.skipped) || "",
+              darkRatio: s.darkRatio, meanLum: s.meanLum, brightRatio: s.brightRatio, coverage: s.coverage,
+            }).catch(function () { /* 诊断日志失败不影响主流程 */ });
+          } catch (e) { /* ignore */ }
+        };
         var blackQueueRef = useRef([]);
+        // 自动补图可以随时叫停：队列清空 + 正在跑的那单 abort，并且这一轮不再自动补。
+        // blackStopRef 在下一轮新任务完成时复位，避免「点过一次停止后就再也不补」。
+        var blackStopRef = useRef(false);
+        var blackJobRef = useRef("");
+        var syncBlackPending = function () {
+          setBlackPendingGlobal(blackQueueRef.current.length + (blackBusyRef.current ? 1 : 0));
+        };
+        var stopBlack = function () {
+          blackStopRef.current = true;
+          blackQueueRef.current = [];
+          var jid = blackJobRef.current;
+          blackJobRef.current = "";
+          syncBlackPending();
+          showToast("已停止自动补图", "ok");
+          if (jid) api.abort(jid).catch(function () { /* 任务可能已经结束了 */ });
+        };
+        // 面板上的「停止自动补图」通过这个入口回调过来。
+        useEffect(function () {
+          BLACK_UI.stop = stopBlack;
+          return function () { if (BLACK_UI.stop === stopBlack) BLACK_UI.stop = null; };
+        }, []);
         /** 同一张图（同一套提示词）跨多次自动换种子仍用同一个 key，用来限制最多补几次。 */
         var blackSlotKey = function (sourceJob, im) {
           var sets = Array.isArray(sourceJob && sourceJob.sets) ? sourceJob.sets : [];
@@ -3738,18 +3846,24 @@ window.__ModuleLoader__.load({
         };
         var enqueueBlack = function (im, sourceJob, attempt, key, label) {
           if (!im || !im.id || !im.url) return;
+          if (blackStopRef.current) return;
           blackQueueRef.current.push({
             id: String(im.id), jobId: im.jobId || (sourceJob && sourceJob.id) || "",
-            setIndex: im.setIndex, url: im.url, attempt: attempt || 1, key: key || "", label: label || "",
+            setIndex: im.setIndex, url: im.url, bytes: im.bytes || 0,
+            attempt: attempt || 1, key: key || "", label: label || "",
           });
+          syncBlackPending();
         };
         var drainBlackQueue = function () {
           if (blackBusyRef.current) return;
           var next = blackQueueRef.current.shift();
-          if (!next) return;
+          if (!next) { syncBlackPending(); return; }
+          if (blackStopRef.current) { blackQueueRef.current = []; syncBlackPending(); return; }
           blackBusyRef.current = true;
-          isNearlyBlack(next.url).then(function (black) {
-            if (!black) return null;
+          syncBlackPending();
+          probeBlackImage(next).then(function (verdict) {
+            reportBlackCheck(next, verdict);
+            if (!verdict.black) return null;
             if (next.attempt === 1) {
               var nk = String(next.jobId || next.id || "");
               if (!blackNotifiedRef.current.has(nk)) {
@@ -3767,17 +3881,32 @@ window.__ModuleLoader__.load({
               mode: "auto",
               sessionId: data && data.activeSessionId || "",
               sessionTitle: data && data.activeSessionTitle || "",
+            }).then(function (r) {
+              blackJobRef.current = r && r.job && r.job.id ? String(r.job.id) : "";
+              return r;
             });
           }).catch(function () { /* 黑图重生成失败不阻塞其它图 */ }).then(function () {
             blackBusyRef.current = false;
+            blackJobRef.current = "";
+            syncBlackPending();
             drainBlackQueue();
           });
         };
         var checkBlackImages = function (sourceJob) {
           if (!sourceJob || sourceJob.status !== "done") return;
+          // 工作流页「图片输出相关 → 黑图自动替换」关掉就整个不检测（连已在队列里的也清掉）。
+          if (data && data.activeWorkflow && data.activeWorkflow.blackRetry === false) {
+            if (blackQueueRef.current.length || blackBusyRef.current) {
+              blackQueueRef.current = [];
+              syncBlackPending();
+            }
+            return;
+          }
           // 只处理刚完成的这一轮；翻旧记录 / 重启页面不追溯历史图。
           var finished = Date.parse(sourceJob.finishedAt || "");
           if (!Number.isFinite(finished) || Date.now() - finished > 120000) return;
+          // 新一轮（非自动补图）开始时解除上一次的「停止」，否则停过一次就再也不会补了。
+          if (sourceJob.regenMode !== "auto") blackStopRef.current = false;
 
           if (sourceJob.regenMode === "auto") {
             // 自动补图后继续检查：仍然黑就再换种子，最多 BLACK_MAX_RETRIES 次。
@@ -3788,8 +3917,9 @@ window.__ModuleLoader__.load({
             if (!retried || !retried.id || !retried.url) return;
             var slotKey = blackSlotKey(sourceJob, retried);
             var attempt = Math.max(1, Number(blackRetryRef.current[slotKey]) || 1);
-            isNearlyBlack(retried.url).then(function (black) {
-              if (!black) {
+            probeBlackImage(retried).then(function (verdict) {
+              reportBlackCheck(retried, verdict);
+              if (!verdict.black) {
                 delete blackRetryRef.current[slotKey];
                 notify("黑图已替换为正常图", "ok");
                 // 替换已经落到图片上、也确认不是黑图了，最后再报出图完成。
@@ -3821,6 +3951,12 @@ window.__ModuleLoader__.load({
           drainBlackQueue();
         };
         var stopJob = function () {
+          // 图片框左下菜单的「终止」就是真正的终止：黑图补图是 internal 任务，
+          // 一起停掉（清队列 + 中止正在跑的那单），否则点了终止它还在后台接着补。
+          if (blackQueueRef.current.length || blackBusyRef.current) {
+            stopBlack();
+            return;
+          }
           if (!job || !job.id) return;
           act(function () {
             return api.abort(job.id).then(function () { showToast("已终止", "ok"); });
@@ -4547,6 +4683,8 @@ window.__ModuleLoader__.load({
         });
         var [toasts, setToasts] = useState([]);
         var [conn, setConn] = useState(true);
+        // 自动补图是 FloatBall 在跑，这里只订阅「还有几个在补」用来显示停止条。
+        var blackPending = useBlackPending();
         var [viewer, setViewer] = useState(null);
         // 切到右侧栏其它标签时 BridgePanel 会卸载；memory 让回来时还在同一张图。
         var bootSession = props && typeof props.sessionId === "string" ? props.sessionId : "";
@@ -5441,6 +5579,8 @@ window.__ModuleLoader__.load({
           }).catch(function (e) { showToast("重新生成失败：" + (e.message || e), "err"); });
         };
         var fullStop = function () {
+          // 全屏里的「终止」也一样：先把自动补图停掉，再中止当前任务。
+          if (BLACK_UI.stop) BLACK_UI.stop();
           if (!liveJob || !liveJob.id) return;
           Promise.resolve().then(function () { return api.abort(liveJob.id); }).then(function () { showToast("已终止", "ok"); }).catch(function (e) { showToast("终止失败：" + (e.message || e), "err"); });
         };
@@ -5809,6 +5949,11 @@ window.__ModuleLoader__.load({
         };
 
         return h("div", { className: cls("ac-root", fullImage && "fullimg", theme === "light" && "light") },
+          blackPending > 0 ? h("div", { className: "ac-blackbar" },
+            h("span", { className: "ac-blackbar-txt" },
+              "检测到纯黑图，正在自动重新生成" + (blackPending > 1 ? "（队列 " + blackPending + " 个）" : "")),
+            h(Btn, { small: true, variant: "danger", onClick: function () { if (BLACK_UI.stop) BLACK_UI.stop(); } }, "停止自动补图"),
+          ) : null,
           fullImage
             ? h("div", {
               className: cls("ac-fullview", square && "square"),
@@ -6843,7 +6988,7 @@ window.__ModuleLoader__.load({
           h("div", { className: "ac-wfbar" },
             h("span", { className: "ac-wfname", title: wf ? wf.name : "未选择" }, "工作流：" + (wf ? wf.name : "未选择")),
             h("span", { style: { flex: 1 } }),
-            job && job.cancellable ? h(Btn, { small: true, variant: "danger", onClick: function () { api.abort(job.id).then(function () { props.toast("已终止", "ok"); }).catch(function (e) { props.toast("终止失败：" + (e.message || e), "err"); }); } }, "终止") : null,
+            job && job.cancellable ? h(Btn, { small: true, variant: "danger", onClick: function () { if (BLACK_UI.stop) BLACK_UI.stop(); api.abort(job.id).then(function () { props.toast("已终止", "ok"); }).catch(function (e) { props.toast("终止失败：" + (e.message || e), "err"); }); } }, "终止") : null,
             h(Btn, {
               variant: "primary", className: "ac-genbtn",
               disabled: busy || !sets.length || !sets.some(function (s) { return s.positive; }) || !!(job && job.cancellable),
@@ -7363,6 +7508,21 @@ window.__ModuleLoader__.load({
         var [dry, setDry] = useState(props.initialDry || null);
         var [jsonOpen, setJsonOpen] = useState(props.initialJsonOpen === true);
         var fileRef = useRef(null);
+        // 「固定种子」文本框：null = 不在编辑（显示自动 / 已保存的值），字符串 = 正在输入的原文。
+        var [seedDraft, setSeedDraft] = useState(null);
+        var seedTimer = useRef(null);
+        useEffect(function () {
+          return function () { if (seedTimer.current) clearTimeout(seedTimer.current); };
+        }, []);
+        // 种子这类开关不走「保存」按钮也会立刻落库，否则改完忘了保存，出图还是老种子。
+        var persistWf = function (p) {
+          patch(p);
+          if (!wf || !wf.id) return;
+          if (seedTimer.current) clearTimeout(seedTimer.current);
+          seedTimer.current = setTimeout(function () {
+            api.updateWorkflow(wf.id, p).catch(function () { /* 落库失败不阻塞界面 */ });
+          }, 400);
+        };
 
         var loadWf = function (wid) {
           if (!wid) { setWf(null); setScan(null); setJsonText(""); return Promise.resolve(null); }
@@ -7425,6 +7585,7 @@ window.__ModuleLoader__.load({
             size: wf ? wf.size : null,
             sizeMode: wf ? wf.sizeMode : "manual",
             randomSeed: wf ? wf.randomSeed : true,
+            seed: wf && wf.seed !== undefined && wf.seed !== null && Number.isFinite(Number(wf.seed)) ? Math.round(Number(wf.seed)) : null,
             pruneOutputs: wf ? wf.pruneOutputs : true,
             onlyFirst: true,
           };
@@ -7455,7 +7616,7 @@ window.__ModuleLoader__.load({
           doSave(undefined, name);
         };
         var create = function () {
-          setWf({ id: "", name: "新工作流", json: {}, mapping: {}, mappingSeeded: false, mappingVersion: 0, outputNodes: [], outputSelectionVersion: 2, size: null, sizeMode: "manual", randomSeed: true, pruneOutputs: true, onlyFirst: false, loraState: null });
+          setWf({ id: "", name: "新工作流", json: {}, mapping: {}, mappingSeeded: false, mappingVersion: 0, outputNodes: [], outputSelectionVersion: 2, size: null, sizeMode: "manual", randomSeed: true, seed: null, lastSeed: null, pruneOutputs: true, onlyFirst: false, loraState: null });
           setId("");
           setJsonText("{}");
           setScan(null);
@@ -7479,6 +7640,32 @@ window.__ModuleLoader__.load({
         var patch = function (p) {
           setWf(function (old) { return old ? Object.assign({}, old, p) : old; });
         };
+        // 固定种子：自动模式只读，显示上一轮实际用的种子；取消自动后可以手填，
+        // 填的数字会随保存写进工作流，出图时覆盖每一处字面量 seed。
+        var seedAuto = !wf || wf.randomSeed !== false;
+        var seedDisplay = seedAuto
+          ? (wf && wf.lastSeed !== null && wf.lastSeed !== undefined ? String(wf.lastSeed) : "")
+          : (wf && wf.seed !== null && wf.seed !== undefined ? String(wf.seed) : "");
+        var editSeed = function (value) {
+          setSeedDraft(value);
+          var n = Number(value);
+          if (String(value).trim() !== "" && isFinite(n) && n >= 0) patch({ seed: Math.round(n) });
+        };
+        var commitSeed = function (value) {
+          setSeedDraft(null);
+          var raw = String(value === undefined || value === null ? "" : value).trim();
+          if (raw === "") { persistWf({ seed: null }); return; }
+          var n = Number(raw);
+          if (!isFinite(n)) { persistWf({ seed: null }); return; }
+          persistWf({ seed: Math.max(0, Math.min(9007199254740991, Math.round(n))) });
+        };
+        var toggleRandomSeed = function (on) {
+          if (on) { persistWf({ randomSeed: true }); return; }
+          // 取消自动时顺手把「上一轮用的种子」带过来，省得再手敲一遍。
+          var carry = wf.seed !== null && wf.seed !== undefined ? wf.seed
+            : (wf.lastSeed !== null && wf.lastSeed !== undefined ? wf.lastSeed : null);
+          persistWf({ randomSeed: false, seed: carry });
+        };
         var mapping = (wf && wf.mapping) || {};
         var setMapping = function (nodeId, role) {
           var next = Object.assign({}, mapping);
@@ -7787,11 +7974,31 @@ window.__ModuleLoader__.load({
                 h("div", { className: "ac-subtitle", style: { marginTop: 12 } }, "额外设置"),
                 h("div", { className: "ac-form" },
                   h("div", { className: "ac-row" },
-                    h(Switch, { checked: wf.randomSeed !== false, onChange: function (e) { patch({ randomSeed: e.target.checked }); } }, "每次换随机种子"),
+                    h(Switch, { checked: wf.randomSeed !== false, onChange: function (e) { toggleRandomSeed(e.target.checked); } }, "每次换随机种子"),
+                  ),
+                  h("div", { className: "ac-row" },
+                    h(Field, { label: "固定种子" }, h(TextInput, {
+                      value: seedDraft !== null ? seedDraft : seedDisplay,
+                      disabled: seedAuto,
+                      placeholder: seedAuto ? "自动（显示上一轮用的种子）" : "填一个整数，每轮都用它",
+                      title: seedAuto
+                        ? "自动换种子时只读：显示上一轮实际用的种子；取消上面勾选即可编辑"
+                        : "取消自动后，这里填的数字会写进工作流，每轮都用它",
+                      onChange: function (e) { editSeed(e.target.value); },
+                      onBlur: function (e) { commitSeed(e.target.value); },
+                      onKeyDown: function (e) { if (e.key === "Enter") e.currentTarget.blur(); },
+                    })),
+                    h("span", { className: "ac-hint" }, seedAuto ? "自动：每轮随机" : "固定：每轮都用这个种子"),
                   ),
                   h("div", { className: "ac-row" },
                     h(Switch, { checked: wf.pruneOutputs !== false, onChange: function (e) { patch({ pruneOutputs: e.target.checked }); } }, "提交前裁剪输出节点（只提交上面勾选的）"),
                   ),
+                  h("div", { className: "ac-row" },
+                    h(Switch, { checked: wf.blackRetry !== false, onChange: function (e) { persistWf({ blackRetry: e.target.checked }); } }, "黑图自动替换"),
+                    h("span", { className: "ac-hint" }, wf.blackRetry !== false
+                      ? "出图后检测到纯黑图就自动换种子重生成；进行中可在图片框菜单点「终止」"
+                      : "已关闭：纯黑图不再自动替换"),
+                  ),
                 ),
               ),
             ),

package/lib/comfy.js

@@ -631,7 +631,7 @@ function countOccurrences(hay, needle) {
  */
 export function applyOverrides(
   workflow,
-  { positive = '', negative = '', mapping = {}, tokenEmpty = 'blank', randomSeed = true, loraState = null, size = null, sizeSource = '' } = {},
+  { positive = '', negative = '', mapping = {}, tokenEmpty = 'blank', randomSeed = true, seed = null, loraState = null, size = null, sizeSource = '' } = {},
 ) {
   let wf = structuredClone(workflow);
   const report = {
@@ -978,6 +978,29 @@ export function applyOverrides(
         });
       }
     }
+  } else if (seed !== null && seed !== undefined && Number.isFinite(Number(seed))) {
+    // 固定种子：把每一处字面量 seed 都写成用户填的这个值（工作台「固定种子」文本框）。
+    // 只动和上面同一类节点，连线出来的种子不碰。
+    const fixed = Math.round(Number(seed));
+    for (const [nodeId, node] of Object.entries(wf)) {
+      if (!node || typeof node !== 'object' || !node.inputs) continue;
+      if (!SEED_NODE_RE.test(String(node.class_type || ''))) continue;
+      for (const key of Object.keys(node.inputs)) {
+        if (key !== 'seed' && key !== 'noise_seed' && key !== 'rand_seed') continue;
+        const before = node.inputs[key];
+        if (typeof before !== 'number' || !Number.isFinite(before)) continue;
+        node.inputs[key] = fixed;
+        report.seeds.push({
+          nodeId,
+          classType: node.class_type,
+          title: node?._meta?.title || node?.title || '',
+          inputKey: key,
+          before,
+          after: fixed,
+          fixed: true,
+        });
+      }
+    }
   }
 
   /* ── 第 4 步：LoRA 开关 ──

package/lib/jobs.js

@@ -578,6 +578,7 @@ export function createJobsEngine({ ctx, sc, store, hub, getConfig, getActiveSess
       mapping: wf.mapping || {},
       tokenEmpty: 'blank',
       randomSeed: job?.forceRandomSeed === true || wf.randomSeed !== false,
+      seed: wf.seed === null || wf.seed === undefined ? null : Number(wf.seed),
       loraState: set.continuousShot
         ? withLoraStrength(wf, resolveLoraState(wf), set.continuousShot)
         : resolveLoraState(wf),
@@ -743,6 +744,11 @@ export function createJobsEngine({ ctx, sc, store, hub, getConfig, getActiveSess
       const wfN = prepared.workflow;
       if (index === 0) job.overrideReport = prepared.report;
       const usedSeeds = seedsOfWorkflow(wfN);
+      // 把这一轮实际用的种子记到工作流上：工作流页「固定种子」那一栏在自动模式下
+      // 显示的就是它，用户看到满意的一张可以直接取消自动、把这颗种子固定下来。
+      if (index === 0 && wf.id && usedSeeds.length) {
+        try { store.patchWorkflow(wf.id, { lastSeed: usedSeeds[0].value }); } catch { /* 记录失败不影响出图 */ }
+      }
       if (runSets.length > 1) log('info', `第 ${index + 1}/${runSets.length} 套：排队提交`, { jobId: job.id });
       const { promptId } = await queuePrompt(cfg.comfy.baseUrl, wfN, CLIENT_ID);
       job.comfyPromptId = promptId;

package/lib/meta.js

@@ -6,7 +6,7 @@
  */
 export const PACKAGE_NAME = 'dsh-comfyui-rp';
 export const PLUGIN_NAME = 'dsh-comfyui-rp';
-export const VERSION = '0.2.2';
+export const VERSION = '0.2.4';
 
 /** 对外路由前缀。不能带尾斜杠（dsh-host-webserver 的 prefix 匹配规则）。 */
 export const ROUTE_PATH = '/__airp_comfy';

package/lib/store.js

@@ -483,6 +483,9 @@ export function createStore(dataDir) {
           size: null,
           sizeMode: 'manual',
           randomSeed: true,
+          seed: null,
+          lastSeed: null,
+          blackRetry: true,
           pruneOutputs: true,
           onlyFirst: false,
           loraState: null,
@@ -553,6 +556,9 @@ export function createStore(dataDir) {
           size: null,
           sizeMode: 'manual',
           randomSeed: true,
+          seed: null,
+          lastSeed: null,
+          blackRetry: true,
           pruneOutputs: true,
           onlyFirst: false,
           loraState: null,
@@ -577,7 +583,7 @@ export function createStore(dataDir) {
       const w = api.getWorkflow(id);
       if (!w) return null;
       const allow = ['name', 'json', 'mapping', 'mappingSeeded', 'mappingVersion', 'outputNodes', 'outputSelectionVersion', 'tokenEmpty', 'size', 'sizeMode',
-        'randomSeed', 'pruneOutputs', 'onlyFirst', 'loraState'];
+        'randomSeed', 'seed', 'lastSeed', 'pruneOutputs', 'onlyFirst', 'loraState', 'blackRetry'];
       for (const k of allow) {
         if (patch && Object.prototype.hasOwnProperty.call(patch, k)) w[k] = k === 'tokenEmpty' ? 'blank' : patch[k];
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-comfyui-rp",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "ComfyRP Bridge：装在 DSH 里的本地文生图自动化桥。捕获会话正文 → 提示词会话 → 本地 ComfyUI 出图 → 图片回到右侧栏 / 悬浮球 / 图库。不依赖外部桥进程，也不调用 LLM。",
   "type": "module",
   "main": "lib/index.js",