minecodex 1.2.1 → 2.0.0

package/README.md

@@ -11,10 +11,12 @@ MineCodex 给 Codex Desktop 增加一组轻量、本地优先的扩展功能。
 | 插件 | 说明 |
 | --- | --- |
 | **Model Slider** | 更清晰、更顺滑的模型切换面板：具备品牌标识、常用收藏与流畅交互 |
-| **Notes** | 跨会话管理待办事项、常用提示词与文件，可随时从 Codex 工具栏快速复用 |
-| **Images** | 集中浏览生成的图片、Prompt 和来源任务，轻松保存原图或快速返回原会话 |
+| **Prompts** | 专页分类管理提示词与调用统计，输入框 Quick Prompts 快速调用 |
+| **Usage Meter** | 在 Help 与 Account 之间显示剩余额度环，悬浮查看周 / 五小时额度，点击进入 Usage 设置 |
+| **Images** | 在原生 Library 图片详情中查看并复制提示词 |
 | **Hide Upsell Banner** | 隐藏输入框上方的用量提示横幅，仅优化界面展示，不影响正常的用量统计 |
 | **Session Status** | 在输入框下方查看当前任务的步骤、观测速度、Token 用量与上下文明细 |
+| **Task Switcher** | 点击聊天标题或标签页前的任务按钮，查看并切换工作中与未读会话 |
 
 ## 安装
 
@@ -54,7 +56,7 @@ mcx open
 
 ## 工作原理
 
-MineCodex 统一管理 Codex 内的菜单入口、主题风格与界面适配。Model Slider、Notes、Images 各自管理数据与操作页面；Session Status 只读汇总本机 Codex 会话事件，Hide Upsell Banner 优化界面展示。所有功能按需开启，关闭后即停止运行。
+MineCodex 统一管理 Codex 内的菜单入口、主题风格与界面适配。Model Slider、Prompts 各自管理操作界面，Images 增强原生 Library 的提示词查看；Session Status 只读汇总本机 Codex 会话事件，Hide Upsell Banner 优化界面展示。所有功能按需开启，关闭后即停止运行。
 
 ## 开发
 
@@ -69,3 +71,7 @@ npm run pack:audit
 ## 许可
 
 MineCodex 是非官方独立扩展项目，与 OpenAI 无关联。项目自有代码以 MIT License 授权；第三方图标、品牌和兼容资产遵循各自的权利说明，见 [`features/model-slider/THIRD_PARTY_NOTICES.md`](features/model-slider/THIRD_PARTY_NOTICES.md) 与 [`features/session-status/vendor/lucide-LICENSE`](features/session-status/vendor/lucide-LICENSE)。
+
+### Sidebar Focus / 侧栏聚焦
+
+展开侧栏时，点击铃铛与搜索之间的聚焦按钮，保留当前任务路径并收起其他分支。再次点击恢复原先布局；切换任务时跟随路径，手动调整分支时退出聚焦。

package/features/images/README.md

@@ -1,107 +1,25 @@
-# CodexImageHost
+# Images · Library 提示词
 
-CodexImageHost 给 Codex 增加一个轻量的 `Images` 入口。它自动汇集不同 Thread 中的 ImageGen PNG，但不复制图片。
+Images 在 Codex 原生 **Library → 图片详情**中补充提示词查看能力。
 
-## 当前功能
+- 有可追溯的提示词时，在缩放胶囊左侧显示 **Prompt / 提示词**。
+- 点击后，使用原生 Version history 相同布局和 design token 的右侧面板展示内容。
+- 面板只展示提示词正文，支持一键复制；优先使用生成提示词，否则追溯该图片的用户输入。
+- 未找到提示词、普通上传图片或来源对话不可用时，不显示按钮。
+- 切换图片或关闭详情会移除旧内容；Escape 先关闭提示词面板。
 
-- 服务先初始化路径索引并开放 HTTP health，再在后台扫描 `~/.codex/generated_images` 中已有的图片；扫描完成后开始文件监听。
-- 运行时监听新图片，自动加入 Images。
-- 通过 All images、Chats 或有图片的 Project 筛选来源；数量直接显示在筛选菜单中。
-- 工具栏内直接提供 2–6 列 Grid 滑条，使用无描边的 4px 轨道；首次打开按可用宽度给一个初始列数，之后只记住用户自己的选择。每张卡片显示来源 Project 或独立 Chat，以及生成时间。
-- 可按 Thread 聚合成图板；进入图板后，左侧图片选择带只保留该 Thread 的图片，关闭详情即返回原图板位置。
-- 标题栏固定在独立滚动区上方；图片按 36 张一批渐进加载，滚动条保持至少 48px 的可抓取高度。
-- 点击图片后，以左侧图片选择带 + 右侧详情区的 20/80 布局查看原图。
-- 按需读取该次 ImageGen 实际使用的 Prompt，并显示 Project、Thread、尺寸、时间与文件大小。
-- 通过 `Save as` 打开 macOS 系统保存面板并保存原始 PNG。
-- 从详情区通过 `Open Thread` 打开真实来源 Thread。
-- 已归档 Thread 的图片仍可查看和 Save as，但 `Open Thread` 会禁用并在悬浮时说明原因。
-- 通过上层同级项目 `CodexRuntimeHost` 启动一个统一宿主，在 Codex 左侧栏注册 Images。
+新版不再在 Sites 下方注入独立 Images 入口，也不启动第二套图库服务。
+图片浏览、编辑与下载使用 Codex 原生能力。读取仅在本机原生 Renderer 内完成，
+沿用当前登录态，不复制图片或持久化来源对话。
 
-不包含收藏按钮、图片副本、Asset Store、标签、Collection 或删除功能。Codex 的 PNG 是原图，SQLite 只是路径索引。
+## 开发
 
-## 运行
-
-需要 Node.js 22.5 或更高版本，不需要安装第三方 npm 依赖。
-
-启动统一宿主；它会读取 `codex-feature.json`、启动 Images 服务并注册侧边入口：
-
-```bash
-npm start
-```
-
-只启动独立 Web UI：
-
-```bash
-npm run service
-```
-
-然后打开 <http://127.0.0.1:47831>。
-
-运行测试：
+统一宿主通过 `codex-feature.json` 注册 `src/library-prompt-page.mjs` 页面脚本。
+原生 DOM 或 API 契约缺失时不注入。视觉契约见 [DESIGN.md](DESIGN.md)。
 
 ```bash
-npm test
-```
-
-服务运行时，路径索引默认保存在 `~/.codex-image-host/library.sqlite`。统一宿主暂时沿用 `~/.codex-image-host/codex-profile`，避免迁移后丢失现有专用 Codex 实例状态。项目不会写入或删除 `~/.codex/generated_images` 中的文件。
-
-## 精简结构
-
-```text
-~/.codex/generated_images
-        │ scan + watch
-        ▼
-ImageLibrary ── SQLite path index
-        │                  Codex state + session index
-        │                  ├─ Project / Chat / Thread 名称与 Archive 状态
-        │                  └─ revised_prompt（按需读取 Session JSONL）
-        ▼
-HTTP + Images UI
-        │
-        └── codex-feature.json
-                    │ sibling discovery
-                    ▼
-          ../CodexRuntimeHost
-                    └── Codex sidebar + Theme Bridge + open Thread
-```
-
-- `src/image-library.mjs`：扫描、监听和路径索引，是产品核心。
-- `src/thread-metadata.mjs`：读取 Codex 当前 Project、projectless Chat、Thread 名称与 Archive 状态。
-- `src/prompt-index.mjs`：按 Thread 与 ImageGen item 定位真实 `revised_prompt`。
-- `src/http-server.mjs`：图片列表、来源 facets、Thread 图板、原图读取、系统 Save as 和静态页面。
-- `codex-feature.json`：Images 对统一宿主的最小声明，不包含图片业务逻辑。
-- `../CodexRuntimeHost`：可复用的 CDP 集成，统一负责多个个人功能的入口、Surface、主题与导航。
-- `web/`：零框架 Images 页面。
-
-## Codex 设计语言与主题
-
-- Images 不维护独立品牌皮肤，而是通过 Theme Bridge 读取当前 Codex Renderer 已解析的 semantic tokens。
-- 支持 Codex 的明亮 / 暗黑主题，并监听根节点 theme class 与 style 变化。
-- 用户修改 accent、ink 或 surface 后，新的 resolved tokens 会同步到 iframe，不需要重新读取或猜测内部配置文件位置。
-- 侧边栏 Images 入口克隆原生 Plugins 控件的布局与状态，再替换为 Codex 图标体系中的独立 Image 图标；iframe 内不导入 Codex 私有 React 模块或 hashed CSS bundle，以免 Codex 更新后直接失效。
-- 原生左侧栏隐藏时，Images 标题左侧显示同源图标入口；点击由 RuntimeHost 转发给原生侧栏开关，恢复后入口自动隐藏。
-
-取证、token Interface 和代码复用边界见 [`docs/CODEX_DESIGN_LANGUAGE.md`](docs/CODEX_DESIGN_LANGUAGE.md)。
-
-## 当前边界
-
-- Images 服务需要保持运行，才会持续监听新图片；侧边栏注册由 `CodexRuntimeHost` 统一维持。
-- 每次服务启动都会先开放 health，再在后台补扫停机期间新增的图片并刷新来源名称；初始补扫完成后，运行期间的新图片由文件监听自动加入。手动 Refresh 会再次补扫来源和 Archive 状态，但不会重置筛选、图板模式、详情、滚动位置或列数。刷新 ring 至少显示 1 秒。
-- 侧边栏使用 Codex 当前未公开的 CDP / DOM 能力，Codex UI 更新后只需调整统一宿主；独立 Web UI 和路径索引不受影响。
-- 当前 Codex 的 CSP 会屏蔽普通本地 iframe。统一宿主会先启用 CSP bypass 并注册 document-start 脚本；尚未完成该初始化的首次或旧版 document 会受控 reload 一次。完成初始化后会留下 document 标记，后续 RuntimeHost 重启只替换旧的 MineCodex runtime，不再刷新 Codex 页面（Issue #1）。
-- 详情打开时会从本机 Session JSONL 按需读取该 ImageGen item 的真实 `revised_prompt` 并缓存到索引；历史记录缺少该事件时明确显示 Prompt 不可用，不从附近文本猜测。
-- 当前没有发现 Codex 会因运行时间增长而自动清理 `generated_images` 的证据。如果未来观察到真实清理，再决定是否增加可选备份。
-
-Phase 0 的原图、来源元数据与 Thread 导航证据见 [`spikes/phase0/README.md`](spikes/phase0/README.md)。
-
-需要验证 Codex 内的 iframe 是否真正加载时，可在 `npm start` 运行期间执行：
-
-```bash
-node spikes/phase0/cdp-probe.mjs frame-check --port 9231 \
-  --url http://127.0.0.1:47831/
-
-node spikes/phase0/cdp-probe.mjs overlay-check --port 9231 \
-  --url http://127.0.0.1:47831/
+node --test features/images/test/library-prompt-page.test.mjs
 ```
 
-`overlay-check` 会打开 Codex 原生帮助菜单，验证菜单能覆盖 Images，同时确认 iframe 本身仍可交互。
+旧 `src/image-library.mjs`、索引、独立 `web/` 与服务脚本暂保留为历史工具，
+不属于当前插件入口；已有本地图片和缓存不会被迁移或删除。

package/features/images/codex-feature.json

@@ -7,23 +7,15 @@
     "zh-CN": "图片"
   },
   "description": {
-    "en": "Browse generated images, inspect prompts and sources, and return to the original task.",
-    "zh-CN": "集中浏览生成图片，查看提示词和来源任务，并保存原图或返回原任务。"
+    "en": "View image prompts inside the native Library image viewer.",
+    "zh-CN": "在原生 Library 图片详情中查看并复制提示词。"
   },
-  "surfaceUrl": "http://127.0.0.1:47831/",
-  "healthUrl": "http://127.0.0.1:47831/api/health",
-  "runtimePortEnvironment": "CODEX_IMAGE_HOST_PORT",
-  "pageScript": {
-    "resource": "src/chatgpt-image-source-page.mjs"
-  },
-  "hostActions": ["import-generated-image", "create-image-edit-thread", "open-sidebar"],
-  "placement": {
-    "after": "sites",
-    "order": 10
-  },
-  "command": ["node", "src/main.mjs"],
   "icon": {
     "viewBox": "0 0 24 24",
     "markup": "<rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\" ry=\"2\"></rect><circle cx=\"9\" cy=\"9\" r=\"2\"></circle><path d=\"m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21\"></path>"
+  },
+  "entry": {
+    "kind": "page-script",
+    "script": "src/library-prompt-page.mjs"
   }
 }

package/features/images/src/http-server.mjs

@@ -48,7 +48,7 @@ function publicImage(image, { includePrompt = false } = {}) {
     downloadUrl: `/api/images/${image.id}/download`,
     sourceUrl: image.threadId.startsWith("chatgpt:") ? null : `codex://threads/${image.threadId}`,
   };
-  if (includePrompt) result.prompt = image.prompt;
+  if (includePrompt) { result.prompt = image.prompt; result.promptKind = image.promptKind; }
   return result;
 }
 
@@ -295,11 +295,13 @@ export async function createHttpServer({
 
       if (request.method === "GET" && url.pathname === "/api/images") {
         const { limit, offset } = paginationFor(url);
+        const snapshot = parseIntegerQuery(url.searchParams, "snapshot", { defaultValue: library.snapshot(), min: 0, max: Number.MAX_SAFE_INTEGER });
         const source = url.searchParams.get("source") ?? "all";
         const threadId = url.searchParams.get("threadId") || null;
         const sort = url.searchParams.get("sort") === "asc" ? "asc" : "desc";
         const query = url.searchParams.get("q") ?? "";
         const images = library.list({
+          snapshot,
           query,
           source,
           threadId,
@@ -309,7 +311,8 @@ export async function createHttpServer({
         }).map(publicImage);
         json(response, 200, {
           images,
-          count: library.count({ query, source, threadId }),
+          count: library.count({ query, source, threadId, snapshot }),
+          snapshot,
           limit,
           offset,
         });
@@ -323,18 +326,25 @@ export async function createHttpServer({
 
       if (request.method === "GET" && url.pathname === "/api/image-groups") {
         const { limit, offset } = paginationFor(url);
+        const snapshot = parseIntegerQuery(url.searchParams, "snapshot", { defaultValue: library.snapshot(), min: 0, max: Number.MAX_SAFE_INTEGER });
         const source = url.searchParams.get("source") ?? "all";
-        const groups = library.groups({ source, limit, offset }).map(publicGroup);
+        const groups = library.groups({ source, limit, offset, snapshot }).map(publicGroup);
         json(response, 200, {
           groups,
-          count: library.countGroups({ source }),
-          imageCount: library.count({ source }),
+          count: library.countGroups({ source, snapshot }),
+          imageCount: library.count({ source, snapshot }),
+          snapshot,
           limit,
           offset,
         });
         return;
       }
 
+      if (request.method === "GET" && url.pathname === "/api/cloud-image-cache") {
+        json(response, 200, { items: library.cloudCache() });
+        return;
+      }
+
       if (request.method === "POST" && url.pathname === "/api/rescan") {
         if (library.rescanStatus().inProgress) {
           json(response, 202, { imported: 0, total: library.count(), inProgress: true });

package/features/images/src/image-library.mjs

@@ -28,10 +28,15 @@ function imageIdFor(sourcePath) {
   return createHash("sha256").update(sourcePath).digest("hex").slice(0, 24);
 }
 
-function buildWhere({ query = "", source = "all", threadId = null } = {}) {
+function buildWhere({ query = "", source = "all", threadId = null, snapshot = null } = {}) {
   const clauses = [];
   const parameters = [];
 
+  if (snapshot !== null) {
+    clauses.push("images.rowid <= ?");
+    parameters.push(snapshot);
+  }
+
   if (threadId) {
     clauses.push("images.thread_id = ?");
     parameters.push(threadId);
@@ -153,6 +158,7 @@ function rowToImage(row) {
     imageGenerationItemId: row.image_generation_item_id,
     sourcePath: row.source_path,
     prompt: row.prompt,
+    promptKind: row.prompt_kind ?? "generation",
     width: row.width,
     height: row.height,
     byteLength: row.byte_length,
@@ -235,6 +241,10 @@ export class ImageLibrary {
         updated_at TEXT NOT NULL
       );
     `);
+    const imageColumns = new Set(this.database.prepare("PRAGMA table_info(images)").all().map(column => column.name));
+    for (const name of ["prompt_kind", "cloud_library_id", "cloud_version"]) {
+      if (!imageColumns.has(name)) this.database.exec(`ALTER TABLE images ADD COLUMN ${name} TEXT`);
+    }
     const threadSourceColumns = new Set(
       this.database.prepare("PRAGMA table_info(thread_sources)").all().map((column) => column.name),
     );
@@ -299,6 +309,10 @@ export class ImageLibrary {
     });
   }
 
+  snapshot() {
+    return this.database.prepare("SELECT COALESCE(MAX(rowid), 0) AS value FROM images").get().value;
+  }
+
   count(options = {}) {
     const { sql, parameters } = buildWhere(options);
     return this.database.prepare(`
@@ -309,8 +323,8 @@ export class ImageLibrary {
     `).get(...parameters).count;
   }
 
-  list({ query = "", source = "all", threadId = null, sort = "desc", limit = null, offset = 0 } = {}) {
-    const { sql, parameters } = buildWhere({ query, source, threadId });
+  list({ query = "", source = "all", threadId = null, sort = "desc", limit = null, offset = 0, snapshot = null } = {}) {
+    const { sql, parameters } = buildWhere({ query, source, threadId, snapshot });
     const pagination = Number.isInteger(limit) ? "LIMIT ? OFFSET ?" : "";
     if (pagination) parameters.push(limit, offset);
     const direction = sort === "asc" ? "ASC" : "DESC";
@@ -358,8 +372,8 @@ export class ImageLibrary {
     return { total: this.count(), chats, works, projects };
   }
 
-  countGroups({ source = "all" } = {}) {
-    const { sql, parameters } = buildWhere({ source });
+  countGroups({ source = "all", snapshot = null } = {}) {
+    const { sql, parameters } = buildWhere({ source, snapshot });
     return this.database.prepare(`
       SELECT COUNT(DISTINCT images.thread_id) AS count
       FROM images
@@ -368,8 +382,8 @@ export class ImageLibrary {
     `).get(...parameters).count;
   }
 
-  groups({ source = "all", limit = null, offset = 0, previewLimit = 4 } = {}) {
-    const { sql, parameters } = buildWhere({ source });
+  groups({ source = "all", limit = null, offset = 0, previewLimit = 4, snapshot = null } = {}) {
+    const { sql, parameters } = buildWhere({ source, snapshot });
     const pagination = Number.isInteger(limit) ? "LIMIT ? OFFSET ?" : "";
     if (pagination) parameters.push(limit, offset);
     const rows = this.database.prepare(`
@@ -400,10 +414,11 @@ export class ImageLibrary {
           FROM images
           LEFT JOIN thread_sources ON thread_sources.thread_id = images.thread_id
           WHERE images.thread_id IN (${placeholders})
+            ${snapshot === null ? "" : "AND images.rowid <= ?"}
         )
         WHERE preview_rank <= ?
         ORDER BY thread_id ASC, created_at ASC, id ASC
-      `).all(...threadIds, previewLimit);
+      `).all(...threadIds, ...(snapshot === null ? [] : [snapshot]), previewLimit);
       for (const previewRow of previewRows) {
         const previews = previewsByThread.get(previewRow.thread_id) ?? [];
         previews.push(rowToImage(previewRow));
@@ -621,6 +636,10 @@ export class ImageLibrary {
     return true;
   }
 
+  cloudCache() {
+    return this.database.prepare("SELECT cloud_library_id AS libraryId, cloud_version AS version FROM images WHERE cloud_library_id IS NOT NULL").all();
+  }
+
   async importExternalImage({
     bytes,
     mimeType,
@@ -630,6 +649,9 @@ export class ImageLibrary {
     sourceKind,
     prompt = null,
     createdAt = null,
+    promptKind = "generation",
+    cloudLibraryId = null,
+    cloudVersion = null,
   } = {}) {
     if (!this.isLifecycleActive() || !Buffer.isBuffer(bytes)) return { imported: false, reason: "INVALID_BYTES" };
     const normalizedMime = normalizedImportMime(mimeType);
@@ -660,10 +682,15 @@ export class ImageLibrary {
     const assetDir = path.join(this.dataDir, "external-images");
     const sourcePath = path.join(assetDir, `${id}.${extension}`);
     const existing = this.database.prepare("SELECT source_path, byte_length FROM images WHERE id = ?").get(id);
+    const updateCloudMetadata = () => {
+      if (typeof cloudLibraryId !== "string" || !/^libfile_[\w-]+$/.test(cloudLibraryId)) return;
+      this.database.prepare("UPDATE images SET cloud_library_id = ?, cloud_version = ?, prompt = ?, prompt_kind = ? WHERE id = ?")
+        .run(cloudLibraryId, String(cloudVersion ?? "").slice(0, 256), safePrompt, promptKind === "request" ? "request" : "generation", id);
+    };
     if (existing && existing.byte_length === bytes.length) {
       try {
         const existingBytes = await readFile(existing.source_path);
-        if (existingBytes.equals(bytes)) return { imported: false, id, reason: "DUPLICATE" };
+        if (existingBytes.equals(bytes)) { updateCloudMetadata(); return { imported: false, id, reason: "DUPLICATE" }; }
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -712,6 +739,7 @@ export class ImageLibrary {
         normalizedCreatedAt,
         importedAt,
       );
+    updateCloudMetadata();
     this.database
       .prepare(`
         INSERT INTO thread_sources (

package/features/images/src/library-prompt-page.mjs

@@ -0,0 +1,239 @@
+// 仅增强原生 Library 图片详情；不创建第二个图库或侧栏入口。
+const PANEL_ID = "minecodex-library-prompt";
+const zh = () => (document.documentElement.lang || navigator.language || "en").toLowerCase().startsWith("zh");
+const label = (en, cn) => zh() ? cn : en;
+let mounted = null;
+let apiPromise = null;
+let scheduled = false;
+let candidate = null;
+
+function libraryImage(header) {
+  const key = Object.keys(header).find(key => key.startsWith("__reactFiber$"));
+  let fiber = key ? header[key] : null;
+  let selected = null;
+  for (let depth = 0; fiber && depth < 80; depth++, fiber = fiber.return) {
+    const file = fiber.memoizedProps?.file;
+    if (!file || !/^libfile_[\w-]+$/.test(file.id ?? "") || !file.mime_type?.startsWith("image/")) continue;
+    if (selected && selected.id !== file.id) break;
+    selected = file;
+    if (file.origination_thread_id && file.origination_message_id) break;
+  }
+  if (!selected) return null;
+  // 只保留关联字段，签名下载地址和图片数据不进入插件。
+  return Object.fromEntries(["id", "file_id", "current_version_number", "origination_thread_id", "origination_message_id"].map(key => [key, selected[key]]));
+}
+
+async function nativeApi() {
+  if (!apiPromise) apiPromise = (async () => {
+    const initialUrl = [...document.querySelectorAll('link[rel="modulepreload"],script[src]')]
+      .map(element => element.href || element.src).find(url => /\/app-initial-[^/]+\.js/.test(url));
+    if (!initialUrl) throw new Error("Library API unavailable");
+    const initialSource = await (await fetch(initialUrl, { signal })).text();
+    const metadataAsset = initialSource.match(/library-file-metadata-[\w-]+\.js/)?.[0];
+    if (!metadataAsset) throw new Error("Library metadata unavailable");
+    const metadataUrl = new URL(metadataAsset, initialUrl).href;
+    const source = await (await fetch(metadataUrl, { signal })).text();
+    const apiLocal = source.match(/([\w$]+)\.safePost\(`\/files\/library`/)?.[1];
+    const imports = [...source.matchAll(/import\{([^}]+)\}from["']([^"']+)["']/g)]
+      .find(match => match[1].split(",").some(binding => binding.trim().split(/\s+as\s+/).at(-1) === apiLocal));
+    const apiExport = imports?.[1].split(",").map(s => s.trim().split(/\s+as\s+/)).find(parts => parts.at(-1) === apiLocal)?.[0];
+    const initLocal = source.match(/function ([\w$]+)\(\)\{return\(\1=/)?.[1];
+    const exports = source.match(/export\{([^}]+)\}/)?.[1].split(",").map(s => s.trim().split(/\s+as\s+/)) ?? [];
+    const initExport = exports.find(parts => parts[0] === initLocal)?.at(-1);
+    const metadata = await import(metadataUrl);
+    if (typeof metadata[initExport] !== "function" || !apiExport) throw new Error("Library API contract changed");
+    metadata[initExport]();
+    const api = (await import(new URL(imports[2], metadataUrl).href))[apiExport];
+    if (typeof api?.safeGet !== "function") throw new Error("Library API unavailable");
+    return api;
+  })().catch(error => { apiPromise = null; throw error; });
+  return apiPromise;
+}
+
+function promptFromConversation(file, conversation) {
+  const node = conversation.mapping?.[file.origination_message_id];
+  const part = node?.message?.content?.parts?.find(part => part && typeof part === "object"
+    && part.content_type === "image_asset_pointer"
+    && [file.file_id, `sediment://${file.file_id}`].includes(part.asset_pointer));
+  if (!part || !["assistant", "tool"].includes(node.message.author?.role)
+    || !(part.metadata?.generation?.gen_id || part.metadata?.dalle?.gen_id)) return null;
+  const prompt = part.metadata?.dalle?.prompt;
+  if (typeof prompt === "string" && prompt.trim()) return { text: prompt, kind: "generation" };
+  let ancestor = conversation.mapping[node.parent];
+  const visited = new Set();
+  while (ancestor && !visited.has(ancestor.id)) {
+    visited.add(ancestor.id);
+    if (ancestor.message?.author?.role === "user") {
+      const text = ancestor.message.content?.parts?.filter(part => typeof part === "string").join("\n");
+      return text?.trim() ? { text, kind: "request" } : null;
+    }
+    ancestor = conversation.mapping[ancestor.parent];
+  }
+  return null;
+}
+
+function element(tag, className, text) {
+  const node = document.createElement(tag);
+  node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+// 复用旧 Images 的 Lucide copy/check 图形，统一为 16px 图标按钮。
+function copyGlyph(copied = false) {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  for (const [key, value] of Object.entries({ viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", "stroke-width": "1.5", "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" })) svg.setAttribute(key, value);
+  svg.innerHTML = copied
+    ? '<path d="m20 6-11 11-5-5"></path>'
+    : '<rect width="14" height="14" x="8" y="8" rx="2" ry="2"></rect><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"></path>';
+  return svg;
+}
+
+function closePanel(record, restoreFocus = false) {
+  record.request?.abort();
+  record.request = null;
+  record.panel.hidden = true;
+  record.button.setAttribute("aria-expanded", "false");
+  if (restoreFocus && record.button.isConnected) record.button.focus();
+}
+
+function showPrompt(record) {
+  record.panel.hidden = false;
+  record.button.setAttribute("aria-expanded", "true");
+  record.close.focus();
+}
+
+async function resolvePrompt(file, request) {
+  if (!file.origination_thread_id || !file.origination_message_id) return null;
+  const api = await nativeApi();
+  request.signal.throwIfAborted();
+  const conversation = await api.safeGet("/conversation/{conversation_id}", {
+    parameters: { path: { conversation_id: file.origination_thread_id } },
+    signal: AbortSignal.any([signal, request.signal, AbortSignal.timeout(25_000)]),
+  });
+  return promptFromConversation(file, conversation);
+}
+
+function unmount() {
+  if (!mounted) return;
+  closePanel(mounted);
+  clearTimeout(mounted.copyTimer);
+  mounted.button.remove();
+  mounted.panel.remove();
+  mounted = null;
+}
+
+async function scan() {
+  scheduled = false;
+  if (signal.aborted) return;
+  const header = [...document.querySelectorAll('[data-testid="viewer-header"]')].find(header => header.getBoundingClientRect().width > 0 && libraryImage(header));
+  const file = header && libraryImage(header);
+  const identity = file && JSON.stringify(file);
+  if (candidate?.header === header && candidate?.identity === identity
+    && (!mounted || (mounted.button.isConnected && mounted.panel.isConnected))) return;
+  candidate?.request.abort();
+  unmount();
+  candidate = null;
+  if (!file) return;
+  const next = { header, identity, request: new AbortController() };
+  candidate = next;
+  let prompt;
+  try { prompt = await resolvePrompt(file, next.request); }
+  catch { return; }
+  // 异步结果只能写回当前图片；没有提示词时不展示入口。
+  if (!prompt || signal.aborted || candidate !== next || !header.isConnected) return;
+  // 缩放项在图片详情中是百分比菜单；沿用它的胶囊类，不固定构建 hash。
+  const zoom = [...header.querySelectorAll('button[aria-haspopup="menu"]')].find(button => /^\d+(?:\.\d+)?%$/.test(button.textContent.trim()));
+  const group = zoom?.parentElement?.parentElement;
+  const host = header.closest('[role="presentation"]');
+  if (!zoom || !group || !host) return;
+  const capsuleClass = zoom.className.split(/\s+/).filter(name => !/^_(?:dropdown|zoom)_/.test(name)).join(" ");
+  const button = element("button", capsuleClass, label("Prompt", "提示词"));
+  button.type = "button";
+  button.dataset.minecodexLibraryPrompt = "trigger";
+  button.setAttribute("aria-expanded", "false");
+  button.setAttribute("aria-controls", PANEL_ID);
+  button.style.width = "max-content";
+  button.style.minWidth = "0";
+  button.style.flex = "0 0 auto";
+  button.style.paddingInline = "calc(var(--spacing) * 3)";
+  group.prepend(button);
+  // 对齐原生 Library Version history 的面板、标题和内容区 token。
+  const panel = element("aside", "absolute inset-x-2 top-toolbar bottom-2 z-30 ms-auto mt-2 flex max-w-75 flex-col overflow-hidden rounded-2xl border border-default bg-surface shadow-lg select-none");
+  panel.id = PANEL_ID;
+  panel.setAttribute("aria-label", label("Image prompt", "图片提示词"));
+  panel.hidden = true;
+  panel.style.setProperty("-webkit-app-region", "no-drag");
+  panel.style.paddingBottom = "calc(var(--spacing) * 3)";
+  const heading = element("div", "flex items-center justify-between py-2 ps-4 pe-2");
+  const close = element("button", "flex size-8 shrink-0 items-center justify-center rounded-full text-default hover:bg-primary-ghost-hover focus-visible:outline-ring");
+  close.type = "button";
+  close.setAttribute("aria-label", label("Close prompt", "关闭提示词"));
+  // 直接复用原生关闭图标，避免手绘近似图形。
+  const nativeClose = [...header.querySelectorAll("button")].at(-1)?.querySelector("svg");
+  if (nativeClose) close.append(nativeClose.cloneNode(true));
+  else close.textContent = "×";
+  const actions = element("div", "flex items-center gap-1");
+  const copy = element("button", close.className);
+  copy.type = "button";
+  function copyFeedback(copied = false, failed = false) {
+    const text = failed ? label("Try copying again", "重试复制") : copied ? label("Copied", "已复制") : label("Copy prompt", "复制提示词");
+    copy.title = text;
+    copy.setAttribute("aria-label", text);
+    copy.replaceChildren(copyGlyph(copied));
+  }
+  copyFeedback();
+  actions.append(copy, close);
+  heading.append(element("span", "text-base font-semibold text-default", label("Prompt", "提示词")), actions);
+  const body = element("div", "min-h-0 flex-1 overflow-y-auto px-3");
+  body.style.paddingTop = "var(--spacing)";
+  body.append(
+    element("p", "px-1 text-sm leading-5 text-default whitespace-pre-wrap break-words select-text", prompt.text),
+  );
+  panel.append(heading, body);
+  host.append(panel);
+  const record = { header, file, identity, button, panel, body, close, request: null,
+    refreshLocale() {
+      button.textContent = label("Prompt", "提示词");
+      panel.setAttribute("aria-label", label("Image prompt", "图片提示词"));
+      close.setAttribute("aria-label", label("Close prompt", "关闭提示词"));
+      heading.firstElementChild.textContent = label("Prompt", "提示词");
+      copyFeedback();
+    },
+  };
+  mounted = record;
+  copy.addEventListener("click", async () => {
+    try {
+      await navigator.clipboard.writeText(prompt.text);
+      if (mounted !== record) return;
+      copyFeedback(true);
+    } catch {
+      if (mounted !== record) return;
+      copyFeedback(false, true);
+    }
+    clearTimeout(record.copyTimer);
+    record.copyTimer = setTimeout(() => copyFeedback(), 2000);
+  });
+  button.addEventListener("click", () => panel.hidden ? showPrompt(record) : closePanel(record));
+  close.addEventListener("click", () => closePanel(record, true));
+}
+
+const localeObserver = new MutationObserver(() => mounted?.refreshLocale());
+localeObserver.observe(document.documentElement, { attributes:true, attributeFilter:["lang"] });
+const observer = new MutationObserver(() => {
+  if (scheduled) return;
+  scheduled = true;
+  queueMicrotask(scan);
+});
+observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true, attributeFilter: ["src", "data-state", "inert"] });
+function escape(event) {
+  if (event.key !== "Escape" || !mounted || mounted.panel.hidden) return;
+  event.preventDefault();
+  event.stopImmediatePropagation();
+  closePanel(mounted, true);
+}
+document.addEventListener("keydown", escape, true);
+const cleanup = () => { candidate?.request.abort(); candidate = null; observer.disconnect(); localeObserver.disconnect(); document.removeEventListener("keydown", escape, true); unmount(); };
+signal.addEventListener("abort", cleanup, { once: true });
+scan();
+return cleanup;