cortico-world-image 0.2.0 → 0.5.4

package/src/world.js

@@ -14,7 +14,9 @@ import { extname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { ImageApiError, editImage, generateImage } from './api.js';
+import { ChainError, chainSnapshot, entryLabel, entryState, parseChainEntries, runChain } from './chain.js';
 import { applyChatImagePatches, consolePort, patchBackupStatus, requestConsoleRestart, resolveAppRoot, restoreChatImagePatches } from './chat-image-patch.js';
+import { comfyDraw, comfyEdit, listModels, probe as probeComfy } from './comfyui.js';
 import { DEFAULTS, ID, configGroup, text } from './config.js';
 import { Gallery } from './gallery.js';
 import { samplePng } from './png.js';
@@ -38,14 +40,21 @@ const asText = (value) => (typeof value === 'string' ? value.trim() : '');
 const PACKAGE_DIR = resolve(fileURLToPath(new URL('..', import.meta.url)));
 
 // ---------------------------------------------------------------------------
-// 自愈补丁：安装目录里的两处代码每次启动都对一遍
+// 自愈补丁：QQ 扩展里的两处代码每次启动都对一遍
 // ---------------------------------------------------------------------------
 //
-// 桌宠要在控制台「对话」页发图，得改安装目录里的两份文件（客户端 bundle 的 say 渲染、
-// 桌宠包的 chat.ts/world.ts）。程序自动更新会把这些文件覆写回去，所以靠扩展模块的
-// 顶层代码每次启动重打一遍 —— `loadExtensions()` 无论世界开没开都会 import 本模块。
+// 这里只给**旧版**第三方 QQ 扩展（`cortico-world-qq-better-alont1`，world `qqbot`）打补丁：
+// 它的 `qq_send_image` / `qq_view_image` 只按扩展目录解析相对路径，这里改成先按桌宠工作区
+// （记忆目录）解析、扩展目录兜底。第三方包升级会把这些文件覆写回去，所以靠扩展模块的顶层
+// 代码每次启动重打一遍 —— `loadExtensions()` 无论世界开没开都会 import 本模块。
 //
-// 打好的补丁写回了磁盘，但桌宠包的 TS 是进程启动时 import 的，要重启进程才装载；
+// 官方 `cortico-world-qq`（world `qq`）发图收的是 blob 句柄（`host.blob(...)`），根本不解析
+// 本地路径，用不着补丁；切到它之后 `worlds.qqbot.enabled=false`，这两处会自动记 absent、不碰文件。
+//
+// 0.3.0 起不再往桌宠包里打补丁（改用官方 `pet_say.images`）；早先版本打过的旧补丁会在启动时
+// 按 `.coopanion-orig` 备份还原回去。
+//
+// 打好的补丁写回了磁盘，但扩展的代码是进程启动时 import 的，要重启进程才装载；
 // 重启请求放在 `start()` 里（那时才拿得到控制台端口），并用状态文件防死循环。
 
 /** 最近一次补丁检查的结果；「状态」页显示它，也能手动重打或按备份还原。 */
@@ -58,6 +67,8 @@ let PATCH_STATE = {
   total: 0,
   stuck: false,
   restartPending: false,
+  /** 这次启动从桌宠包里还原掉的旧补丁文件（0.3.0 起才有）。 */
+  reverted: [],
   error: '',
   restart: null,
   /** 手动还原的记录：`{at, restored:[id], failed:[id], byFile:[{file,backup,state}]}`，没还原过就是 null。 */
@@ -77,10 +88,13 @@ function refreshPatchState({ stateDir, log } = {}) {
       .filter((r) => r.state === 'failed' || r.state === 'missing')
       .map((r) => ({ id: r.id, what: r.what, error: r.error ?? '' })),
     done: report.results.filter((r) => r.state === 'done').length,
-    // 可选补丁（第三方扩展没装）记 absent：不计进总数，免得状态页写「7/9 没打上」。
+    // 可选补丁（QQ 扩展没装、或那个世界没开）记 absent：不计进总数，免得状态页写「1/2 没打上」。
     total: report.results.filter((r) => r.state !== 'absent').length,
+    // 切到官方 QQ 扩展后一处都不用打：状态页据此显示「没有要打补丁的 QQ 扩展」。
+    skipped: report.results.filter((r) => r.state === 'absent').length,
     stuck: report.stuck,
     restartPending: report.restartPending,
+    reverted: report.reverted?.filter((r) => r.reverted).map((r) => r.file) ?? [],
     error: report.error ?? '',
     restored: report.patched.length ? null : PATCH_STATE.restored,
   };
@@ -145,6 +159,38 @@ export class ImageWorld {
     return text(this.language);
   }
 
+  /**
+   * 解析模型链：`worlds.image.models`（JSON 数组）优先，空则退回旧的单档配置。
+   * 每次现读，控制台改完即生效。
+   */
+  #chain() {
+    return parseChainEntries(this.#raw('models'), {
+      baseUrl: this.#str('baseUrl'),
+      model: this.#str('model'),
+      apiKeySecret: this.#str('apiKeySecret'),
+      size: this.#str('size'),
+      quality: this.#str('quality'),
+      format: this.#str('format'),
+      timeoutMs: this.#num('timeoutMs', 10000, 900000),
+    });
+  }
+
+  /** 这一档现在能不能用（ComfyUI 只要地址 + ckpt，OpenAI 兼容还要求有密钥）。 */
+  #entryState(entry) {
+    return entryState(entry, { apiKey: this.#entryKey(entry) });
+  }
+
+  /** 能出图的那些档，顺序不变。 */
+  #usableEntries(entries, { forEdit = false } = {}) {
+    return entries.filter((entry) => this.#entryState(entry).ok && (!forEdit || entry.edit));
+  }
+
+  /** 一档都没有时，把每档差在哪拼成一句话。 */
+  #chainReasons(entries) {
+    const lines = entries.map((entry) => `- ${entryLabel(entry)}（${entry.preset}）：${this.#entryState(entry).reason || '可用'}`);
+    return lines.length ? `\n${lines.join('\n')}` : '模型链是空的，去「图片工坊 → 状态 → 模型链」里配一档';
+  }
+
   /** 图片根目录：配置了就用配置的（相对路径按 bot 目录解析），否则 <dataDir>/images。 */
   dir() {
     const raw = String(this.#raw('saveDir') ?? '').trim();
@@ -158,8 +204,7 @@ export class ImageWorld {
    * 先问部署 .env（`ctx.secret`），再退到同级 `providers/<端点>/.env`：
    * 机器上往往已经为画图建过一个端点，密钥名直接填那个就行，不必抄第二份。
    */
-  #keyLookup() {
-    const name = this.#str('apiKeySecret');
+  #keyLookup(name = this.#str('apiKeySecret')) {
     if (!name) return { name, value: '', from: '', provider: '' };
     let own = '';
     try {
@@ -177,6 +222,12 @@ export class ImageWorld {
     };
   }
 
+  /** 某一档要的密钥：先看这一档的 `apiKeySecret`，没写就用全局那个。 */
+  #entryKey(entry) {
+    const name = String(entry?.apiKeySecret ?? '').trim() || this.#str('apiKeySecret');
+    return name ? this.#keyLookup(name).value : '';
+  }
+
   /** 扫 `<botDir>/../providers/<端点>/.env`，找同名变量。 */
   #keyFromProviders(name) {
     const root = resolve(this.botDir, '..', 'providers');
@@ -207,15 +258,50 @@ export class ImageWorld {
 
   #envState() {
     const t = this.#text();
-    const baseUrl = this.#str('baseUrl');
-    const model = this.#str('model');
+    const { entries, error } = this.#chain();
     const key = this.#keyLookup();
-    const name = key.name;
-    const keySet = Boolean(key.value);
-    const extra = { keyFrom: key.from, keyProvider: key.provider };
-    if (!baseUrl) return { ok: false, baseUrl, model, name, keySet, detail: t.readyNoBase, ...extra };
-    if (!keySet) return { ok: false, baseUrl, model, name, keySet, detail: t.readyNoKey, ...extra };
-    return { ok: true, baseUrl, model, name, keySet, detail: t.readyOk(model), ...extra };
+    const base = {
+      name: key.name,
+      keySet: Boolean(key.value),
+      keyFrom: key.from,
+      keyProvider: key.provider,
+      baseUrl: '',
+      model: '',
+      chain: [],
+      chainError: error,
+    };
+    if (error) return { ...base, ok: false, detail: `${t.readyChainBad}：${error}` };
+    const states = entries.map((entry) => ({ entry, state: this.#entryState(entry) }));
+    const chain = states.map(({ entry, state }) => ({
+      name: entryLabel(entry),
+      preset: entry.preset,
+      baseUrl: entry.baseUrl,
+      model: entry.preset === 'comfyui' ? entry.ckpt : entry.model,
+      ok: state.ok,
+      reason: state.reason,
+    }));
+    const usable = states.filter((s) => s.state.ok).map((s) => s.entry);
+    if (!usable.length) {
+      const first = entries[0];
+      const bare = entries.length === 1 && !first?.baseUrl;
+      return {
+        ...base,
+        chain,
+        ok: false,
+        baseUrl: first?.baseUrl ?? '',
+        model: first ? entryLabel(first) : '',
+        detail: bare ? t.readyNoBase : `${t.readyNoChain}${this.#chainReasons(entries)}`,
+      };
+    }
+    const labels = usable.map(entryLabel);
+    return {
+      ...base,
+      chain,
+      ok: true,
+      baseUrl: usable[0].baseUrl,
+      model: labels[0],
+      detail: labels.length > 1 ? t.readyChain(labels.join(' → ')) : t.readyOk(labels[0]),
+    };
   }
 
   // -------------------------------------------------------------------------
@@ -260,38 +346,28 @@ export class ImageWorld {
   async #draw(args) {
     const prompt = asText(args.prompt);
     if (!prompt) return { text: '[image_draw 没执行] prompt 是空的。不想画就别调用。', failed: true };
-    const keyName = this.#str('apiKeySecret');
-    const key = this.apiKey();
-    if (!key) {
-      return {
-        text: `[image_draw 没执行] 没有配置 ${keyName}：请在控制台「图片工坊 → 状态」里填入密钥（或在部署 .env 里写 ${keyName}=...）。`,
-        failed: true,
-      };
-    }
-    const model = this.#str('model');
-    const size = asText(args.size) || this.#str('size');
-    const quality = asText(args.quality) || this.#str('quality');
+    const { entries, error } = this.#chain();
+    if (error) return { text: `[image_draw 没执行] ${error}`, failed: true };
+    const usable = this.#usableEntries(entries);
+    if (!usable.length) return { text: `[image_draw 没执行] 没有能出图的一档：${this.#chainReasons(entries)}`, failed: true };
+    const named = asText(args.model);
+    const size = asText(args.size);
+    const quality = asText(args.quality);
     this.#busy += 1;
     try {
-      const res = await generateImage({
-        baseUrl: this.#str('baseUrl'),
-        apiKey: key,
-        model,
-        prompt,
-        size,
-        quality,
-        format: this.#str('format'),
-        timeoutMs: this.#num('timeoutMs', 10000, 900000),
-      });
+      const res = await runChain(usable, (entry) => this.#generateWith(entry, { prompt, size, quality }), { only: named });
+      const used = res.entry;
+      const label = entryLabel(used);
       const shown = res.revisedPrompt ? String(res.revisedPrompt) : prompt;
       const note = asText(args.note);
+      const dims = res.size || size || used.size || 'auto';
       const { item, warning } = this.#saveSafe({
         bytes: res.bytes,
         mime: res.mime,
         prompt: shown,
         note,
-        model,
-        size: size || 'auto',
+        model: label,
+        size: dims,
         source: 'api',
       });
       return this.#outcome({
@@ -300,10 +376,11 @@ export class ImageWorld {
         mime: res.mime,
         prompt: shown,
         note,
-        model,
-        size: size || 'auto',
+        model: label,
+        size: dims,
         item,
         warning,
+        attempts: res.attempts,
       });
     } catch (err) {
       return this.#failure('image_draw', err);
@@ -322,37 +399,28 @@ export class ImageWorld {
         failed: true,
       };
     }
-    const key = this.apiKey();
-    if (!key) {
-      return { text: `[image_edit 没执行] 没有配置 ${this.#str('apiKeySecret')}。`, failed: true };
-    }
-    const model = this.#str('model');
-    const size = asText(args.size) || this.#str('size');
-    const quality = asText(args.quality) || this.#str('quality');
+    const { entries, error } = this.#chain();
+    if (error) return { text: `[image_edit 没执行] ${error}`, failed: true };
+    const usable = this.#usableEntries(entries, { forEdit: true });
+    if (!usable.length) return { text: `[image_edit 没执行] 没有能改图的一档：${this.#chainReasons(entries)}`, failed: true };
+    const named = asText(args.model);
+    const size = asText(args.size);
+    const quality = asText(args.quality);
     this.#busy += 1;
     try {
-      const res = await editImage({
-        baseUrl: this.#str('baseUrl'),
-        apiKey: key,
-        model,
-        prompt,
-        image: readFileSync(local.path),
-        mime: local.mime,
-        name: local.path.split(/[\\/]/).pop(),
-        size,
-        quality,
-        format: this.#str('format'),
-        timeoutMs: this.#num('timeoutMs', 10000, 900000),
-      });
+      const res = await runChain(usable, (entry) => this.#editWith(entry, { prompt, size, quality, local }), { only: named });
+      const used = res.entry;
+      const label = entryLabel(used);
       const shown = res.revisedPrompt ? String(res.revisedPrompt) : prompt;
       const note = asText(args.note);
+      const dims = res.size || size || used.size || 'auto';
       const { item, warning } = this.#saveSafe({
         bytes: res.bytes,
         mime: res.mime,
         prompt: shown,
         note,
-        model,
-        size: size || 'auto',
+        model: label,
+        size: dims,
         source: 'edit',
       });
       return this.#outcome({
@@ -361,10 +429,11 @@ export class ImageWorld {
         mime: res.mime,
         prompt: shown,
         note,
-        model,
-        size: size || 'auto',
+        model: label,
+        size: dims,
         item,
         warning,
+        attempts: res.attempts,
       });
     } catch (err) {
       return this.#failure('image_edit', err);
@@ -373,6 +442,93 @@ export class ImageWorld {
     }
   }
 
+  /** 用一档后端画一张新图。 */
+  async #generateWith(entry, { prompt, size, quality }) {
+    if (entry.preset === 'comfyui') {
+      const res = await comfyDraw({
+        baseUrl: entry.baseUrl,
+        ckpt: entry.ckpt,
+        unet: entry.unet,
+        textEncoder: entry.textEncoder,
+        textEncoderType: entry.textEncoderType,
+        vaeName: entry.vaeName,
+        loras: entry.loras,
+        negative: entry.negative,
+        prompt,
+        size: size || entry.size,
+        steps: entry.steps,
+        cfg: entry.cfg,
+        sampler: entry.sampler,
+        scheduler: entry.scheduler,
+        workflow: entry.workflow,
+        prefix: 'coopanion',
+        timeoutMs: entry.timeoutMs,
+      });
+      return { bytes: res.bytes, mime: res.mime, revisedPrompt: null, promptId: res.promptId, size: res.size };
+    }
+    const key = this.#entryKey(entry);
+    if (!key) {
+      throw new ImageApiError(`没有配置 ${entry.apiKeySecret || this.#str('apiKeySecret')}：在「图片工坊 → 状态」里填入密钥，或在部署 .env 里写这个变量`, { status: 401 });
+    }
+    return await generateImage({
+      baseUrl: entry.baseUrl,
+      apiKey: key,
+      model: entry.model,
+      prompt,
+      size: size || entry.size,
+      quality: quality || entry.quality,
+      format: entry.format,
+      timeoutMs: entry.timeoutMs,
+    });
+  }
+
+  /** 用一档后端改一张已有的图。 */
+  async #editWith(entry, { prompt, size, quality, local }) {
+    if (entry.preset === 'comfyui') {
+      const res = await comfyEdit({
+        baseUrl: entry.baseUrl,
+        ckpt: entry.ckpt,
+        unet: entry.unet,
+        textEncoder: entry.textEncoder,
+        textEncoderType: entry.textEncoderType,
+        vaeName: entry.vaeName,
+        loras: entry.loras,
+        negative: entry.negative,
+        prompt,
+        image: readFileSync(local.path),
+        mime: local.mime,
+        name: local.path.split(/[\\/]/).pop(),
+        size: size || entry.size,
+        denoise: entry.denoise,
+        steps: entry.steps,
+        cfg: entry.cfg,
+        sampler: entry.sampler,
+        scheduler: entry.scheduler,
+        workflow: entry.workflow,
+        prefix: 'coopanion',
+        timeoutMs: entry.timeoutMs,
+      });
+      return { bytes: res.bytes, mime: res.mime, revisedPrompt: null, promptId: res.promptId, size: res.size };
+    }
+    const key = this.#entryKey(entry);
+    if (!key) {
+      throw new ImageApiError(`没有配置 ${entry.apiKeySecret || this.#str('apiKeySecret')}`, { status: 401 });
+    }
+    return await editImage({
+      baseUrl: entry.baseUrl,
+      apiKey: key,
+      model: entry.model,
+      prompt,
+      image: readFileSync(local.path),
+      mime: local.mime,
+      name: local.path.split(/[\\/]/).pop(),
+      size: size || entry.size,
+      quality: quality || entry.quality,
+      format: entry.format,
+      timeoutMs: entry.timeoutMs,
+    });
+  }
+
   async #list(args) {
     const raw = Number(args.limit);
     const limit = Number.isFinite(raw) ? Math.max(1, Math.min(Math.round(raw), 50)) : 12;
@@ -445,10 +601,13 @@ export class ImageWorld {
     const lines = [spec.verb];
     if (spec.item) lines.push(`文件：${spec.item.path}`);
     lines.push(`参数：${spec.size || '默认尺寸'} · ${spec.model || '默认模型'} · ${kb} KB`);
+    if (Array.isArray(spec.attempts) && spec.attempts.length) {
+      lines.push(`前几档没成：${spec.attempts.map((it) => `${it.name}（${it.message}）`).join('；')}`);
+    }
     if (spec.note) lines.push(`名字：${spec.note}`);
     if (spec.prompt) lines.push(`画面：${spec.prompt}`);
     if (spec.warning) lines.push(spec.warning);
-    lines.push('图已进入本次对话，也显示在「图片工坊」页。要发给某人或某个群，把上面的绝对路径交给 qq_send_image。');
+    lines.push('图已进入本次对话，也显示在「图片工坊」页。要发给某人或某个群，就把上面那行 `[blob …]` 的句柄交给那个世界的发图工具（官方 QQ 扩展是 `qq_draft` 的 `image`；旧版 QQ 扩展是 `qq_send_image`，填文件绝对路径）。');
     return {
       text: lines.join('\n'),
       blobs: [{
@@ -550,6 +709,7 @@ export class ImageWorld {
     if (panel === 'status') {
       switch (method) {
         case 'state': return this.#state();
+        case 'probe': return await this.#probeChain();
         case 'repatch': return this.#repatch();
         case 'restore': return this.#restore();
         case 'restart': return this.#askRestart('控制台手动请求');
@@ -587,6 +747,9 @@ export class ImageWorld {
       keyFrom: env.keyFrom,
       keyProvider: env.keyProvider,
       detail: env.detail,
+      models: this.#raw('models'),
+      chain: env.chain,
+      chainError: env.chainError,
       patch: {
         ...PATCH_STATE,
         packageDir: PACKAGE_DIR,
@@ -596,7 +759,88 @@ export class ImageWorld {
   }
 
   /**
-   * 重新对一遍「对话页发图」补丁。
+   * 逐个探活：ComfyUI 看 `/system_stats`（顺带核对 ckpt 在不在），
+   * OpenAI 兼容看 `/models`（有的端点没这条路由，当作不判定）。
+   * 「状态」页的「测试模型链」用它；只返回结果，不改配置。
+   */
+  async #probeChain() {
+    const { entries, error } = this.#chain();
+    const at = new Date().toISOString();
+    if (error) return { at, error, items: [] };
+    // 探活是给人在面板上点的，宁可「说不清」也不能把 RPC 拖到超时：
+    // 每档最多 6 秒、几档并行，最慢一次也就 6 秒出结果。
+    const cap = (ms) => Math.max(1000, Math.min(Number(ms) > 0 ? Number(ms) : 6000, 6000));
+    const items = await Promise.all(
+      entries.map(async (entry) => {
+        const name = entryLabel(entry);
+        const preset = entry.preset;
+        try {
+          const state = this.#entryState(entry);
+          if (!state.ok) return { name, preset, ok: false, detail: state.reason };
+          if (preset === 'comfyui') {
+            const probe = await probeComfy(entry.baseUrl, { timeoutMs: cap(entry.timeoutMs) });
+            if (!probe.ok) return { name, preset, ok: false, detail: probe.error };
+            const where = probe.gpu ? `（${probe.gpu}）` : '';
+            // 自定义工作流里的文件名都写在模板里，这里只确认服务在线。
+            if (entry.workflow) return { name, preset, ok: true, detail: `在线${where} · 自定义工作流` };
+            const files = await listModels(entry.baseUrl, { timeoutMs: cap(entry.timeoutMs) });
+            // 拿不到清单（老版本 / 路由没有）就只报在线，不硬说文件不在。
+            if (entry.unet) {
+              const miss = [];
+              const check = (list, value, hint) => {
+                if (!value || !list.length || list.includes(value)) return;
+                miss.push(`${hint}：${value}`);
+              };
+              check(files.unets, entry.unet, '没有这个 UNet');
+              check(files.textEncoders, entry.textEncoder, '没有这个文本编码器');
+              check(files.vaes, entry.vaeName, '没有这个 VAE');
+              const label = `${entry.unet} + ${entry.textEncoder || '?'} + ${entry.vaeName || '?'}`;
+              return {
+                name,
+                preset,
+                ok: miss.length === 0,
+                detail: miss.length
+                  ? `在线，但${miss.join('、')}（那边有 ${files.unets.length} 个 UNet / ${files.textEncoders.length} 个文本编码器 / ${files.vaes.length} 个 VAE）`
+                  : `在线${where} · ${label}${files.unets.length ? '' : '（没拿到模型清单，未核对）'}`,
+              };
+            }
+            const ckpts = files.checkpoints;
+            const has = !ckpts.length || ckpts.includes(entry.ckpt);
+            return {
+              name,
+              preset,
+              ok: has,
+              detail: has
+                ? `在线${where} · ${entry.ckpt || '没写 ckpt'}`
+                : `在线，但没有这个 ckpt：${entry.ckpt}（那边装了 ${ckpts.length} 个）`,
+            };
+          }
+          const key = this.#entryKey(entry);
+          const target = `${String(entry.baseUrl ?? '').replace(/[/\s]+$/, '')}/models`;
+          const res = await fetch(target, {
+            headers: key ? { Authorization: `Bearer ${key}` } : {},
+            signal: AbortSignal.timeout(cap(entry.timeoutMs)),
+          });
+          return {
+            name,
+            preset,
+            ok: res.ok || res.status === 404,
+            detail: res.ok
+              ? `在线 · ${entry.model}`
+              : res.status === 404
+                ? `端点没有 /models，跳过检查 · ${entry.model}`
+                : `返回 ${res.status} · ${entry.model}`,
+          };
+        } catch (err) {
+          return { name, preset, ok: false, detail: `连不上：${msg(err)}` };
+        }
+      }),
+    );
+    return { at, error: '', items };
+  }
+
+  /**
+   * 重新对一遍「QQ 发图路径」补丁（顺带还原桌宠包上的旧补丁）。
    *
    * 平时用不着（每次启动都会自己打），留给两处：更新覆写后发现没打上，
    * 或者想看看到底改了哪几处。
@@ -611,10 +855,10 @@ export class ImageWorld {
   }
 
   /**
-   * 按 `.coopanion-orig` 手动还原：把安装目录里的三份文件覆盖回更新下发的原样。
+   * 按 `.coopanion-orig` 手动还原：把改过的文件覆盖回更新下发的原样。
    *
    * 备份不删，所以这是可逆的（再点「重打补丁」或下次启动就会补回来）。
-   * 还原后桌宠那一侧要重启才回到「没有发图功能」，但这里**不自动重启**
+   * 还原后 QQ 发图回到「只认扩展目录的相对路径」，要重启才生效；但这里**不自动重启**
    * ——用户是主动撤销的，等他自己决定。
    */
   #restore() {
@@ -809,7 +1053,7 @@ export class ImageWorld {
     });
     if (PATCH_STATE.error) this.#host?.log?.warn?.(`图片工坊补丁:${PATCH_STATE.error}`);
     if (PATCH_STATE.failed.length) {
-      this.#host?.log?.warn?.(`图片工坊补丁:有 ${PATCH_STATE.failed.length} 处没打上(${PATCH_STATE.failed.map((f) => f.id).join(', ')}),桌宠发图可能不生效`);
+      this.#host?.log?.warn?.(`图片工坊补丁:有 ${PATCH_STATE.failed.length} 处没打上(${PATCH_STATE.failed.map((f) => f.id).join(', ')}),QQ 发图可能不认工作区相对路径`);
     }
     if (PATCH_STATE.restartPending) this.#scheduleRestart('这次启动补上了新补丁');
   }