cortico-world-image 0.2.0 → 0.3.1

package/src/chat-image-patch.js

@@ -1,30 +1,21 @@
 /**
- * 「桌宠把图片发到「对话」页」这件事的运行时补丁。
+ * QQ 扩展里那两处「图片路径」补丁（第三方包：认不出原文就报失败，没装就跳过）。
  *
- * 为什么还需要补丁：框架 0.1.23 起，「say 带图」这条链路本身已经是原生的——
- * `chat.ts` 的 `chatItem()` 里 `wireImages()` 会把事件上的 `blobs` 里 `image/*` 映射成 `images`，
- * `ChatItem` 的 say 变体带着 `images?: WireImage[]`，客户端 bundle 的 say 那段也会画
- * `chat-thumb` 缩略图，`world.ts` 的 `record(meta, text, blobs = [])` 本来就能把附件写进事件。
- * 所以原先针对客户端 bundle / `chat.ts` / `record()` 的那 4 处补丁**全部删掉了**。
+ * 为什么还需要补丁：`qq_send_image` / `qq_view_image` 的本地路径过去一律按**扩展目录**解析，
+ * 于是模型拿工作区里的相对路径（如 `blobs/xx.jpg`）去发就报「本地没有这个文件」。这里改成
+ * **先按桌宠工作区（`memoryDir`）解析、扩展目录兜底**，顺带把两个工具的参数说明改成同一口径
+ * —— 模型只看得到工具说明。
  *
- * 留下来的补丁只做框架原生**没有**的那件事：`pet_say.images` 只认 `[blob …]` 句柄，
- * 不认文件路径，所以「把本地一张图贴进对话页」仍然需要一个按路径收图的工具
- * `pet_show_image`（挂在桌宠世界上，见 `pet-show-image-tool`），
- * 以及它认「相对桌宠工作区」路径的那几处。
+ * 桌宠包本身**不再打任何补丁**（0.3.0 起）。官方 `pet_say` 从桌宠包 0.2.0 起就收
+ * `images: Array<handle>`，而本扩展 `image_draw` / `image_edit` / `image_show` 的回执本来就带
+ * `blobs`，框架会把它们渲染成 `[blob …]` 句柄交给模型 —— 模型直接
+ * `pet_say({ script: '', images: ['<句柄>'] })` 就能把图贴到「对话」页，不必再往桌宠包里注入工具。
+ * 早先版本注入过 `pet_show_image` 与它的相对路径支持（`world.ts` 5 处 + `definition.ts` 2 处），
+ * `revertObsoletePetPatches()` 负责把那样的旧安装用 `.coopanion-orig` 还原成原样。
  *
  * 这些文件都在安装目录里，而程序会自动更新、把变动覆写掉，所以每次启动都由本模块
  * 重新检查一遍：认得出的原文就改写，已经打过的跳过，认不出来就记一条失败并在控制台
- * 状态页报出来 —— 绝不猜着改。（文件同时留一份 `.coopanion-orig` 备份，只存第一次的原文。）
- *
- * 补丁一律幂等：靠 detect 文本（以及插进 `tools()` 那段的 `/*COOPANION_CHAT_IMAGE_TOOL*\/` 标记）。
- *
- * 还有一处跟「图片路径」有关的补丁落在 QQ 扩展（`cortico-world-qq-better-alont1`）上：
- * `qq_send_image` / `qq_view_image` 的本地路径过去一律按**扩展目录**解析，于是桌宠拿
- * `blobs/xx.jpg`（工作区里的图）去发就报「本地没有这个文件」，只能写死绝对路径。
- * 这里把它改成**先按桌宠工作区（`memoryDir` = `<botDir>/workspace`）解析、扩展目录兜底**，
- * 顺带把两个工具的参数说明改成同样口径 —— 模型只看得到工具说明。
- * 那是第三方包（pnpm 装在 `.pnpm/` 下、升级会换目录），所以同样走
- * 「认得出原文才改 + 留备份 + 可还原」，装不到就记 `absent`、不算失败。
+ * 状态页报出来 —— 绝不猜着改。补丁一律幂等：靠 detect 文本判断。
  */
 import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
@@ -142,158 +133,6 @@ function withImport(text, mod, want) {
   return { text: text.replace(cur.whole, () => next) };
 }
 
-/** 我们插进 `tools()` 的那一小段（带标记，认得出自己插过什么）。 */
-const TOOL_PIECE = '{ /*COOPANION_CHAT_IMAGE_TOOL*/ ...CHAT_IMAGE_TOOL, handler: (args) => this.showImage(args) }';
-
-/** 自己插过的旧写法（曾经把 `.map(…)` 又包了一层 `[...]`，结果 6 个工具全变成 null）。 */
-const TOOL_PIECE_OLD = [
-  /, \{ \/\*COOPANION_CHAT_IMAGE_TOOL\*\/ \.\.\.CHAT_IMAGE_TOOL, handler: \(args\) => this\.showImage\(args\) \}/,
-  /, \{ \.\.\.CHAT_IMAGE_TOOL, handler: \(args\) => this\.showImage\(args\) \}/,
-];
-
-/** 剥掉我们插过的那一段，拿回「原始的 return 表达式」。 */
-function unwrapToolsExpr(expr) {
-  let e = String(expr).trim();
-  for (const re of TOOL_PIECE_OLD) {
-    const m = re.exec(e);
-    if (m) { e = e.slice(0, m.index).trim(); break }
-  }
-  if (e.startsWith('[...[].concat(')) {
-    e = e.slice('[...[].concat('.length).trim();
-    if (e.endsWith(')]')) e = e.slice(0, -2).trim();
-    else if (e.endsWith(')')) e = e.slice(0, -1).trim();
-    return e;
-  }
-  if (e.startsWith('[') && e.endsWith(']')) return e.slice(1, -1).trim();
-  if (e.startsWith('[')) return e.slice(1).trim();
-  return e;
-}
-
-/**
- * `tools()` 里那句 `return …;` —— 0.1.19 是 `DESKTOP_PET_TOOL_DECLS.map(…)`，
- * 0.1.21 变成 `petToolDecls(this.appLanguage).map(…)`，所以整句按原文抓，
- * 再用 `[].concat(…)` **摊平**着把我们的工具接上去。
- *
- * 为什么不写 `[${expr}, TOOL]`：`expr` 本身就是数组，那么写会变成嵌套数组，
- * 框架读出来的 6 个工具名会全变 null（0.1.21 上真翻过这个车）。
- * 已经打过的（含旧的嵌套写法）先剥掉再重写，所以重复跑是安全的。
- */
-function patchToolsReturn(text) {
-  const head = /tools\(\): ToolDef\[\] \{/.exec(text);
-  if (!head) return { error: '没找到 tools() 方法' };
-  const seg = text.slice(head.index, head.index + 3000);
-  const rm = /^([ \t]*)return ([^\n]*);$/m.exec(seg);
-  if (!rm) return { error: '没找到 tools() 里的 return' };
-  const expr = unwrapToolsExpr(rm[2]);
-  if (!expr || /CHAT_IMAGE_TOOL/.test(expr)) return { error: `认不出原始的 return 表达式:${rm[2].slice(0, 80)}` };
-  const next = `${rm[1]}return [...[].concat(${expr}), ${TOOL_PIECE}];`;
-  const start = head.index + rm.index;
-  return { text: text.slice(0, start) + next + text.slice(start + rm[0].length) };
-}
-
-const WORLD_EXTRA = [
-  '/** coopanion-chat-image: `pet_show_image` 认的图片后缀，文件头嗅探优先。 */',
-  "const IMAGE_MIME_BY_EXT: Record<string, string> = {",
-  "  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif',",
-  '};',
-  '',
-  '/** coopanion-chat-image: 按文件头认图片，认不出来才退回后缀。 */',
-  'function sniffImageMime(bytes: Buffer): string | null {',
-  '  if (bytes.length > 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) return \'image/png\';',
-  '  if (bytes.length > 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return \'image/jpeg\';',
-  "  if (bytes.length > 12 && bytes.subarray(0, 4).toString('latin1') === 'RIFF' && bytes.subarray(8, 12).toString('latin1') === 'WEBP') return 'image/webp';",
-  "  if (bytes.length > 6 && bytes.subarray(0, 6).toString('latin1').startsWith('GIF8')) return 'image/gif';",
-  '  return null;',
-  '}',
-  '',
-  '/** coopanion-chat-image: 贴图工具；tags 里没有 speak，所以 CosyVoice 那类只认 `pet_say` 的扩展不会碰它。 */',
-  "const CHAT_IMAGE_TOOL: Omit<ToolDef, 'handler'> = {",
-  "  name: 'pet_show_image',",
-  "  tags: ['act'],",
-  "  description: '把本地一张图片贴到「对话」页(桌宠这一侧),配文可选。图先画好/存好再调用;只认 PNG、JPEG、WebP、GIF,单张不超过 8 MB。',",
-  '  parameters: {',
-  "    type: 'object',",
-  '    properties: {',
-  "      path: { type: 'string', description: '图片文件的完整路径。' },",
-  "      caption: { type: 'string', maxLength: 200, description: '配文,一句话;不写就只贴图。' },",
-  '    },',
-  "    required: ['path'],",
-  '  },',
-  '};',
-].join('\n');
-
-const SHOW_IMAGE_METHOD = [
-  '  /**',
-  '   * coopanion-chat-image: 把一张本地图片贴到「对话」页。',
-  '   *',
-  '   * 图片随事件存成附件(blobs),页面用 `chat.blob` 取回;只写对话记录,不碰气泡窗口,',
-  '   * 所以桌宠窗口没连接也能用。',
-  '   */',
-  '  private async showImage(args: Record<string, unknown>): Promise<ToolOutcome> {',
-  "    const raw = typeof args.path === 'string' ? args.path.trim() : '';",
-  "    const caption = typeof args.caption === 'string' ? args.caption.trim().slice(0, 200) : '';",
-  "    if (!raw) return { text: '[pet_show_image 没执行] 要给图片的完整路径。', failed: true };",
-  "    if (!isAbsolute(raw)) return { text: '[pet_show_image 没执行] 需要完整路径(例如 C:\\\\Users\\\\...\\\\pic.png)。', failed: true };",
-  '    let bytes: Buffer;',
-  '    try {',
-  '      bytes = readFileSync(raw);',
-  '    } catch (err) {',
-  '      return { text: `[pet_show_image 没执行] 这个文件读不到:${(err as Error).message}`, failed: true };',
-  '    }',
-  '    const mime = sniffImageMime(bytes) ?? IMAGE_MIME_BY_EXT[extname(raw).toLowerCase()];',
-  "    if (!mime) return { text: '[pet_show_image 没执行] 这不是 PNG / JPEG / WebP / GIF 图片。', failed: true };",
-  '    if (bytes.length > IMAGE_MAX_BYTES) {',
-  '      return { text: `[pet_show_image 没执行] 这张图 ${(bytes.length / 1048576).toFixed(1)} MB,超过 ${IMAGE_MAX_BYTES / 1048576} MB 了。`, failed: true };',
-  '    }',
-  "    if (!this.host) return { text: '[pet_show_image 没执行] 现在没连着对话记录。', failed: true };",
-  "    const name = basename(raw).slice(0, 120) || 'image';",
-  '    const cursor = await this.record(',
-  "      { kind: 'say', beats: caption ? [{ text: caption }] : [] },",
-  '      caption,',
-  '      [{ bytes, mime, name, fallbackText: `对话页配图:${name}(${mime},${bytes.length} 字节)` }],',
-  '    );',
-  "    if (cursor === null) return { text: '[pet_show_image 没执行] 对话记录没能保存。', failed: true };",
-  "    const shown = this.chat.size ? '对话页正开着,图已经贴上去了。' : '对话页没开,打开就能看到。';",
-  '    return { text: `已把 ${name}(${mime},${(bytes.length / 1024).toFixed(0)} KB)贴到「对话」页${caption ? `,配文「${caption}」` : \'\'}。${shown}` };',
-  '  }',
-].join('\n');
-
-// ---------------------------------------------------------------------------
-// 桌宠自己那份：`pet_show_image` 也认相对工作区的路径
-// ---------------------------------------------------------------------------
-
-/**
- * 上面两段载荷（`WORLD_EXTRA` 的工具表 + `SHOW_IMAGE_METHOD` 的实现）**故意保持旧写法**，
- * 由下面这条补丁在原文里就地改写。这样「全新安装」和「早先打过旧版补丁的安装」走的是同一条路
- * （旧文本 → 新文本），不会出现两种终态。
- *
- * 注意：`SHOW_IMAGE_METHOD` 里是 `this.record(meta, text, blobs)` 三参调用 —— 框架 0.1.23 起
- * `record()` 原生就收第三个 `blobs` 参数，所以这里不再需要 `pet-record-blobs` 那处签名补丁。
- */
-const PET_WORKSPACE_OPTION_ANCHOR = '  avatarFile?: string;';
-const PET_WORKSPACE_OPTION = [
-  '  /** coopanion-chat-image: 桌宠工作区(相对图片路径按它解析);装配层给,没给就只能用绝对路径。 */',
-  '  workspaceDir?: () => string;',
-].join('\n');
-
-/** 装配层在 `definition.ts` 里补的那一行（`join` 那儿的 import 本来就有）。 */
-const PET_WORKSPACE_WIRE_ANCHOR = '        avatarFile: join(ctx.botDir, AVATAR_FILE),';
-const PET_WORKSPACE_WIRE = "        workspaceDir: () => join(ctx.botDir, 'workspace'),";
-
-const PET_WORKSPACE_DONE = 'raw = join(ws, raw);';
-const PET_RAW_OLD = "    const raw = typeof args.path === 'string' ? args.path.trim() : '';";
-const PET_RAW_NEW = "    let raw = typeof args.path === 'string' ? args.path.trim() : '';";
-const PET_PATH_GUARD_OLD = "    if (!isAbsolute(raw)) return { text: '[pet_show_image 没执行] 需要完整路径(例如 C:\\\\Users\\\\...\\\\pic.png)。', failed: true };";
-const PET_PATH_GUARD_NEW = [
-  '    if (!isAbsolute(raw)) {',
-  "      const ws = (this.opts.workspaceDir?.() ?? '').trim();",
-  "      if (!ws) return { text: '[pet_show_image 没执行] 相对路径没有工作区可拼;请给完整路径(例如 C:\\\\Users\\\\...\\\\pic.png)。', failed: true };",
-  '      raw = join(ws, raw);',
-  '    }',
-].join('\n');
-const PET_PATH_HINT_OLD = "description: '图片文件的完整路径。'";
-const PET_PATH_HINT_NEW = "description: '图片路径:绝对路径,或相对桌宠工作区的路径(例如 blobs/xx.jpg)。'";
-
 // ---------------------------------------------------------------------------
 // QQ 扩展那两处：本地图片路径按桌宠工作区解析（第三方包，认不出原文就报失败）
 // ---------------------------------------------------------------------------
@@ -351,101 +190,43 @@ const hintNeedsWork = (text, h) => !text.includes(h.to) && [].concat(h.from).som
  * `apply` 返回新文本或 `{ error }`。全部按顺序跑，互不依赖。
  */
 export function patchSpecs(appRoot) {
-  const pet = join(appRoot, 'node_modules', PET_PKG, 'src');
   const qq = qqWorldFile(appRoot);
   const specs = [
-    { id: 'pet-fs-import', file: join(pet, 'world.ts'), what: '桌宠包导入 readFileSync' },
-    { id: 'pet-path-import', file: join(pet, 'world.ts'), what: '桌宠包导入 basename/extname/isAbsolute' },
-    { id: 'pet-show-image-tool', file: join(pet, 'world.ts'), what: 'pet_show_image 工具与它的实现' },
-    // 这三处让 pet_show_image 也认「相对桌宠工作区」的路径；最后一条依赖上面那条先插好方法。
-    { id: 'pet-workspace-option', file: join(pet, 'world.ts'), what: '桌宠包选项加 workspaceDir' },
-    { id: 'pet-workspace-relpaths', file: join(pet, 'world.ts'), what: 'pet_show_image 认工作区相对路径' },
-    { id: 'pet-workspace-wire', file: join(pet, 'definition.ts'), what: '装配层把工作区喂给桌宠世界' },
-    // 这两处落在第三方 QQ 扩展上：没装就记 absent（不算失败），装了才改。
-    { id: 'qq-image-relpaths', file: qq, what: 'QQ 发图/看图认工作区相对路径', optional: true },
-    { id: 'qq-image-hints', file: qq, what: 'QQ 发图/看图的说明写明相对工作区', optional: true },
+    // 这两处落在第三方 QQ 扩展（qq-better）上：没装、或那个世界没开，就记 absent（不算失败）。
+    // 官方 `cortico-world-qq` 发图按 blob 句柄，不解析本地路径，用不着补丁。
+    { id: 'qq-image-relpaths', file: qq, what: 'QQ 发图/看图认工作区相对路径', optional: true, worldId: 'qqbot' },
+    { id: 'qq-image-hints', file: qq, what: 'QQ 发图/看图的说明写明相对工作区', optional: true, worldId: 'qqbot' },
   ];
   return specs;
 }
 
+/**
+ * 宿主配置里那个世界开没开（`worlds.<id>.enabled`）。
+ *
+ * 补丁改的是某个第三方扩展的源码：那个世界没在跑，改了也只是给一份不加载的文件留个备份，
+ * 状态页还会写「2 处都在」——看起来像在维护一个根本不生效的东西。所以这里读一下开关。
+ * 配置读不到时返回 `{ known: false, enabled: true }`：不猜，照旧打补丁。
+ */
+export function worldSwitch(appRoot, worldId) {
+  if (!worldId) return { known: false, enabled: true };
+  const files = [];
+  if (appRoot) files.push(join(dirname(dirname(resolve(appRoot))), 'data', 'home', 'companion', 'config.json'));
+  files.push(join(process.cwd(), 'data', 'home', 'companion', 'config.json'));
+  for (const file of files) {
+    try {
+      const world = JSON.parse(readFileSync(file, 'utf8'))?.worlds?.[worldId];
+      if (world && typeof world === 'object') return { known: true, enabled: world.enabled !== false };
+    } catch {
+      // 读不到就试下一个。
+    }
+  }
+  return { known: false, enabled: true };
+}
+
 /** 一处补丁的改写规则（拆出来是为了能在副本上单测）。 */
 export function rulesFor(id) {
   const nl = (text) => (text.includes('\r\n') ? '\r\n' : '\n');
   switch (id) {
-    case 'pet-fs-import':
-      return {
-        done: (text) => importHas(text, 'node:fs', ['readFileSync']),
-        apply: (text) => withImport(text, 'node:fs', ['readFileSync']),
-      };
-    case 'pet-path-import':
-      return {
-        done: (text) => importHas(text, 'node:path', ['basename', 'extname', 'isAbsolute']),
-        apply: (text) => withImport(text, 'node:path', ['basename', 'extname', 'isAbsolute']),
-      };
-    case 'pet-show-image-tool':
-      return {
-        // 必须连标记一起要求：只认「工具表和实现都在」会让上一版写坏的
-        // `[EXPR, TOOL]`（嵌套数组）被当成已完成，6 个老工具名就一直是 null。
-        done: (text) =>
-          text.includes('const CHAT_IMAGE_TOOL') &&
-          text.includes('this.showImage(args)') &&
-          text.includes('/*COOPANION_CHAT_IMAGE_TOOL*/'),
-        apply: (text) => {
-          let work = text;
-          // 这两段插过一次就不再插（否则报 Identifier 'CHAT_IMAGE_TOOL' has already been declared）。
-          if (!work.includes('const IMAGE_MIME_BY_EXT: Record<string, string> = {')) {
-            const withTool = swap(work, 'export class DesktopPetWorld implements World {', `${asWritten(WORLD_EXTRA, nl(work))}\n\nexport class DesktopPetWorld implements World {`);
-            if (withTool === null) return { error: '没找到 DesktopPetWorld 的类声明' };
-            work = withTool;
-          }
-          if (!work.includes('private async showImage(args: Record<string, unknown>): Promise<ToolOutcome> {')) {
-            const withMethod = swap(work, '  private notConnected(tool: string): ToolOutcome {', `${asWritten(SHOW_IMAGE_METHOD, nl(work))}\n\n  private notConnected(tool: string): ToolOutcome {`);
-            if (withMethod === null) return { error: '没找到 notConnected()（插方法的锚点）' };
-            work = withMethod;
-          }
-          const out = patchToolsReturn(work);
-          if (out.error) return { error: out.error };
-          return { text: out.text };
-        },
-      };
-    case 'pet-workspace-option':
-      return {
-        done: (text) => text.includes('workspaceDir?: () => string;'),
-        apply: (text) => {
-          const block = asWritten(PET_WORKSPACE_OPTION, nl(text));
-          const out = swap(text, PET_WORKSPACE_OPTION_ANCHOR, `${PET_WORKSPACE_OPTION_ANCHOR}\n${block}`);
-          return out === null ? { error: `没找到 ${PET_WORKSPACE_OPTION_ANCHOR}（桌宠包版本变了）` } : { text: out };
-        },
-      };
-    case 'pet-workspace-relpaths':
-      return {
-        // 认「相对路径真的拼上工作区」那段：只认到工具表里的说明不算打过。
-        done: (text) => text.includes(PET_WORKSPACE_DONE),
-        apply: (text) => {
-          let work = text;
-          if (!importHas(work, 'node:path', ['isAbsolute', 'join'])) {
-            const p = withImport(work, 'node:path', ['isAbsolute', 'join']);
-            if (p.error) return { error: `补 node:path 导入失败：${p.error}` };
-            work = p.text;
-          }
-          const letRaw = swap(work, PET_RAW_OLD, PET_RAW_NEW);
-          if (letRaw === null) return { error: `没找到 ${PET_RAW_OLD.trim()}（pet-show-image-tool 还没打上?）` };
-          const guard = swap(letRaw, PET_PATH_GUARD_OLD, asWritten(PET_PATH_GUARD_NEW, nl(work)));
-          if (guard === null) return { error: `没找到只认绝对路径的那行：${PET_PATH_GUARD_OLD.trim()}` };
-          const hint = swap(guard, PET_PATH_HINT_OLD, PET_PATH_HINT_NEW);
-          if (hint === null) return { error: `工具说明对不上：${PET_PATH_HINT_OLD}` };
-          return { text: hint };
-        },
-      };
-    case 'pet-workspace-wire':
-      return {
-        done: (text) => text.includes(PET_WORKSPACE_WIRE),
-        apply: (text) => {
-          const line = asWritten(PET_WORKSPACE_WIRE, nl(text));
-          const out = swap(text, PET_WORKSPACE_WIRE_ANCHOR, `${PET_WORKSPACE_WIRE_ANCHOR}\n${line}`);
-          return out === null ? { error: `没找到 ${PET_WORKSPACE_WIRE_ANCHOR}（桌宠包版本变了）` } : { text: out };
-        },
-      };
     case 'qq-image-relpaths':
       return {
         // 助手在 + 两处都换了才算打过（助手没插上就调用它会是 ReferenceError）。
@@ -506,9 +287,39 @@ export function rulesFor(id) {
 }
 
 /**
- * 检查并补齐所有补丁。
+ * 0.3.0 起不再往桌宠包里打补丁。早先版本注入过 `pet_show_image`（`world.ts` 的工具与实现、
+ * `definition.ts` 的自描述与工作区接线），这里把那样的安装用 `.coopanion-orig` 还原成原样。
+ * 只认「文件里还有我们的标记」的文件：桌宠包自己升级过（标记没了）就一律不动。
+ */
+export function revertObsoletePetPatches(appRoot, { log } = {}) {
+  const out = [];
+  if (!appRoot) return out;
+  const dir = join(appRoot, 'node_modules', PET_PKG, 'src');
+  for (const name of ['world.ts', 'definition.ts']) {
+    const file = join(dir, name);
+    const backup = `${file}.coopanion-orig`;
+    if (!existsSync(file) || !existsSync(backup)) continue;
+    try {
+      const text = readFileSync(file, 'utf8');
+      const ours = text.includes('coopanion-chat-image')
+        || text.includes('COOPANION_CHAT_IMAGE_TOOL')
+        || text.includes("name: 'pet_show_image'");
+      if (!ours) continue;
+      copyFileSync(backup, file);
+      log?.info?.(`图片工坊补丁:桌宠包 ${name} 已还原（0.3.0 起不再注入 pet_show_image）`);
+      out.push({ file, reverted: true });
+    } catch (err) {
+      log?.warn?.(`图片工坊补丁:桌宠包 ${name} 还原失败:${msg(err)}`);
+      out.push({ file, reverted: false, error: msg(err) });
+    }
+  }
+  return out;
+}
+
+/**
+ * 检查并补齐所有补丁（先还原早先版本打在桌宠包上的旧补丁）。
  *
- * 返回 `{ appRoot, results, patched, failed, restartPending, stuck }`；
+ * 返回 `{ appRoot, results, patched, failed, restartPending, stuck, reverted }`；
  * `results[i]` 是 `{ id, what, file, state, error? }`，state 取 `patched`/`done`/`failed`/`missing`
  * （目标文件不在）——`optional` 的补丁没装那个扩展时记 `absent`，不计失败也不计「缺」。
  */
@@ -519,10 +330,26 @@ export function applyChatImagePatches(appRoot, { stateDir, log } = {}) {
     log?.warn?.(`图片工坊补丁:${error}`);
     return { appRoot, results, patched: [], failed: ['*'], restartPending: false, stuck: false, error };
   }
+  const reverted = revertObsoletePetPatches(appRoot, { log });
   for (const spec of patchSpecs(appRoot)) {
     const rules = rulesFor(spec.id);
     const name = spec.file ? basename(spec.file) : '(没找到)';
     const backup = spec.file ? `${spec.file}.coopanion-orig` : '';
+    // 那个世界没在跑：不改它的文件（换了官方 QQ 扩展时就是这种情形）。
+    const sw = worldSwitch(appRoot, spec.worldId);
+    if (sw.known && !sw.enabled) {
+      results.push({
+        id: spec.id,
+        what: spec.what,
+        file: spec.file,
+        backup,
+        state: 'absent',
+        optional: Boolean(spec.optional),
+        worldId: spec.worldId,
+        error: `${spec.id}: 世界「${spec.worldId}」没启用(worlds.${spec.worldId}.enabled=false)，跳过`,
+      });
+      continue;
+    }
     if (!spec.file || !existsSync(spec.file)) {
       const gone = spec.optional ? 'absent' : 'missing';
       results.push({
@@ -570,7 +397,8 @@ export function applyChatImagePatches(appRoot, { stateDir, log } = {}) {
   }
   const sameApp = Boolean(prev && prev.appRoot === resolve(appRoot));
   const stuck = Boolean(sameApp && prev.requested === true && patched.some((id) => (prev.patched ?? []).includes(id)));
-  const restartPending = patched.length > 0 && !stuck;
+  const changed = patched.length > 0 || reverted.some((r) => r.reverted);
+  const restartPending = changed && !stuck;
   if (stateFile) {
     try {
       mkdirSync(dirname(stateFile), { recursive: true });
@@ -579,6 +407,7 @@ export function applyChatImagePatches(appRoot, { stateDir, log } = {}) {
         appRoot: resolve(appRoot),
         patched,
         failed,
+        reverted: reverted.filter((r) => r.reverted).map((r) => basename(r.file)),
         requested: restartPending || (sameApp && prev.requested === true && stuck),
       }, null, 2)}\n`, 'utf8');
     } catch (err) {
@@ -588,7 +417,7 @@ export function applyChatImagePatches(appRoot, { stateDir, log } = {}) {
   if (stuck) {
     log?.warn?.('图片工坊补丁:上一轮已经为同一处补丁请求过重启,这次仍然缺,先不再重启;请在「图片工坊」状态页点「重打补丁」');
   }
-  return { appRoot, results, patched, failed, restartPending, stuck };
+  return { appRoot, results, patched, failed, restartPending, stuck, reverted };
 }
 
 /**
@@ -598,6 +427,8 @@ export function patchBackupStatus(appRoot) {
   const out = [];
   if (!appRoot || !looksLikeApp(appRoot)) return out;
   for (const spec of patchSpecs(appRoot)) {
+    const sw = worldSwitch(appRoot, spec.worldId);
+    if (sw.known && !sw.enabled) continue;
     const backup = spec.file ? `${spec.file}.coopanion-orig` : '';
     const hasFile = Boolean(spec.file && existsSync(spec.file));
     // 可选的第三方扩展没装：整行不出现（状态页按行数算「已打 n/总数」）。

package/src/config.js

@@ -28,7 +28,7 @@ const ZH = {
   lamp: '画图接口',
   badgeWorks: '作品',
   badgeKey: '密钥',
-  badgePatch: '发图补丁',
+  badgePatch: 'QQ 发图路径',
   patchOk: '在',
   patchPending: '待重启',
   patchMissing: (n) => `缺 ${n} 处`,
@@ -81,7 +81,7 @@ const EN = {
   lamp: 'Image API',
   badgeWorks: 'Pictures',
   badgeKey: 'API key',
-  badgePatch: 'Chat images',
+  badgePatch: 'QQ image paths',
   patchOk: 'in place',
   patchPending: 'restart needed',
   patchMissing: (n) => `${n} missing`,

package/src/world.js

@@ -38,14 +38,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 +65,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 +86,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,
   };
@@ -448,7 +460,7 @@ export class ImageWorld {
     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: [{
@@ -596,7 +608,7 @@ export class ImageWorld {
   }
 
   /**
-   * 重新对一遍「对话页发图」补丁。
+   * 重新对一遍「QQ 发图路径」补丁（顺带还原桌宠包上的旧补丁）。
    *
    * 平时用不着（每次启动都会自己打），留给两处：更新覆写后发现没打上，
    * 或者想看看到底改了哪几处。
@@ -611,10 +623,10 @@ export class ImageWorld {
   }
 
   /**
-   * 按 `.coopanion-orig` 手动还原：把安装目录里的三份文件覆盖回更新下发的原样。
+   * 按 `.coopanion-orig` 手动还原：把改过的文件覆盖回更新下发的原样。
    *
    * 备份不删，所以这是可逆的（再点「重打补丁」或下次启动就会补回来）。
-   * 还原后桌宠那一侧要重启才回到「没有发图功能」，但这里**不自动重启**
+   * 还原后 QQ 发图回到「只认扩展目录的相对路径」，要重启才生效；但这里**不自动重启**
    * ——用户是主动撤销的，等他自己决定。
    */
   #restore() {
@@ -809,7 +821,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('这次启动补上了新补丁');
   }