dsh-comfyui-rp 0.2.3 → 0.2.5

package/docs/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 更新记录
 
+## 0.2.5
+
+- **修「只收到时间戳、正文没跟着来」**：自动投递前先等目标会话空闲（最多 15 秒）。有些宿主（例如带自动续写的 Tavern）会让会话一直有事在跑，这时 `queue` 投递的正文会被排到下一轮，而当前这一轮模型只看到时间上下文注入的那三行。
+- 等不到空闲就改用 `steer`，把正文塞进正在跑的这一轮，至少模型能看到内容；任务记录里新增 `deliveryMode` 字段，日志里也会写「目标会话忙，正文改用 steer 投递」。
+- 顺带在任务 / 日志里带上等待时长，方便判断是不是宿主一直在忙。
+
+## 0.2.4
+
+- **纯黑图误判修复**：判定前先看体积——真·纯黑 PNG 只有 20 多 KB，超过 **120 KB** 的图直接不参与判定。之前有正常图（约 1 MB）在「原地替换后立刻复查」时被判成黑图，导致同一张图被连续替换 3 次。
+- **判黑要两次都黑**：第一次判黑后会隔 0.9 秒、绕过浏览器缓存再验一次，两次都黑才自动替换，避免一次绘制的偶发全黑。
+- **判定可追溯**：每次判定都会把统计（体积、暗像素比例、平均亮度、亮点比例、不透明覆盖）写进 Host 日志，「日志」页能直接看到；出现误判时能一眼定位是哪条规则触发。
+
 ## 0.2.3
 
 - **自动补图可以随时停下**：补图进行中，图片框左下菜单的按钮会变成「终止」（之前因为补图是内部任务，菜单里根本看不到它），点一下清空队列并中止正在跑的那一单；全屏和工作台的「终止」也一样。右侧栏顶部还有一条「停止自动补图」。下一次新任务开始时自动复位。

package/lib/api.js

@@ -1293,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

@@ -447,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 : "")); },
@@ -3752,29 +3753,62 @@ window.__ModuleLoader__.load({
             && darkRatio >= 0.995 && meanLum <= 8 && brightRatio < 0.001;
           return { black: black, darkRatio: darkRatio, brightRatio: brightRatio, meanLum: meanLum, coverage: coverage, opaque: opaque };
         }
-        var isNearlyBlack = function (url) {
+        // 纯黑图 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 {
-                if (!probe.naturalWidth || !probe.naturalHeight) return resolve(false);
+                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;
-                resolve(judgeNearlyBlack(d).black);
-              } 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 在下一轮新任务完成时复位，避免「点过一次停止后就再也不补」。
@@ -3815,7 +3849,8 @@ window.__ModuleLoader__.load({
           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();
         };
@@ -3826,8 +3861,9 @@ window.__ModuleLoader__.load({
           if (blackStopRef.current) { blackQueueRef.current = []; syncBlackPending(); return; }
           blackBusyRef.current = true;
           syncBlackPending();
-          isNearlyBlack(next.url).then(function (black) {
-            if (!black) return null;
+          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)) {
@@ -3881,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");
                 // 替换已经落到图片上、也确认不是黑图了，最后再报出图完成。

package/lib/jobs.js

@@ -388,6 +388,12 @@ export function createJobsEngine({ ctx, sc, store, hub, getConfig, getActiveSess
         job.replyText = r.text;
         job.deliveryMs = r.ms;
         job.sawOwnPrompt = r.sawOwnPrompt;
+        job.deliveryMode = r.deliveryMode || '';
+        if (r.deliveryMode === 'steer') {
+          // 目标会话当时不空闲（例如宿主在做自动续写），正文改成 steer 塞进当前这一轮；
+          // 不用 queue 的话正文会排到下一轮，这一轮模型只看到时间上下文。
+          log('warn', `目标会话忙，正文改用 steer 投递（等待空闲 ${r.idleWaited || 0}ms）`, { jobId: job.id });
+        }
         job.interrupted = r.interrupted;
         job.targetSessionId = r.sessionId || job.targetSessionId;
         job.promptSource = r.mode;
@@ -1295,6 +1301,7 @@ export function createJobsEngine({ ctx, sc, store, hub, getConfig, getActiveSess
       replyChars: String(job.replyText || '').length,
       deliveryMs: job.deliveryMs,
       sawOwnPrompt: job.sawOwnPrompt,
+      deliveryMode: job.deliveryMode || '',
       promptSource: job.promptSource || '',
       interrupted: job.interrupted,
       ruleId: job.ruleId,

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.3';
+export const VERSION = '0.2.5';
 
 /** 对外路由前缀。不能带尾斜杠（dsh-host-webserver 的 prefix 匹配规则）。 */
 export const ROUTE_PATH = '/__airp_comfy';

package/lib/session.js

@@ -294,7 +294,19 @@ export async function askLocal(ctx, sc, { sessionId, text, timeoutMs, signal } =
       `读不到会话的日志位置（session.seq = ${String(session?.seq)}）。为避免把上一轮回复当成本次答案，这次不猜。`,
       'bad-session-state');
   }
+  // 先等目标会话空闲再投递。有些宿主（Tavern 这种带自动续写的）会让会话一直有事在跑，
+  // 这时 `queue` 的正文会排到下一轮，而当前这轮模型只看到时间上下文注入的那条
+  // ——表现就是「只收到时间戳，正文没跟着来」。
+  // 等不到空闲就用 `steer` 把正文塞进正在跑的这一轮，至少模型能看到内容。
+  const IDLE_WAIT_MS = 15000;
+  const waitBegan = Date.now();
+  while (agent.status !== 'idle' && Date.now() - waitBegan < IDLE_WAIT_MS) {
+    if (signal && signal.aborted) break;
+    await sleep(200);
+  }
+  const idleWaited = Date.now() - waitBegan;
   const busyBefore = agent.status !== 'idle';
+  const deliveryMode = busyBefore ? 'steer' : 'queue';
   const expectEnds = busyBefore ? 2 : 1;
   const started = Date.now();
 
@@ -321,7 +333,7 @@ export async function askLocal(ctx, sc, { sessionId, text, timeoutMs, signal } =
   inflightLocal.add(sid);
   try {
     await controller.prompt(
-      { requestId, sessionId: sid, mode: 'queue', content: [{ type: 'text', text: body }] },
+      { requestId, sessionId: sid, mode: deliveryMode, content: [{ type: 'text', text: body }] },
       ac.signal,
     );
 
@@ -378,6 +390,8 @@ export async function askLocal(ctx, sc, { sessionId, text, timeoutMs, signal } =
       turn: got.turn,
       ms: Date.now() - started,
       busyBefore,
+      deliveryMode,
+      idleWaited,
       sawOwnPrompt,
       interrupted: got.interrupted,
     };

package/package.json

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