chore: release v1.75.0

fix(baoyu-image-gen): align `OpenRouter` image generation with current API

.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Skills shared by Baoyu for improving daily work efficiency",
-    "version": "1.65.0"
+    "version": "1.75.0"
   },
   "plugins": [
     {
@@ -47,7 +47,8 @@
         "./skills/baoyu-url-to-markdown",
         "./skills/baoyu-format-markdown",
         "./skills/baoyu-markdown-to-html",
-        "./skills/baoyu-translate"
+        "./skills/baoyu-translate",
+        "./skills/baoyu-youtube-transcript"
       ]
     }
   ]

.github/workflows/test.yml

@@ -0,0 +1,25 @@
+name: Test
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  node-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test

.gitignore

@@ -166,3 +166,4 @@ posts/
 .clawdhub/
 .release-artifacts/
 .worktrees/
+youtube-transcript/

CHANGELOG.md

@@ -2,6 +2,125 @@
 
 English | [中文](./CHANGELOG.zh.md)
 
+## 1.75.0 - 2026-03-21
+
+### Features
+- `baoyu-youtube-transcript`: new skill — download YouTube video transcripts/subtitles and cover images with multi-language, chapters, and speaker identification support
+
+## 1.74.1 - 2026-03-21
+
+### Fixes
+- `baoyu-image-gen`: align OpenRouter image generation with current API, harden image support, and narrow Gemini aspect ratios (by @cwandev)
+- `baoyu-image-gen`: broaden OpenRouter model detection and aspect ratio validation
+
+## 1.74.0 - 2026-03-20
+
+### Features
+- `baoyu-markdown-to-html`: CLI now supports all rendering options — color, font-family, font-size, code-theme, mac-code-block, line-number, count, legend
+
+### Fixes
+- `baoyu-markdown-to-html`: fix CSS custom property regex to handle quoted values; grace/simple themes now layer default CSS
+
+## 1.73.3 - 2026-03-20
+
+### Fixes
+- `baoyu-post-to-wechat`: fix placeholder replacement to avoid shorter placeholders matching longer numbered variants
+
+## 1.73.2 - 2026-03-20
+
+### Fixes
+- `baoyu-post-to-wechat`: fix body image upload to correctly use media/uploadimg API with format and size validation (by @AICreator-Wind)
+
+### Refactor
+- `baoyu-post-to-wechat`: extract image processor module for local format conversion (WebP/BMP/GIF → JPEG/PNG) instead of material API fallback
+
+## 1.73.1 - 2026-03-18
+
+### Refactor
+- `baoyu-danger-x-to-markdown`: migrate tests from bun:test to node:test
+
+## 1.73.0 - 2026-03-18
+
+### Features
+- `baoyu-danger-x-to-markdown`: add video media support for X articles with poster image and video link rendering
+
+## 1.72.0 - 2026-03-18
+
+### Features
+- `baoyu-danger-x-to-markdown`: add MARKDOWN entity support for rendering embedded markdown/code blocks in X articles
+
+## 1.71.0 - 2026-03-17
+
+### Features
+- `baoyu-image-gen`: add Seedream reference image support for 5.0/4.5/4.0 models with model-specific size validation
+
+## 1.70.0 - 2026-03-17
+
+### Features
+- `baoyu-format-markdown`: optimize title generation with formula-based recommendations and straightforward alternatives
+- `baoyu-format-markdown`: auto-generate dual summaries (`summary` + `description`) in frontmatter
+
+## 1.69.1 - 2026-03-16
+
+### Fixes
+- `baoyu-chrome-cdp`: tighten chrome auto-connect logic to reduce false positives
+
+## 1.69.0 - 2026-03-16
+
+### Features
+- `baoyu-chrome-cdp`: support connecting to existing Chrome session (by @bviews)
+
+### Fixes
+- `baoyu-chrome-cdp`: support Chrome 146 native remote debugging in approval mode (by @bviews)
+- `baoyu-chrome-cdp`: keep HTTP validation in findExistingChromeDebugPort (by @bviews)
+- `baoyu-danger-gemini-web`: reuse openPageSession and fix orphaned tab leak (by @bviews)
+- `baoyu-danger-gemini-web`: respect explicit profile config over auto-discovery (by @bviews)
+- `baoyu-danger-gemini-web`: respect BAOYU_CHROME_PROFILE_DIR in auto-discovery skip (by @bviews)
+- `baoyu-post-to-wechat`: improve browser publishing reliability (by @cfh-7598)
+
+### Documentation
+- `baoyu-cover-image`: clarify people reference image workflow and interactive confirmation
+
+## 1.68.0 - 2026-03-14
+
+### Features
+- `baoyu-article-illustrator`: add configurable output directory (`default_output_dir`) with 4 options — `imgs-subdir`, `same-dir`, `illustrations-subdir`, `independent`
+- `baoyu-cover-image`: add character preservation from reference images — use `usage: direct` to pass people references to model for stylized likeness
+
+## 1.67.0 - 2026-03-13
+
+### Features
+- `baoyu-image-gen`: add qwen-image-2.0-pro model support for DashScope provider with free-form sizes and text rendering (by @JianJang2017)
+
+## 1.66.1 - 2026-03-13
+
+### Tests
+- Migrate test files from centralized `tests/` directory to colocate with source code
+- Convert tests from `.mjs` to TypeScript (`.test.ts`) with `tsx` runner
+- Add npm workspaces configuration and npm cache to CI workflow
+
+## 1.66.0 - 2026-03-13
+
+### Features
+- `baoyu-image-gen`: add Jimeng (即梦) and Seedream (豆包) image generation providers (by @lindaifeng)
+
+### Fixes
+- `baoyu-image-gen`: tighten Jimeng provider behavior
+
+### Refactor
+- `baoyu-image-gen`: export functions for testability and add module entry guard
+
+### Documentation
+- `baoyu-image-gen`: add Jimeng and Seedream provider documentation to SKILL.md and READMEs
+
+### Tests
+- Add test infrastructure with CI workflow and image-gen unit tests
+
+## 1.65.1 - 2026-03-13
+
+### Refactor
+- `baoyu-translate`: replace remark/unified with markdown-it for chunk parsing, add main.ts CLI entry point
+
 ## 1.65.0 - 2026-03-13
 
 ### Features

CHANGELOG.zh.md

@@ -2,6 +2,125 @@
 
 [English](./CHANGELOG.md) | 中文
 
+## 1.75.0 - 2026-03-21
+
+### 新功能
+- `baoyu-youtube-transcript`：新技能 — 下载 YouTube 视频字幕/转录文本和封面图片，支持多语言、章节分段和说话人识别
+
+## 1.74.1 - 2026-03-21
+
+### 修复
+- `baoyu-image-gen`：对齐 OpenRouter 图像生成与当前 API，增强图像支持，收窄 Gemini 宽高比范围 (by @cwandev)
+- `baoyu-image-gen`：扩展 OpenRouter 模型检测和宽高比验证
+
+## 1.74.0 - 2026-03-20
+
+### 新功能
+- `baoyu-markdown-to-html`：CLI 支持全部渲染选项 — color、font-family、font-size、code-theme、mac-code-block、line-number、count、legend
+
+### 修复
+- `baoyu-markdown-to-html`：修复 CSS 自定义属性正则无法处理带引号值的问题；grace/simple 主题现在会叠加 default 主题 CSS
+
+## 1.73.3 - 2026-03-20
+
+### 修复
+- `baoyu-post-to-wechat`：修复占位符替换时短占位符错误匹配更长编号变体的问题
+
+## 1.73.2 - 2026-03-20
+
+### 修复
+- `baoyu-post-to-wechat`：修复正文图片上传，正确使用 media/uploadimg 接口并处理格式和大小限制 (by @AICreator-Wind)
+
+### 重构
+- `baoyu-post-to-wechat`：提取图片处理模块，本地转换不支持的格式（WebP/BMP/GIF → JPEG/PNG）而非回退到 material 接口
+
+## 1.73.1 - 2026-03-18
+
+### 重构
+- `baoyu-danger-x-to-markdown`：测试从 bun:test 迁移至 node:test
+
+## 1.73.0 - 2026-03-18
+
+### 新功能
+- `baoyu-danger-x-to-markdown`：支持 X 文章中的视频媒体，渲染封面图和视频链接
+
+## 1.72.0 - 2026-03-18
+
+### 新功能
+- `baoyu-danger-x-to-markdown`：支持渲染 X 文章中嵌入的 MARKDOWN 实体（代码块等）
+
+## 1.71.0 - 2026-03-17
+
+### 新功能
+- `baoyu-image-gen`：为 Seedream 5.0/4.5/4.0 模型添加参考图支持，并增加模型特定的尺寸校验
+
+## 1.70.0 - 2026-03-17
+
+### 新功能
+- `baoyu-format-markdown`：优化标题生成，基于公式智能推荐并提供平实风格备选
+- `baoyu-format-markdown`：自动生成双版本摘要（`summary` + `description`），写入 frontmatter
+
+## 1.69.1 - 2026-03-16
+
+### 修复
+- `baoyu-chrome-cdp`：收紧 Chrome 自动连接逻辑，减少误连接
+
+## 1.69.0 - 2026-03-16
+
+### 新功能
+- `baoyu-chrome-cdp`：支持连接到已有的 Chrome 会话 (by @bviews)
+
+### 修复
+- `baoyu-chrome-cdp`：支持 Chrome 146 原生远程调试（审批模式）(by @bviews)
+- `baoyu-chrome-cdp`：保留 findExistingChromeDebugPort 中的 HTTP 验证 (by @bviews)
+- `baoyu-danger-gemini-web`：复用 openPageSession 并修复孤立标签页泄漏 (by @bviews)
+- `baoyu-danger-gemini-web`：显式配置优先于自动发现 (by @bviews)
+- `baoyu-danger-gemini-web`：自动发现跳过时也遵循 BAOYU_CHROME_PROFILE_DIR (by @bviews)
+- `baoyu-post-to-wechat`：提升浏览器发布可靠性 (by @cfh-7598)
+
+### 文档
+- `baoyu-cover-image`：完善人物参考图片工作流和交互式确认说明
+
+## 1.68.0 - 2026-03-14
+
+### 新功能
+- `baoyu-article-illustrator`：新增可配置输出目录（`default_output_dir`），支持 4 种选项——`imgs-subdir`、`same-dir`、`illustrations-subdir`、`independent`
+- `baoyu-cover-image`：新增参考图片人物保留功能——当参考图包含人物时使用 `usage: direct` 传递给模型，风格化保留人物特征
+
+## 1.67.0 - 2026-03-13
+
+### 新功能
+- `baoyu-image-gen`：新增 DashScope qwen-image-2.0-pro 模型支持，支持自由尺寸和文字渲染 (by @JianJang2017)
+
+## 1.66.1 - 2026-03-13
+
+### 测试
+- 将测试文件从集中式 `tests/` 目录迁移至与源码同级
+- 将测试从 `.mjs` 转换为 TypeScript（`.test.ts`），使用 `tsx` 运行器
+- 新增 npm workspaces 配置，CI 工作流添加 npm 缓存
+
+## 1.66.0 - 2026-03-13
+
+### 新功能
+- `baoyu-image-gen`：新增即梦（Jimeng）和豆包（Seedream）图像生成服务商 (by @lindaifeng)
+
+### 修复
+- `baoyu-image-gen`：收紧即梦服务商行为
+
+### 重构
+- `baoyu-image-gen`：导出函数以支持测试，新增模块入口守卫
+
+### 文档
+- `baoyu-image-gen`：在 SKILL.md 和 README 中添加即梦和豆包服务商文档
+
+### 测试
+- 新增测试基础设施，包含 CI 工作流和 image-gen 单元测试
+
+## 1.65.1 - 2026-03-13
+
+### 重构
+- `baoyu-translate`：将 chunk 解析从 remark/unified 替换为 markdown-it，新增 main.ts CLI 入口
+
 ## 1.65.0 - 2026-03-13
 
 ### 新功能

CLAUDE.md

@@ -1,6 +1,6 @@
 # CLAUDE.md
 
-Claude Code marketplace plugin providing AI-powered content generation skills. Version: **1.65.0**.
+Claude Code marketplace plugin providing AI-powered content generation skills. Version: **1.75.0**.
 
 ## Architecture
 

README.md

@@ -76,7 +76,7 @@ Simply tell Claude Code:
 |--------|-------------|--------|
 | **content-skills** | Content generation and publishing | [xhs-images](#baoyu-xhs-images), [infographic](#baoyu-infographic), [cover-image](#baoyu-cover-image), [slide-deck](#baoyu-slide-deck), [comic](#baoyu-comic), [article-illustrator](#baoyu-article-illustrator), [post-to-x](#baoyu-post-to-x), [post-to-wechat](#baoyu-post-to-wechat), [post-to-weibo](#baoyu-post-to-weibo) |
 | **ai-generation-skills** | AI-powered generation backends | [image-gen](#baoyu-image-gen), [danger-gemini-web](#baoyu-danger-gemini-web) |
-| **utility-skills** | Utility tools for content processing | [url-to-markdown](#baoyu-url-to-markdown), [danger-x-to-markdown](#baoyu-danger-x-to-markdown), [compress-image](#baoyu-compress-image), [format-markdown](#baoyu-format-markdown), [markdown-to-html](#baoyu-markdown-to-html), [translate](#baoyu-translate) |
+| **utility-skills** | Utility tools for content processing | [youtube-transcript](#baoyu-youtube-transcript), [url-to-markdown](#baoyu-url-to-markdown), [danger-x-to-markdown](#baoyu-danger-x-to-markdown), [compress-image](#baoyu-compress-image), [format-markdown](#baoyu-format-markdown), [markdown-to-html](#baoyu-markdown-to-html), [translate](#baoyu-translate) |
 
 ## Update Skills
 
@@ -665,7 +665,7 @@ AI-powered generation backends.
 
 #### baoyu-image-gen
 
-AI SDK-based image generation using OpenAI, Google, OpenRouter, DashScope (Aliyun Tongyi Wanxiang), and Replicate APIs. Supports text-to-image, reference images, aspect ratios, and quality presets.
+AI SDK-based image generation using OpenAI, Google, OpenRouter, DashScope (Aliyun Tongyi Wanxiang), Jimeng (即梦), Seedream (豆包), and Replicate APIs. Supports text-to-image, reference images, aspect ratios, and quality presets.
 
 ```bash
 # Basic generation (auto-detect provider)
@@ -689,7 +689,13 @@ AI SDK-based image generation using OpenAI, Google, OpenRouter, DashScope (Aliyu
 # Replicate
 /baoyu-image-gen --prompt "A cat" --image cat.png --provider replicate
 
-# With reference images (Google, OpenAI, OpenRouter, or Replicate)
+# Jimeng (即梦)
+/baoyu-image-gen --prompt "一只可爱的猫" --image cat.png --provider jimeng
+
+# Seedream (豆包)
+/baoyu-image-gen --prompt "一只可爱的猫" --image cat.png --provider seedream
+
+# With reference images (Google, OpenAI, OpenRouter, Replicate, or Seedream 5.0/4.5/4.0)
 /baoyu-image-gen --prompt "Make it blue" --image out.png --ref source.png
 ```
 
@@ -699,12 +705,12 @@ AI SDK-based image generation using OpenAI, Google, OpenRouter, DashScope (Aliyu
 | `--prompt`, `-p` | Prompt text |
 | `--promptfiles` | Read prompt from files (concatenated) |
 | `--image` | Output image path (required) |
-| `--provider` | `google`, `openai`, `openrouter`, `dashscope` or `replicate` (default: auto-detect; prefers google) |
+| `--provider` | `google`, `openai`, `openrouter`, `dashscope`, `jimeng`, `seedream` or `replicate` (default: auto-detect; prefers google) |
 | `--model`, `-m` | Model ID |
 | `--ar` | Aspect ratio (e.g., `16:9`, `1:1`, `4:3`) |
 | `--size` | Size (e.g., `1024x1024`) |
 | `--quality` | `normal` or `2k` (default: `2k`) |
-| `--ref` | Reference images (Google, OpenAI, OpenRouter or Replicate) |
+| `--ref` | Reference images (Google, OpenAI, OpenRouter, Replicate, or Seedream 5.0/4.5/4.0) |
 
 **Environment Variables** (see [Environment Configuration](#environment-configuration) for setup):
 | Variable | Description | Default |
@@ -714,16 +720,24 @@ AI SDK-based image generation using OpenAI, Google, OpenRouter, DashScope (Aliyu
 | `GOOGLE_API_KEY` | Google API key | - |
 | `DASHSCOPE_API_KEY` | DashScope API key (Aliyun) | - |
 | `REPLICATE_API_TOKEN` | Replicate API token | - |
+| `JIMENG_ACCESS_KEY_ID` | Jimeng Volcengine access key | - |
+| `JIMENG_SECRET_ACCESS_KEY` | Jimeng Volcengine secret key | - |
+| `ARK_API_KEY` | Seedream Volcengine ARK API key | - |
 | `OPENAI_IMAGE_MODEL` | OpenAI model | `gpt-image-1.5` |
 | `OPENROUTER_IMAGE_MODEL` | OpenRouter model | `google/gemini-3.1-flash-image-preview` |
 | `GOOGLE_IMAGE_MODEL` | Google model | `gemini-3-pro-image-preview` |
-| `DASHSCOPE_IMAGE_MODEL` | DashScope model | `z-image-turbo` |
+| `DASHSCOPE_IMAGE_MODEL` | DashScope model | `qwen-image-2.0-pro` |
 | `REPLICATE_IMAGE_MODEL` | Replicate model | `google/nano-banana-pro` |
+| `JIMENG_IMAGE_MODEL` | Jimeng model | `jimeng_t2i_v40` |
+| `SEEDREAM_IMAGE_MODEL` | Seedream model | `doubao-seedream-5-0-260128` |
 | `OPENAI_BASE_URL` | Custom OpenAI endpoint | - |
 | `OPENROUTER_BASE_URL` | Custom OpenRouter endpoint | `https://openrouter.ai/api/v1` |
 | `GOOGLE_BASE_URL` | Custom Google endpoint | - |
 | `DASHSCOPE_BASE_URL` | Custom DashScope endpoint | - |
 | `REPLICATE_BASE_URL` | Custom Replicate endpoint | - |
+| `JIMENG_BASE_URL` | Custom Jimeng endpoint | `https://visual.volcengineapi.com` |
+| `JIMENG_REGION` | Jimeng region | `cn-north-1` |
+| `SEEDREAM_BASE_URL` | Custom Seedream endpoint | `https://ark.cn-beijing.volces.com/api/v3` |
 
 **Provider Auto-Selection**:
 1. If `--provider` specified → use it
@@ -752,6 +766,40 @@ Interacts with Gemini Web to generate text and images.
 
 Utility tools for content processing.
 
+#### baoyu-youtube-transcript
+
+Download YouTube video transcripts/subtitles and cover images. Supports multiple languages, translation, chapters, and speaker identification. Caches raw data for fast re-formatting.
+
+```bash
+# Default: markdown with timestamps
+/baoyu-youtube-transcript https://www.youtube.com/watch?v=VIDEO_ID
+
+# Specify languages (priority order)
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --languages zh,en,ja
+
+# With chapters and speaker identification
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --chapters --speakers
+
+# SRT subtitle format
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --format srt
+
+# List available transcripts
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --list
+```
+
+**Options**:
+| Option | Description | Default |
+|--------|-------------|---------|
+| `<url-or-id>` | YouTube URL or video ID | Required |
+| `--languages <codes>` | Language codes, comma-separated | `en` |
+| `--format <fmt>` | Output format: `text`, `srt` | `text` |
+| `--translate <code>` | Translate to specified language | |
+| `--chapters` | Chapter segmentation from video description | |
+| `--speakers` | Speaker identification (requires AI post-processing) | |
+| `--no-timestamps` | Disable timestamps | |
+| `--list` | List available transcripts | |
+| `--refresh` | Force re-fetch, ignore cache | |
+
 #### baoyu-url-to-markdown
 
 Fetch any URL via Chrome CDP and convert to clean markdown. Saves rendered HTML snapshot alongside the markdown, and automatically falls back to a legacy extractor when Defuddle fails.
@@ -982,13 +1030,25 @@ GOOGLE_IMAGE_MODEL=gemini-3-pro-image-preview
 
 # DashScope (Aliyun Tongyi Wanxiang)
 DASHSCOPE_API_KEY=sk-xxx
-DASHSCOPE_IMAGE_MODEL=z-image-turbo
+DASHSCOPE_IMAGE_MODEL=qwen-image-2.0-pro
 # DASHSCOPE_BASE_URL=https://dashscope.aliyuncs.com/api/v1
 
 # Replicate
 REPLICATE_API_TOKEN=r8_xxx
 REPLICATE_IMAGE_MODEL=google/nano-banana-pro
 # REPLICATE_BASE_URL=https://api.replicate.com
+
+# Jimeng (即梦)
+JIMENG_ACCESS_KEY_ID=xxx
+JIMENG_SECRET_ACCESS_KEY=xxx
+JIMENG_IMAGE_MODEL=jimeng_t2i_v40
+# JIMENG_BASE_URL=https://visual.volcengineapi.com
+# JIMENG_REGION=cn-north-1
+
+# Seedream (豆包)
+ARK_API_KEY=xxx
+SEEDREAM_IMAGE_MODEL=doubao-seedream-5-0-260128
+# SEEDREAM_BASE_URL=https://ark.cn-beijing.volces.com/api/v3
 EOF
 ```
 

README.zh.md

@@ -76,7 +76,7 @@ clawhub install baoyu-markdown-to-html
 |------|------|----------|
 | **content-skills** | 内容生成和发布 | [xhs-images](#baoyu-xhs-images), [infographic](#baoyu-infographic), [cover-image](#baoyu-cover-image), [slide-deck](#baoyu-slide-deck), [comic](#baoyu-comic), [article-illustrator](#baoyu-article-illustrator), [post-to-x](#baoyu-post-to-x), [post-to-wechat](#baoyu-post-to-wechat), [post-to-weibo](#baoyu-post-to-weibo) |
 | **ai-generation-skills** | AI 生成后端 | [image-gen](#baoyu-image-gen), [danger-gemini-web](#baoyu-danger-gemini-web) |
-| **utility-skills** | 内容处理工具 | [url-to-markdown](#baoyu-url-to-markdown), [danger-x-to-markdown](#baoyu-danger-x-to-markdown), [compress-image](#baoyu-compress-image), [format-markdown](#baoyu-format-markdown), [markdown-to-html](#baoyu-markdown-to-html), [translate](#baoyu-translate) |
+| **utility-skills** | 内容处理工具 | [youtube-transcript](#baoyu-youtube-transcript), [url-to-markdown](#baoyu-url-to-markdown), [danger-x-to-markdown](#baoyu-danger-x-to-markdown), [compress-image](#baoyu-compress-image), [format-markdown](#baoyu-format-markdown), [markdown-to-html](#baoyu-markdown-to-html), [translate](#baoyu-translate) |
 
 ## 更新技能
 
@@ -665,7 +665,7 @@ AI 驱动的生成后端。
 
 #### baoyu-image-gen
 
-基于 AI SDK 的图像生成，支持 OpenAI、Google、OpenRouter、DashScope（阿里通义万相）和 Replicate API。支持文生图、参考图、宽高比和质量预设。
+基于 AI SDK 的图像生成，支持 OpenAI、Google、OpenRouter、DashScope（阿里通义万相）、即梦（Jimeng）、豆包（Seedream）和 Replicate API。支持文生图、参考图、宽高比和质量预设。
 
 ```bash
 # 基础生成（自动检测服务商）
@@ -689,7 +689,13 @@ AI 驱动的生成后端。
 # Replicate
 /baoyu-image-gen --prompt "一只猫" --image cat.png --provider replicate
 
-# 带参考图（Google、OpenAI、OpenRouter 或 Replicate）
+# 即梦（Jimeng）
+/baoyu-image-gen --prompt "一只可爱的猫" --image cat.png --provider jimeng
+
+# 豆包（Seedream）
+/baoyu-image-gen --prompt "一只可爱的猫" --image cat.png --provider seedream
+
+# 带参考图（Google、OpenAI、OpenRouter、Replicate 或 Seedream 5.0/4.5/4.0）
 /baoyu-image-gen --prompt "把它变成蓝色" --image out.png --ref source.png
 ```
 
@@ -699,12 +705,12 @@ AI 驱动的生成后端。
 | `--prompt`, `-p` | 提示词文本 |
 | `--promptfiles` | 从文件读取提示词（多文件拼接） |
 | `--image` | 输出图片路径（必需） |
-| `--provider` | `google`、`openai`、`openrouter`、`dashscope` 或 `replicate`（默认：自动检测，优先 google） |
+| `--provider` | `google`、`openai`、`openrouter`、`dashscope`、`jimeng`、`seedream` 或 `replicate`（默认：自动检测，优先 google） |
 | `--model`, `-m` | 模型 ID |
 | `--ar` | 宽高比（如 `16:9`、`1:1`、`4:3`） |
 | `--size` | 尺寸（如 `1024x1024`） |
 | `--quality` | `normal` 或 `2k`（默认：`2k`） |
-| `--ref` | 参考图片（Google、OpenAI、OpenRouter 或 Replicate） |
+| `--ref` | 参考图片（Google、OpenAI、OpenRouter、Replicate 或 Seedream 5.0/4.5/4.0） |
 
 **环境变量**（配置方法见[环境配置](#环境配置)）：
 | 变量 | 说明 | 默认值 |
@@ -714,16 +720,24 @@ AI 驱动的生成后端。
 | `GOOGLE_API_KEY` | Google API 密钥 | - |
 | `DASHSCOPE_API_KEY` | DashScope API 密钥（阿里云） | - |
 | `REPLICATE_API_TOKEN` | Replicate API Token | - |
+| `JIMENG_ACCESS_KEY_ID` | 即梦火山引擎 Access Key | - |
+| `JIMENG_SECRET_ACCESS_KEY` | 即梦火山引擎 Secret Key | - |
+| `ARK_API_KEY` | 豆包火山引擎 ARK API 密钥 | - |
 | `OPENAI_IMAGE_MODEL` | OpenAI 模型 | `gpt-image-1.5` |
 | `OPENROUTER_IMAGE_MODEL` | OpenRouter 模型 | `google/gemini-3.1-flash-image-preview` |
 | `GOOGLE_IMAGE_MODEL` | Google 模型 | `gemini-3-pro-image-preview` |
-| `DASHSCOPE_IMAGE_MODEL` | DashScope 模型 | `z-image-turbo` |
+| `DASHSCOPE_IMAGE_MODEL` | DashScope 模型 | `qwen-image-2.0-pro` |
 | `REPLICATE_IMAGE_MODEL` | Replicate 模型 | `google/nano-banana-pro` |
+| `JIMENG_IMAGE_MODEL` | 即梦模型 | `jimeng_t2i_v40` |
+| `SEEDREAM_IMAGE_MODEL` | 豆包模型 | `doubao-seedream-5-0-260128` |
 | `OPENAI_BASE_URL` | 自定义 OpenAI 端点 | - |
 | `OPENROUTER_BASE_URL` | 自定义 OpenRouter 端点 | `https://openrouter.ai/api/v1` |
 | `GOOGLE_BASE_URL` | 自定义 Google 端点 | - |
 | `DASHSCOPE_BASE_URL` | 自定义 DashScope 端点 | - |
 | `REPLICATE_BASE_URL` | 自定义 Replicate 端点 | - |
+| `JIMENG_BASE_URL` | 自定义即梦端点 | `https://visual.volcengineapi.com` |
+| `JIMENG_REGION` | 即梦区域 | `cn-north-1` |
+| `SEEDREAM_BASE_URL` | 自定义豆包端点 | `https://ark.cn-beijing.volces.com/api/v3` |
 
 **服务商自动选择**：
 1. 如果指定了 `--provider` → 使用指定的
@@ -752,6 +766,40 @@ AI 驱动的生成后端。
 
 内容处理工具。
 
+#### baoyu-youtube-transcript
+
+下载 YouTube 视频字幕/转录文本和封面图片。支持多语言、翻译、章节分段和说话人识别。缓存原始数据以便快速重新格式化。
+
+```bash
+# 默认：带时间戳的 Markdown
+/baoyu-youtube-transcript https://www.youtube.com/watch?v=VIDEO_ID
+
+# 指定语言（按优先级排列）
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --languages zh,en,ja
+
+# 章节分段 + 说话人识别
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --chapters --speakers
+
+# SRT 字幕格式
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --format srt
+
+# 列出可用字幕
+/baoyu-youtube-transcript https://youtu.be/VIDEO_ID --list
+```
+
+**选项**：
+| 选项 | 说明 | 默认值 |
+|------|------|--------|
+| `<url-or-id>` | YouTube URL 或视频 ID | 必填 |
+| `--languages <codes>` | 语言代码，逗号分隔 | `en` |
+| `--format <fmt>` | 输出格式：`text`、`srt` | `text` |
+| `--translate <code>` | 翻译为指定语言 | |
+| `--chapters` | 根据视频描述进行章节分段 | |
+| `--speakers` | 说话人识别（需 AI 后处理） | |
+| `--no-timestamps` | 禁用时间戳 | |
+| `--list` | 列出可用字幕 | |
+| `--refresh` | 强制重新获取，忽略缓存 | |
+
 #### baoyu-url-to-markdown
 
 通过 Chrome CDP 抓取任意 URL 并转换为 Markdown。同时保存渲染后的 HTML 快照，Defuddle 失败时自动回退到旧版提取器。
@@ -982,13 +1030,25 @@ GOOGLE_IMAGE_MODEL=gemini-3-pro-image-preview
 
 # DashScope（阿里通义万相）
 DASHSCOPE_API_KEY=sk-xxx
-DASHSCOPE_IMAGE_MODEL=z-image-turbo
+DASHSCOPE_IMAGE_MODEL=qwen-image-2.0-pro
 # DASHSCOPE_BASE_URL=https://dashscope.aliyuncs.com/api/v1
 
 # Replicate
 REPLICATE_API_TOKEN=r8_xxx
 REPLICATE_IMAGE_MODEL=google/nano-banana-pro
 # REPLICATE_BASE_URL=https://api.replicate.com
+
+# 即梦（Jimeng）
+JIMENG_ACCESS_KEY_ID=xxx
+JIMENG_SECRET_ACCESS_KEY=xxx
+JIMENG_IMAGE_MODEL=jimeng_t2i_v40
+# JIMENG_BASE_URL=https://visual.volcengineapi.com
+# JIMENG_REGION=cn-north-1
+
+# 豆包（Seedream）
+ARK_API_KEY=xxx
+SEEDREAM_IMAGE_MODEL=doubao-seedream-5-0-260128
+# SEEDREAM_BASE_URL=https://ark.cn-beijing.volces.com/api/v3
 EOF
 ```
 

docs/testing.md

@@ -0,0 +1,73 @@
+# Testing Strategy
+
+This repository has many scripts, but they do not share a single runtime or dependency graph. The lowest-risk testing strategy is to start from stable Node-based library code, then expand outward to CLI and skill-specific smoke tests.
+
+## Current Baseline
+
+- Root test runner: `node:test`
+- Entry point: `npm test`
+- Coverage command: `npm run test:coverage`
+- CI trigger: GitHub Actions on `push`, `pull_request`, and manual dispatch
+
+This avoids introducing Jest/Vitest across a repo that already mixes plain Node scripts, Bun-based skill packages, vendored code, and browser automation.
+
+## Rollout Plan
+
+### Phase 1: Stable library coverage
+
+Focus on pure functions under `scripts/lib/` first.
+
+- `scripts/lib/release-files.mjs`
+- `scripts/lib/shared-skill-packages.mjs`
+
+Goals:
+
+- Validate file filtering and release packaging rules
+- Catch regressions in package vendoring and dependency rewriting
+- Keep tests deterministic and free of network, Bun, or browser requirements
+
+### Phase 2: Root CLI integration tests
+
+Add temp-directory integration tests for root CLIs that already support dry-run or local-only flows.
+
+- `scripts/sync-shared-skill-packages.mjs`
+- `scripts/publish-skill.mjs --dry-run`
+- `scripts/sync-clawhub.mjs` argument handling and local skill discovery
+
+Goals:
+
+- Assert exit codes and stdout for common flows
+- Cover CLI argument parsing without hitting external services
+
+### Phase 3: Skill script smoke tests
+
+Add opt-in smoke tests for selected `skills/*/scripts/` packages, starting with those that:
+
+- accept local input files
+- have deterministic output
+- do not require authenticated browser sessions
+
+Examples:
+
+- markdown transforms
+- file conversion helpers
+- local content analyzers
+
+Keep browser automation, login flows, and live API publishing scripts outside the default CI path unless they are explicitly mocked.
+
+### Phase 4: Coverage gates
+
+After the stable Node path has enough breadth, add coverage thresholds in CI for the tested root modules.
+
+Recommended order:
+
+1. Start with reporting only
+2. Add line/function thresholds for `scripts/lib/**`
+3. Expand include patterns once skill-level smoke tests are reliable
+
+## Conventions For New Tests
+
+- Prefer temp directories over committed fixtures unless the fixture is reused heavily
+- Test exported functions before testing CLI wrappers
+- Avoid network, browser, and credential dependencies in default CI
+- Keep tests isolated so they can run with plain `node --test`

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "baoyu-skills",
+  "private": true,
+  "type": "module",
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "test": "node --import tsx --test",
+    "test:coverage": "node --import tsx --experimental-test-coverage --test"
+  },
+  "devDependencies": {
+    "tsx": "^4.20.5"
+  }
+}

packages/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

packages/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }

packages/baoyu-md/src/content.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  extractSummaryFromBody,
+  extractTitleFromMarkdown,
+  parseFrontmatter,
+  pickFirstString,
+  serializeFrontmatter,
+  stripWrappingQuotes,
+  toFrontmatterString,
+} from "./content.ts";
+
+test("parseFrontmatter extracts YAML fields and strips wrapping quotes", () => {
+  const input = `---
+title: "Hello World"
+author: ‘Baoyu’
+summary: plain text
+---
+# Heading
+
+Body`;
+
+  const result = parseFrontmatter(input);
+
+  assert.deepEqual(result.frontmatter, {
+    title: "Hello World",
+    author: "Baoyu",
+    summary: "plain text",
+  });
+  assert.match(result.body, /^# Heading/);
+});
+
+test("parseFrontmatter returns original content when no frontmatter exists", () => {
+  const input = "# No frontmatter";
+  assert.deepEqual(parseFrontmatter(input), {
+    frontmatter: {},
+    body: input,
+  });
+});
+
+test("serializeFrontmatter renders YAML only when fields exist", () => {
+  assert.equal(serializeFrontmatter({}), "");
+  assert.equal(
+    serializeFrontmatter({ title: "Hello", author: "Baoyu" }),
+    "---\ntitle: Hello\nauthor: Baoyu\n---\n",
+  );
+});
+
+test("quote and frontmatter string helpers normalize mixed scalar values", () => {
+  assert.equal(stripWrappingQuotes(`" quoted "`), "quoted");
+  assert.equal(stripWrappingQuotes("“ 中文标题 ”"), "中文标题");
+  assert.equal(stripWrappingQuotes("plain"), "plain");
+
+  assert.equal(toFrontmatterString("'hello'"), "hello");
+  assert.equal(toFrontmatterString(42), "42");
+  assert.equal(toFrontmatterString(false), "false");
+  assert.equal(toFrontmatterString({}), undefined);
+
+  assert.equal(
+    pickFirstString({ summary: 123, title: "" }, ["title", "summary"]),
+    "123",
+  );
+});
+
+test("markdown title and summary extraction skip non-body content and clean formatting", () => {
+  const markdown = `
+![cover](cover.png)
+## “My Title”
+
+Body paragraph
+`;
+  assert.equal(extractTitleFromMarkdown(markdown), "My Title");
+
+  const summary = extractSummaryFromBody(
+    `
+# Heading
+> quote
+- list
+1. ordered
+\`\`\`
+code
+\`\`\`
+This is **the first paragraph** with [a link](https://example.com) and \`inline code\` that should be summarized cleanly.
+`,
+    70,
+  );
+
+  assert.equal(
+    summary,
+    "This is the first paragraph with a link and inline code that should...",
+  );
+});

packages/baoyu-md/src/document.test.ts

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import { COLOR_PRESETS, FONT_FAMILY_MAP } from "./constants.ts";
+import {
+  buildMarkdownDocumentMeta,
+  formatTimestamp,
+  renderMarkdownDocument,
+  resolveColorToken,
+  resolveFontFamilyToken,
+  resolveMarkdownStyle,
+  resolveRenderOptions,
+} from "./document.ts";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`);
+}
+
+function findInlineStyle(html: string, tagName: string, text: string): string {
+  const pattern = new RegExp(
+    `<${tagName}[^>]*style="([^"]*)"[^>]*>${escapeRegExp(text)}</${tagName}>`,
+  );
+  const match = html.match(pattern);
+  assert.ok(match, `Expected inline style for <${tagName}>${text}</${tagName}>`);
+  return match![1]!;
+}
+
+function useCwd(t: TestContext, cwd: string): void {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  t.after(() => {
+    process.chdir(previous);
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("document token resolvers map known presets and allow passthrough values", () => {
+  assert.equal(resolveColorToken("green"), COLOR_PRESETS.green);
+  assert.equal(resolveColorToken("#123456"), "#123456");
+  assert.equal(resolveColorToken(), undefined);
+
+  assert.equal(resolveFontFamilyToken("mono"), FONT_FAMILY_MAP.mono);
+  assert.equal(resolveFontFamilyToken("Custom Font"), "Custom Font");
+  assert.equal(resolveFontFamilyToken(), undefined);
+});
+
+test("formatTimestamp uses compact sortable datetime output", () => {
+  const date = new Date("2026-03-13T21:04:05.000Z");
+  const pad = (value: number) => String(value).padStart(2, "0");
+  const expected = `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(
+    date.getDate(),
+  )}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+
+  assert.equal(formatTimestamp(date), expected);
+});
+
+test("buildMarkdownDocumentMeta prefers frontmatter and falls back to markdown title and summary", () => {
+  const metaFromYaml = buildMarkdownDocumentMeta(
+    "# Markdown Title\n\nBody summary paragraph that should be ignored.",
+    {
+      title: `" YAML Title "`,
+      author: "'Baoyu'",
+      summary: `" YAML Summary "`,
+    },
+    "fallback",
+  );
+
+  assert.deepEqual(metaFromYaml, {
+    title: "YAML Title",
+    author: "Baoyu",
+    description: "YAML Summary",
+  });
+
+  const metaFromMarkdown = buildMarkdownDocumentMeta(
+    `## “Markdown Title”\n\nThis is the first body paragraph that should become the summary because it is long enough.`,
+    {},
+    "fallback",
+  );
+
+  assert.equal(metaFromMarkdown.title, "Markdown Title");
+  assert.match(metaFromMarkdown.description ?? "", /^This is the first body paragraph/);
+});
+
+test("resolveMarkdownStyle merges theme defaults with explicit overrides", () => {
+  const style = resolveMarkdownStyle({
+    theme: "modern",
+    primaryColor: "#112233",
+    fontFamily: "Custom Sans",
+  });
+
+  assert.equal(style.primaryColor, "#112233");
+  assert.equal(style.fontFamily, "Custom Sans");
+  assert.equal(style.fontSize, "15px");
+  assert.equal(style.containerBg, "rgba(250, 249, 245, 1)");
+});
+
+test("resolveRenderOptions loads workspace EXTEND settings and lets explicit options win", async (t) => {
+  const root = await makeTempDir("baoyu-md-render-options-");
+  useCwd(t, root);
+
+  const extendPath = path.join(
+    root,
+    ".baoyu-skills",
+    "baoyu-markdown-to-html",
+    "EXTEND.md",
+  );
+  await fs.mkdir(path.dirname(extendPath), { recursive: true });
+  await fs.writeFile(
+    extendPath,
+    `---
+default_theme: modern
+default_color: green
+default_font_family: mono
+default_font_size: 17
+default_code_theme: nord
+mac_code_block: false
+show_line_number: true
+cite: true
+count: true
+legend: title-alt
+keep_title: true
+---
+`,
+  );
+
+  const fromExtend = resolveRenderOptions();
+  assert.equal(fromExtend.theme, "modern");
+  assert.equal(fromExtend.primaryColor, COLOR_PRESETS.green);
+  assert.equal(fromExtend.fontFamily, FONT_FAMILY_MAP.mono);
+  assert.equal(fromExtend.fontSize, "17px");
+  assert.equal(fromExtend.codeTheme, "nord");
+  assert.equal(fromExtend.isMacCodeBlock, false);
+  assert.equal(fromExtend.isShowLineNumber, true);
+  assert.equal(fromExtend.citeStatus, true);
+  assert.equal(fromExtend.countStatus, true);
+  assert.equal(fromExtend.legend, "title-alt");
+  assert.equal(fromExtend.keepTitle, true);
+
+  const explicit = resolveRenderOptions({
+    theme: "simple",
+    fontSize: "18px",
+    keepTitle: false,
+  });
+  assert.equal(explicit.theme, "simple");
+  assert.equal(explicit.fontSize, "18px");
+  assert.equal(explicit.keepTitle, false);
+});
+
+test("renderMarkdownDocument layers default rules into grace theme before CSS inlining", async () => {
+  const { html } = await renderMarkdownDocument(
+    `## Section\n\nParagraph with **bold** text.`,
+    { keepTitle: true, theme: "grace" },
+  );
+
+  const h2Style = findInlineStyle(html, "h2", "Section");
+  assert.match(h2Style, /background: #92617E/);
+  assert.match(h2Style, /box-shadow: 0 4px 6px rgba\(0, 0, 0, 0\.1\)/);
+
+  const pMatch = html.match(/<p[^>]*style="([^"]*)"[^>]*>/);
+  assert.ok(pMatch, "Expected inline style on <p> tag");
+  assert.match(pMatch![1]!, /color:/);
+
+  const strongPattern = /<strong[^>]*style="([^"]*)"[^>]*>bold<\/strong>/;
+  const strongMatch = html.match(strongPattern);
+  assert.ok(strongMatch, "Expected inline style for <strong>bold</strong>");
+  assert.match(strongMatch![1]!, /font-weight:/);
+});

packages/baoyu-md/src/html-builder.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEFAULT_STYLE } from "./constants.ts";
+import {
+  buildCss,
+  buildHtmlDocument,
+  modifyHtmlStructure,
+  normalizeCssText,
+  normalizeInlineCss,
+  removeFirstHeading,
+} from "./html-builder.ts";
+
+test("buildCss injects style variables and concatenates base and theme CSS", () => {
+  const css = buildCss("body { color: red; }", ".theme { color: blue; }");
+
+  assert.match(css, /--md-primary-color: #0F4C81;/);
+  assert.match(css, /body \{ color: red; \}/);
+  assert.match(css, /\.theme \{ color: blue; \}/);
+});
+
+test("buildHtmlDocument includes optional meta tags and code theme CSS", () => {
+  const html = buildHtmlDocument(
+    {
+      title: "Doc",
+      author: "Baoyu",
+      description: "Summary",
+    },
+    "body { color: red; }",
+    "<article>Hello</article>",
+    ".hljs { color: blue; }",
+  );
+
+  assert.match(html, /<title>Doc<\/title>/);
+  assert.match(html, /meta name="author" content="Baoyu"/);
+  assert.match(html, /meta name="description" content="Summary"/);
+  assert.match(html, /<style>body \{ color: red; \}<\/style>/);
+  assert.match(html, /<style>\.hljs \{ color: blue; \}<\/style>/);
+  assert.match(html, /<article>Hello<\/article>/);
+});
+
+test("normalizeCssText and normalizeInlineCss replace variables and strip declarations", () => {
+  const rawCss = `
+:root { --md-primary-color: #000; --md-font-size: 12px; --foreground: 0 0% 5%; }
+.box { color: var(--md-primary-color); font-size: var(--md-font-size); background: hsl(var(--foreground)); }
+`;
+
+  const normalizedCss = normalizeCssText(rawCss, DEFAULT_STYLE);
+  assert.match(normalizedCss, /color: #0F4C81/);
+  assert.match(normalizedCss, /font-size: 16px/);
+  assert.match(normalizedCss, /background: #3f3f3f/);
+  assert.doesNotMatch(normalizedCss, /--md-primary-color/);
+
+  const normalizedHtml = normalizeInlineCss(
+    `<style>${rawCss}</style><div style="color: var(--md-primary-color)"></div>`,
+    DEFAULT_STYLE,
+  );
+  assert.match(normalizedHtml, /color: #0F4C81/);
+  assert.doesNotMatch(normalizedHtml, /var\(--md-primary-color\)/);
+});
+
+test("normalizeInlineCss removes quoted custom property values without leaving fragments behind", () => {
+  const normalizedHtml = normalizeInlineCss(
+    `<html style="--md-font-family: Menlo, Monaco, 'Courier New', monospace; color: var(--md-primary-color)"></html>`,
+    DEFAULT_STYLE,
+  );
+
+  assert.match(normalizedHtml, /style=" color: #0F4C81"/);
+  assert.doesNotMatch(normalizedHtml, /Courier New/);
+  assert.doesNotMatch(normalizedHtml, /--md-font-family/);
+});
+
+test("HTML structure helpers hoist nested lists and remove the first heading", () => {
+  const nestedList = `<ul><li>Parent<ul><li>Child</li></ul></li></ul>`;
+  assert.equal(
+    modifyHtmlStructure(nestedList),
+    `<ul><li>Parent</li><ul><li>Child</li></ul></ul>`,
+  );
+
+  const html = `<h1>Title</h1><p>Intro</p><h2>Sub</h2>`;
+  assert.equal(removeFirstHeading(html), `<p>Intro</p><h2>Sub</h2>`);
+});

packages/baoyu-md/src/html-builder.ts

@@ -100,13 +100,13 @@ export function normalizeCssText(cssText: string, style: StyleConfig = DEFAULT_S
     .replace(/var\(--md-accent-color\)/g, style.accentColor)
     .replace(/var\(--md-container-bg\)/g, style.containerBg)
     .replace(/hsl\(var\(--foreground\)\)/g, "#3f3f3f")
-    .replace(/--md-primary-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-family:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-size:\s*[^;"']+;?/g, "")
-    .replace(/--blockquote-background:\s*[^;"']+;?/g, "")
-    .replace(/--md-accent-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-container-bg:\s*[^;"']+;?/g, "")
-    .replace(/--foreground:\s*[^;"']+;?/g, "");
+    .replace(/--md-primary-color:\s*[^;]+;?/g, "")
+    .replace(/--md-font-family:\s*[^;]+;?/g, "")
+    .replace(/--md-font-size:\s*[^;]+;?/g, "")
+    .replace(/--blockquote-background:\s*[^;]+;?/g, "")
+    .replace(/--md-accent-color:\s*[^;]+;?/g, "")
+    .replace(/--md-container-bg:\s*[^;]+;?/g, "")
+    .replace(/--foreground:\s*[^;]+;?/g, "");
 }
 
 export function normalizeInlineCss(html: string, style: StyleConfig = DEFAULT_STYLE): string {

packages/baoyu-md/src/images.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  getImageExtension,
+  replaceMarkdownImagesWithPlaceholders,
+  resolveContentImages,
+  resolveImagePath,
+} from "./images.ts";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("replaceMarkdownImagesWithPlaceholders rewrites markdown and tracks image metadata", () => {
+  const result = replaceMarkdownImagesWithPlaceholders(
+    `![cover](images/cover.png)\n\nText\n\n![diagram](images/diagram.webp)`,
+    "IMG_",
+  );
+
+  assert.equal(result.markdown, `IMG_1\n\nText\n\nIMG_2`);
+  assert.deepEqual(result.images, [
+    { alt: "cover", originalPath: "images/cover.png", placeholder: "IMG_1" },
+    { alt: "diagram", originalPath: "images/diagram.webp", placeholder: "IMG_2" },
+  ]);
+});
+
+test("image extension and local fallback resolution handle common path variants", async (t) => {
+  assert.equal(getImageExtension("https://example.com/a.jpeg?x=1"), "jpeg");
+  assert.equal(getImageExtension("/tmp/figure"), "png");
+
+  const root = await makeTempDir("baoyu-md-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "figure.webp"), "webp");
+
+  const resolved = await resolveImagePath("figure.png", baseDir, tempDir, "test");
+  assert.equal(resolved, path.join(baseDir, "figure.webp"));
+});
+
+test("resolveContentImages resolves image placeholders against the content directory", async (t) => {
+  const root = await makeTempDir("baoyu-md-content-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "cover.png"), "png");
+
+  const resolved = await resolveContentImages(
+    [
+      {
+        alt: "cover",
+        originalPath: "cover.png",
+        placeholder: "IMG_1",
+      },
+    ],
+    baseDir,
+    tempDir,
+    "test",
+  );
+
+  assert.deepEqual(resolved, [
+    {
+      alt: "cover",
+      originalPath: "cover.png",
+      placeholder: "IMG_1",
+      localPath: path.join(baseDir, "cover.png"),
+    },
+  ]);
+});

packages/baoyu-md/src/renderer.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { initRenderer, renderMarkdown } from "./renderer.ts";
+
+const render = (md: string) => {
+  const r = initRenderer();
+  return renderMarkdown(md, r).html;
+};
+
+test("bold with inline code (no underscore)", () => {
+  const html = render("**算出 `logits`，算出 `loss`。**");
+  assert.match(html, /<code[^>]*>logits<\/code>/);
+  assert.match(html, /<code[^>]*>loss<\/code>/);
+});
+
+test("bold with inline code (contains underscore)", () => {
+  const html = render("**变成 `input_ids`。**");
+  assert.match(html, /<code[^>]*>input_ids<\/code>/);
+});
+
+test("emphasis with inline code", () => {
+  const html = render("*查看 `hidden_states`*");
+  assert.match(html, /<code[^>]*>hidden_states<\/code>/);
+});
+
+test("plain inline code (regression)", () => {
+  const html = render("`lm_head`");
+  assert.match(html, /<code[^>]*>lm_head<\/code>/);
+});
+
+test("bold without code (regression)", () => {
+  const html = render("**纯粗体文本**");
+  assert.match(html, /<strong[^>]*>纯粗体文本<\/strong>/);
+  assert.doesNotMatch(html, /<code/);
+});
+
+test("bold with inline code containing backticks", () => {
+  const html = render("**``a`b``**");
+  assert.match(html, /<code[^>]*>a&#96;b<\/code>/);
+});
+
+test("emphasis with inline code containing backticks", () => {
+  const html = render("*``a`b``*");
+  assert.match(html, /<em[^>]*><code[^>]*>a&#96;b<\/code><\/em>/);
+});
+
+test("bold with inline code containing consecutive backticks", () => {
+  const html = render("**```a``b```**");
+  assert.match(html, /<code[^>]*>a&#96;&#96;b<\/code>/);
+});
+
+test("bold with inline code containing only backticks", () => {
+  const html = render("**```` `` ````**");
+  assert.match(html, /<code[^>]*>&#96;&#96;<\/code>/);
+});
+
+test("bold with inline code containing only spaces", () => {
+  const oneSpace = render("**`` ``**");
+  assert.match(oneSpace, /<code[^>]*> <\/code>/);
+
+  const twoSpaces = render("**``  ``**");
+  assert.match(twoSpaces, /<code[^>]*>  <\/code>/);
+});

packages/baoyu-md/src/renderer.ts

@@ -109,6 +109,13 @@ function parseFrontMatterAndContent(markdownText: string): ParseResult {
   }
 }
 
+function wrapInlineCode(value: string): string {
+  const runs = value.match(/`+/g);
+  const fence = "`".repeat(Math.max(...(runs?.map((run) => run.length) ?? [0])) + 1);
+  const padding = /^ *$/.test(value) ? "" : " ";
+  return `${fence}${padding}${value}${padding}${fence}`;
+}
+
 export function initRenderer(opts: IOpts = {}): RendererAPI {
   const footnotes: [number, string, string][] = [];
   let footnoteIndex = 0;
@@ -369,6 +376,7 @@ function preprocessCjkEmphasis(markdown: string): string {
   const tree = processor.parse(markdown);
   const extractText = (node: any): string => {
     if (node.type === "text") return node.value;
+    if (node.type === "inlineCode") return wrapInlineCode(node.value);
     if (node.children) return node.children.map(extractText).join("");
     return "";
   };

packages/baoyu-md/src/themes.ts

@@ -6,6 +6,7 @@ import type { ThemeName } from "./types.js";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const THEME_DIR = path.resolve(SCRIPT_DIR, "themes");
 const FALLBACK_THEMES: ThemeName[] = ["default", "grace", "simple"];
+const THEMES_EXTENDING_DEFAULT = new Set<ThemeName>(["grace", "simple"]);
 
 function stripOutputScope(cssContent: string): string {
   let css = cssContent;
@@ -41,6 +42,7 @@ export function loadThemeCss(theme: ThemeName): {
   themeCss: string;
 } {
   const basePath = path.join(THEME_DIR, "base.css");
+  const defaultThemePath = path.join(THEME_DIR, "default.css");
   const themePath = path.join(THEME_DIR, `${theme}.css`);
 
   if (!fs.existsSync(basePath)) {
@@ -51,9 +53,18 @@ export function loadThemeCss(theme: ThemeName): {
     throw new Error(`Missing theme CSS for "${theme}": ${themePath}`);
   }
 
+  const layeredThemeCss: string[] = [];
+  if (theme !== "default" && THEMES_EXTENDING_DEFAULT.has(theme)) {
+    if (!fs.existsSync(defaultThemePath)) {
+      throw new Error(`Missing default theme CSS: ${defaultThemePath}`);
+    }
+    layeredThemeCss.push(fs.readFileSync(defaultThemePath, "utf-8"));
+  }
+  layeredThemeCss.push(fs.readFileSync(themePath, "utf-8"));
+
   return {
     baseCss: fs.readFileSync(basePath, "utf-8"),
-    themeCss: fs.readFileSync(themePath, "utf-8"),
+    themeCss: layeredThemeCss.join("\n"),
   };
 }
 

scripts/lib/release-files.test.ts

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  listReleaseFiles,
+  validateSelfContainedRelease,
+} from "./release-files.mjs";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function writeFile(filePath: string, contents = ""): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, contents);
+}
+
+async function writeJson(filePath: string, value: unknown): Promise<void> {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+test("listReleaseFiles skips generated paths and returns sorted relative paths", async (t) => {
+  const root = await makeTempDir("baoyu-release-files-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  await writeFile(path.join(root, "b.txt"), "b");
+  await writeFile(path.join(root, "a.txt"), "a");
+  await writeFile(path.join(root, "nested", "keep.txt"), "keep");
+  await writeFile(path.join(root, "node_modules", "skip.js"), "skip");
+  await writeFile(path.join(root, ".git", "config"), "skip");
+  await writeFile(path.join(root, "dist", "artifact.txt"), "skip");
+  await writeFile(path.join(root, "out", "artifact.txt"), "skip");
+  await writeFile(path.join(root, "build", "artifact.txt"), "skip");
+  await writeFile(path.join(root, ".DS_Store"), "skip");
+  await writeFile(path.join(root, "bun.lockb"), "skip");
+
+  const files = await listReleaseFiles(root);
+
+  assert.deepEqual(
+    files.map((file) => file.relPath),
+    ["a.txt", "b.txt", "nested/keep.txt"],
+  );
+});
+
+test("validateSelfContainedRelease accepts file dependencies that stay within the release root", async (t) => {
+  const root = await makeTempDir("baoyu-release-ok-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  await writeJson(path.join(root, "shared", "package.json"), {
+    name: "shared-package",
+    version: "1.0.0",
+  });
+  await writeFile(path.join(root, "shared", "index.js"), "export const shared = true;\n");
+  await writeJson(path.join(root, "skill", "package.json"), {
+    name: "test-skill",
+    version: "1.0.0",
+    dependencies: {
+      "shared-package": "file:../shared",
+    },
+  });
+
+  await assert.doesNotReject(() => validateSelfContainedRelease(root));
+});
+
+test("validateSelfContainedRelease rejects missing local file dependencies", async (t) => {
+  const root = await makeTempDir("baoyu-release-missing-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  await writeJson(path.join(root, "skill", "package.json"), {
+    name: "test-skill",
+    version: "1.0.0",
+    dependencies: {
+      "shared-package": "file:../shared",
+    },
+  });
+
+  await assert.rejects(
+    () => validateSelfContainedRelease(root),
+    /Missing local dependency for release/,
+  );
+});
+
+test("validateSelfContainedRelease rejects file dependencies outside the release root", async (t) => {
+  const root = await makeTempDir("baoyu-release-root-");
+  const outside = await makeTempDir("baoyu-release-outside-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+  t.after(() => fs.rm(outside, { recursive: true, force: true }));
+
+  const skillDir = path.join(root, "skill");
+  const externalSpec = path
+    .relative(skillDir, outside)
+    .split(path.sep)
+    .join("/");
+
+  await writeJson(path.join(skillDir, "package.json"), {
+    name: "test-skill",
+    version: "1.0.0",
+    dependencies: {
+      "outside-package": `file:${externalSpec}`,
+    },
+  });
+
+  await assert.rejects(
+    () => validateSelfContainedRelease(root),
+    /Release target is not self-contained/,
+  );
+});

scripts/lib/shared-skill-packages.test.ts

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { syncSharedSkillPackages } from "./shared-skill-packages.mjs";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function writeFile(filePath: string, contents = ""): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, contents);
+}
+
+async function writeJson(filePath: string, value: unknown): Promise<void> {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+test("syncSharedSkillPackages vendors workspace packages into skill scripts", async (t) => {
+  const root = await makeTempDir("baoyu-sync-shared-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  await writeJson(path.join(root, "packages", "baoyu-md", "package.json"), {
+    name: "baoyu-md",
+    version: "1.0.0",
+  });
+  await writeFile(
+    path.join(root, "packages", "baoyu-md", "src", "index.ts"),
+    "export const markdown = true;\n",
+  );
+
+  const consumerDir = path.join(root, "skills", "demo-skill", "scripts");
+  await writeJson(path.join(consumerDir, "package.json"), {
+    name: "demo-skill-scripts",
+    version: "1.0.0",
+    dependencies: {
+      "baoyu-md": "^1.0.0",
+      kleur: "^4.1.5",
+    },
+  });
+
+  const result = await syncSharedSkillPackages(root, { install: false });
+
+  assert.deepEqual(result.packageDirs, [consumerDir]);
+  assert.deepEqual(result.managedPaths, [
+    "skills/demo-skill/scripts/bun.lock",
+    "skills/demo-skill/scripts/package.json",
+    "skills/demo-skill/scripts/vendor",
+  ]);
+
+  const updatedPackageJson = JSON.parse(
+    await fs.readFile(path.join(consumerDir, "package.json"), "utf8"),
+  ) as { dependencies: Record<string, string> };
+  assert.equal(updatedPackageJson.dependencies["baoyu-md"], "file:./vendor/baoyu-md");
+  assert.equal(updatedPackageJson.dependencies.kleur, "^4.1.5");
+
+  const vendoredPackageJson = JSON.parse(
+    await fs.readFile(path.join(consumerDir, "vendor", "baoyu-md", "package.json"), "utf8"),
+  ) as { name: string };
+  assert.equal(vendoredPackageJson.name, "baoyu-md");
+
+  const vendoredFile = await fs.readFile(
+    path.join(consumerDir, "vendor", "baoyu-md", "src", "index.ts"),
+    "utf8",
+  );
+  assert.match(vendoredFile, /markdown = true/);
+});

skills/baoyu-article-illustrator/SKILL.md

@@ -133,7 +133,7 @@ Full procedures: [references/workflow.md](references/workflow.md#step-5-generate
 
 ### Step 6: Finalize
 
-Insert `![description](path/NN-{type}-{slug}.png)` after paragraphs.
+Insert `![description]({relative-path}/NN-{type}-{slug}.png)` after paragraphs. Path computed relative to article file based on output directory setting.
 
 ```
 Article Illustration Complete!
@@ -143,15 +143,27 @@ Images: X/N generated
 
 ## Output Directory
 
+Output directory is determined by `default_output_dir` in EXTEND.md (set during first-time setup):
+
+| `default_output_dir` | Output Path | Markdown Insert Path |
+|----------------------|-------------|----------------------|
+| `imgs-subdir` (default) | `{article-dir}/imgs/` | `imgs/NN-{type}-{slug}.png` |
+| `same-dir` | `{article-dir}/` | `NN-{type}-{slug}.png` |
+| `illustrations-subdir` | `{article-dir}/illustrations/` | `illustrations/NN-{type}-{slug}.png` |
+| `independent` | `illustrations/{topic-slug}/` | `illustrations/{topic-slug}/NN-{type}-{slug}.png` (relative to cwd) |
+
+All auxiliary files (outline, prompts) are saved inside the output directory:
+
 ```
-illustrations/{topic-slug}/
-├── source-{slug}.{ext}
-├── references/           # if provided
+{output-dir}/
 ├── outline.md
 ├── prompts/
+│   └── NN-{type}-{slug}.md
 └── NN-{type}-{slug}.png
 ```
 
+When input is **pasted content** (no file path), always uses `illustrations/{topic-slug}/` with `source-{slug}.{ext}` saved alongside.
+
 **Slug**: 2-4 words, kebab-case. **Conflict**: append `-YYYYMMDD-HHMMSS`.
 
 ## Modification

skills/baoyu-article-illustrator/references/config/first-time-setup.md

@@ -69,7 +69,23 @@ options:
     description: "Friendly, approachable, personal"
 ```
 
-### Question 3: Save Location
+### Question 3: Output Directory
+
+```
+header: "Output Directory"
+question: "Where to save generated illustrations when illustrating a file?"
+options:
+  - label: "imgs-subdir (Recommended)"
+    description: "{article-dir}/imgs/ — images in a subdirectory next to the article"
+  - label: "same-dir"
+    description: "{article-dir}/ — images alongside the article file"
+  - label: "illustrations-subdir"
+    description: "{article-dir}/illustrations/ — separate illustrations subdirectory"
+  - label: "independent"
+    description: "illustrations/{topic-slug}/ — standalone directory in cwd"
+```
+
+### Question 4: Save Location
 
 ```
 header: "Save"
@@ -108,6 +124,7 @@ watermark:
 preferred_style:
   name: [selected style or null]
   description: ""
+default_output_dir: imgs-subdir  # same-dir | imgs-subdir | illustrations-subdir | independent
 language: null
 custom_styles: []
 ---

skills/baoyu-article-illustrator/references/workflow.md

@@ -55,7 +55,7 @@ Reference Style Extracted (no file):
 
 | Input | Output Directory | Next |
 |-------|------------------|------|
-| File path | Ask user (1.2) | → 1.2 |
+| File path | EXTEND.md `default_output_dir` (default: `imgs-subdir`). If not configured, confirm in 1.2. | → 1.2 |
 | Pasted content | `illustrations/{topic-slug}/` | → 1.4 |
 
 **Backup rule for pasted content**: If `source.md` exists in target directory, rename to `source-backup-YYYYMMDD-HHMMSS.md` before saving.
@@ -68,7 +68,7 @@ Check preferences and existing state, then ask ALL needed questions in ONE AskUs
 
 | Question | When to Ask | Options |
 |----------|-------------|---------|
-| Output directory | No `default_output_dir` in EXTEND.md | `{article-dir}/`, `{article-dir}/imgs/` (Recommended), `{article-dir}/illustrations/`, `illustrations/{topic-slug}/` |
+| Output directory | No `default_output_dir` in EXTEND.md | `{article-dir}/imgs/` (Recommended), `{article-dir}/`, `{article-dir}/illustrations/`, `illustrations/{topic-slug}/` |
 | Existing images | Target dir has `.png/.jpg/.webp` files | `supplement`, `overwrite`, `regenerate` |
 | Article update | Always (file path input) | `update`, `copy` |
 
@@ -237,7 +237,7 @@ Reference Images:
 
 ## Step 4: Generate Outline
 
-Save as `outline.md`:
+Save as `{output-dir}/outline.md` (all paths below are relative to the output directory determined in Step 1.1/1.2):
 
 ```yaml
 ---
@@ -285,7 +285,7 @@ references:                    # Only if references provided
 
 For each illustration in the outline:
 
-1. **Create prompt file**: `prompts/NN-{type}-{slug}.md`
+1. **Create prompt file**: `{output-dir}/prompts/NN-{type}-{slug}.md`
 2. **Include YAML frontmatter**:
    ```yaml
    ---
@@ -381,10 +381,14 @@ Add: `Include a subtle watermark "[content]" at [position].`
 
 ### 6.1 Update Article
 
-Insert after corresponding paragraph:
-```markdown
-![description](illustrations/{slug}/NN-{type}-{slug}.png)
-```
+Insert after corresponding paragraph, using path relative to article file:
+
+| `default_output_dir` | Insert Path |
+|----------------------|-------------|
+| `imgs-subdir` | `![description](imgs/NN-{type}-{slug}.png)` |
+| `same-dir` | `![description](NN-{type}-{slug}.png)` |
+| `illustrations-subdir` | `![description](illustrations/NN-{type}-{slug}.png)` |
+| `independent` | `![description](illustrations/{topic-slug}/NN-{type}-{slug}.png)` (relative to cwd) |
 
 Alt text: concise description in article's language.
 

skills/baoyu-cover-image/SKILL.md

@@ -162,9 +162,21 @@ if (Test-Path "$HOME/.baoyu-skills/baoyu-cover-image/EXTEND.md") { "user" }
 5. **Detect language**: Compare source, user input, EXTEND.md preference
 6. **Determine output directory**: Per File Structure rules
 
+**⚠️ People in Reference Images — MUST follow all 3 rules:**
+
+If reference images contain **people** who should appear in the cover:
+
+1. **`usage: direct`** — MUST set in refs description file. NEVER use `style` or `palette` when people need to appear
+2. **Per-character description** — MUST describe each person's distinctive features (hair, glasses, skin tone, clothing) in `refs/ref-NN-{slug}.md`. Vague descriptions like "a man" will fail
+3. **`--ref` flag** — MUST pass reference image via `--ref` in Step 4 so the model sees actual faces
+
+See [reference-images.md § Character Analysis](references/workflow/reference-images.md) for description format.
+
 ### Step 2: Confirm Options ⚠️
 
-Full confirmation flow: [references/workflow/confirm-options.md](references/workflow/confirm-options.md)
+**MUST use `AskUserQuestion` tool** to present options as interactive selection — NOT plain text tables. Present up to 4 questions in a single `AskUserQuestion` call (Type, Palette, Rendering, Font + Settings). Each question shows the recommended option first with reason, followed by alternatives.
+
+Full confirmation flow and question format: [references/workflow/confirm-options.md](references/workflow/confirm-options.md)
 
 | Condition | Skipped | Still Asked |
 |-----------|---------|-------------|

skills/baoyu-cover-image/references/base-prompt.md

@@ -83,12 +83,17 @@ Full library: [references/visual-elements.md](visual-elements.md)
 
 ### Character Handling
 
-When people are needed:
+**Default (no reference with people)**:
 - Use simplified silhouettes or abstract stick figures
 - Symbolic representations (head + shoulders outline)
 - NO realistic faces, detailed anatomy, or photographic representations
 - Cartoon/icon style consistent with rendering choice
 
+**When reference images contain people**:
+- Reference image is passed to model (`usage: direct`) — model must visually reference it to preserve character likeness
+- Stylize to match chosen rendering (cartoon/vector), preserving distinctive features (hair, clothing, pose)
+- NEVER photorealistic
+
 ## Mood Application
 
 Apply mood adjustments to the base palette:

skills/baoyu-cover-image/references/workflow/prompt-template.md

@@ -201,6 +201,12 @@ CRITICAL: The generated cover MUST visually reference the provided images. The c
 - [Typography]: [Specific treatment, e.g., "Uppercase text with wide letter-spacing"]
 - [Layout element]: [Specific spatial element, e.g., "Bottom banner strip in dark color"]
 
+## From Ref 1 ([filename]) — Characters (if people present):
+- **Character 1**: [Appearance, e.g., "Woman, long wavy blonde hair"] → MUST stylize: [e.g., "flat-vector, simplified face, keep blonde hair, label: 'Nicole Forsgren'"]
+- **Character 2**: [Appearance, e.g., "Man, short dark hair, stubble"] → MUST stylize: [e.g., "flat-vector, simplified face, keep dark hair, label: 'Gergely Orosz'"]
+- **Placement**: [e.g., "Right third, side by side, facing left toward main visual"]
+- **Style**: Match rendering style, NOT photorealistic
+
 ## From Ref 2 ([filename]) — REQUIRED elements:
 [Same detailed breakdown]
 

skills/baoyu-cover-image/references/workflow/reference-images.md

@@ -31,8 +31,8 @@ usage: direct | style | palette
 
 | Usage | When to Use |
 |-------|-------------|
-| `direct` | Reference matches desired output closely |
-| `style` | Extract visual style characteristics only |
+| `direct` | Model sees reference image directly; required if people must appear in output |
+| `style` | Extract visual style only (not for people who must appear) |
 | `palette` | Extract color scheme only |
 
 ## Verbal Extraction (No File)
@@ -59,6 +59,19 @@ References are high-priority inputs. Extract **specific, concrete, reproducible*
 
 **Output format**: List each element as bullet that can be copy-pasted into prompt as mandatory instruction.
 
+### Character Analysis ⚠️ If Reference Contains People
+
+Use `usage: direct` so model sees the reference image. Additionally describe per character: **appearance**, **pose**, **clothing** → with **transformation rules** (stylize to match rendering).
+
+| Extract | Good | Bad |
+|---------|------|-----|
+| Appearance | "Woman: long wavy blonde hair, friendly smile" | "A woman" |
+| Pose | "Standing, facing camera, confident posture" | "Standing" |
+| Clothing | "Dark T-shirt, business casual" | "Formal" |
+| Transform | "Flat-vector cartoon, keep hair color & clothing" | "Make cartoon" |
+
+Use `usage: direct`. Output each character as MUST/REQUIRED prompt instruction.
+
 ## Verification Output
 
 **For saved files**:

skills/baoyu-danger-gemini-web/SKILL.md

@@ -139,6 +139,10 @@ ${BUN_X} {baseDir}/scripts/main.ts "Hello" --json
 
 First run opens browser for Google auth. Cookies cached automatically.
 
+When no explicit profile dir is set, cookie refresh may reuse an already-running local Chrome/Chromium debugging session tied to a standard user-data dir.
+Set `--profile-dir` or `GEMINI_WEB_CHROME_PROFILE_DIR` to force a dedicated profile and skip existing-session reuse.
+This is a best-effort CDP session reuse path, not the Chrome DevTools MCP prompt-based `--autoConnect` flow described in Chrome's official docs.
+
 Supported browsers (auto-detected): Chrome, Chrome Canary/Beta, Chromium, Edge.
 
 Force refresh: `--login` flag. Override browser: `GEMINI_WEB_CHROME_PATH` env var.

skills/baoyu-danger-gemini-web/scripts/gemini-webapi/utils/load-browser-cookies.ts

@@ -2,6 +2,7 @@ import process from 'node:process';
 
 import {
   CdpConnection,
+  discoverRunningChromeDebugPort,
   findChromeExecutable as findChromeExecutableBase,
   findExistingChromeDebugPort,
   getFreePort,
@@ -97,6 +98,87 @@ async function is_gemini_session_ready(cookies: CookieMap, verbose: boolean): Pr
   }
 }
 
+async function fetch_cookies_from_existing_chrome(
+  timeoutMs: number,
+  verbose: boolean,
+): Promise<CookieMap | null> {
+  const discovered = await discoverRunningChromeDebugPort();
+  if (discovered === null) return null;
+
+  if (verbose) logger.info(`Found reusable Chrome debugging session on port ${discovered.port}. Connecting via WebSocket...`);
+
+  let cdp: CdpConnection | null = null;
+  let targetId: string | null = null;
+  let createdTarget = false;
+  try {
+    const connectStart = Date.now();
+    const connectTimeout = 30_000;
+    let lastConnErr: unknown = null;
+    while (Date.now() - connectStart < connectTimeout) {
+      try {
+        cdp = await CdpConnection.connect(discovered.wsUrl, 5_000);
+        break;
+      } catch (e) {
+        lastConnErr = e;
+        if (verbose) logger.debug(`WebSocket connect attempt failed: ${e instanceof Error ? e.message : String(e)}, retrying...`);
+        await sleep(1000);
+      }
+    }
+    if (!cdp) {
+      if (verbose) logger.debug(`Could not connect to Chrome after ${connectTimeout / 1000}s: ${lastConnErr instanceof Error ? lastConnErr.message : String(lastConnErr)}`);
+      return null;
+    }
+
+    const page = await openPageSession({
+      cdp,
+      reusing: false,
+      url: GEMINI_APP_URL,
+      matchTarget: (target) => target.type === 'page' && target.url.includes('gemini.google.com'),
+      enableNetwork: true,
+      activateTarget: false,
+    });
+    const { sessionId } = page;
+    targetId = page.targetId;
+    createdTarget = page.createdTarget;
+
+    if (verbose) logger.debug(createdTarget ? 'No Gemini tab found, creating new tab...' : 'Found existing Gemini tab, attaching...');
+
+    const start = Date.now();
+    let last: CookieMap = {};
+
+    while (Date.now() - start < timeoutMs) {
+      const { cookies } = await cdp.send<{ cookies: Array<{ name: string; value: string }> }>(
+        'Network.getCookies',
+        { urls: ['https://gemini.google.com/', 'https://accounts.google.com/', 'https://www.google.com/'] },
+        { sessionId, timeoutMs: 10_000 },
+      );
+
+      const cookieMap: CookieMap = {};
+      for (const cookie of cookies) {
+        if (cookie?.name && typeof cookie.value === 'string') cookieMap[cookie.name] = cookie.value;
+      }
+
+      last = cookieMap;
+      if (await is_gemini_session_ready(cookieMap, verbose)) return cookieMap;
+
+      await sleep(1000);
+    }
+
+    if (verbose) logger.debug(`Existing Chrome did not yield valid cookies. Last keys: ${Object.keys(last).join(', ')}`);
+    return null;
+  } catch (e) {
+    if (verbose) logger.debug(`Failed to connect to existing Chrome debugging session: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  } finally {
+    if (cdp) {
+      if (createdTarget && targetId) {
+        try { await cdp.send('Target.closeTarget', { targetId }, { timeoutMs: 5_000 }); } catch {}
+      }
+      cdp.close();
+    }
+  }
+}
+
 async function fetch_google_cookies_via_cdp(
   profileDir: string,
   timeoutMs: number,
@@ -178,6 +260,19 @@ export async function load_browser_cookies(domain_name: string = '', verbose: bo
     if (cached) return { chrome: cached };
   }
 
+  const hasExplicitProfile = !!(process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || process.env.BAOYU_CHROME_PROFILE_DIR?.trim());
+  const existingCookies = hasExplicitProfile ? null : await fetch_cookies_from_existing_chrome(30_000, verbose);
+  if (existingCookies) {
+    const filtered: CookieMap = {};
+    for (const [key, value] of Object.entries(existingCookies)) {
+      if (typeof value === 'string' && value.length > 0) filtered[key] = value;
+    }
+
+    await write_cookie_file(filtered, resolveGeminiWebCookiePath(), 'cdp-existing');
+    void domain_name;
+    return { chrome: filtered };
+  }
+
   const profileDir = process.env.GEMINI_WEB_CHROME_PROFILE_DIR?.trim() || resolveGeminiWebChromeProfileDir();
   const cookies = await fetch_google_cookies_via_cdp(profileDir, 120_000, verbose);
 

skills/baoyu-danger-gemini-web/scripts/main.ts

@@ -101,7 +101,12 @@ Options:
   -h, --help                Show help
 
 Env overrides:
-  GEMINI_WEB_DATA_DIR, GEMINI_WEB_COOKIE_PATH, GEMINI_WEB_CHROME_PROFILE_DIR, GEMINI_WEB_CHROME_PATH`);
+  GEMINI_WEB_DATA_DIR, GEMINI_WEB_COOKIE_PATH, GEMINI_WEB_CHROME_PROFILE_DIR, GEMINI_WEB_CHROME_PATH
+
+Notes:
+  By default cookie refresh may reuse an already-running local Chrome/Chromium debugging session.
+  Set --profile-dir or GEMINI_WEB_CHROME_PROFILE_DIR to force a dedicated profile and skip existing-session reuse.
+  This reuse path is separate from Chrome DevTools MCP's prompt-based --autoConnect flow.`);
 }
 
 function parseArgs(argv: string[]): CliArgs {

skills/baoyu-danger-gemini-web/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

skills/baoyu-danger-gemini-web/scripts/vendor/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }

skills/baoyu-danger-x-to-markdown/scripts/markdown.test.ts

@@ -0,0 +1,179 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { formatArticleMarkdown } from "./markdown.js";
+
+test("formatArticleMarkdown renders MARKDOWN entities from atomic blocks", () => {
+  const article = {
+    title: "Atomic Markdown Example",
+    content_state: {
+      blocks: [
+        {
+          type: "unstyled",
+          text: "Before the snippet.",
+          entityRanges: [],
+        },
+        {
+          type: "atomic",
+          text: " ",
+          entityRanges: [{ key: 0, offset: 0, length: 1 }],
+        },
+        {
+          type: "unstyled",
+          text: "After the snippet.",
+          entityRanges: [],
+        },
+      ],
+      entityMap: {
+        "0": {
+          key: "5",
+          value: {
+            type: "MARKDOWN",
+            mutability: "Mutable",
+            data: {
+              markdown: "```python\nprint('hello from x article')\n```\n",
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const { markdown } = formatArticleMarkdown(article);
+
+  assert.ok(markdown.includes("Before the snippet."));
+  assert.ok(markdown.includes("```python\nprint('hello from x article')\n```"));
+  assert.ok(markdown.includes("After the snippet."));
+  assert.strictEqual(markdown, `# Atomic Markdown Example
+
+Before the snippet.
+
+\`\`\`python
+print('hello from x article')
+\`\`\`
+
+After the snippet.`);
+});
+
+test("formatArticleMarkdown renders article video media as poster plus video link", () => {
+  const posterUrl = "https://pbs.twimg.com/amplify_video_thumb/123/img/poster.jpg";
+  const videoUrl = "https://video.twimg.com/amplify_video/123/vid/avc1/720x720/demo.mp4?tag=21";
+  const article = {
+    title: "Video Example",
+    content_state: {
+      blocks: [
+        {
+          type: "unstyled",
+          text: "Intro text.",
+          entityRanges: [],
+        },
+        {
+          type: "atomic",
+          text: " ",
+          entityRanges: [{ key: 0, offset: 0, length: 1 }],
+        },
+      ],
+      entityMap: {
+        "0": {
+          key: "0",
+          value: {
+            type: "MEDIA",
+            mutability: "Immutable",
+            data: {
+              caption: "Demo reel",
+              mediaItems: [{ mediaId: "vid-1" }],
+            },
+          },
+        },
+      },
+    },
+    media_entities: [
+      {
+        media_id: "vid-1",
+        media_info: {
+          __typename: "ApiVideo",
+          preview_image: {
+            original_img_url: posterUrl,
+          },
+          variants: [
+            {
+              content_type: "video/mp4",
+              bit_rate: 256000,
+              url: videoUrl,
+            },
+          ],
+        },
+      },
+    ],
+  };
+
+  const { markdown } = formatArticleMarkdown(article);
+
+  assert.ok(markdown.includes("Intro text."));
+  assert.ok(markdown.includes(`![Demo reel](${posterUrl})`));
+  assert.ok(markdown.includes(`[video](${videoUrl})`));
+  assert.ok(!markdown.includes(`![Demo reel](${videoUrl})`));
+  assert.ok(!markdown.includes("## Media"));
+});
+
+test("formatArticleMarkdown renders unused article videos in trailing media section", () => {
+  const posterUrl = "https://pbs.twimg.com/amplify_video_thumb/456/img/poster.jpg";
+  const videoUrl = "https://video.twimg.com/amplify_video/456/vid/avc1/1080x1080/demo.mp4?tag=21";
+  const article = {
+    title: "Trailing Media Example",
+    plain_text: "Body text.",
+    media_entities: [
+      {
+        media_id: "vid-2",
+        media_info: {
+          __typename: "ApiVideo",
+          preview_image: {
+            original_img_url: posterUrl,
+          },
+          variants: [
+            {
+              content_type: "video/mp4",
+              bit_rate: 832000,
+              url: videoUrl,
+            },
+          ],
+        },
+      },
+    ],
+  };
+
+  const { markdown, coverUrl } = formatArticleMarkdown(article);
+
+  assert.strictEqual(coverUrl, null);
+  assert.ok(markdown.includes("## Media"));
+  assert.ok(markdown.includes(`![video](${posterUrl})`));
+  assert.ok(markdown.includes(`[video](${videoUrl})`));
+});
+
+test("formatArticleMarkdown keeps coverUrl as preview image for video cover media", () => {
+  const posterUrl = "https://pbs.twimg.com/amplify_video_thumb/789/img/poster.jpg";
+  const videoUrl = "https://video.twimg.com/amplify_video/789/vid/avc1/720x720/demo.mp4?tag=21";
+  const article = {
+    title: "Video Cover Example",
+    plain_text: "Body text.",
+    cover_media: {
+      media_info: {
+        __typename: "ApiVideo",
+        preview_image: {
+          original_img_url: posterUrl,
+        },
+        variants: [
+          {
+            content_type: "video/mp4",
+            bit_rate: 1280000,
+            url: videoUrl,
+          },
+        ],
+      },
+    },
+  };
+
+  const { coverUrl } = formatArticleMarkdown(article);
+
+  assert.strictEqual(coverUrl, posterUrl);
+});

skills/baoyu-danger-x-to-markdown/scripts/markdown.ts

@@ -18,6 +18,17 @@ export type FormatArticleOptions = {
   referencedTweets?: Map<string, ReferencedTweetInfo>;
 };
 
+type ResolvedMediaAsset =
+  | {
+      kind: "image";
+      url: string;
+    }
+  | {
+      kind: "video";
+      url: string;
+      posterUrl?: string;
+    };
+
 function coerceArticleEntity(value: unknown): ArticleEntity | null {
   if (!value || typeof value !== "object") return null;
   const candidate = value as ArticleEntity;
@@ -109,58 +120,127 @@ function resolveEntityEntry(
   return entityMap[String(entityKey)];
 }
 
-function resolveMediaUrl(info?: ArticleMediaInfo): string | undefined {
+function resolveVideoUrl(info?: ArticleMediaInfo): string | undefined {
   if (!info) return undefined;
-  if (info.original_img_url) return info.original_img_url;
-  if (info.preview_image?.original_img_url) return info.preview_image.original_img_url;
   const variants = info.variants ?? [];
   const mp4 = variants
     .filter((variant) => variant?.content_type?.includes("video"))
     .sort((a, b) => (b.bit_rate ?? 0) - (a.bit_rate ?? 0))[0];
-  return mp4?.url ?? variants[0]?.url;
+  return mp4?.url ?? variants.find((variant) => typeof variant?.url === "string")?.url;
 }
 
-function buildMediaById(article: ArticleEntity): Map<string, string> {
-  const map = new Map<string, string>();
+function resolveMediaAsset(info?: ArticleMediaInfo): ResolvedMediaAsset | undefined {
+  if (!info) return undefined;
+
+  const posterUrl = info.preview_image?.original_img_url ?? info.original_img_url;
+  const videoUrl = resolveVideoUrl(info);
+  if (videoUrl) {
+    return {
+      kind: "video",
+      url: videoUrl,
+      posterUrl,
+    };
+  }
+
+  const imageUrl = info.original_img_url ?? info.preview_image?.original_img_url;
+  if (imageUrl) {
+    return {
+      kind: "image",
+      url: imageUrl,
+    };
+  }
+
+  return undefined;
+}
+
+function resolveFallbackMediaAsset(rawUrl?: string): ResolvedMediaAsset | undefined {
+  if (!rawUrl) return undefined;
+
+  if (/^https:\/\/video\.twimg\.com\//i.test(rawUrl) || /\.(mp4|m4v|mov|webm)(?:$|[?#])/i.test(rawUrl)) {
+    return {
+      kind: "video",
+      url: rawUrl,
+    };
+  }
+
+  return {
+    kind: "image",
+    url: rawUrl,
+  };
+}
+
+function resolveCoverUrl(info?: ArticleMediaInfo): string | undefined {
+  if (!info) return undefined;
+  return info.original_img_url ?? info.preview_image?.original_img_url;
+}
+
+function buildMediaIdentity(asset: ResolvedMediaAsset): string {
+  return asset.kind === "video"
+    ? `video:${asset.url}:${asset.posterUrl ?? ""}`
+    : `image:${asset.url}`;
+}
+
+function renderMediaLines(
+  asset: ResolvedMediaAsset,
+  altText: string,
+  usedUrls: Set<string>
+): string[] {
+  if (asset.kind === "video") {
+    const lines: string[] = [];
+    if (asset.posterUrl && !usedUrls.has(asset.posterUrl)) {
+      usedUrls.add(asset.posterUrl);
+      lines.push(`![${altText || "video"}](${asset.posterUrl})`);
+    }
+    if (!usedUrls.has(asset.url)) {
+      usedUrls.add(asset.url);
+      lines.push(`[video](${asset.url})`);
+    }
+    return lines;
+  }
+
+  if (usedUrls.has(asset.url)) {
+    return [];
+  }
+
+  usedUrls.add(asset.url);
+  return [`![${altText}](${asset.url})`];
+}
+
+function buildMediaById(article: ArticleEntity): Map<string, ResolvedMediaAsset> {
+  const map = new Map<string, ResolvedMediaAsset>();
   for (const entity of article.media_entities ?? []) {
     if (!entity?.media_id) continue;
-    const url = resolveMediaUrl(entity.media_info);
-    if (url) {
-      map.set(entity.media_id, url);
+    const asset = resolveMediaAsset(entity.media_info);
+    if (asset) {
+      map.set(entity.media_id, asset);
     }
   }
   return map;
 }
 
-function collectMediaUrls(
-  article: ArticleEntity,
-  usedUrls: Set<string>,
-  excludeUrl?: string
-): string[] {
-  const urls: string[] = [];
-  const addUrl = (url?: string) => {
-    if (!url) return;
-    if (excludeUrl && url === excludeUrl) {
-      usedUrls.add(url);
-      return;
-    }
-    if (usedUrls.has(url)) return;
-    usedUrls.add(url);
-    urls.push(url);
+function collectMediaAssets(article: ArticleEntity): ResolvedMediaAsset[] {
+  const assets: ResolvedMediaAsset[] = [];
+  const seen = new Set<string>();
+  const addAsset = (asset?: ResolvedMediaAsset) => {
+    if (!asset) return;
+    const identity = buildMediaIdentity(asset);
+    if (seen.has(identity)) return;
+    seen.add(identity);
+    assets.push(asset);
   };
 
   for (const entity of article.media_entities ?? []) {
-    addUrl(resolveMediaUrl(entity?.media_info));
+    addAsset(resolveMediaAsset(entity?.media_info));
   }
 
-  return urls;
+  return assets;
 }
 
 function resolveEntityMediaLines(
   entityKey: number | undefined,
   entityMap: ArticleContentState["entityMap"] | undefined,
   entityLookup: EntityLookup,
-  mediaById: Map<string, string>,
+  mediaById: Map<string, ResolvedMediaAsset>,
   usedUrls: Set<string>
 ): string[] {
   if (entityKey === undefined) return [];
@@ -182,17 +262,16 @@ function resolveEntityMediaLines(
         : typeof item?.media_id === "string"
           ? item.media_id
           : undefined;
-    const url = mediaId ? mediaById.get(mediaId) : undefined;
-    if (url && !usedUrls.has(url)) {
-      usedUrls.add(url);
-      lines.push(`![${altText}](${url})`);
+    const asset = mediaId ? mediaById.get(mediaId) : undefined;
+    if (asset) {
+      lines.push(...renderMediaLines(asset, altText, usedUrls));
     }
   }
 
   const fallbackUrl = typeof value.data?.url === "string" ? value.data.url : undefined;
-  if (fallbackUrl && !usedUrls.has(fallbackUrl)) {
-    usedUrls.add(fallbackUrl);
-    lines.push(`![${altText}](${fallbackUrl})`);
+  const fallbackAsset = resolveFallbackMediaAsset(fallbackUrl);
+  if (fallbackAsset) {
+    lines.push(...renderMediaLines(fallbackAsset, altText, usedUrls));
   }
 
   return lines;
@@ -237,6 +316,22 @@ function resolveEntityTweetLines(
   return lines;
 }
 
+function resolveEntityMarkdownLines(
+  entityKey: number | undefined,
+  entityMap: ArticleContentState["entityMap"] | undefined,
+  entityLookup: EntityLookup
+): string[] {
+  if (entityKey === undefined) return [];
+  const entry = resolveEntityEntry(entityKey, entityMap, entityLookup);
+  const value = entry?.value;
+  if (!value || value.type !== "MARKDOWN") return [];
+
+  const markdown = typeof value.data?.markdown === "string" ? value.data.markdown : "";
+  const normalized = markdown.replace(/\r\n/g, "\n").trimEnd();
+  if (!normalized) return [];
+  return normalized.split("\n");
+}
+
 function buildMediaLinkMap(
   entityMap: ArticleContentState["entityMap"] | undefined
 ): Map<number, string> {
@@ -330,7 +425,7 @@ function renderContentBlocks(
   blocks: ArticleBlock[],
   entityMap: ArticleContentState["entityMap"] | undefined,
   entityLookup: EntityLookup,
-  mediaById: Map<string, string>,
+  mediaById: Map<string, ResolvedMediaAsset>,
   usedUrls: Set<string>,
   mediaLinkMap: Map<number, string>,
   referencedTweets?: Map<string, ReferencedTweetInfo>
@@ -397,6 +492,16 @@ function renderContentBlocks(
     return [...new Set(linkLines)];
   };
 
+  const collectMarkdownLines = (block: ArticleBlock): string[] => {
+    const ranges = Array.isArray(block.entityRanges) ? block.entityRanges : [];
+    const markdownLines: string[] = [];
+    for (const range of ranges) {
+      if (typeof range?.key !== "number") continue;
+      markdownLines.push(...resolveEntityMarkdownLines(range.key, entityMap, entityLookup));
+    }
+    return markdownLines;
+  };
+
   const pushTrailingMedia = (mediaLines: string[]) => {
     if (mediaLines.length > 0) {
       pushBlock(mediaLines, "media");
@@ -441,6 +546,11 @@ function renderContentBlocks(
         pushBlock(tweetLines, "quote");
       }
 
+      const markdownLines = collectMarkdownLines(block);
+      if (markdownLines.length > 0) {
+        pushBlock(markdownLines, "text");
+      }
+
       const mediaLines = collectMediaLines(block);
       if (mediaLines.length > 0) {
         pushBlock(mediaLines, "media");
@@ -571,7 +681,7 @@ export function formatArticleMarkdown(
     lines.push(`# ${title}`);
   }
 
-  const coverUrl = resolveMediaUrl(candidate.cover_media?.media_info) ?? null;
+  const coverUrl = resolveCoverUrl(candidate.cover_media?.media_info) ?? null;
   if (coverUrl) {
     usedUrls.add(coverUrl);
   }
@@ -602,12 +712,13 @@ export function formatArticleMarkdown(
     lines.push(candidate.preview_text.trim());
   }
 
-  const mediaUrls = collectMediaUrls(candidate, usedUrls, coverUrl ?? undefined);
-  if (mediaUrls.length > 0) {
+  const trailingMediaLines: string[] = [];
+  for (const asset of collectMediaAssets(candidate)) {
+    trailingMediaLines.push(...renderMediaLines(asset, "", usedUrls));
+  }
+  if (trailingMediaLines.length > 0) {
     lines.push("", "## Media", "");
-    for (const url of mediaUrls) {
-      lines.push(`![](${url})`);
-    }
+    lines.push(...trailingMediaLines);
   }
 
   return { markdown: lines.join("\n").trimEnd(), coverUrl };

skills/baoyu-danger-x-to-markdown/scripts/media-localizer.ts

@@ -202,6 +202,13 @@ function toHighResUrl(rawUrl: string): string {
   }
 }
 
+function isPlausibleMediaUrl(rawUrl: string): boolean {
+  const ext = resolveExtensionFromUrl(rawUrl);
+  if (ext && (IMAGE_EXTENSIONS.has(ext) || VIDEO_EXTENSIONS.has(ext))) return true;
+  if (resolveKindFromHostname(rawUrl) !== undefined) return true;
+  return false;
+}
+
 function collectMarkdownLinkCandidates(markdown: string): MarkdownLinkCandidate[] {
   const candidates: MarkdownLinkCandidate[] = [];
   const seen = new Set<string>();
@@ -221,10 +228,12 @@ function collectMarkdownLinkCandidates(markdown: string): MarkdownLinkCandidate[
     const label = match[1] ?? "";
     const rawUrl = match[3] ?? "";
     if (!rawUrl || seen.has(rawUrl)) continue;
+    const isImage = label.startsWith("![");
+    if (!isImage && !isPlausibleMediaUrl(rawUrl)) continue;
     seen.add(rawUrl);
     candidates.push({
       url: rawUrl,
-      hint: label.startsWith("![") ? "image" : "unknown",
+      hint: isImage ? "image" : "unknown",
     });
   }
 

skills/baoyu-danger-x-to-markdown/scripts/types.ts

@@ -38,6 +38,7 @@ export type ArticleEntityMapEntry = {
     mutability?: string;
     data?: {
       caption?: string;
+      markdown?: string;
       mediaItems?: ArticleEntityMapMediaItem[];
       url?: string;
       tweetId?: string;

skills/baoyu-danger-x-to-markdown/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

skills/baoyu-danger-x-to-markdown/scripts/vendor/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }

skills/baoyu-format-markdown/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: baoyu-format-markdown
 description: Formats plain text or markdown files with frontmatter, titles, summaries, headings, bold, lists, and code blocks. Use when user asks to "format markdown", "beautify article", "add formatting", or improve article layout. Outputs to {filename}-formatted.md.
-version: 1.56.1
+version: 1.57.0
 metadata:
   openclaw:
     homepage: https://github.com/JimLiu/baoyu-skills#baoyu-format-markdown
@@ -88,7 +88,7 @@ Read the user-specified file, then detect content type:
 | Has `**bold**`, `*italic*`, lists, code blocks, blockquotes | Markdown |
 | None of above | Plain text |
 
-**If Markdown detected, ask user:**
+**If Markdown detected, use `AskUserQuestion` to ask:**
 
 ```
 Detected existing markdown formatting. What would you like to do?
@@ -174,7 +174,8 @@ Check for YAML frontmatter (`---` block). Create if missing.
 |-------|------------|
 | `title` | See **Title Generation** below |
 | `slug` | Infer from file path or generate from title |
-| `summary` | See **Summary Generation** below |
+| `summary` | One-sentence concise summary (see **Summary Generation** below) |
+| `description` | Longer descriptive summary (see **Summary Generation** below) |
 | `coverImage` | Check if `imgs/cover.png` exists in same directory; if so, use relative path |
 
 **Title Generation:**
@@ -187,73 +188,52 @@ Whether or not a title already exists, always run the title optimization flow (u
 - Reader pain point or curiosity trigger
 - Most memorable metaphor or golden quote
 
-**Generate 3-4 style-differentiated candidates:**
+**Generate titles** using formulas from `references/title-formulas.md`:
 
-| Style | Characteristics | Example |
-|-------|----------------|---------|
-| Subversive | Deny common practice, create conflict | "All de-AI-flavor prompts are wrong" |
-| Solution | Give the answer directly, promise value | "One recipe to make AI write in your voice" |
-| Suspense | Reveal half, spark curiosity | "It took me six months to find how to remove AI flavor" |
-| Concrete number | Use numbers for credibility | "150 lines of docs taught AI my writing style" |
+1. Select the **2-3 best-matching hook formulas** based on the article's content, tone, and structure (see "When to pick each formula" in the reference)
+2. Generate **1-2 straightforward titles** (descriptive or declarative, no formula — clear and accurate)
+3. If the user specifies a direction (e.g., "make it suspenseful"), prioritize that direction
+4. Total: **4-5 candidates**
 
-Present to user:
+Use `AskUserQuestion` to present candidates:
 
 ```
 Pick a title:
 
-1. [Title A] — (recommended)
-2. [Title B] — [style note]
-3. [Title C] — [style note]
+1. [Hook title A] — (recommended) [formula name]
+2. [Hook title B] — [formula name]
+3. [Hook title C] — [formula name]
+4. [Straightforward title D] — straightforward
+5. [Straightforward title E] — straightforward
 
 Enter number, or type a custom title:
 ```
 
-Put the strongest hook first and mark it (recommended).
-
-**Title principles:**
-- **Hook in first 5 chars**: create information gap or cognitive conflict
-- **Specific > abstract**: "150 lines" beats "a document"
-- **Negation > affirmation**: "you're doing it wrong" beats "the right way"
-- **Conversational**: like chatting with a friend, not a paper title
-- **Max ~25 chars**: longer titles get truncated in feeds
-- **Accurate, not clickbait**: the article must deliver what the title promises
-
-**Prohibited patterns:**
-- "浅谈 XX"、"关于 XX 的思考"、"XX 的探索与实践"
-- "震惊！"、"万字长文"、"建议收藏"
-- Pure questions without direction: "AI 写作的未来在哪里？"
+Put the strongest hook first and mark it (recommended). See `references/title-formulas.md` for title principles and prohibited patterns.
 
 If first line is H1, extract to frontmatter and remove from body. If frontmatter already has `title`, include it as context but still generate fresh candidates.
 
 **Summary Generation:**
 
-Generate 3 candidate summaries with different angles. Present to user:
+Generate two versions directly (no user selection needed), both stored in frontmatter:
 
-```
-Pick a summary:
+| Field | Length | Purpose |
+|-------|--------|---------|
+| `summary` | 1 sentence, ~50-80 chars | Concise hook — for feeds, social sharing, SEO meta |
+| `description` | 2-3 sentences, ~100-200 chars | Richer context — for article previews, newsletter blurbs |
 
-1. [Summary A] — [focus note]
-2. [Summary B] — [focus note]
-3. [Summary C] — [focus note]
-
-Enter number, or type a custom summary:
-```
-
-**Summary principles:**
-- 80-150 characters, precise and information-rich
+**Principles:**
 - Convey **core value** to the reader, not just the topic
-- Vary angles: problem-driven, result-driven, insight-driven
-- **Hook the reader**: make them want to read the full article
 - Use concrete details (numbers, outcomes, specific methods) over vague descriptions
+- `summary` should be punchy and self-contained; `description` can expand with supporting details
+- If frontmatter already has `summary` or `description`, keep existing and only generate the missing one
 
 **Prohibited patterns:**
-- "本文介绍了..."、"本文探讨了..."
+- "This article introduces...", "This article explores..."
 - Pure topic description without value proposition
 - Repeating the title in different words
 
-If frontmatter already has `summary`, skip selection and use it.
-
-**EXTEND.md skip behavior:** If `auto_select: true` is set in EXTEND.md, skip title and summary selection — generate the best candidate directly without asking. User can also set `auto_select_title: true` or `auto_select_summary: true` independently.
+**EXTEND.md skip behavior:** If `auto_select: true` or `auto_select_title: true` is set in EXTEND.md, skip title selection — generate the best candidate directly without asking.
 
 Once title is in frontmatter, body should NOT have H1 (avoid duplication).
 

skills/baoyu-format-markdown/references/title-formulas.md

@@ -0,0 +1,53 @@
+# Title Formulas Reference
+
+8 hook formulas + straightforward style for balanced title generation.
+
+## Hook Formulas
+
+| # | Formula | Characteristics | Example |
+|---|---------|----------------|---------|
+| 1 | Subversive | Deny common belief, create cognitive conflict | "All de-AI-flavor prompts are wrong" |
+| 2 | Solution | Give the answer directly, promise concrete value | "One recipe to make AI write in your voice" |
+| 3 | Suspense | Reveal half, spark a curiosity gap | "It took me six months to find how to remove AI flavor" |
+| 4 | Concrete Number | Use specific numbers for credibility and impact | "150 lines of docs taught AI my writing style" |
+| 5 | Contrast | Small cause → big result, or expectation vs reality | "One doc replaced three months of AI tuning" |
+| 6 | Result First | Lead with a surprising outcome, hook reader to find out why | "After using this method, nobody could tell it was AI" |
+| 7 | Rhetorical Question | Ask a question that creates an unfinished feeling | "Why can people spot your AI writing at a glance?" |
+| 8 | Empathy | Touch pain points, trigger shared frustration or relief | "Three months fighting AI flavor — I finally broke free" |
+
+### When to pick each formula
+
+| Formula | Best for |
+|---------|----------|
+| Subversive | Articles that challenge mainstream advice or debunk myths |
+| Solution | How-to guides, tutorials, actionable advice pieces |
+| Suspense | Personal stories, case studies, journey narratives |
+| Concrete Number | Data-driven articles, benchmarks, step-by-step guides |
+| Contrast | Before/after stories, unexpected discoveries, comparisons |
+| Result First | Success stories, transformation pieces, "I tried X" articles |
+| Rhetorical Question | Problem-awareness pieces, diagnostic/explainer content |
+| Empathy | Struggle narratives, community pain points, relatable experiences |
+
+## Straightforward Style
+
+Not every title needs a hook. Straightforward titles work well as alternatives:
+
+- **Descriptive**: clearly state the topic and scope
+- **Declarative**: state the main conclusion or thesis directly
+
+These provide balance — readers who prefer clarity over curiosity will appreciate them.
+
+## Title Principles
+
+- **Hook in first 5 characters**: create information gap or cognitive conflict
+- **Specific > abstract**: "150 lines" beats "a document"
+- **Negation > affirmation**: "you're doing it wrong" beats "the right way"
+- **Conversational**: like chatting with a friend, not an academic paper
+- **Max ~30 characters**: longer titles get truncated in feeds
+- **Accurate, not clickbait**: the article must deliver what the title promises — titles can be bold but the content must back them up
+
+## Prohibited Patterns
+
+- Vague academic-style: "On XX", "Thoughts on XX", "Exploration and Practice of XX"
+- Pure shock bait: "Shocking!", "10,000-word essay", "Must bookmark"
+- Directionless questions: "Where is the future of AI writing?"

skills/baoyu-image-gen/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: baoyu-image-gen
-description: AI image generation with OpenAI, Google, OpenRouter, DashScope and Replicate APIs. Supports text-to-image, reference images, aspect ratios, and batch generation from saved prompt files. Sequential by default; use batch parallel generation when the user already has multiple prompts or wants stable multi-image throughput. Use when user asks to generate, create, or draw images.
-version: 1.56.2
+description: AI image generation with OpenAI, Google, OpenRouter, DashScope, Jimeng, Seedream and Replicate APIs. Supports text-to-image, reference images, aspect ratios, and batch generation from saved prompt files. Sequential by default; use batch parallel generation when the user already has multiple prompts or wants stable multi-image throughput. Use when user asks to generate, create, or draw images.
+version: 1.56.3
 metadata:
   openclaw:
     homepage: https://github.com/JimLiu/baoyu-skills#baoyu-image-gen
@@ -13,7 +13,7 @@ metadata:
 
 # Image Generation (AI SDK)
 
-Official API-based image generation. Supports OpenAI, Google, OpenRouter, DashScope (阿里通义万象) and Replicate providers.
+Official API-based image generation. Supports OpenAI, Google, OpenRouter, DashScope (阿里通义万象), Jimeng (即梦), Seedream (豆包) and Replicate providers.
 
 ## Script Directory
 
@@ -74,7 +74,7 @@ ${BUN_X} {baseDir}/scripts/main.ts --prompt "A cat" --image out.png --quality 2k
 # From prompt files
 ${BUN_X} {baseDir}/scripts/main.ts --promptfiles system.md content.md --image out.png
 
-# With reference images (Google, OpenAI, OpenRouter, or Replicate)
+# With reference images (Google, OpenAI, OpenRouter, Replicate, or Seedream 4.0/4.5/5.0)
 ${BUN_X} {baseDir}/scripts/main.ts --prompt "Make blue" --image out.png --ref source.png
 
 # With reference images (explicit provider/model)
@@ -92,6 +92,12 @@ ${BUN_X} {baseDir}/scripts/main.ts --prompt "A cat" --image out.png --provider o
 # DashScope (阿里通义万象)
 ${BUN_X} {baseDir}/scripts/main.ts --prompt "一只可爱的猫" --image out.png --provider dashscope
 
+# DashScope Qwen-Image 2.0 Pro (recommended for custom sizes and text rendering)
+${BUN_X} {baseDir}/scripts/main.ts --prompt "为咖啡品牌设计一张 21:9 横幅海报，包含清晰中文标题" --image out.png --provider dashscope --model qwen-image-2.0-pro --size 2048x872
+
+# DashScope legacy Qwen fixed-size model
+${BUN_X} {baseDir}/scripts/main.ts --prompt "一张电影感海报" --image out.png --provider dashscope --model qwen-image-max --size 1664x928
+
 # Replicate (google/nano-banana-pro)
 ${BUN_X} {baseDir}/scripts/main.ts --prompt "A cat" --image out.png --provider replicate
 
@@ -141,13 +147,13 @@ Paths in `promptFiles`, `image`, and `ref` are resolved relative to the batch fi
 | `--image <path>` | Output image path (required in single-image mode) |
 | `--batchfile <path>` | JSON batch file for multi-image generation |
 | `--jobs <count>` | Worker count for batch mode (default: auto, max from config, built-in default 10) |
-| `--provider google\|openai\|openrouter\|dashscope\|replicate` | Force provider (default: auto-detect) |
-| `--model <id>`, `-m` | Model ID (Google: `gemini-3-pro-image-preview`; OpenAI: `gpt-image-1.5`; OpenRouter: `google/gemini-3.1-flash-image-preview`) |
+| `--provider google\|openai\|openrouter\|dashscope\|jimeng\|seedream\|replicate` | Force provider (default: auto-detect) |
+| `--model <id>`, `-m` | Model ID (Google: `gemini-3-pro-image-preview`; OpenAI: `gpt-image-1.5`; OpenRouter: `google/gemini-3.1-flash-image-preview`; DashScope: `qwen-image-2.0-pro`) |
 | `--ar <ratio>` | Aspect ratio (e.g., `16:9`, `1:1`, `4:3`) |
 | `--size <WxH>` | Size (e.g., `1024x1024`) |
 | `--quality normal\|2k` | Quality preset (default: `2k`) |
 | `--imageSize 1K\|2K\|4K` | Image size for Google/OpenRouter (default: from quality) |
-| `--ref <files...>` | Reference images. Supported by Google multimodal, OpenAI GPT Image edits, OpenRouter multimodal models, and Replicate |
+| `--ref <files...>` | Reference images. Supported by Google multimodal, OpenAI GPT Image edits, OpenRouter multimodal models, Replicate, and Seedream 5.0/4.5/4.0. Not supported by Jimeng, Seedream 3.0, or removed SeedEdit 3.0 |
 | `--n <count>` | Number of images |
 | `--json` | JSON output |
 
@@ -160,11 +166,16 @@ Paths in `promptFiles`, `image`, and `ref` are resolved relative to the batch fi
 | `GOOGLE_API_KEY` | Google API key |
 | `DASHSCOPE_API_KEY` | DashScope API key (阿里云) |
 | `REPLICATE_API_TOKEN` | Replicate API token |
+| `JIMENG_ACCESS_KEY_ID` | Jimeng (即梦) Volcengine access key |
+| `JIMENG_SECRET_ACCESS_KEY` | Jimeng (即梦) Volcengine secret key |
+| `ARK_API_KEY` | Seedream (豆包) Volcengine ARK API key |
 | `OPENAI_IMAGE_MODEL` | OpenAI model override |
 | `OPENROUTER_IMAGE_MODEL` | OpenRouter model override (default: `google/gemini-3.1-flash-image-preview`) |
 | `GOOGLE_IMAGE_MODEL` | Google model override |
-| `DASHSCOPE_IMAGE_MODEL` | DashScope model override (default: z-image-turbo) |
+| `DASHSCOPE_IMAGE_MODEL` | DashScope model override (default: `qwen-image-2.0-pro`) |
 | `REPLICATE_IMAGE_MODEL` | Replicate model override (default: google/nano-banana-pro) |
+| `JIMENG_IMAGE_MODEL` | Jimeng model override (default: jimeng_t2i_v40) |
+| `SEEDREAM_IMAGE_MODEL` | Seedream model override (default: doubao-seedream-5-0-260128) |
 | `OPENAI_BASE_URL` | Custom OpenAI endpoint |
 | `OPENROUTER_BASE_URL` | Custom OpenRouter endpoint (default: `https://openrouter.ai/api/v1`) |
 | `OPENROUTER_HTTP_REFERER` | Optional app/site URL for OpenRouter attribution |
@@ -172,6 +183,9 @@ Paths in `promptFiles`, `image`, and `ref` are resolved relative to the batch fi
 | `GOOGLE_BASE_URL` | Custom Google endpoint |
 | `DASHSCOPE_BASE_URL` | Custom DashScope endpoint |
 | `REPLICATE_BASE_URL` | Custom Replicate endpoint |
+| `JIMENG_BASE_URL` | Custom Jimeng endpoint (default: `https://visual.volcengineapi.com`) |
+| `JIMENG_REGION` | Jimeng region (default: `cn-north-1`) |
+| `SEEDREAM_BASE_URL` | Custom Seedream endpoint (default: `https://ark.cn-beijing.volces.com/api/v3`) |
 | `BAOYU_IMAGE_GEN_MAX_WORKERS` | Override batch worker cap |
 | `BAOYU_IMAGE_GEN_<PROVIDER>_CONCURRENCY` | Override provider concurrency, e.g. `BAOYU_IMAGE_GEN_REPLICATE_CONCURRENCY` |
 | `BAOYU_IMAGE_GEN_<PROVIDER>_START_INTERVAL_MS` | Override provider start gap, e.g. `BAOYU_IMAGE_GEN_REPLICATE_START_INTERVAL_MS` |
@@ -193,6 +207,52 @@ Model priority (highest → lowest), applies to all providers:
 - Show: `Using [provider] / [model]`
 - Show switch hint: `Switch model: --model <id> | EXTEND.md default_model.[provider] | env <PROVIDER>_IMAGE_MODEL`
 
+### DashScope Models
+
+Use `--model qwen-image-2.0-pro` or set `default_model.dashscope` / `DASHSCOPE_IMAGE_MODEL` when the user wants official Qwen-Image behavior.
+
+Official DashScope model families:
+
+- `qwen-image-2.0-pro`, `qwen-image-2.0-pro-2026-03-03`, `qwen-image-2.0`, `qwen-image-2.0-2026-03-03`
+  - Free-form `size` in `宽*高` format
+  - Total pixels must stay between `512*512` and `2048*2048`
+  - Default size is approximately `1024*1024`
+  - Best choice for custom ratios such as `21:9` and text-heavy Chinese/English layouts
+- `qwen-image-max`, `qwen-image-max-2025-12-30`, `qwen-image-plus`, `qwen-image-plus-2026-01-09`, `qwen-image`
+  - Fixed sizes only: `1664*928`, `1472*1104`, `1328*1328`, `1104*1472`, `928*1664`
+  - Default size is `1664*928`
+  - `qwen-image` currently has the same capability as `qwen-image-plus`
+- Legacy DashScope models such as `z-image-turbo`, `z-image-ultra`, `wanx-v1`
+  - Keep using them only when the user explicitly asks for legacy behavior or compatibility
+
+When translating CLI args into DashScope behavior:
+
+- `--size` wins over `--ar`
+- For `qwen-image-2.0*`, prefer explicit `--size`; otherwise infer from `--ar` and use the official recommended resolutions below
+- For `qwen-image-max/plus/image`, only use the five official fixed sizes; if the requested ratio is not covered, switch to `qwen-image-2.0-pro`
+- `--quality` is a baoyu-image-gen compatibility preset, not a native DashScope API field. Mapping `normal` / `2k` onto the `qwen-image-2.0*` table below is an implementation inference, not an official API guarantee
+
+Recommended `qwen-image-2.0*` sizes for common aspect ratios:
+
+| Ratio | `normal` | `2k` |
+|-------|----------|------|
+| `1:1` | `1024*1024` | `1536*1536` |
+| `2:3` | `768*1152` | `1024*1536` |
+| `3:2` | `1152*768` | `1536*1024` |
+| `3:4` | `960*1280` | `1080*1440` |
+| `4:3` | `1280*960` | `1440*1080` |
+| `9:16` | `720*1280` | `1080*1920` |
+| `16:9` | `1280*720` | `1920*1080` |
+| `21:9` | `1344*576` | `2048*872` |
+
+DashScope official APIs also expose `negative_prompt`, `prompt_extend`, and `watermark`, but `baoyu-image-gen` does not expose them as dedicated CLI flags today.
+
+Official references:
+
+- [Qwen-Image API](https://help.aliyun.com/zh/model-studio/qwen-image-api)
+- [Text-to-image guide](https://help.aliyun.com/zh/model-studio/text-to-image)
+- [Qwen-Image Edit API](https://help.aliyun.com/zh/model-studio/qwen-image-edit-api)
+
 ### OpenRouter Models
 
 Use full OpenRouter model IDs, e.g.:
@@ -227,7 +287,7 @@ ${BUN_X} {baseDir}/scripts/main.ts --prompt "A cat" --image out.png --provider r
 
 ## Provider Selection
 
-1. `--ref` provided + no `--provider` → auto-select Google first, then OpenAI, then OpenRouter, then Replicate
+1. `--ref` provided + no `--provider` → auto-select Google first, then OpenAI, then OpenRouter, then Replicate (Jimeng and Seedream do not support reference images)
 2. `--provider` specified → use it (if `--ref`, must be `google`, `openai`, `openrouter`, or `replicate`)
 3. Only one API key available → use that provider
 4. Multiple available → default to Google

skills/baoyu-image-gen/references/config/first-time-setup.md

@@ -50,7 +50,7 @@ options:
   - label: "OpenRouter"
     description: "Router for Gemini/FLUX/OpenAI-compatible image models"
   - label: "DashScope"
-    description: "Alibaba Cloud - z-image-turbo, good for Chinese content"
+    description: "Alibaba Cloud - Qwen-Image, strong Chinese/English text rendering"
   - label: "Replicate"
     description: "Community models - nano-banana-pro, flexible model selection"
 ```
@@ -186,12 +186,26 @@ options:
 header: "DashScope Model"
 question: "Choose a default DashScope image generation model?"
 options:
-  - label: "z-image-turbo (Recommended)"
-    description: "Fast generation, good quality"
+  - label: "qwen-image-2.0-pro (Recommended)"
+    description: "Best DashScope model for text rendering and custom sizes"
+  - label: "qwen-image-2.0"
+    description: "Faster 2.0 variant with flexible output size"
+  - label: "qwen-image-max"
+    description: "Legacy Qwen model with five fixed output sizes"
+  - label: "qwen-image-plus"
+    description: "Legacy Qwen model, same current capability as qwen-image"
+  - label: "z-image-turbo"
+    description: "Legacy DashScope model for compatibility"
   - label: "z-image-ultra"
-    description: "Higher quality, slower generation"
+    description: "Legacy DashScope model, higher quality but slower"
 ```
 
+Notes for DashScope setup:
+
+- Prefer `qwen-image-2.0-pro` when the user needs custom `--size`, uncommon ratios like `21:9`, or strong Chinese/English text rendering.
+- `qwen-image-max` / `qwen-image-plus` / `qwen-image` only support five fixed sizes: `1664*928`, `1472*1104`, `1328*1328`, `1104*1472`, `928*1664`.
+- In `baoyu-image-gen`, `quality` is a compatibility preset. It is not a native DashScope parameter.
+
 ### Replicate Model Selection
 
 ```yaml

skills/baoyu-image-gen/references/config/preferences-schema.md

@@ -23,7 +23,7 @@ default_model:
   google: null              # e.g., "gemini-3-pro-image-preview", "gemini-3.1-flash-image-preview"
   openai: null              # e.g., "gpt-image-1.5", "gpt-image-1"
   openrouter: null          # e.g., "google/gemini-3.1-flash-image-preview"
-  dashscope: null           # e.g., "z-image-turbo"
+  dashscope: null           # e.g., "qwen-image-2.0-pro"
   replicate: null           # e.g., "google/nano-banana-pro"
 
 batch:
@@ -88,7 +88,7 @@ default_model:
   google: "gemini-3-pro-image-preview"
   openai: "gpt-image-1.5"
   openrouter: "google/gemini-3.1-flash-image-preview"
-  dashscope: "z-image-turbo"
+  dashscope: "qwen-image-2.0-pro"
   replicate: "google/nano-banana-pro"
 batch:
   max_workers: 10

skills/baoyu-image-gen/scripts/main.test.ts

@@ -0,0 +1,339 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test, { type TestContext } from "node:test";
+
+import type { CliArgs, ExtendConfig } from "./types.ts";
+import {
+  createTaskArgs,
+  detectProvider,
+  getConfiguredMaxWorkers,
+  getConfiguredProviderRateLimits,
+  getWorkerCount,
+  isRetryableGenerationError,
+  loadBatchTasks,
+  mergeConfig,
+  normalizeOutputImagePath,
+  parseArgs,
+  parseSimpleYaml,
+} from "./main.ts";
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("parseArgs parses the main image-gen CLI flags", () => {
+  const args = parseArgs([
+    "--promptfiles",
+    "prompts/system.md",
+    "prompts/content.md",
+    "--image",
+    "out/hero",
+    "--provider",
+    "openai",
+    "--quality",
+    "2k",
+    "--imageSize",
+    "4k",
+    "--ref",
+    "ref/one.png",
+    "ref/two.jpg",
+    "--n",
+    "3",
+    "--jobs",
+    "5",
+    "--json",
+  ]);
+
+  assert.deepEqual(args.promptFiles, ["prompts/system.md", "prompts/content.md"]);
+  assert.equal(args.imagePath, "out/hero");
+  assert.equal(args.provider, "openai");
+  assert.equal(args.quality, "2k");
+  assert.equal(args.imageSize, "4K");
+  assert.deepEqual(args.referenceImages, ["ref/one.png", "ref/two.jpg"]);
+  assert.equal(args.n, 3);
+  assert.equal(args.jobs, 5);
+  assert.equal(args.json, true);
+});
+
+test("parseArgs falls back to positional prompt and rejects invalid provider", () => {
+  const positional = parseArgs(["draw", "a", "cat"]);
+  assert.equal(positional.prompt, "draw a cat");
+
+  assert.throws(
+    () => parseArgs(["--provider", "stability"]),
+    /Invalid provider/,
+  );
+});
+
+test("parseSimpleYaml parses nested defaults and provider limits", () => {
+  const yaml = `
+version: 2
+default_provider: openrouter
+default_quality: normal
+default_aspect_ratio: '16:9'
+default_image_size: 2K
+default_model:
+  google: gemini-3-pro-image-preview
+  openai: gpt-image-1.5
+batch:
+  max_workers: 8
+  provider_limits:
+    google:
+      concurrency: 2
+      start_interval_ms: 900
+    openai:
+      concurrency: 4
+`;
+
+  const config = parseSimpleYaml(yaml);
+
+  assert.equal(config.version, 2);
+  assert.equal(config.default_provider, "openrouter");
+  assert.equal(config.default_quality, "normal");
+  assert.equal(config.default_aspect_ratio, "16:9");
+  assert.equal(config.default_image_size, "2K");
+  assert.equal(config.default_model?.google, "gemini-3-pro-image-preview");
+  assert.equal(config.default_model?.openai, "gpt-image-1.5");
+  assert.equal(config.batch?.max_workers, 8);
+  assert.deepEqual(config.batch?.provider_limits?.google, {
+    concurrency: 2,
+    start_interval_ms: 900,
+  });
+  assert.deepEqual(config.batch?.provider_limits?.openai, {
+    concurrency: 4,
+  });
+});
+
+test("mergeConfig only fills values missing from CLI args", () => {
+  const merged = mergeConfig(
+    makeArgs({
+      provider: "openai",
+      quality: null,
+      aspectRatio: null,
+      imageSize: "4K",
+    }),
+    {
+      default_provider: "google",
+      default_quality: "2k",
+      default_aspect_ratio: "3:2",
+      default_image_size: "2K",
+    } satisfies Partial<ExtendConfig>,
+  );
+
+  assert.equal(merged.provider, "openai");
+  assert.equal(merged.quality, "2k");
+  assert.equal(merged.aspectRatio, "3:2");
+  assert.equal(merged.imageSize, "4K");
+});
+
+test("detectProvider rejects non-ref-capable providers and prefers Google first when multiple keys exist", (t) => {
+  assert.throws(
+    () =>
+      detectProvider(
+        makeArgs({
+          provider: "dashscope",
+          referenceImages: ["ref.png"],
+        }),
+      ),
+    /Reference images require a ref-capable provider/,
+  );
+
+  useEnv(t, {
+    GOOGLE_API_KEY: "google-key",
+    OPENAI_API_KEY: "openai-key",
+    OPENROUTER_API_KEY: null,
+    DASHSCOPE_API_KEY: null,
+    REPLICATE_API_TOKEN: null,
+    JIMENG_ACCESS_KEY_ID: null,
+    JIMENG_SECRET_ACCESS_KEY: null,
+    ARK_API_KEY: null,
+  });
+  assert.equal(detectProvider(makeArgs()), "google");
+});
+
+test("detectProvider selects an available ref-capable provider for reference-image tasks", (t) => {
+  useEnv(t, {
+    GOOGLE_API_KEY: null,
+    OPENAI_API_KEY: "openai-key",
+    OPENROUTER_API_KEY: null,
+    DASHSCOPE_API_KEY: null,
+    REPLICATE_API_TOKEN: null,
+    JIMENG_ACCESS_KEY_ID: null,
+    JIMENG_SECRET_ACCESS_KEY: null,
+    ARK_API_KEY: null,
+  });
+  assert.equal(
+    detectProvider(makeArgs({ referenceImages: ["ref.png"] })),
+    "openai",
+  );
+});
+
+test("detectProvider infers Seedream from model id and allows Seedream reference-image workflows", (t) => {
+  useEnv(t, {
+    GOOGLE_API_KEY: null,
+    OPENAI_API_KEY: null,
+    OPENROUTER_API_KEY: null,
+    DASHSCOPE_API_KEY: null,
+    REPLICATE_API_TOKEN: null,
+    JIMENG_ACCESS_KEY_ID: null,
+    JIMENG_SECRET_ACCESS_KEY: null,
+    ARK_API_KEY: "ark-key",
+  });
+
+  assert.equal(
+    detectProvider(
+      makeArgs({
+        model: "doubao-seedream-4-5-251128",
+        referenceImages: ["ref.png"],
+      }),
+    ),
+    "seedream",
+  );
+
+  assert.equal(
+    detectProvider(
+      makeArgs({
+        provider: "seedream",
+        referenceImages: ["ref.png"],
+      }),
+    ),
+    "seedream",
+  );
+});
+
+test("batch worker and provider-rate-limit configuration prefer env over EXTEND config", (t) => {
+  useEnv(t, {
+    BAOYU_IMAGE_GEN_MAX_WORKERS: "12",
+    BAOYU_IMAGE_GEN_GOOGLE_CONCURRENCY: "5",
+    BAOYU_IMAGE_GEN_GOOGLE_START_INTERVAL_MS: "450",
+  });
+
+  const extendConfig: Partial<ExtendConfig> = {
+    batch: {
+      max_workers: 7,
+      provider_limits: {
+        google: {
+          concurrency: 2,
+          start_interval_ms: 900,
+        },
+      },
+    },
+  };
+
+  assert.equal(getConfiguredMaxWorkers(extendConfig), 12);
+  assert.deepEqual(getConfiguredProviderRateLimits(extendConfig).google, {
+    concurrency: 5,
+    startIntervalMs: 450,
+  });
+});
+
+test("loadBatchTasks and createTaskArgs resolve batch-relative paths", async (t) => {
+  const root = await makeTempDir("baoyu-image-gen-batch-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const batchFile = path.join(root, "jobs", "batch.json");
+  await fs.mkdir(path.dirname(batchFile), { recursive: true });
+  await fs.writeFile(
+    batchFile,
+    JSON.stringify({
+      jobs: 2,
+      tasks: [
+        {
+          id: "hero",
+          promptFiles: ["prompts/hero.md"],
+          image: "out/hero",
+          ref: ["refs/hero.png"],
+          ar: "16:9",
+        },
+      ],
+    }),
+  );
+
+  const loaded = await loadBatchTasks(batchFile);
+  assert.equal(loaded.jobs, 2);
+  assert.equal(loaded.batchDir, path.dirname(batchFile));
+  assert.equal(loaded.tasks[0]?.id, "hero");
+
+  const taskArgs = createTaskArgs(
+    makeArgs({
+      provider: "replicate",
+      quality: "2k",
+      json: true,
+    }),
+    loaded.tasks[0]!,
+    loaded.batchDir,
+  );
+
+  assert.deepEqual(taskArgs.promptFiles, [
+    path.join(loaded.batchDir, "prompts/hero.md"),
+  ]);
+  assert.equal(taskArgs.imagePath, path.join(loaded.batchDir, "out/hero"));
+  assert.deepEqual(taskArgs.referenceImages, [
+    path.join(loaded.batchDir, "refs/hero.png"),
+  ]);
+  assert.equal(taskArgs.provider, "replicate");
+  assert.equal(taskArgs.aspectRatio, "16:9");
+  assert.equal(taskArgs.quality, "2k");
+  assert.equal(taskArgs.json, true);
+});
+
+test("path normalization, worker count, and retry classification follow expected rules", () => {
+  assert.match(normalizeOutputImagePath("out/sample"), /out[\\/]+sample\.png$/);
+  assert.match(normalizeOutputImagePath("out/sample", ".jpg"), /out[\\/]+sample\.jpg$/);
+  assert.match(normalizeOutputImagePath("out/sample.webp"), /out[\\/]+sample\.webp$/);
+
+  assert.equal(getWorkerCount(8, null, 3), 3);
+  assert.equal(getWorkerCount(2, 6, 5), 2);
+  assert.equal(getWorkerCount(5, 0, 4), 1);
+
+  assert.equal(isRetryableGenerationError(new Error("API error (401): denied")), false);
+  assert.equal(isRetryableGenerationError(new Error("socket hang up")), true);
+});

skills/baoyu-image-gen/scripts/main.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import process from "node:process";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import type {
   BatchFile,
@@ -13,6 +14,8 @@ import type {
 type ProviderModule = {
   getDefaultModel: () => string;
   generateImage: (prompt: string, model: string, args: CliArgs) => Promise<Uint8Array>;
+  validateArgs?: (model: string, args: CliArgs) => void;
+  getDefaultOutputExtension?: (model: string, args: CliArgs) => string;
 };
 
 type PreparedTask = {
@@ -55,6 +58,8 @@ const DEFAULT_PROVIDER_RATE_LIMITS: Record<Provider, ProviderRateLimit> = {
   openai: { concurrency: 3, startIntervalMs: 1100 },
   openrouter: { concurrency: 3, startIntervalMs: 1100 },
   dashscope: { concurrency: 3, startIntervalMs: 1100 },
+  jimeng: { concurrency: 3, startIntervalMs: 1100 },
+  seedream: { concurrency: 3, startIntervalMs: 1100 },
 };
 
 function printUsage(): void {
@@ -69,13 +74,13 @@ Options:
   --image <path>            Output image path (required in single-image mode)
   --batchfile <path>        JSON batch file for multi-image generation
   --jobs <count>            Worker count for batch mode (default: auto, max from config, built-in default 10)
-  --provider google|openai|openrouter|dashscope|replicate  Force provider (auto-detect by default)
+  --provider google|openai|openrouter|dashscope|replicate|jimeng|seedream  Force provider (auto-detect by default)
   -m, --model <id>          Model ID
   --ar <ratio>              Aspect ratio (e.g., 16:9, 1:1, 4:3)
   --size <WxH>              Size (e.g., 1024x1024)
   --quality normal|2k       Quality preset (default: 2k)
   --imageSize 1K|2K|4K      Image size for Google/OpenRouter (default: from quality)
-  --ref <files...>          Reference images (Google multimodal, OpenAI GPT Image edits, OpenRouter multimodal, or Replicate)
+  --ref <files...>          Reference images (Google, OpenAI, OpenRouter, Replicate, or Seedream 4.0/4.5/5.0)
   --n <count>               Number of images for the current task (default: 1)
   --json                    JSON output
   -h, --help                Show help
@@ -107,11 +112,16 @@ Environment variables:
   GEMINI_API_KEY            Gemini API key (alias for GOOGLE_API_KEY)
   DASHSCOPE_API_KEY         DashScope API key
   REPLICATE_API_TOKEN       Replicate API token
+  JIMENG_ACCESS_KEY_ID      Jimeng Access Key ID
+  JIMENG_SECRET_ACCESS_KEY  Jimeng Secret Access Key
+  ARK_API_KEY               Seedream/Ark API key
   OPENAI_IMAGE_MODEL        Default OpenAI model (gpt-image-1.5)
   OPENROUTER_IMAGE_MODEL    Default OpenRouter model (google/gemini-3.1-flash-image-preview)
   GOOGLE_IMAGE_MODEL        Default Google model (gemini-3-pro-image-preview)
-  DASHSCOPE_IMAGE_MODEL     Default DashScope model (z-image-turbo)
+  DASHSCOPE_IMAGE_MODEL     Default DashScope model (qwen-image-2.0-pro)
   REPLICATE_IMAGE_MODEL     Default Replicate model (google/nano-banana-pro)
+  JIMENG_IMAGE_MODEL        Default Jimeng model (jimeng_t2i_v40)
+  SEEDREAM_IMAGE_MODEL      Default Seedream model (doubao-seedream-5-0-260128)
   OPENAI_BASE_URL           Custom OpenAI endpoint
   OPENAI_IMAGE_USE_CHAT     Use /chat/completions instead of /images/generations (true|false)
   OPENROUTER_BASE_URL       Custom OpenRouter endpoint
@@ -120,6 +130,8 @@ Environment variables:
   GOOGLE_BASE_URL           Custom Google endpoint
   DASHSCOPE_BASE_URL        Custom DashScope endpoint
   REPLICATE_BASE_URL        Custom Replicate endpoint
+  JIMENG_BASE_URL           Custom Jimeng endpoint
+  SEEDREAM_BASE_URL         Custom Seedream endpoint
   BAOYU_IMAGE_GEN_MAX_WORKERS  Override batch worker cap
   BAOYU_IMAGE_GEN_<PROVIDER>_CONCURRENCY  Override provider concurrency
   BAOYU_IMAGE_GEN_<PROVIDER>_START_INTERVAL_MS  Override provider start gap in ms
@@ -127,7 +139,7 @@ Environment variables:
 Env file load order: CLI args > EXTEND.md > process.env > <cwd>/.baoyu-skills/.env > ~/.baoyu-skills/.env`);
 }
 
-function parseArgs(argv: string[]): CliArgs {
+export function parseArgs(argv: string[]): CliArgs {
   const out: CliArgs = {
     prompt: null,
     promptFiles: [],
@@ -217,7 +229,9 @@ function parseArgs(argv: string[]): CliArgs {
         v !== "openai" &&
         v !== "openrouter" &&
         v !== "dashscope" &&
-        v !== "replicate"
+        v !== "replicate" &&
+        v !== "jimeng" &&
+        v !== "seedream"
       ) {
         throw new Error(`Invalid provider: ${v}`);
       }
@@ -327,12 +341,12 @@ async function loadEnv(): Promise<void> {
   }
 }
 
-function extractYamlFrontMatter(content: string): string | null {
+export function extractYamlFrontMatter(content: string): string | null {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*$/m);
   return match ? match[1] : null;
 }
 
-function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
+export function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
   const config: Partial<ExtendConfig> = {};
   const lines = yaml.split("\n");
   let currentKey: string | null = null;
@@ -370,6 +384,8 @@ function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
           openrouter: null,
           dashscope: null,
           replicate: null,
+          jimeng: null,
+          seedream: null,
         };
         currentKey = "default_model";
         currentProvider = null;
@@ -393,7 +409,9 @@ function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
           key === "openai" ||
           key === "openrouter" ||
           key === "dashscope" ||
-          key === "replicate"
+          key === "replicate" ||
+          key === "jimeng" ||
+          key === "seedream"
         )
       ) {
         config.batch ??= {};
@@ -407,7 +425,9 @@ function parseSimpleYaml(yaml: string): Partial<ExtendConfig> {
           key === "openai" ||
           key === "openrouter" ||
           key === "dashscope" ||
-          key === "replicate"
+          key === "replicate" ||
+          key === "jimeng" ||
+          key === "seedream"
         )
       ) {
         const cleaned = value.replace(/['"]/g, "");
@@ -456,7 +476,7 @@ async function loadExtendConfig(): Promise<Partial<ExtendConfig>> {
   return {};
 }
 
-function mergeConfig(args: CliArgs, extend: Partial<ExtendConfig>): CliArgs {
+export function mergeConfig(args: CliArgs, extend: Partial<ExtendConfig>): CliArgs {
   return {
     ...args,
     provider: args.provider ?? extend.default_provider ?? null,
@@ -466,13 +486,13 @@ function mergeConfig(args: CliArgs, extend: Partial<ExtendConfig>): CliArgs {
   };
 }
 
-function parsePositiveInt(value: string | undefined): number | null {
+export function parsePositiveInt(value: string | undefined): number | null {
   if (!value) return null;
   const parsed = parseInt(value, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 
-function parsePositiveBatchInt(value: unknown): number | null {
+export function parsePositiveBatchInt(value: unknown): number | null {
   if (value === null || value === undefined) return null;
   if (typeof value === "number") {
     return Number.isInteger(value) && value > 0 ? value : null;
@@ -483,13 +503,13 @@ function parsePositiveBatchInt(value: unknown): number | null {
   return null;
 }
 
-function getConfiguredMaxWorkers(extendConfig: Partial<ExtendConfig>): number {
+export function getConfiguredMaxWorkers(extendConfig: Partial<ExtendConfig>): number {
   const envValue = parsePositiveInt(process.env.BAOYU_IMAGE_GEN_MAX_WORKERS);
   const configValue = extendConfig.batch?.max_workers ?? null;
   return Math.max(1, envValue ?? configValue ?? DEFAULT_MAX_WORKERS);
 }
 
-function getConfiguredProviderRateLimits(
+export function getConfiguredProviderRateLimits(
   extendConfig: Partial<ExtendConfig>
 ): Record<Provider, ProviderRateLimit> {
   const configured: Record<Provider, ProviderRateLimit> = {
@@ -498,9 +518,11 @@ function getConfiguredProviderRateLimits(
     openai: { ...DEFAULT_PROVIDER_RATE_LIMITS.openai },
     openrouter: { ...DEFAULT_PROVIDER_RATE_LIMITS.openrouter },
     dashscope: { ...DEFAULT_PROVIDER_RATE_LIMITS.dashscope },
+    jimeng: { ...DEFAULT_PROVIDER_RATE_LIMITS.jimeng },
+    seedream: { ...DEFAULT_PROVIDER_RATE_LIMITS.seedream },
   };
 
-  for (const provider of ["replicate", "google", "openai", "openrouter", "dashscope"] as Provider[]) {
+  for (const provider of ["replicate", "google", "openai", "openrouter", "dashscope", "jimeng", "seedream"] as Provider[]) {
     const envPrefix = `BAOYU_IMAGE_GEN_${provider.toUpperCase()}`;
     const extendLimit = extendConfig.batch?.provider_limits?.[provider];
     configured[provider] = {
@@ -540,24 +562,31 @@ async function readPromptFromStdin(): Promise<string | null> {
   }
 }
 
-function normalizeOutputImagePath(p: string): string {
+export function normalizeOutputImagePath(p: string, defaultExtension = ".png"): string {
   const full = path.resolve(p);
   const ext = path.extname(full);
   if (ext) return full;
-  return `${full}.png`;
+  return `${full}${defaultExtension}`;
 }
 
-function detectProvider(args: CliArgs): Provider {
+function inferProviderFromModel(model: string | null): Provider | null {
+  if (!model) return null;
+  if (model.includes("seedream") || model.includes("seededit")) return "seedream";
+  return null;
+}
+
+export function detectProvider(args: CliArgs): Provider {
   if (
     args.referenceImages.length > 0 &&
     args.provider &&
     args.provider !== "google" &&
     args.provider !== "openai" &&
     args.provider !== "openrouter" &&
-    args.provider !== "replicate"
+    args.provider !== "replicate" &&
+    args.provider !== "seedream"
   ) {
     throw new Error(
-      "Reference images require a ref-capable provider. Use --provider google (Gemini multimodal), --provider openai (GPT Image edits), --provider openrouter (OpenRouter multimodal), or --provider replicate."
+      "Reference images require a ref-capable provider. Use --provider google (Gemini multimodal), --provider openai (GPT Image edits), --provider openrouter (OpenRouter multimodal), --provider replicate, or --provider seedream for supported Seedream models."
     );
   }
 
@@ -568,14 +597,25 @@ function detectProvider(args: CliArgs): Provider {
   const hasOpenrouter = !!process.env.OPENROUTER_API_KEY;
   const hasDashscope = !!process.env.DASHSCOPE_API_KEY;
   const hasReplicate = !!process.env.REPLICATE_API_TOKEN;
+  const hasJimeng = !!(process.env.JIMENG_ACCESS_KEY_ID && process.env.JIMENG_SECRET_ACCESS_KEY);
+  const hasSeedream = !!process.env.ARK_API_KEY;
+  const modelProvider = inferProviderFromModel(args.model);
+
+  if (modelProvider === "seedream") {
+    if (!hasSeedream) {
+      throw new Error("Model looks like a Volcengine ARK image model, but ARK_API_KEY is not set.");
+    }
+    return "seedream";
+  }
 
   if (args.referenceImages.length > 0) {
     if (hasGoogle) return "google";
     if (hasOpenai) return "openai";
     if (hasOpenrouter) return "openrouter";
     if (hasReplicate) return "replicate";
+    if (hasSeedream) return "seedream";
     throw new Error(
-      "Reference images require Google, OpenAI, OpenRouter or Replicate. Set GOOGLE_API_KEY/GEMINI_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY, or REPLICATE_API_TOKEN, or remove --ref."
+      "Reference images require Google, OpenAI, OpenRouter, Replicate, or supported Seedream models. Set GOOGLE_API_KEY/GEMINI_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY, REPLICATE_API_TOKEN, or ARK_API_KEY, or remove --ref."
     );
   }
 
@@ -585,18 +625,20 @@ function detectProvider(args: CliArgs): Provider {
     hasOpenrouter && "openrouter",
     hasDashscope && "dashscope",
     hasReplicate && "replicate",
+    hasJimeng && "jimeng",
+    hasSeedream && "seedream",
   ].filter(Boolean) as Provider[];
 
   if (available.length === 1) return available[0]!;
   if (available.length > 1) return available[0]!;
 
   throw new Error(
-    "No API key found. Set GOOGLE_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY, DASHSCOPE_API_KEY, or REPLICATE_API_TOKEN.\n" +
+    "No API key found. Set GOOGLE_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY, DASHSCOPE_API_KEY, REPLICATE_API_TOKEN, JIMENG keys, or ARK_API_KEY.\n" +
       "Create ~/.baoyu-skills/.env or <cwd>/.baoyu-skills/.env with your keys."
   );
 }
 
-async function validateReferenceImages(referenceImages: string[]): Promise<void> {
+export async function validateReferenceImages(referenceImages: string[]): Promise<void> {
   for (const refPath of referenceImages) {
     const fullPath = path.resolve(refPath);
     try {
@@ -607,7 +649,7 @@ async function validateReferenceImages(referenceImages: string[]): Promise<void>
   }
 }
 
-function isRetryableGenerationError(error: unknown): boolean {
+export function isRetryableGenerationError(error: unknown): boolean {
   const msg = error instanceof Error ? error.message : String(error);
   const nonRetryableMarkers = [
     "Reference image",
@@ -632,6 +674,8 @@ async function loadProviderModule(provider: Provider): Promise<ProviderModule> {
   if (provider === "dashscope") return (await import("./providers/dashscope")) as ProviderModule;
   if (provider === "replicate") return (await import("./providers/replicate")) as ProviderModule;
   if (provider === "openrouter") return (await import("./providers/openrouter")) as ProviderModule;
+  if (provider === "jimeng") return (await import("./providers/jimeng")) as ProviderModule;
+  if (provider === "seedream") return (await import("./providers/seedream")) as ProviderModule;
   return (await import("./providers/openai")) as ProviderModule;
 }
 
@@ -658,6 +702,8 @@ function getModelForProvider(
     }
     if (provider === "dashscope" && extendConfig.default_model.dashscope) return extendConfig.default_model.dashscope;
     if (provider === "replicate" && extendConfig.default_model.replicate) return extendConfig.default_model.replicate;
+    if (provider === "jimeng" && extendConfig.default_model.jimeng) return extendConfig.default_model.jimeng;
+    if (provider === "seedream" && extendConfig.default_model.seedream) return extendConfig.default_model.seedream;
   }
   return providerModule.getDefaultModel();
 }
@@ -673,6 +719,8 @@ async function prepareSingleTask(args: CliArgs, extendConfig: Partial<ExtendConf
   const provider = detectProvider(args);
   const providerModule = await loadProviderModule(provider);
   const model = getModelForProvider(provider, args.model, extendConfig, providerModule);
+  providerModule.validateArgs?.(model, args);
+  const defaultOutputExtension = providerModule.getDefaultOutputExtension?.(model, args) ?? ".png";
 
   return {
     id: "single",
@@ -680,12 +728,12 @@ async function prepareSingleTask(args: CliArgs, extendConfig: Partial<ExtendConf
     args,
     provider,
     model,
-    outputPath: normalizeOutputImagePath(args.imagePath),
+    outputPath: normalizeOutputImagePath(args.imagePath, defaultOutputExtension),
     providerModule,
   };
 }
 
-async function loadBatchTasks(batchFilePath: string): Promise<LoadedBatchTasks> {
+export async function loadBatchTasks(batchFilePath: string): Promise<LoadedBatchTasks> {
   const resolvedBatchFilePath = path.resolve(batchFilePath);
   const content = await readFile(resolvedBatchFilePath, "utf8");
   const parsed = JSON.parse(content.replace(/^\uFEFF/, "")) as BatchFile;
@@ -711,11 +759,11 @@ async function loadBatchTasks(batchFilePath: string): Promise<LoadedBatchTasks>
   throw new Error("Invalid batch file. Expected an array of tasks or an object with a tasks array.");
 }
 
-function resolveBatchPath(batchDir: string, filePath: string): string {
+export function resolveBatchPath(batchDir: string, filePath: string): string {
   return path.isAbsolute(filePath) ? filePath : path.resolve(batchDir, filePath);
 }
 
-function createTaskArgs(baseArgs: CliArgs, task: BatchTaskInput, batchDir: string): CliArgs {
+export function createTaskArgs(baseArgs: CliArgs, task: BatchTaskInput, batchDir: string): CliArgs {
   return {
     ...baseArgs,
     prompt: task.prompt ?? null,
@@ -756,13 +804,15 @@ async function prepareBatchTasks(
     const provider = detectProvider(taskArgs);
     const providerModule = await loadProviderModule(provider);
     const model = getModelForProvider(provider, taskArgs.model, extendConfig, providerModule);
+    providerModule.validateArgs?.(model, taskArgs);
+    const defaultOutputExtension = providerModule.getDefaultOutputExtension?.(model, taskArgs) ?? ".png";
     prepared.push({
       id: task.id || `task-${String(i + 1).padStart(2, "0")}`,
       prompt,
       args: taskArgs,
       provider,
       model,
-      outputPath: normalizeOutputImagePath(taskArgs.imagePath),
+      outputPath: normalizeOutputImagePath(taskArgs.imagePath, defaultOutputExtension),
       providerModule,
     });
   }
@@ -854,7 +904,7 @@ function createProviderGate(providerRateLimits: Record<Provider, ProviderRateLim
   };
 }
 
-function getWorkerCount(taskCount: number, jobs: number | null, maxWorkers: number): number {
+export function getWorkerCount(taskCount: number, jobs: number | null, maxWorkers: number): number {
   const requested = jobs ?? Math.min(taskCount, maxWorkers);
   return Math.max(1, Math.min(requested, taskCount, maxWorkers));
 }
@@ -873,7 +923,7 @@ async function runBatchTasks(
   const acquireProvider = createProviderGate(providerRateLimits);
   const workerCount = getWorkerCount(tasks.length, jobs, maxWorkers);
   console.error(`Batch mode: ${tasks.length} tasks, ${workerCount} workers, parallel mode enabled.`);
-  for (const provider of ["replicate", "google", "openai", "dashscope"] as Provider[]) {
+  for (const provider of ["replicate", "google", "openai", "openrouter", "dashscope", "jimeng", "seedream"] as Provider[]) {
     const limit = providerRateLimits[provider];
     console.error(`- ${provider}: concurrency=${limit.concurrency}, startIntervalMs=${limit.startIntervalMs}`);
   }
@@ -984,8 +1034,21 @@ async function main(): Promise<void> {
   await runSingleMode(mergedArgs, extendConfig);
 }
 
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(message);
-  process.exit(1);
-});
+function isDirectExecution(metaUrl: string): boolean {
+  const entryPath = process.argv[1];
+  if (!entryPath) return false;
+
+  try {
+    return path.resolve(entryPath) === fileURLToPath(metaUrl);
+  } catch {
+    return false;
+  }
+}
+
+if (isDirectExecution(import.meta.url)) {
+  main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+  });
+}

skills/baoyu-image-gen/scripts/providers/dashscope.test.ts

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import test, { type TestContext } from "node:test";
+
+import {
+  getDefaultModel,
+  getModelFamily,
+  getQwen2SizeFromAspectRatio,
+  getSizeFromAspectRatio,
+  normalizeSize,
+  parseAspectRatio,
+  parseSize,
+  resolveSizeForModel,
+} from "./dashscope.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+test("DashScope default model prefers env override and otherwise uses qwen-image-2.0-pro", (t) => {
+  useEnv(t, { DASHSCOPE_IMAGE_MODEL: null });
+  assert.equal(getDefaultModel(), "qwen-image-2.0-pro");
+
+  process.env.DASHSCOPE_IMAGE_MODEL = "qwen-image-max";
+  assert.equal(getDefaultModel(), "qwen-image-max");
+});
+
+test("DashScope aspect-ratio parsing accepts numeric ratios only", () => {
+  assert.deepEqual(parseAspectRatio("3:2"), { width: 3, height: 2 });
+  assert.equal(parseAspectRatio("square"), null);
+  assert.equal(parseAspectRatio("-1:2"), null);
+});
+
+test("DashScope model family routing distinguishes qwen-2.0, fixed-size qwen, and legacy models", () => {
+  assert.equal(getModelFamily("qwen-image-2.0-pro"), "qwen2");
+  assert.equal(getModelFamily("qwen-image"), "qwenFixed");
+  assert.equal(getModelFamily("z-image-turbo"), "legacy");
+  assert.equal(getModelFamily("wanx-v1"), "legacy");
+});
+
+test("Legacy DashScope size selection keeps the previous quality-based heuristic", () => {
+  assert.equal(getSizeFromAspectRatio(null, "normal"), "1024*1024");
+  assert.equal(getSizeFromAspectRatio("16:9", "normal"), "1280*720");
+  assert.equal(getSizeFromAspectRatio("16:9", "2k"), "2048*1152");
+  assert.equal(getSizeFromAspectRatio("invalid", "2k"), "1536*1536");
+});
+
+test("Qwen 2.0 recommended sizes follow the official common-ratio table", () => {
+  assert.equal(getQwen2SizeFromAspectRatio(null, "normal"), "1024*1024");
+  assert.equal(getQwen2SizeFromAspectRatio(null, "2k"), "1536*1536");
+  assert.equal(getQwen2SizeFromAspectRatio("16:9", "normal"), "1280*720");
+  assert.equal(getQwen2SizeFromAspectRatio("21:9", "2k"), "2048*872");
+});
+
+test("Qwen 2.0 derives free-form sizes within pixel budget for uncommon ratios", () => {
+  const size = getQwen2SizeFromAspectRatio("5:2", "normal");
+  const parsed = parseSize(size);
+  assert.ok(parsed);
+  assert.ok(parsed.width * parsed.height >= 512 * 512);
+  assert.ok(parsed.width * parsed.height <= 2048 * 2048);
+  assert.ok(Math.abs(parsed.width / parsed.height - 2.5) < 0.08);
+});
+
+test("resolveSizeForModel validates explicit qwen-image-2.0 sizes by total pixels", () => {
+  assert.equal(
+    resolveSizeForModel("qwen-image-2.0-pro", {
+      size: "2048x872",
+      aspectRatio: null,
+      quality: "2k",
+    }),
+    "2048*872",
+  );
+
+  assert.throws(
+    () =>
+      resolveSizeForModel("qwen-image-2.0-pro", {
+        size: "4096x4096",
+        aspectRatio: null,
+        quality: "2k",
+      }),
+    /total pixels between/,
+  );
+});
+
+test("resolveSizeForModel enforces fixed sizes for qwen-image-max/plus/image", () => {
+  assert.equal(
+    resolveSizeForModel("qwen-image-max", {
+      size: null,
+      aspectRatio: "1:1",
+      quality: "2k",
+    }),
+    "1328*1328",
+  );
+
+  assert.equal(
+    resolveSizeForModel("qwen-image", {
+      size: "1664x928",
+      aspectRatio: "9:16",
+      quality: "normal",
+    }),
+    "1664*928",
+  );
+
+  assert.throws(
+    () =>
+      resolveSizeForModel("qwen-image-max", {
+        size: null,
+        aspectRatio: "21:9",
+        quality: "2k",
+      }),
+    /supports only fixed ratios/,
+  );
+
+  assert.throws(
+    () =>
+      resolveSizeForModel("qwen-image-plus", {
+        size: "1024x1024",
+        aspectRatio: null,
+        quality: "2k",
+      }),
+    /support only these sizes/,
+  );
+});
+
+test("DashScope size normalization converts WxH into provider format", () => {
+  assert.equal(normalizeSize("1024x1024"), "1024*1024");
+  assert.equal(normalizeSize("2048*1152"), "2048*1152");
+});

skills/baoyu-image-gen/scripts/providers/dashscope.ts

@@ -1,28 +1,46 @@
-import type { CliArgs } from "../types";
+import type { CliArgs, Quality } from "../types";
 
-export function getDefaultModel(): string {
-  return process.env.DASHSCOPE_IMAGE_MODEL || "z-image-turbo";
-}
+type DashScopeModelFamily = "qwen2" | "qwenFixed" | "legacy";
 
-function getApiKey(): string | null {
-  return process.env.DASHSCOPE_API_KEY || null;
-}
+type DashScopeModelSpec = {
+  family: DashScopeModelFamily;
+  defaultSize: string;
+};
 
-function getBaseUrl(): string {
-  const base = process.env.DASHSCOPE_BASE_URL || "https://dashscope.aliyuncs.com";
-  return base.replace(/\/+$/g, "");
-}
+const DEFAULT_MODEL = "qwen-image-2.0-pro";
+const MIN_QWEN_2_TOTAL_PIXELS = 512 * 512;
+const MAX_QWEN_2_TOTAL_PIXELS = 2048 * 2048;
+const SIZE_STEP = 16;
+const QWEN_NEGATIVE_PROMPT =
+  "低分辨率，低画质，肢体畸形，手指畸形，画面过饱和，蜡像感，人脸无细节，过度光滑，画面具有AI感，构图混乱，文字模糊，扭曲";
 
-function parseAspectRatio(ar: string): { width: number; height: number } | null {
-  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
-  if (!match) return null;
-  const w = parseFloat(match[1]!);
-  const h = parseFloat(match[2]!);
-  if (w <= 0 || h <= 0) return null;
-  return { width: w, height: h };
-}
+const QWEN_2_TARGET_PIXELS: Record<Quality, number> = {
+  normal: 1024 * 1024,
+  "2k": 1536 * 1536,
+};
 
-const STANDARD_SIZES: [number, number][] = [
+const QWEN_2_RECOMMENDED: Record<string, Record<Quality, string>> = {
+  "1:1": { normal: "1024*1024", "2k": "1536*1536" },
+  "2:3": { normal: "768*1152", "2k": "1024*1536" },
+  "3:2": { normal: "1152*768", "2k": "1536*1024" },
+  "3:4": { normal: "960*1280", "2k": "1080*1440" },
+  "4:3": { normal: "1280*960", "2k": "1440*1080" },
+  "9:16": { normal: "720*1280", "2k": "1080*1920" },
+  "16:9": { normal: "1280*720", "2k": "1920*1080" },
+  "21:9": { normal: "1344*576", "2k": "2048*872" },
+};
+
+const QWEN_FIXED_SIZES_BY_RATIO: Record<string, string> = {
+  "16:9": "1664*928",
+  "4:3": "1472*1104",
+  "1:1": "1328*1328",
+  "3:4": "1104*1472",
+  "9:16": "928*1664",
+};
+
+const QWEN_FIXED_SIZES = Object.values(QWEN_FIXED_SIZES_BY_RATIO);
+
+const LEGACY_STANDARD_SIZES: [number, number][] = [
   [1024, 1024],
   [1280, 720],
   [720, 1280],
@@ -34,7 +52,7 @@ const STANDARD_SIZES: [number, number][] = [
   [864, 1536],
 ];
 
-const STANDARD_SIZES_2K: [number, number][] = [
+const LEGACY_STANDARD_SIZES_2K: [number, number][] = [
   [1536, 1536],
   [2048, 1152],
   [1152, 2048],
@@ -45,9 +63,167 @@ const STANDARD_SIZES_2K: [number, number][] = [
   [2048, 2048],
 ];
 
-function getSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
-  const is2k = quality === "2k";
-  const defaultSize = is2k ? "1536*1536" : "1024*1024";
+const QWEN_2_SPEC: DashScopeModelSpec = {
+  family: "qwen2",
+  defaultSize: "1024*1024",
+};
+
+const QWEN_FIXED_SPEC: DashScopeModelSpec = {
+  family: "qwenFixed",
+  defaultSize: QWEN_FIXED_SIZES_BY_RATIO["16:9"],
+};
+
+const LEGACY_SPEC: DashScopeModelSpec = {
+  family: "legacy",
+  defaultSize: "1536*1536",
+};
+
+const MODEL_SPEC_ALIASES: Record<string, DashScopeModelSpec> = {
+  "qwen-image-2.0-pro": QWEN_2_SPEC,
+  "qwen-image-2.0-pro-2026-03-03": QWEN_2_SPEC,
+  "qwen-image-2.0": QWEN_2_SPEC,
+  "qwen-image-2.0-2026-03-03": QWEN_2_SPEC,
+  "qwen-image-max": QWEN_FIXED_SPEC,
+  "qwen-image-max-2025-12-30": QWEN_FIXED_SPEC,
+  "qwen-image-plus": QWEN_FIXED_SPEC,
+  "qwen-image-plus-2026-01-09": QWEN_FIXED_SPEC,
+  "qwen-image": QWEN_FIXED_SPEC,
+};
+
+export function getDefaultModel(): string {
+  return process.env.DASHSCOPE_IMAGE_MODEL || DEFAULT_MODEL;
+}
+
+function getApiKey(): string | null {
+  return process.env.DASHSCOPE_API_KEY || null;
+}
+
+function getBaseUrl(): string {
+  const base = process.env.DASHSCOPE_BASE_URL || "https://dashscope.aliyuncs.com";
+  return base.replace(/\/+$/g, "");
+}
+
+function getModelSpec(model: string): DashScopeModelSpec {
+  return MODEL_SPEC_ALIASES[model.trim().toLowerCase()] || LEGACY_SPEC;
+}
+
+export function getModelFamily(model: string): DashScopeModelFamily {
+  return getModelSpec(model).family;
+}
+
+function normalizeQuality(quality: CliArgs["quality"]): Quality {
+  return quality === "normal" ? "normal" : "2k";
+}
+
+export function parseAspectRatio(ar: string): { width: number; height: number } | null {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (!match) return null;
+  const w = parseFloat(match[1]!);
+  const h = parseFloat(match[2]!);
+  if (w <= 0 || h <= 0) return null;
+  return { width: w, height: h };
+}
+
+export function normalizeSize(size: string): string {
+  return size.replace("x", "*");
+}
+
+export function parseSize(size: string): { width: number; height: number } | null {
+  const match = normalizeSize(size).match(/^(\d+)\*(\d+)$/);
+  if (!match) return null;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+  return { width, height };
+}
+
+function formatSize(width: number, height: number): string {
+  return `${width}*${height}`;
+}
+
+function getRatioValue(ar: string): number | null {
+  const parsed = parseAspectRatio(ar);
+  if (!parsed) return null;
+  return parsed.width / parsed.height;
+}
+
+function findKnownRatioKey(ar: string, candidates: string[], tolerance = 0.02): string | null {
+  const targetRatio = getRatioValue(ar);
+  if (targetRatio == null) return null;
+
+  let bestKey: string | null = null;
+  let bestDiff = Infinity;
+
+  for (const candidate of candidates) {
+    const candidateRatio = getRatioValue(candidate);
+    if (candidateRatio == null) continue;
+    const diff = Math.abs(candidateRatio - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestKey = candidate;
+    }
+  }
+
+  return bestDiff <= tolerance ? bestKey : null;
+}
+
+function roundToStep(value: number): number {
+  return Math.max(SIZE_STEP, Math.round(value / SIZE_STEP) * SIZE_STEP);
+}
+
+function fitToPixelBudget(
+  width: number,
+  height: number,
+  minPixels: number,
+  maxPixels: number,
+): { width: number; height: number } {
+  let nextWidth = width;
+  let nextHeight = height;
+  let pixels = nextWidth * nextHeight;
+
+  if (pixels > maxPixels) {
+    const scale = Math.sqrt(maxPixels / pixels);
+    nextWidth *= scale;
+    nextHeight *= scale;
+  } else if (pixels < minPixels) {
+    const scale = Math.sqrt(minPixels / pixels);
+    nextWidth *= scale;
+    nextHeight *= scale;
+  }
+
+  let roundedWidth = roundToStep(nextWidth);
+  let roundedHeight = roundToStep(nextHeight);
+  pixels = roundedWidth * roundedHeight;
+
+  while (pixels > maxPixels && (roundedWidth > SIZE_STEP || roundedHeight > SIZE_STEP)) {
+    if (roundedWidth >= roundedHeight && roundedWidth > SIZE_STEP) {
+      roundedWidth -= SIZE_STEP;
+    } else if (roundedHeight > SIZE_STEP) {
+      roundedHeight -= SIZE_STEP;
+    } else {
+      break;
+    }
+    pixels = roundedWidth * roundedHeight;
+  }
+
+  while (pixels < minPixels) {
+    if (roundedWidth <= roundedHeight) {
+      roundedWidth += SIZE_STEP;
+    } else {
+      roundedHeight += SIZE_STEP;
+    }
+    pixels = roundedWidth * roundedHeight;
+  }
+
+  return { width: roundedWidth, height: roundedHeight };
+}
+
+export function getSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
+  const normalizedQuality = normalizeQuality(quality);
+  const sizes = normalizedQuality === "2k" ? LEGACY_STANDARD_SIZES_2K : LEGACY_STANDARD_SIZES;
+  const defaultSize = normalizedQuality === "2k" ? "1536*1536" : "1024*1024";
 
   if (!ar) return defaultSize;
 
@@ -55,86 +231,157 @@ function getSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]):
   if (!parsed) return defaultSize;
 
   const targetRatio = parsed.width / parsed.height;
-  const sizes = is2k ? STANDARD_SIZES_2K : STANDARD_SIZES;
-
   let best = defaultSize;
   let bestDiff = Infinity;
 
-  for (const [w, h] of sizes) {
-    const diff = Math.abs(w / h - targetRatio);
+  for (const [width, height] of sizes) {
+    const diff = Math.abs(width / height - targetRatio);
     if (diff < bestDiff) {
       bestDiff = diff;
-      best = `${w}*${h}`;
+      best = formatSize(width, height);
     }
   }
 
   return best;
 }
 
-function normalizeSize(size: string): string {
-  return size.replace("x", "*");
+export function getQwen2SizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
+  const normalizedQuality = normalizeQuality(quality);
+
+  if (!ar) {
+    return QWEN_2_RECOMMENDED["1:1"][normalizedQuality];
+  }
+
+  const recommendedRatio = findKnownRatioKey(ar, Object.keys(QWEN_2_RECOMMENDED));
+  if (recommendedRatio) {
+    return QWEN_2_RECOMMENDED[recommendedRatio][normalizedQuality];
+  }
+
+  const parsed = parseAspectRatio(ar);
+  if (!parsed) {
+    return QWEN_2_RECOMMENDED["1:1"][normalizedQuality];
+  }
+
+  const targetRatio = parsed.width / parsed.height;
+  const targetPixels = QWEN_2_TARGET_PIXELS[normalizedQuality];
+  const rawWidth = Math.sqrt(targetPixels * targetRatio);
+  const rawHeight = Math.sqrt(targetPixels / targetRatio);
+  const fitted = fitToPixelBudget(
+    rawWidth,
+    rawHeight,
+    MIN_QWEN_2_TOTAL_PIXELS,
+    MAX_QWEN_2_TOTAL_PIXELS,
+  );
+
+  return formatSize(fitted.width, fitted.height);
 }
 
-export async function generateImage(
-  prompt: string,
-  model: string,
-  args: CliArgs
-): Promise<Uint8Array> {
-  const apiKey = getApiKey();
-  if (!apiKey) throw new Error("DASHSCOPE_API_KEY is required");
-
-  if (args.referenceImages.length > 0) {
-    throw new Error(
-      "Reference images are not supported with DashScope provider in baoyu-image-gen. Use --provider google with a Gemini multimodal model."
+function getQwenFixedSizeFromAspectRatio(ar: string | null, quality: CliArgs["quality"]): string {
+  if (quality === "normal") {
+    console.warn(
+      "DashScope qwen-image-max/plus/image models use fixed output sizes; --quality normal does not change the generated resolution."
     );
   }
 
-  const size = args.size ? normalizeSize(args.size) : getSizeFromAspectRatio(args.aspectRatio, args.quality);
-  const url = `${getBaseUrl()}/api/v1/services/aigc/multimodal-generation/generation`;
+  if (!ar) return QWEN_FIXED_SPEC.defaultSize;
 
-  const body = {
-    model,
-    input: {
-      messages: [
-        {
-          role: "user",
-          content: [{ text: prompt }],
-        },
-      ],
-    },
-    parameters: {
-      prompt_extend: false,
-      size,
-    },
-  };
-
-  console.log(`Generating image with DashScope (${model})...`, { size });
-
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const err = await res.text();
-    throw new Error(`DashScope API error (${res.status}): ${err}`);
+  const ratioKey = findKnownRatioKey(ar, Object.keys(QWEN_FIXED_SIZES_BY_RATIO));
+  if (!ratioKey) {
+    throw new Error(
+      `DashScope model supports only fixed ratios ${Object.keys(QWEN_FIXED_SIZES_BY_RATIO).join(", ")}. ` +
+      `For custom ratios like "${ar}", use --model qwen-image-2.0-pro.`
+    );
   }
 
-  const result = await res.json() as {
-    output?: {
-      result_image?: string;
-      choices?: Array<{
-        message?: {
-          content?: Array<{ image?: string }>;
-        };
-      }>;
-    };
+  return QWEN_FIXED_SIZES_BY_RATIO[ratioKey]!;
+}
+
+function validateSizeFormat(size: string): { width: number; height: number } {
+  const parsed = parseSize(size);
+  if (!parsed) {
+    throw new Error(`Invalid DashScope size "${size}". Expected <width>x<height> or <width>*<height>.`);
+  }
+  return parsed;
+}
+
+function validateQwen2Size(size: string): string {
+  const normalized = normalizeSize(size);
+  const parsed = validateSizeFormat(normalized);
+  const totalPixels = parsed.width * parsed.height;
+  if (totalPixels < MIN_QWEN_2_TOTAL_PIXELS || totalPixels > MAX_QWEN_2_TOTAL_PIXELS) {
+    throw new Error(
+      `DashScope qwen-image-2.0* models require total pixels between ${MIN_QWEN_2_TOTAL_PIXELS} ` +
+      `and ${MAX_QWEN_2_TOTAL_PIXELS}. Received ${normalized} (${totalPixels} pixels).`
+    );
+  }
+  return normalized;
+}
+
+function validateQwenFixedSize(size: string): string {
+  const normalized = normalizeSize(size);
+  validateSizeFormat(normalized);
+  if (!QWEN_FIXED_SIZES.includes(normalized)) {
+    throw new Error(
+      `DashScope qwen-image-max/plus/image models support only these sizes: ${QWEN_FIXED_SIZES.join(", ")}. ` +
+      `Received ${normalized}.`
+    );
+  }
+  return normalized;
+}
+
+export function resolveSizeForModel(
+  model: string,
+  args: Pick<CliArgs, "size" | "aspectRatio" | "quality">,
+): string {
+  const spec = getModelSpec(model);
+
+  if (args.size) {
+    if (spec.family === "qwen2") return validateQwen2Size(args.size);
+    if (spec.family === "qwenFixed") return validateQwenFixedSize(args.size);
+    validateSizeFormat(args.size);
+    return normalizeSize(args.size);
+  }
+
+  if (spec.family === "qwen2") {
+    return getQwen2SizeFromAspectRatio(args.aspectRatio, args.quality);
+  }
+
+  if (spec.family === "qwenFixed") {
+    return getQwenFixedSizeFromAspectRatio(args.aspectRatio, args.quality);
+  }
+
+  return getSizeFromAspectRatio(args.aspectRatio, args.quality);
+}
+
+function buildParameters(
+  family: DashScopeModelFamily,
+  size: string,
+): Record<string, unknown> {
+  const parameters: Record<string, unknown> = {
+    prompt_extend: false,
+    size,
   };
 
+  if (family === "qwen2" || family === "qwenFixed") {
+    parameters.watermark = false;
+    parameters.negative_prompt = QWEN_NEGATIVE_PROMPT;
+  }
+
+  return parameters;
+}
+
+type DashScopeResponse = {
+  output?: {
+    result_image?: string;
+    choices?: Array<{
+      message?: {
+        content?: Array<{ image?: string }>;
+      };
+    }>;
+  };
+};
+
+async function extractImageFromResponse(result: DashScopeResponse): Promise<Uint8Array> {
   let imageData: string | null = null;
 
   if (result.output?.result_image) {
@@ -163,3 +410,54 @@ export async function generateImage(
 
   return Uint8Array.from(Buffer.from(imageData, "base64"));
 }
+
+export async function generateImage(
+  prompt: string,
+  model: string,
+  args: CliArgs
+): Promise<Uint8Array> {
+  const apiKey = getApiKey();
+  if (!apiKey) throw new Error("DASHSCOPE_API_KEY is required");
+
+  if (args.referenceImages.length > 0) {
+    throw new Error(
+      "Reference images are not supported with DashScope provider in baoyu-image-gen. Use --provider google with a Gemini multimodal model."
+    );
+  }
+
+  const spec = getModelSpec(model);
+  const size = resolveSizeForModel(model, args);
+  const url = `${getBaseUrl()}/api/v1/services/aigc/multimodal-generation/generation`;
+
+  const body = {
+    model,
+    input: {
+      messages: [
+        {
+          role: "user",
+          content: [{ text: prompt }],
+        },
+      ],
+    },
+    parameters: buildParameters(spec.family, size),
+  };
+
+  console.log(`Generating image with DashScope (${model})...`, { family: spec.family, size });
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`DashScope API error (${res.status}): ${err}`);
+  }
+
+  const result = await res.json() as DashScopeResponse;
+  return extractImageFromResponse(result);
+}

skills/baoyu-image-gen/scripts/providers/google.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test, { type TestContext } from "node:test";
+
+import type { CliArgs } from "../types.ts";
+import {
+  addAspectRatioToPrompt,
+  buildGoogleUrl,
+  buildPromptWithAspect,
+  extractInlineImageData,
+  extractPredictedImageData,
+  getGoogleImageSize,
+  isGoogleImagen,
+  isGoogleMultimodal,
+  normalizeGoogleModelId,
+} from "./google.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+test("Google provider helpers normalize model IDs and select image size defaults", () => {
+  assert.equal(
+    normalizeGoogleModelId("models/gemini-3.1-flash-image-preview"),
+    "gemini-3.1-flash-image-preview",
+  );
+  assert.equal(isGoogleMultimodal("models/gemini-3-pro-image-preview"), true);
+  assert.equal(isGoogleImagen("imagen-3.0-generate-002"), true);
+  assert.equal(getGoogleImageSize(makeArgs({ imageSize: null, quality: "2k" })), "2K");
+  assert.equal(getGoogleImageSize(makeArgs({ imageSize: "4K", quality: "normal" })), "4K");
+});
+
+test("Google URL builder appends v1beta when the base URL does not already include it", (t) => {
+  useEnv(t, { GOOGLE_BASE_URL: "https://generativelanguage.googleapis.com" });
+  assert.equal(
+    buildGoogleUrl("models/demo:generateContent"),
+    "https://generativelanguage.googleapis.com/v1beta/models/demo:generateContent",
+  );
+});
+
+test("Google URL and prompt helpers preserve existing v1beta paths and aspect hints", (t) => {
+  useEnv(t, { GOOGLE_BASE_URL: "https://example.com/custom/v1beta/" });
+  assert.equal(
+    buildGoogleUrl("/models/demo:predict"),
+    "https://example.com/custom/v1beta/models/demo:predict",
+  );
+
+  assert.equal(
+    addAspectRatioToPrompt("A city skyline", "16:9"),
+    "A city skyline Aspect ratio: 16:9.",
+  );
+  assert.equal(
+    buildPromptWithAspect("A city skyline", "16:9", "2k"),
+    "A city skyline Aspect ratio: 16:9. High resolution 2048px.",
+  );
+});
+
+test("Google response extractors find inline and predicted image payloads", () => {
+  assert.equal(
+    extractInlineImageData({
+      candidates: [
+        {
+          content: {
+            parts: [{ inlineData: { data: "inline-base64" } }],
+          },
+        },
+      ],
+    }),
+    "inline-base64",
+  );
+
+  assert.equal(
+    extractPredictedImageData({
+      predictions: [{ image: { imageBytes: "predicted-base64" } }],
+    }),
+    "predicted-base64",
+  );
+
+  assert.equal(
+    extractPredictedImageData({
+      generatedImages: [{ bytesBase64Encoded: "generated-base64" }],
+    }),
+    "generated-base64",
+  );
+});

skills/baoyu-image-gen/scripts/providers/google.ts

@@ -17,16 +17,16 @@ export function getDefaultModel(): string {
   return process.env.GOOGLE_IMAGE_MODEL || "gemini-3-pro-image-preview";
 }
 
-function normalizeGoogleModelId(model: string): string {
+export function normalizeGoogleModelId(model: string): string {
   return model.startsWith("models/") ? model.slice("models/".length) : model;
 }
 
-function isGoogleMultimodal(model: string): boolean {
+export function isGoogleMultimodal(model: string): boolean {
   const normalized = normalizeGoogleModelId(model);
   return GOOGLE_MULTIMODAL_MODELS.some((m) => normalized.includes(m));
 }
 
-function isGoogleImagen(model: string): boolean {
+export function isGoogleImagen(model: string): boolean {
   const normalized = normalizeGoogleModelId(model);
   return GOOGLE_IMAGEN_MODELS.some((m) => normalized.includes(m));
 }
@@ -35,7 +35,7 @@ function getGoogleApiKey(): string | null {
   return process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || null;
 }
 
-function getGoogleImageSize(args: CliArgs): "1K" | "2K" | "4K" {
+export function getGoogleImageSize(args: CliArgs): "1K" | "2K" | "4K" {
   if (args.imageSize) return args.imageSize as "1K" | "2K" | "4K";
   return args.quality === "2k" ? "2K" : "1K";
 }
@@ -46,7 +46,7 @@ function getGoogleBaseUrl(): string {
   return base.replace(/\/+$/g, "");
 }
 
-function buildGoogleUrl(pathname: string): string {
+export function buildGoogleUrl(pathname: string): string {
   const base = getGoogleBaseUrl();
   const cleanedPath = pathname.replace(/^\/+/g, "");
   if (base.endsWith("/v1beta")) return `${base}/${cleanedPath}`;
@@ -162,7 +162,7 @@ async function postGoogleJson<T>(pathname: string, body: unknown): Promise<T> {
   return postGoogleJsonViaFetch<T>(url, apiKey, body);
 }
 
-function buildPromptWithAspect(
+export function buildPromptWithAspect(
   prompt: string,
   ar: string | null,
   quality: CliArgs["quality"],
@@ -177,7 +177,7 @@ function buildPromptWithAspect(
   return result;
 }
 
-function addAspectRatioToPrompt(prompt: string, ar: string | null): string {
+export function addAspectRatioToPrompt(prompt: string, ar: string | null): string {
   if (!ar) return prompt;
   return `${prompt} Aspect ratio: ${ar}.`;
 }
@@ -194,7 +194,7 @@ async function readImageAsBase64(
   return { data: buf.toString("base64"), mimeType };
 }
 
-function extractInlineImageData(response: {
+export function extractInlineImageData(response: {
   candidates?: Array<{
     content?: { parts?: Array<{ inlineData?: { data?: string } }> };
   }>;
@@ -208,7 +208,7 @@ function extractInlineImageData(response: {
   return null;
 }
 
-function extractPredictedImageData(response: {
+export function extractPredictedImageData(response: {
   predictions?: Array<any>;
   generatedImages?: Array<any>;
 }): string | null {

skills/baoyu-image-gen/scripts/providers/jimeng.ts

@@ -0,0 +1,467 @@
+import type { CliArgs } from "../types";
+import * as crypto from "node:crypto";
+
+type JimengSizePreset = "normal" | "2k" | "4k";
+
+export function getDefaultModel(): string {
+  return process.env.JIMENG_IMAGE_MODEL || "jimeng_t2i_v40";
+}
+
+function getAccessKey(): string | null {
+  return process.env.JIMENG_ACCESS_KEY_ID || null;
+}
+
+function getSecretKey(): string | null {
+  return process.env.JIMENG_SECRET_ACCESS_KEY || null;
+}
+
+function getRegion(): string {
+  return process.env.JIMENG_REGION || "cn-north-1";
+}
+
+function getBaseUrl(): string {
+  return process.env.JIMENG_BASE_URL || "https://visual.volcengineapi.com";
+}
+
+function resolveEndpoint(query: Record<string, string>): {
+  url: string;
+  host: string;
+  canonicalUri: string;
+} {
+  let baseUrl: URL;
+  try {
+    baseUrl = new URL(getBaseUrl());
+  } catch {
+    throw new Error(`Invalid JIMENG_BASE_URL: ${getBaseUrl()}`);
+  }
+
+  baseUrl.search = "";
+  for (const [key, value] of Object.entries(query).sort(([a], [b]) => a.localeCompare(b))) {
+    baseUrl.searchParams.set(key, value);
+  }
+
+  return {
+    url: baseUrl.toString(),
+    host: baseUrl.host,
+    canonicalUri: baseUrl.pathname || "/",
+  };
+}
+
+/**
+ * Volcengine HMAC-SHA256 signature generation
+ * Following the official documentation at:
+ * https://www.volcengine.com/docs/85621/1817045
+ */
+function generateSignature(
+  method: string,
+  query: Record<string, string>,
+  headers: Record<string, string>,
+  body: string,
+  accessKey: string,
+  secretKey: string,
+  region: string,
+  service: string,
+  canonicalUri: string
+): string {
+  // 1. Create canonical request
+  // Sort query parameters alphabetically
+  const sortedQuery = Object.entries(query)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join("&");
+
+  // Sort headers alphabetically and create canonical headers
+  const sortedHeaders = Object.entries(headers)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k.toLowerCase()}:${v.trim()}\n`)
+    .join("");
+
+  const signedHeaders = Object.keys(headers)
+    .sort()
+    .map(k => k.toLowerCase())
+    .join(";");
+
+  const hashedPayload = crypto.createHash("sha256").update(body, "utf8").digest("hex");
+
+  const canonicalRequest = [
+    method,
+    canonicalUri,
+    sortedQuery,
+    sortedHeaders,
+    signedHeaders,
+    hashedPayload,
+  ].join("\n");
+
+  const hashedCanonicalRequest = crypto
+    .createHash("sha256")
+    .update(canonicalRequest, "utf8")
+    .digest("hex");
+
+  // 2. Create string to sign
+  const algorithm = "HMAC-SHA256";
+  const timestamp = headers["X-Date"] || headers["x-date"];
+  if (!timestamp) {
+    throw new Error("Jimeng signature generation requires an X-Date header.");
+  }
+  const dateStamp = timestamp.slice(0, 8);
+
+  const credentialScope = `${dateStamp}/${region}/${service}/request`;
+
+  const stringToSign = [
+    algorithm,
+    timestamp,
+    credentialScope,
+    hashedCanonicalRequest,
+  ].join("\n");
+
+  // 3. Calculate signature
+  const kDate = crypto
+    .createHmac("sha256", secretKey)
+    .update(dateStamp)
+    .digest();
+
+  const kRegion = crypto.createHmac("sha256", kDate).update(region).digest();
+  const kService = crypto.createHmac("sha256", kRegion).update(service).digest();
+  const kSigning = crypto.createHmac("sha256", kService).update("request").digest();
+
+  const signature = crypto
+    .createHmac("sha256", kSigning)
+    .update(stringToSign)
+    .digest("hex");
+
+  // 4. Create authorization header
+  return `${algorithm} Credential=${accessKey}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+
+/**
+ * Parse aspect ratio string like "16:9", "1:1", "4:3" into width and height
+ */
+function parseAspectRatio(ar: string): { width: number; height: number } | null {
+  const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
+  if (!match) return null;
+  const w = parseFloat(match[1]!);
+  const h = parseFloat(match[2]!);
+  if (w <= 0 || h <= 0) return null;
+  return { width: w, height: h };
+}
+
+/**
+ * Supported size presets for different quality levels
+ * Based on Volcengine Jimeng documentation
+ */
+const SIZE_PRESETS: Record<string, Record<string, string>> = {
+  normal: {
+    "1:1": "1024x1024",
+    "4:3": "1360x1020",
+    "16:9": "1536x864",
+    "3:2": "1440x960",
+    "21:9": "1920x824",
+  },
+  "2k": {
+    "1:1": "2048x2048",
+    "4:3": "2304x1728",
+    "16:9": "2560x1440",
+    "3:2": "2496x1664",
+    "21:9": "3024x1296",
+  },
+  "4k": {
+    "1:1": "4096x4096",
+    "4:3": "4694x3520",
+    "16:9": "5404x3040",
+    "3:2": "4992x3328",
+    "21:9": "6198x2656",
+  },
+};
+
+function normalizeDimensions(value: string): string | null {
+  const match = value.trim().match(/^(\d+)\s*[xX*]\s*(\d+)$/);
+  if (!match) return null;
+  return `${match[1]}x${match[2]}`;
+}
+
+function getClosestPresetSize(ar: string | null, qualityLevel: JimengSizePreset): string {
+  const presets = SIZE_PRESETS[qualityLevel];
+  const defaultSize = presets["1:1"]!;
+
+  if (!ar) return defaultSize;
+
+  const parsed = parseAspectRatio(ar);
+  if (!parsed) return defaultSize;
+
+  const targetRatio = parsed.width / parsed.height;
+  let bestMatch = defaultSize;
+  let bestDiff = Infinity;
+
+  for (const [ratio, size] of Object.entries(presets)) {
+    const [w, h] = ratio.split(":").map(Number);
+    const presetRatio = w / h;
+    const diff = Math.abs(presetRatio - targetRatio);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestMatch = size;
+    }
+  }
+
+  return bestMatch;
+}
+
+function normalizeImageSizePreset(imageSize: string, ar: string | null): string | null {
+  const preset = imageSize.trim().toUpperCase();
+  if (preset === "1K") return getClosestPresetSize(ar, "normal");
+  if (preset === "2K") return getClosestPresetSize(ar, "2k");
+  if (preset === "4K") return getClosestPresetSize(ar, "4k");
+  return normalizeDimensions(imageSize);
+}
+
+function getImageSize(ar: string | null, quality: CliArgs["quality"], imageSize?: string | null): string {
+  if (imageSize) {
+    const normalizedSize = normalizeImageSizePreset(imageSize, ar);
+    if (normalizedSize) return normalizedSize;
+  }
+
+  // Default to 2K quality if not specified
+  const qualityLevel: JimengSizePreset = quality === "normal" ? "normal" : "2k";
+  return getClosestPresetSize(ar, qualityLevel);
+}
+
+/**
+ * Step 1: Submit async task to Volcengine Jimeng API
+ */
+async function submitTask(
+  prompt: string,
+  model: string,
+  size: string,
+  accessKey: string,
+  secretKey: string,
+  region: string
+): Promise<string> {
+  // Query parameters for submit endpoint
+  const query = {
+    Action: "CVSync2AsyncSubmitTask",
+    Version: "2022-08-31",
+  };
+  const endpoint = resolveEndpoint(query);
+
+  // Request body - Jimeng API expects width/height as separate integers
+  const [width, height] = size.split("x").map(Number);
+  const bodyObj = {
+    req_key: model,
+    prompt_text: prompt,
+    // Use separate width and height parameters instead of size string
+    width: width,
+    height: height,
+    // Optional: seed for reproducibility
+    // seed: Math.floor(Math.random() * 999999),
+  };
+
+  const body = JSON.stringify(bodyObj);
+
+  // Headers
+  const timestampHeader = new Date().toISOString().replace(/[:\-]|\.\d{3}/g, "");
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Date": timestampHeader,
+    "Host": endpoint.host,
+  };
+
+  // Generate signature
+  const authorization = generateSignature(
+    "POST",
+    query,
+    headers,
+    body,
+    accessKey,
+    secretKey,
+    region,
+    "cv",
+    endpoint.canonicalUri
+  );
+
+  console.error(`Submitting task to Jimeng (${model})...`, { width, height });
+
+  const res = await fetch(endpoint.url, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Authorization": authorization,
+    },
+    body,
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Jimeng API submit error (${res.status}): ${err}`);
+  }
+
+  const result = (await res.json()) as {
+    code?: number;
+    message?: string;
+    data?: {
+      task_id?: string;
+    };
+  };
+
+  // Volcengine API returns code 10000 for success
+  if (result.code !== 10000 || !result.data?.task_id) {
+    console.error("Submit response:", JSON.stringify(result, null, 2));
+    throw new Error(`Failed to submit task: ${result.message || "Unknown error"}`);
+  }
+
+  return result.data.task_id;
+}
+
+/**
+ * Step 2: Poll for task result
+ * Returns image data directly as Uint8Array
+ */
+async function pollForResult(
+  taskId: string,
+  model: string,
+  accessKey: string,
+  secretKey: string,
+  region: string
+): Promise<Uint8Array> {
+  const maxAttempts = 60;
+  const pollIntervalMs = 2000;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // Query parameters for result endpoint
+    const query = {
+      Action: "CVSync2AsyncGetResult",
+      Version: "2022-08-31",
+    };
+    const endpoint = resolveEndpoint(query);
+
+    // Request body - include req_key and task_id
+    const bodyObj = {
+      req_key: model,
+      task_id: taskId,
+    };
+
+    const body = JSON.stringify(bodyObj);
+
+    // Headers
+    const timestampHeader = new Date().toISOString().replace(/[:\-]|\.\d{3}/g, "");
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Date": timestampHeader,
+      "Host": endpoint.host,
+    };
+
+    // Generate signature
+    const authorization = generateSignature(
+      "POST",
+      query,
+      headers,
+      body,
+      accessKey,
+      secretKey,
+      region,
+      "cv",
+      endpoint.canonicalUri
+    );
+
+    const res = await fetch(endpoint.url, {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Authorization": authorization,
+      },
+      body,
+    });
+
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Jimeng API poll error (${res.status}): ${err}`);
+    }
+
+    const result = (await res.json()) as {
+      code?: number;
+      message?: string;
+      data?: {
+        status?: string;
+        image_urls?: string[];
+        binary_data_base64?: string[];
+      };
+    };
+
+    // Volcengine API returns code 10000 for success
+    if (result.code === 10000 && result.data) {
+      const { status, image_urls, binary_data_base64 } = result.data;
+
+      // Check for base64 image data (preferred by Jimeng)
+      if (binary_data_base64 && binary_data_base64.length > 0) {
+        console.error("Image received as base64 data");
+        const base64Data = binary_data_base64[0]!;
+        // Convert base64 to Uint8Array
+        const binaryString = Buffer.from(base64Data, "base64").toString("binary");
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes;
+      }
+
+      // Fallback to URL format
+      if (status === "done" && image_urls && image_urls.length > 0) {
+        // Download from URL
+        console.error(`Downloading image from ${image_urls[0]}...`);
+        const imgRes = await fetch(image_urls[0]!);
+        if (!imgRes.ok) {
+          throw new Error(`Failed to download image from ${image_urls[0]}`);
+        }
+        const buffer = await imgRes.arrayBuffer();
+        return new Uint8Array(buffer);
+      }
+
+      if (status === "in_queue" || status === "generating") {
+        console.error(`Task status: ${status} (${attempt + 1}/${maxAttempts})`);
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+        continue;
+      }
+
+      if (status === "fail") {
+        throw new Error(`Jimeng task failed: ${result.message || "Generation failed"}`);
+      }
+    }
+
+    console.error("Poll response:", JSON.stringify(result, null, 2));
+    throw new Error(`Unexpected response during polling: ${result.message || "Unknown error"}`);
+  }
+
+  throw new Error("Task timeout: image generation took too long");
+}
+
+export async function generateImage(
+  prompt: string,
+  model: string,
+  args: CliArgs
+): Promise<Uint8Array> {
+  if (args.referenceImages.length > 0) {
+    throw new Error(
+      "Jimeng does not support reference images. Use --provider google, openai, openrouter, or replicate."
+    );
+  }
+
+  const accessKey = getAccessKey();
+  const secretKey = getSecretKey();
+  const region = getRegion();
+
+  if (!accessKey || !secretKey) {
+    throw new Error(
+      "JIMENG_ACCESS_KEY_ID and JIMENG_SECRET_ACCESS_KEY are required. " +
+      "Get your credentials from https://console.volcengine.com/iam/keymanage"
+    );
+  }
+
+  const size = getImageSize(args.aspectRatio, args.quality, args.imageSize);
+
+  // Step 1: Submit task
+  const taskId = await submitTask(prompt, model, size, accessKey, secretKey, region);
+
+  // Step 2: Poll for result (returns image data directly)
+  const imageData = await pollForResult(taskId, model, accessKey, secretKey, region);
+
+  console.error("Image generation complete!");
+  return imageData;
+}

skills/baoyu-image-gen/scripts/providers/openai.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  extractImageFromResponse,
+  getMimeType,
+  getOpenAISize,
+  parseAspectRatio,
+} from "./openai.ts";
+
+test("OpenAI aspect-ratio parsing and size selection match model families", () => {
+  assert.deepEqual(parseAspectRatio("16:9"), { width: 16, height: 9 });
+  assert.equal(parseAspectRatio("wide"), null);
+  assert.equal(parseAspectRatio("0:1"), null);
+
+  assert.equal(getOpenAISize("dall-e-3", "16:9", "2k"), "1792x1024");
+  assert.equal(getOpenAISize("dall-e-3", "9:16", "normal"), "1024x1792");
+  assert.equal(getOpenAISize("dall-e-2", "16:9", "2k"), "1024x1024");
+  assert.equal(getOpenAISize("gpt-image-1.5", "16:9", "2k"), "1536x1024");
+  assert.equal(getOpenAISize("gpt-image-1.5", "4:3", "2k"), "1024x1024");
+});
+
+test("OpenAI mime-type detection covers supported reference image extensions", () => {
+  assert.equal(getMimeType("frame.png"), "image/png");
+  assert.equal(getMimeType("frame.jpg"), "image/jpeg");
+  assert.equal(getMimeType("frame.webp"), "image/webp");
+  assert.equal(getMimeType("frame.gif"), "image/gif");
+});
+
+test("OpenAI response extraction supports base64 and URL download flows", async (t) => {
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  const fromBase64 = await extractImageFromResponse({
+    data: [{ b64_json: Buffer.from("hello").toString("base64") }],
+  });
+  assert.equal(Buffer.from(fromBase64).toString("utf8"), "hello");
+
+  globalThis.fetch = async () =>
+    new Response(Uint8Array.from([1, 2, 3]), {
+      status: 200,
+      headers: { "Content-Type": "application/octet-stream" },
+    });
+
+  const fromUrl = await extractImageFromResponse({
+    data: [{ url: "https://example.com/image.png" }],
+  });
+  assert.deepEqual([...fromUrl], [1, 2, 3]);
+
+  await assert.rejects(
+    () => extractImageFromResponse({ data: [{}] }),
+    /No image in response/,
+  );
+});

skills/baoyu-image-gen/scripts/providers/openai.ts

@@ -8,7 +8,7 @@ export function getDefaultModel(): string {
 
 type OpenAIImageResponse = { data: Array<{ url?: string; b64_json?: string }> };
 
-function parseAspectRatio(ar: string): { width: number; height: number } | null {
+export function parseAspectRatio(ar: string): { width: number; height: number } | null {
   const match = ar.match(/^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$/);
   if (!match) return null;
   const w = parseFloat(match[1]!);
@@ -23,7 +23,7 @@ type SizeMapping = {
   portrait: string;
 };
 
-function getOpenAISize(
+export function getOpenAISize(
   model: string,
   ar: string | null,
   quality: CliArgs["quality"]
@@ -201,7 +201,7 @@ async function generateWithOpenAIEdits(
   return extractImageFromResponse(result);
 }
 
-function getMimeType(filename: string): string {
+export function getMimeType(filename: string): string {
   const ext = path.extname(filename).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
@@ -209,7 +209,7 @@ function getMimeType(filename: string): string {
   return "image/png";
 }
 
-async function extractImageFromResponse(result: OpenAIImageResponse): Promise<Uint8Array> {
+export async function extractImageFromResponse(result: OpenAIImageResponse): Promise<Uint8Array> {
   const img = result.data[0];
 
   if (img?.b64_json) {

skills/baoyu-image-gen/scripts/providers/openrouter.test.ts

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { CliArgs } from "../types.ts";
+import {
+  buildContent,
+  buildRequestBody,
+  extractImageFromResponse,
+  getAspectRatio,
+  getImageSize,
+  validateArgs,
+} from "./openrouter.ts";
+
+const GEMINI_MODEL = "google/gemini-3.1-flash-image-preview";
+const GEMINI_25_MODEL = "google/gemini-2.5-flash-image";
+const GPT_5_IMAGE_MODEL = "openai/gpt-5-image";
+const OPENROUTER_AUTO_MODEL = "openrouter/auto";
+const FLUX_MODEL = "black-forest-labs/flux.2-pro";
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+test("OpenRouter request body uses image_config and string content for text-only prompts", () => {
+  const args = makeArgs({ aspectRatio: "16:9", quality: "2k" });
+  const body = buildRequestBody("hello", GEMINI_MODEL, args, []);
+
+  assert.deepEqual(body.image_config, {
+    image_size: "2K",
+    aspect_ratio: "16:9",
+  });
+  assert.deepEqual(body.provider, {
+    require_parameters: true,
+  });
+  assert.deepEqual(body.modalities, ["image", "text"]);
+  assert.equal(body.stream, false);
+  assert.equal(body.messages[0].content, "hello");
+});
+
+test("OpenRouter request body keeps text+image modalities for current text+image models", () => {
+  for (const model of [GEMINI_MODEL, GEMINI_25_MODEL, GPT_5_IMAGE_MODEL, OPENROUTER_AUTO_MODEL]) {
+    const body = buildRequestBody("hello", model, makeArgs({ quality: "2k" }), []);
+
+    assert.deepEqual(body.image_config, {
+      image_size: "2K",
+    });
+    assert.deepEqual(body.provider, {
+      require_parameters: true,
+    });
+    assert.deepEqual(body.modalities, ["image", "text"]);
+    assert.equal(body.messages[0].content, "hello");
+  }
+});
+
+test("OpenRouter request body uses image-only modalities for image-only models under CLI defaults", () => {
+  const body = buildRequestBody("hello", FLUX_MODEL, makeArgs({ quality: "2k" }), []);
+
+  assert.deepEqual(body.image_config, {
+    image_size: "2K",
+  });
+  assert.deepEqual(body.provider, {
+    require_parameters: true,
+  });
+  assert.deepEqual(body.modalities, ["image"]);
+  assert.equal(body.stream, false);
+  assert.equal(body.messages[0].content, "hello");
+});
+
+test("OpenRouter helper omits image_config when no size or quality is passed", () => {
+  const body = buildRequestBody("hello", FLUX_MODEL, makeArgs(), []);
+
+  assert.equal(body.image_config, undefined);
+  assert.equal(body.provider, undefined);
+  assert.deepEqual(body.modalities, ["image"]);
+  assert.equal(body.stream, false);
+  assert.equal(body.messages[0].content, "hello");
+});
+
+test("OpenRouter request body keeps multimodal array content when references are provided", () => {
+  const content = buildContent("hello", ["data:image/png;base64,abc"]);
+  assert.ok(Array.isArray(content));
+  assert.deepEqual(content[0], { type: "text", text: "hello" });
+  assert.deepEqual(content[1], {
+    type: "image_url",
+    image_url: { url: "data:image/png;base64,abc" },
+  });
+});
+
+test("OpenRouter size and aspect helpers infer supported values", () => {
+  assert.equal(getImageSize(makeArgs()), null);
+  assert.equal(getImageSize(makeArgs({ quality: "normal" })), "1K");
+  assert.equal(getImageSize(makeArgs({ size: "2048x1024" })), "2K");
+  assert.equal(getAspectRatio(GEMINI_MODEL, makeArgs({ size: "1600x900" })), "16:9");
+  assert.equal(getAspectRatio(GEMINI_MODEL, makeArgs({ size: "1024x4096" })), "1:4");
+  assert.equal(getAspectRatio(GEMINI_25_MODEL, makeArgs({ size: "1600x900" })), "16:9");
+  assert.equal(getAspectRatio(FLUX_MODEL, makeArgs({ size: "1024x4096" })), null);
+});
+
+test("OpenRouter validates explicit aspect ratios and inferred size ratios against model support", () => {
+  assert.doesNotThrow(() =>
+    validateArgs(GEMINI_MODEL, makeArgs({ aspectRatio: "1:4" })),
+  );
+  assert.doesNotThrow(() =>
+    validateArgs(GEMINI_MODEL, makeArgs({ size: "1024x4096" })),
+  );
+  assert.throws(
+    () => validateArgs(GEMINI_25_MODEL, makeArgs({ aspectRatio: "1:4" })),
+    /does not support aspect ratio 1:4/,
+  );
+  assert.throws(
+    () => validateArgs(FLUX_MODEL, makeArgs({ aspectRatio: "1:4" })),
+    /does not support aspect ratio 1:4/,
+  );
+  assert.throws(
+    () => validateArgs(GEMINI_MODEL, makeArgs({ size: "2048x1024" })),
+    /does not support size 2048x1024 \(aspect ratio 2:1\)/,
+  );
+});
+
+test("OpenRouter response extraction supports inline image data and finish_reason errors", async () => {
+  const bytes = await extractImageFromResponse({
+    choices: [
+      {
+        message: {
+          images: [
+            {
+              image_url: {
+                url: `data:image/png;base64,${Buffer.from("hello").toString("base64")}`,
+              },
+            },
+          ],
+        },
+      },
+    ],
+  });
+  assert.equal(Buffer.from(bytes).toString("utf8"), "hello");
+
+  await assert.rejects(
+    () =>
+      extractImageFromResponse({
+        choices: [
+          {
+            finish_reason: "error",
+            native_finish_reason: "MALFORMED_FUNCTION_CALL",
+            message: { content: null },
+          },
+        ],
+      }),
+    /finish_reason=MALFORMED_FUNCTION_CALL/,
+  );
+});

skills/baoyu-image-gen/scripts/providers/openrouter.ts

@@ -3,6 +3,19 @@ import { readFile } from "node:fs/promises";
 import type { CliArgs } from "../types";
 
 const DEFAULT_MODEL = "google/gemini-3.1-flash-image-preview";
+const COMMON_ASPECT_RATIOS = [
+  "1:1",
+  "2:3",
+  "3:2",
+  "3:4",
+  "4:3",
+  "4:5",
+  "5:4",
+  "9:16",
+  "16:9",
+  "21:9",
+];
+const GEMINI_EXTENDED_ASPECT_RATIOS = ["1:4", "4:1", "1:8", "8:1"];
 
 type OpenRouterImageEntry = {
   image_url?: string | { url?: string | null } | null;
@@ -18,9 +31,11 @@ type OpenRouterMessagePart = {
 
 type OpenRouterResponse = {
   choices?: Array<{
+    finish_reason?: string | null;
+    native_finish_reason?: string | null;
     message?: {
       images?: OpenRouterImageEntry[];
-      content?: string | OpenRouterMessagePart[];
+      content?: string | OpenRouterMessagePart[] | null;
     };
   }>;
 };
@@ -29,6 +44,36 @@ export function getDefaultModel(): string {
   return process.env.OPENROUTER_IMAGE_MODEL || DEFAULT_MODEL;
 }
 
+function normalizeModelId(model: string): string {
+  return model.trim().toLowerCase().split(":")[0]!;
+}
+
+function isTextAndImageModel(model: string): boolean {
+  const normalized = normalizeModelId(model);
+  if (normalized === "openrouter/auto") {
+    return true;
+  }
+
+  if (normalized.startsWith("google/gemini-") && normalized.includes("image")) {
+    return true;
+  }
+
+  if (normalized.startsWith("openai/gpt-") && normalized.includes("image")) {
+    return true;
+  }
+
+  return false;
+}
+
+function getSupportedAspectRatios(model: string): Set<string> {
+  const normalized = normalizeModelId(model);
+  if (normalized !== "google/gemini-3.1-flash-image-preview") {
+    return new Set(COMMON_ASPECT_RATIOS);
+  }
+
+  return new Set([...COMMON_ASPECT_RATIOS, ...GEMINI_EXTENDED_ASPECT_RATIOS]);
+}
+
 function getApiKey(): string | null {
   return process.env.OPENROUTER_API_KEY || null;
 }
@@ -103,17 +148,50 @@ function inferImageSize(size: string | null): "1K" | "2K" | "4K" | null {
   return "4K";
 }
 
-function getImageSize(args: CliArgs): "1K" | "2K" | "4K" {
+export function getImageSize(args: CliArgs): "1K" | "2K" | "4K" | null {
   if (args.imageSize) return args.imageSize as "1K" | "2K" | "4K";
 
   const inferredFromSize = inferImageSize(args.size);
   if (inferredFromSize) return inferredFromSize;
 
-  return args.quality === "normal" ? "1K" : "2K";
+  if (args.quality === "normal") return "1K";
+  if (args.quality === "2k") return "2K";
+  return null;
 }
 
-function getAspectRatio(args: CliArgs): string | null {
-  return args.aspectRatio || inferAspectRatio(args.size);
+export function getAspectRatio(model: string, args: CliArgs): string | null {
+  if (args.aspectRatio) return args.aspectRatio;
+
+  const inferred = inferAspectRatio(args.size);
+  if (!inferred || !getSupportedAspectRatios(model).has(inferred)) {
+    return null;
+  }
+
+  return inferred;
+}
+
+function getModalities(model: string): string[] {
+  return isTextAndImageModel(model) ? ["image", "text"] : ["image"];
+}
+
+export function validateArgs(model: string, args: CliArgs): void {
+  const requestedAspectRatio = args.aspectRatio || inferAspectRatio(args.size);
+  if (!requestedAspectRatio) {
+    return;
+  }
+
+  const supported = getSupportedAspectRatios(model);
+  if (supported.has(requestedAspectRatio)) {
+    return;
+  }
+
+  const requestedValue = args.aspectRatio
+    ? `aspect ratio ${requestedAspectRatio}`
+    : `size ${args.size} (aspect ratio ${requestedAspectRatio})`;
+
+  throw new Error(
+    `OpenRouter model ${model} does not support ${requestedValue}. Supported values: ${Array.from(supported).join(", ")}`
+  );
 }
 
 function getMimeType(filename: string): string {
@@ -129,7 +207,14 @@ async function readImageAsDataUrl(filePath: string): Promise<string> {
   return `data:${getMimeType(filePath)};base64,${bytes.toString("base64")}`;
 }
 
-function buildContent(prompt: string, referenceImages: string[]): Array<Record<string, unknown>> {
+export function buildContent(
+  prompt: string,
+  referenceImages: string[],
+): string | Array<Record<string, unknown>> {
+  if (referenceImages.length === 0) {
+    return prompt;
+  }
+
   const content: Array<Record<string, unknown>> = [{ type: "text", text: prompt }];
 
   for (const imageUrl of referenceImages) {
@@ -171,8 +256,9 @@ async function downloadImage(value: string): Promise<Uint8Array> {
   return Uint8Array.from(Buffer.from(value, "base64"));
 }
 
-async function extractImageFromResponse(result: OpenRouterResponse): Promise<Uint8Array> {
-  const message = result.choices?.[0]?.message;
+export async function extractImageFromResponse(result: OpenRouterResponse): Promise<Uint8Array> {
+  const choice = result.choices?.[0];
+  const message = choice?.message;
 
   for (const image of message?.images ?? []) {
     const imageUrl = extractImageUrl(image);
@@ -194,7 +280,52 @@ async function extractImageFromResponse(result: OpenRouterResponse): Promise<Uin
     if (inline) return inline;
   }
 
-  throw new Error("No image in OpenRouter response");
+  const finishReason =
+    choice?.native_finish_reason || choice?.finish_reason || "unknown";
+  throw new Error(
+    `No image in OpenRouter response (finish_reason=${finishReason})`,
+  );
+}
+
+export function buildRequestBody(
+  prompt: string,
+  model: string,
+  args: CliArgs,
+  referenceImages: string[],
+): Record<string, unknown> {
+  validateArgs(model, args);
+
+  const imageConfig: Record<string, string> = {};
+
+  const imageSize = getImageSize(args);
+  if (imageSize) {
+    imageConfig.image_size = imageSize;
+  }
+
+  const aspectRatio = getAspectRatio(model, args);
+  if (aspectRatio) {
+    imageConfig.aspect_ratio = aspectRatio;
+  }
+
+  const body: Record<string, unknown> = {
+    messages: [
+      {
+        role: "user",
+        content: buildContent(prompt, referenceImages),
+      },
+    ],
+    modalities: getModalities(model),
+    stream: false,
+  };
+
+  if (Object.keys(imageConfig).length > 0) {
+    body.image_config = imageConfig;
+    body.provider = {
+      require_parameters: true,
+    };
+  }
+
+  return body;
 }
 
 export async function generateImage(
@@ -212,32 +343,15 @@ export async function generateImage(
     referenceImages.push(await readImageAsDataUrl(refPath));
   }
 
-  const imageGenerationOptions: Record<string, string> = {
-    size: getImageSize(args),
-  };
-
-  const aspectRatio = getAspectRatio(args);
-  if (aspectRatio) {
-    imageGenerationOptions.aspect_ratio = aspectRatio;
-  }
-
   const body = {
     model,
-    messages: [
-      {
-        role: "user",
-        content: buildContent(prompt, referenceImages),
-      },
-    ],
-    modalities: ["image", "text"],
-    max_tokens: 256,
-    imageGenerationOptions,
-    providerPreferences: {
-      require_parameters: true,
-    },
+    ...buildRequestBody(prompt, model, args, referenceImages),
   };
 
-  console.log(`Generating image with OpenRouter (${model})...`, imageGenerationOptions);
+  console.log(
+    `Generating image with OpenRouter (${model})...`,
+    (body.image_config as Record<string, string>),
+  );
 
   const response = await fetch(`${getBaseUrl()}/chat/completions`, {
     method: "POST",

skills/baoyu-image-gen/scripts/providers/replicate.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { CliArgs } from "../types.ts";
+import {
+  buildInput,
+  extractOutputUrl,
+  parseModelId,
+} from "./replicate.ts";
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+test("Replicate model parsing accepts official formats and rejects malformed ones", () => {
+  assert.deepEqual(parseModelId("google/nano-banana-pro"), {
+    owner: "google",
+    name: "nano-banana-pro",
+    version: null,
+  });
+  assert.deepEqual(parseModelId("owner/model:abc123"), {
+    owner: "owner",
+    name: "model",
+    version: "abc123",
+  });
+
+  assert.throws(
+    () => parseModelId("just-a-model-name"),
+    /Invalid Replicate model format/,
+  );
+});
+
+test("Replicate input builder maps aspect ratio, image count, quality, and refs", () => {
+  assert.deepEqual(
+    buildInput(
+      "A robot painter",
+      makeArgs({
+        aspectRatio: "16:9",
+        quality: "2k",
+        n: 3,
+      }),
+      ["data:image/png;base64,AAAA"],
+    ),
+    {
+      prompt: "A robot painter",
+      aspect_ratio: "16:9",
+      number_of_images: 3,
+      resolution: "2K",
+      output_format: "png",
+      image_input: ["data:image/png;base64,AAAA"],
+    },
+  );
+
+  assert.deepEqual(
+    buildInput("A robot painter", makeArgs({ quality: "normal" }), ["ref"]),
+    {
+      prompt: "A robot painter",
+      aspect_ratio: "match_input_image",
+      resolution: "1K",
+      output_format: "png",
+      image_input: ["ref"],
+    },
+  );
+});
+
+test("Replicate output extraction supports string, array, and object URLs", () => {
+  assert.equal(
+    extractOutputUrl({ output: "https://example.com/a.png" } as never),
+    "https://example.com/a.png",
+  );
+  assert.equal(
+    extractOutputUrl({ output: ["https://example.com/b.png"] } as never),
+    "https://example.com/b.png",
+  );
+  assert.equal(
+    extractOutputUrl({ output: { url: "https://example.com/c.png" } } as never),
+    "https://example.com/c.png",
+  );
+
+  assert.throws(
+    () => extractOutputUrl({ output: { invalid: true } } as never),
+    /Unexpected Replicate output format/,
+  );
+});

skills/baoyu-image-gen/scripts/providers/replicate.ts

@@ -20,7 +20,7 @@ function getBaseUrl(): string {
   return base.replace(/\/+$/g, "");
 }
 
-function parseModelId(model: string): { owner: string; name: string; version: string | null } {
+export function parseModelId(model: string): { owner: string; name: string; version: string | null } {
   const [ownerName, version] = model.split(":");
   const parts = ownerName!.split("/");
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
@@ -31,7 +31,7 @@ function parseModelId(model: string): { owner: string; name: string; version: st
   return { owner: parts[0], name: parts[1], version: version || null };
 }
 
-function buildInput(prompt: string, args: CliArgs, referenceImages: string[]): Record<string, unknown> {
+export function buildInput(prompt: string, args: CliArgs, referenceImages: string[]): Record<string, unknown> {
   const input: Record<string, unknown> = { prompt };
 
   if (args.aspectRatio) {
@@ -144,7 +144,7 @@ async function pollPrediction(apiToken: string, getUrl: string): Promise<Predict
   throw new Error(`Replicate prediction timed out after ${MAX_POLL_MS / 1000}s`);
 }
 
-function extractOutputUrl(prediction: PredictionResponse): string {
+export function extractOutputUrl(prediction: PredictionResponse): string {
   const output = prediction.output;
 
   if (typeof output === "string") return output;

skills/baoyu-image-gen/scripts/providers/seedream.test.ts

@@ -0,0 +1,244 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test, { type TestContext } from "node:test";
+
+import type { CliArgs } from "../types.ts";
+import {
+  buildImageInput,
+  buildRequestBody,
+  generateImage,
+  getDefaultOutputExtension,
+  resolveSeedreamSize,
+  validateArgs,
+} from "./seedream.ts";
+
+function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
+  return {
+    prompt: null,
+    promptFiles: [],
+    imagePath: null,
+    provider: null,
+    model: null,
+    aspectRatio: null,
+    size: null,
+    quality: null,
+    imageSize: null,
+    referenceImages: [],
+    n: 1,
+    batchFile: null,
+    jobs: null,
+    json: false,
+    help: false,
+    ...overrides,
+  };
+}
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempPng(t: TestContext, name: string): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "seedream-test-"));
+  t.after(() => fs.rm(dir, { recursive: true, force: true }));
+
+  const filePath = path.join(dir, name);
+  const png1x1 =
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+a7m0AAAAASUVORK5CYII=";
+  await fs.writeFile(filePath, Buffer.from(png1x1, "base64"));
+  return filePath;
+}
+
+test("Seedream request body and default extensions follow official model capabilities", () => {
+  const five = buildRequestBody(
+    "A robot illustrator",
+    "doubao-seedream-5-0-260128",
+    makeArgs(),
+  );
+  assert.equal(five.size, "2K");
+  assert.equal(five.response_format, "url");
+  assert.equal(five.output_format, "png");
+  assert.equal(getDefaultOutputExtension("doubao-seedream-5-0-260128"), ".png");
+
+  const fourFive = buildRequestBody(
+    "A robot illustrator",
+    "doubao-seedream-4-5-251128",
+    makeArgs(),
+  );
+  assert.equal(fourFive.size, "2K");
+  assert.equal(fourFive.response_format, "url");
+  assert.ok(!("output_format" in fourFive));
+  assert.equal(getDefaultOutputExtension("doubao-seedream-4-5-251128"), ".jpg");
+
+  assert.throws(
+    () =>
+      buildRequestBody(
+        "Change the bubbles into hearts",
+        "doubao-seededit-3-0-i2i-250628",
+        makeArgs({ referenceImages: ["ref.png"] }),
+        "data:image/png;base64,AAAA",
+      ),
+    /no longer supported/,
+  );
+});
+
+test("Seedream size selection validates model-specific presets", () => {
+  assert.equal(
+    resolveSeedreamSize("doubao-seedream-4-0-250828", makeArgs({ quality: "normal" })),
+    "1K",
+  );
+  assert.equal(
+    resolveSeedreamSize("doubao-seedream-3-0-t2i-250415", makeArgs({ quality: "2k" })),
+    "2048x2048",
+  );
+
+  assert.throws(
+    () =>
+      resolveSeedreamSize("doubao-seedream-5-0-260128", makeArgs({ size: "4K" })),
+    /only supports 2K, 3K/,
+  );
+  assert.throws(
+    () =>
+      resolveSeedreamSize("doubao-seedream-3-0-t2i-250415", makeArgs({ imageSize: "2K" })),
+    /only supports explicit WxH sizes/,
+  );
+  assert.throws(
+    () =>
+      resolveSeedreamSize("doubao-seededit-3-0-i2i-250628", makeArgs({ size: "1024x1024" })),
+    /no longer supported/,
+  );
+});
+
+test("Seedream reference-image support is model-specific", () => {
+  assert.doesNotThrow(() =>
+    validateArgs(
+      "doubao-seedream-5-0-260128",
+      makeArgs({ referenceImages: ["a.png", "b.png"] }),
+    ),
+  );
+
+  assert.throws(
+    () =>
+      validateArgs(
+        "doubao-seedream-3-0-t2i-250415",
+        makeArgs({ referenceImages: ["a.png"] }),
+      ),
+    /does not support reference images/,
+  );
+
+  assert.throws(
+    () =>
+      validateArgs(
+        "doubao-seededit-3-0-i2i-250628",
+        makeArgs(),
+      ),
+    /no longer supported/,
+  );
+
+  assert.throws(
+    () =>
+      validateArgs(
+        "ep-20260315171508-t8br2",
+        makeArgs({ referenceImages: ["a.png"] }),
+      ),
+    /require a known model ID/,
+  );
+});
+
+test("Seedream image input encodes local references as data URLs", async (t) => {
+  const refOne = await makeTempPng(t, "one.png");
+  const refTwo = await makeTempPng(t, "two.png");
+
+  const single = await buildImageInput("doubao-seedream-4-5-251128", [refOne]);
+  assert.match(String(single), /^data:image\/png;base64,/);
+
+  const multiple = await buildImageInput("doubao-seedream-5-0-260128", [refOne, refTwo]);
+  assert.ok(Array.isArray(multiple));
+  assert.equal(multiple.length, 2);
+});
+
+test("Seedream generateImage posts the documented response_format and downloads the returned URL", async (t) => {
+  useEnv(t, { ARK_API_KEY: "test-key", SEEDREAM_BASE_URL: null });
+
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  const calls: Array<{
+    input: string;
+    init?: RequestInit;
+  }> = [];
+
+  globalThis.fetch = async (input, init) => {
+    calls.push({
+      input: String(input),
+      init,
+    });
+
+    if (calls.length === 1) {
+      return Response.json({
+        model: "doubao-seedream-4-5-251128",
+        created: 1740000000,
+        data: [
+          {
+            url: "https://example.com/generated-image",
+            size: "2048x2048",
+          },
+        ],
+        usage: {
+          generated_images: 1,
+          output_tokens: 1,
+          total_tokens: 1,
+        },
+      });
+    }
+
+    return new Response(Uint8Array.from([7, 8, 9]), {
+      status: 200,
+      headers: { "Content-Type": "image/jpeg" },
+    });
+  };
+
+  const image = await generateImage(
+    "A robot illustrator",
+    "doubao-seedream-4-5-251128",
+    makeArgs(),
+  );
+
+  assert.deepEqual([...image], [7, 8, 9]);
+  assert.equal(calls.length, 2);
+  assert.equal(
+    calls[0]?.input,
+    "https://ark.cn-beijing.volces.com/api/v3/images/generations",
+  );
+
+  const requestBody = JSON.parse(String(calls[0]?.init?.body)) as Record<string, unknown>;
+  assert.equal(requestBody.model, "doubao-seedream-4-5-251128");
+  assert.equal(requestBody.size, "2K");
+  assert.equal(requestBody.response_format, "url");
+  assert.ok(!("output_format" in requestBody));
+  assert.equal(calls[1]?.input, "https://example.com/generated-image");
+});

skills/baoyu-image-gen/scripts/providers/seedream.ts

@@ -0,0 +1,341 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+
+import type { CliArgs } from "../types";
+
+export type SeedreamModelFamily =
+  | "seedream5"
+  | "seedream45"
+  | "seedream40"
+  | "seedream30"
+  | "unknown";
+
+type SeedreamRequestImage = string | string[];
+
+type SeedreamRequestBody = {
+  model: string;
+  prompt: string;
+  size: string;
+  response_format: "url";
+  watermark: boolean;
+  image?: SeedreamRequestImage;
+  output_format?: "png";
+};
+
+type SeedreamImageResponse = {
+  model?: string;
+  created?: number;
+  data?: Array<{
+    url?: string;
+    b64_json?: string;
+    size?: string;
+    error?: {
+      code?: string;
+      message?: string;
+    };
+  }>;
+  usage?: {
+    generated_images: number;
+    output_tokens: number;
+    total_tokens: number;
+  };
+  error?: {
+    code?: string;
+    message?: string;
+  };
+};
+
+export function getDefaultModel(): string {
+  return process.env.SEEDREAM_IMAGE_MODEL || "doubao-seedream-5-0-260128";
+}
+
+function getApiKey(): string | null {
+  return process.env.ARK_API_KEY || null;
+}
+
+function getBaseUrl(): string {
+  return process.env.SEEDREAM_BASE_URL || "https://ark.cn-beijing.volces.com/api/v3";
+}
+
+function parsePixelSize(value: string): { width: number; height: number } | null {
+  const match = value.trim().match(/^(\d+)\s*[xX]\s*(\d+)$/);
+  if (!match) return null;
+
+  const width = parseInt(match[1]!, 10);
+  const height = parseInt(match[2]!, 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+
+  return { width, height };
+}
+
+function normalizePixelSize(value: string): string | null {
+  const parsed = parsePixelSize(value);
+  if (!parsed) return null;
+  return `${parsed.width}x${parsed.height}`;
+}
+
+function normalizeSizePreset(value: string): string | null {
+  const upper = value.trim().toUpperCase();
+  if (upper === "ADAPTIVE") return "adaptive";
+  if (upper === "1K" || upper === "2K" || upper === "3K" || upper === "4K") return upper;
+  return null;
+}
+
+function normalizeSizeValue(value: string): string | null {
+  return normalizeSizePreset(value) ?? normalizePixelSize(value);
+}
+
+function getMimeType(filename: string): string {
+  const ext = path.extname(filename).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  if (ext === ".gif") return "image/gif";
+  if (ext === ".bmp") return "image/bmp";
+  if (ext === ".tiff" || ext === ".tif") return "image/tiff";
+  return "image/png";
+}
+
+async function readImageAsDataUrl(filePath: string): Promise<string> {
+  const bytes = await readFile(filePath);
+  return `data:${getMimeType(filePath)};base64,${bytes.toString("base64")}`;
+}
+
+export function getModelFamily(model: string): SeedreamModelFamily {
+  const normalized = model.trim();
+  if (/^doubao-seedream-5-0(?:-lite)?-\d+$/.test(normalized)) return "seedream5";
+  if (/^doubao-seedream-4-5-\d+$/.test(normalized)) return "seedream45";
+  if (/^doubao-seedream-4-0-\d+$/.test(normalized)) return "seedream40";
+  if (/^doubao-seedream-3-0-t2i-\d+$/.test(normalized)) return "seedream30";
+  return "unknown";
+}
+
+function isRemovedSeededitModel(model: string): boolean {
+  return /^doubao-seededit-3-0-i2i-\d+$/.test(model.trim());
+}
+
+function assertSupportedModel(model: string): void {
+  if (isRemovedSeededitModel(model)) {
+    throw new Error(
+      `${model} is no longer supported. SeedEdit 3.0 support has been removed from this tool; use Seedream 5.0/4.5/4.0/3.0 instead.`
+    );
+  }
+}
+
+export function supportsReferenceImages(model: string): boolean {
+  const family = getModelFamily(model);
+  return family === "seedream5" || family === "seedream45" || family === "seedream40";
+}
+
+function supportsOutputFormat(model: string): boolean {
+  return getModelFamily(model) === "seedream5";
+}
+
+export function getDefaultOutputExtension(model: string): ".png" | ".jpg" {
+  assertSupportedModel(model);
+  return supportsOutputFormat(model) ? ".png" : ".jpg";
+}
+
+export function getDefaultSeedreamSize(model: string, args: CliArgs): string {
+  assertSupportedModel(model);
+  const family = getModelFamily(model);
+
+  if (family === "seedream5") return "2K";
+  if (family === "seedream45") return "2K";
+  if (family === "seedream40") return args.quality === "normal" ? "1K" : "2K";
+  if (family === "seedream30") return args.quality === "2k" ? "2048x2048" : "1024x1024";
+  return "2K";
+}
+
+export function resolveSeedreamSize(model: string, args: CliArgs): string {
+  assertSupportedModel(model);
+  const family = getModelFamily(model);
+  const requested = args.size || args.imageSize || null;
+  const normalized = requested ? normalizeSizeValue(requested) : null;
+
+  if (!normalized) {
+    return getDefaultSeedreamSize(model, args);
+  }
+
+  if (family === "seedream30") {
+    const pixelSize = normalizePixelSize(normalized);
+    if (!pixelSize) {
+      throw new Error("Seedream 3.0 only supports explicit WxH sizes such as 1024x1024.");
+    }
+    return pixelSize;
+  }
+
+  if (family === "seedream5") {
+    if (normalized === "4K" || normalized === "1K" || normalized === "adaptive") {
+      throw new Error("Seedream 5.0 only supports 2K, 3K, or explicit WxH sizes.");
+    }
+    return normalized;
+  }
+
+  if (family === "seedream45") {
+    if (normalized === "1K" || normalized === "3K" || normalized === "adaptive") {
+      throw new Error("Seedream 4.5 only supports 2K, 4K, or explicit WxH sizes.");
+    }
+    return normalized;
+  }
+
+  if (family === "seedream40") {
+    if (normalized === "3K" || normalized === "adaptive") {
+      throw new Error("Seedream 4.0 only supports 1K, 2K, 4K, or explicit WxH sizes.");
+    }
+    return normalized;
+  }
+
+  if (normalized === "adaptive") {
+    throw new Error("Adaptive size is not supported by Seedream image generation.");
+  }
+
+  if (normalized === "1K" || normalized === "3K" || normalized === "4K") {
+    throw new Error(
+      "Unknown Seedream model ID. Use a documented model ID or pass an explicit WxH size instead of preset imageSize."
+    );
+  }
+
+  return normalized;
+}
+
+export function validateArgs(model: string, args: CliArgs): void {
+  assertSupportedModel(model);
+  const family = getModelFamily(model);
+  const refCount = args.referenceImages.length;
+
+  if (refCount === 0) {
+    resolveSeedreamSize(model, args);
+    return;
+  }
+
+  if (family === "unknown") {
+    throw new Error(
+      "Reference images with Seedream require a known model ID. Use Seedream 5.0/4.5/4.0 model IDs instead of an endpoint ID."
+    );
+  }
+
+  if (!supportsReferenceImages(model)) {
+    throw new Error(`${model} does not support reference images.`);
+  }
+
+  if ((family === "seedream5" || family === "seedream45" || family === "seedream40") && refCount > 14) {
+    throw new Error(`${model} supports at most 14 reference images.`);
+  }
+
+  resolveSeedreamSize(model, args);
+}
+
+export async function buildImageInput(
+  model: string,
+  referenceImages: string[],
+): Promise<SeedreamRequestImage | undefined> {
+  if (referenceImages.length === 0) return undefined;
+  assertSupportedModel(model);
+
+  const encoded = await Promise.all(referenceImages.map((refPath) => readImageAsDataUrl(refPath)));
+
+  return encoded.length === 1 ? encoded[0]! : encoded;
+}
+
+export function buildRequestBody(
+  prompt: string,
+  model: string,
+  args: CliArgs,
+  imageInput?: SeedreamRequestImage,
+): SeedreamRequestBody {
+  validateArgs(model, args);
+
+  const requestBody: SeedreamRequestBody = {
+    model,
+    prompt,
+    size: resolveSeedreamSize(model, args),
+    response_format: "url",
+    watermark: false,
+  };
+
+  if (imageInput) {
+    requestBody.image = imageInput;
+  }
+
+  if (supportsOutputFormat(model)) {
+    requestBody.output_format = "png";
+  }
+
+  return requestBody;
+}
+
+async function downloadImage(url: string): Promise<Uint8Array> {
+  const imgResponse = await fetch(url);
+  if (!imgResponse.ok) {
+    throw new Error(`Failed to download image from ${url}`);
+  }
+
+  const buffer = await imgResponse.arrayBuffer();
+  return new Uint8Array(buffer);
+}
+
+export async function extractImageFromResponse(result: SeedreamImageResponse): Promise<Uint8Array> {
+  const first = result.data?.find((item) => item.url || item.b64_json || item.error);
+
+  if (!first) {
+    throw new Error("No image data in Seedream response");
+  }
+
+  if (first.error) {
+    throw new Error(first.error.message || "Seedream returned an image generation error");
+  }
+
+  if (first.b64_json) {
+    return Uint8Array.from(Buffer.from(first.b64_json, "base64"));
+  }
+
+  if (first.url) {
+    console.error(`Downloading image from ${first.url}...`);
+    return downloadImage(first.url);
+  }
+
+  throw new Error("No image URL or base64 data in Seedream response");
+}
+
+export async function generateImage(
+  prompt: string,
+  model: string,
+  args: CliArgs,
+): Promise<Uint8Array> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error(
+      "ARK_API_KEY is required. " +
+        "Get your API key from https://console.volcengine.com/ark"
+    );
+  }
+
+  validateArgs(model, args);
+  const imageInput = await buildImageInput(model, args.referenceImages);
+  const requestBody = buildRequestBody(prompt, model, args, imageInput);
+
+  console.error(`Calling Seedream API (${model}) with size: ${requestBody.size}`);
+
+  const response = await fetch(`${getBaseUrl()}/images/generations`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(requestBody),
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`Seedream API error (${response.status}): ${err}`);
+  }
+
+  const result = (await response.json()) as SeedreamImageResponse;
+  if (result.error) {
+    throw new Error(result.error.message || "Seedream API returned an error");
+  }
+
+  return extractImageFromResponse(result);
+}

skills/baoyu-image-gen/scripts/types.ts

@@ -1,4 +1,4 @@
-export type Provider = "google" | "openai" | "openrouter" | "dashscope" | "replicate";
+export type Provider = "google" | "openai" | "openrouter" | "dashscope" | "replicate" | "jimeng" | "seedream";
 export type Quality = "normal" | "2k";
 
 export type CliArgs = {
@@ -53,6 +53,8 @@ export type ExtendConfig = {
     openrouter: string | null;
     dashscope: string | null;
     replicate: string | null;
+    jimeng: string | null;
+    seedream: string | null;
   };
   batch?: {
     max_workers?: number | null;

skills/baoyu-markdown-to-html/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: baoyu-markdown-to-html
-description: Converts Markdown to styled HTML with WeChat-compatible themes. Supports code highlighting, math, PlantUML, footnotes, alerts, infographics, and optional bottom citations for external links. Use when user asks for "markdown to html", "convert md to html", "md转html", "微信外链转底部引用", or needs styled HTML output from markdown.
+description: Converts Markdown to styled HTML with WeChat-compatible themes. Supports code highlighting, math, PlantUML, footnotes, alerts, infographics, and optional bottom citations for external links. Use when user asks for "markdown to html", "convert md to html", "md 转 html", "微信外链转底部引用", or needs styled HTML output from markdown.
 version: 1.56.1
 metadata:
   openclaw:

skills/baoyu-markdown-to-html/scripts/main.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT_PATH = path.join(SCRIPT_DIR, "main.ts");
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("CLI forwards wrapper title and vendor render options", async () => {
+  const root = await makeTempDir("baoyu-markdown-to-html-cli-");
+  const markdownPath = path.join(root, "article.md");
+  await fs.writeFile(markdownPath, "## Section\n\nParagraph with **bold** text.\n", "utf-8");
+
+  const { stdout } = await execFileAsync(
+    "bun",
+    [
+      SCRIPT_PATH,
+      markdownPath,
+      "--theme", "grace",
+      "--color", "red",
+      "--font-family", "mono",
+      "--font-size", "18",
+      "--keep-title",
+      "--title", "Overridden",
+    ],
+    { cwd: SCRIPT_DIR },
+  );
+
+  const result = JSON.parse(stdout.trim()) as {
+    htmlPath: string;
+    title: string;
+  };
+
+  assert.equal(result.title, "Overridden");
+
+  const html = await fs.readFile(result.htmlPath, "utf-8");
+  assert.match(html, /<title>Overridden<\/title>/);
+  assert.match(html, /<h2[^>]*style="[^"]*background: #A93226/);
+  assert.match(html, /<strong[^>]*style="[^"]*color: #A93226/);
+  assert.match(
+    html,
+    /<body[^>]*style="[^"]*font-family: Menlo, Monaco, 'Courier New', monospace;[^"]*font-size: 18px/,
+  );
+});

skills/baoyu-markdown-to-html/scripts/main.ts

@@ -4,16 +4,22 @@ import path from "node:path";
 import process from "node:process";
 
 import {
+  COLOR_PRESETS,
+  FONT_FAMILY_MAP,
+  FONT_SIZE_OPTIONS,
+  THEME_NAMES,
   extractSummaryFromBody,
   extractTitleFromMarkdown,
   formatTimestamp,
+  parseArgs,
   parseFrontmatter,
   renderMarkdownDocument,
   replaceMarkdownImagesWithPlaceholders,
   resolveContentImages,
   serializeFrontmatter,
   stripWrappingQuotes,
-} from "baoyu-md";
+} from "./vendor/baoyu-md/src/index.ts";
+import type { CliOptions } from "./vendor/baoyu-md/src/types.ts";
 
 interface ImageInfo {
   placeholder: string;
@@ -30,9 +36,13 @@ interface ParsedResult {
   contentImages: ImageInfo[];
 }
 
+type ConvertMarkdownOptions = Partial<Omit<CliOptions, "inputPath">> & {
+  title?: string;
+};
+
 export async function convertMarkdown(
   markdownPath: string,
-  options?: { title?: string; theme?: string; keepTitle?: boolean; citeStatus?: boolean },
+  options?: ConvertMarkdownOptions,
 ): Promise<ParsedResult> {
   const baseDir = path.dirname(markdownPath);
   const content = fs.readFileSync(markdownPath, "utf-8");
@@ -56,20 +66,32 @@ export async function convertMarkdown(
     summary = extractSummaryFromBody(body, 120);
   }
 
+  const effectiveFrontmatter = options?.title
+    ? { ...frontmatter, title }
+    : frontmatter;
+
   const { images, markdown: rewrittenBody } = replaceMarkdownImagesWithPlaceholders(
     body,
     "MDTOHTMLIMGPH_",
   );
-  const rewrittenMarkdown = `${serializeFrontmatter(frontmatter)}${rewrittenBody}`;
+  const rewrittenMarkdown = `${serializeFrontmatter(effectiveFrontmatter)}${rewrittenBody}`;
 
   console.error(
     `[markdown-to-html] Rendering with theme: ${theme ?? "default"}, keepTitle: ${keepTitle}, citeStatus: ${citeStatus}`,
   );
 
   const { html } = await renderMarkdownDocument(rewrittenMarkdown, {
+    codeTheme: options?.codeTheme,
+    countStatus: options?.countStatus,
     citeStatus,
     defaultTitle: title,
+    fontFamily: options?.fontFamily,
+    fontSize: options?.fontSize,
+    isMacCodeBlock: options?.isMacCodeBlock,
+    isShowLineNumber: options?.isShowLineNumber,
     keepTitle,
+    legend: options?.legend,
+    primaryColor: options?.primaryColor,
     theme,
   });
 
@@ -111,18 +133,30 @@ export async function convertMarkdown(
   };
 }
 
-function printUsage(): never {
+function printUsage(exitCode = 0): never {
+  const colorNames = Object.keys(COLOR_PRESETS).join(", ");
+  const fontFamilyNames = Object.keys(FONT_FAMILY_MAP).join(", ");
+
   console.log(`Convert Markdown to styled HTML
 
 Usage:
   npx -y bun main.ts <markdown_file> [options]
 
 Options:
-  --title <title>     Override title
-  --theme <name>      Theme name (default, grace, simple). Default: default
-  --cite              Convert ordinary external links to bottom citations. Default: off
-  --keep-title        Keep the first heading in content. Default: false (removed)
-  --help              Show this help
+  --title <title>         Override title
+  --theme <name>          Theme name (${THEME_NAMES.join(", ")}). Default: default
+  --color <name|hex>      Primary color: ${colorNames}
+  --font-family <name>    Font: ${fontFamilyNames}, or CSS value
+  --font-size <N>         Font size: ${FONT_SIZE_OPTIONS.join(", ")} (default: 16px)
+  --code-theme <name>     Code highlight theme (default: github)
+  --mac-code-block        Show Mac-style code block header
+  --no-mac-code-block     Hide Mac-style code block header
+  --line-number           Show line numbers in code blocks
+  --cite                  Convert ordinary external links to bottom citations. Default: off
+  --count                 Show reading time / word count
+  --legend <value>        Image caption: title-alt, alt-title, title, alt, none
+  --keep-title            Keep the first heading in content. Default: false (removed)
+  --help                  Show this help
 
 Output:
   HTML file saved to same directory as input markdown file.
@@ -142,40 +176,60 @@ Output JSON format:
 Example:
   npx -y bun main.ts article.md
   npx -y bun main.ts article.md --theme grace
+  npx -y bun main.ts article.md --theme modern --color red
   npx -y bun main.ts article.md --cite
 `);
-  process.exit(0);
+  process.exit(exitCode);
+}
+
+function parseArgValue(argv: string[], i: number, flag: string): string | null {
+  const arg = argv[i]!;
+  if (arg.includes("=")) {
+    return arg.slice(flag.length + 1);
+  }
+  const next = argv[i + 1];
+  return next ?? null;
+}
+
+function extractTitleArg(argv: string[]): { renderArgs: string[]; title?: string } {
+  let title: string | undefined;
+  const renderArgs: string[] = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]!;
+    if (arg === "--title" || arg.startsWith("--title=")) {
+      const value = parseArgValue(argv, i, "--title");
+      if (!value) {
+        console.error("Missing value for --title");
+        printUsage(1);
+      }
+      title = value;
+      if (!arg.includes("=")) {
+        i += 1;
+      }
+      continue;
+    }
+    renderArgs.push(arg);
+  }
+
+  return { renderArgs, title };
 }
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-    printUsage();
+    printUsage(0);
   }
 
-  let markdownPath: string | undefined;
-  let title: string | undefined;
-  let theme: string | undefined;
-  let citeStatus = false;
-  let keepTitle = false;
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]!;
-    if (arg === "--title" && args[i + 1]) {
-      title = args[++i];
-    } else if (arg === "--theme" && args[i + 1]) {
-      theme = args[++i];
-    } else if (arg === "--cite") {
-      citeStatus = true;
-    } else if (arg === "--keep-title") {
-      keepTitle = true;
-    } else if (!arg.startsWith("-")) {
-      markdownPath = arg;
-    }
+  const { renderArgs, title } = extractTitleArg(args);
+  const options = parseArgs(renderArgs);
+  if (!options) {
+    printUsage(1);
   }
 
-  if (!markdownPath) {
-    console.error("Error: Markdown file path is required");
+  const markdownPath = path.resolve(process.cwd(), options.inputPath);
+  if (!markdownPath.toLowerCase().endsWith(".md")) {
+    console.error("Input file must end with .md");
     process.exit(1);
   }
 
@@ -184,7 +238,7 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  const result = await convertMarkdown(markdownPath, { title, theme, keepTitle, citeStatus });
+  const result = await convertMarkdown(markdownPath, { ...options, title });
   console.log(JSON.stringify(result, null, 2));
 }
 

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/content.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  extractSummaryFromBody,
+  extractTitleFromMarkdown,
+  parseFrontmatter,
+  pickFirstString,
+  serializeFrontmatter,
+  stripWrappingQuotes,
+  toFrontmatterString,
+} from "./content.ts";
+
+test("parseFrontmatter extracts YAML fields and strips wrapping quotes", () => {
+  const input = `---
+title: "Hello World"
+author: ‘Baoyu’
+summary: plain text
+---
+# Heading
+
+Body`;
+
+  const result = parseFrontmatter(input);
+
+  assert.deepEqual(result.frontmatter, {
+    title: "Hello World",
+    author: "Baoyu",
+    summary: "plain text",
+  });
+  assert.match(result.body, /^# Heading/);
+});
+
+test("parseFrontmatter returns original content when no frontmatter exists", () => {
+  const input = "# No frontmatter";
+  assert.deepEqual(parseFrontmatter(input), {
+    frontmatter: {},
+    body: input,
+  });
+});
+
+test("serializeFrontmatter renders YAML only when fields exist", () => {
+  assert.equal(serializeFrontmatter({}), "");
+  assert.equal(
+    serializeFrontmatter({ title: "Hello", author: "Baoyu" }),
+    "---\ntitle: Hello\nauthor: Baoyu\n---\n",
+  );
+});
+
+test("quote and frontmatter string helpers normalize mixed scalar values", () => {
+  assert.equal(stripWrappingQuotes(`" quoted "`), "quoted");
+  assert.equal(stripWrappingQuotes("“ 中文标题 ”"), "中文标题");
+  assert.equal(stripWrappingQuotes("plain"), "plain");
+
+  assert.equal(toFrontmatterString("'hello'"), "hello");
+  assert.equal(toFrontmatterString(42), "42");
+  assert.equal(toFrontmatterString(false), "false");
+  assert.equal(toFrontmatterString({}), undefined);
+
+  assert.equal(
+    pickFirstString({ summary: 123, title: "" }, ["title", "summary"]),
+    "123",
+  );
+});
+
+test("markdown title and summary extraction skip non-body content and clean formatting", () => {
+  const markdown = `
+![cover](cover.png)
+## “My Title”
+
+Body paragraph
+`;
+  assert.equal(extractTitleFromMarkdown(markdown), "My Title");
+
+  const summary = extractSummaryFromBody(
+    `
+# Heading
+> quote
+- list
+1. ordered
+\`\`\`
+code
+\`\`\`
+This is **the first paragraph** with [a link](https://example.com) and \`inline code\` that should be summarized cleanly.
+`,
+    70,
+  );
+
+  assert.equal(
+    summary,
+    "This is the first paragraph with a link and inline code that should...",
+  );
+});

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/document.test.ts

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import { COLOR_PRESETS, FONT_FAMILY_MAP } from "./constants.ts";
+import {
+  buildMarkdownDocumentMeta,
+  formatTimestamp,
+  renderMarkdownDocument,
+  resolveColorToken,
+  resolveFontFamilyToken,
+  resolveMarkdownStyle,
+  resolveRenderOptions,
+} from "./document.ts";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`);
+}
+
+function findInlineStyle(html: string, tagName: string, text: string): string {
+  const pattern = new RegExp(
+    `<${tagName}[^>]*style="([^"]*)"[^>]*>${escapeRegExp(text)}</${tagName}>`,
+  );
+  const match = html.match(pattern);
+  assert.ok(match, `Expected inline style for <${tagName}>${text}</${tagName}>`);
+  return match![1]!;
+}
+
+function useCwd(t: TestContext, cwd: string): void {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  t.after(() => {
+    process.chdir(previous);
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("document token resolvers map known presets and allow passthrough values", () => {
+  assert.equal(resolveColorToken("green"), COLOR_PRESETS.green);
+  assert.equal(resolveColorToken("#123456"), "#123456");
+  assert.equal(resolveColorToken(), undefined);
+
+  assert.equal(resolveFontFamilyToken("mono"), FONT_FAMILY_MAP.mono);
+  assert.equal(resolveFontFamilyToken("Custom Font"), "Custom Font");
+  assert.equal(resolveFontFamilyToken(), undefined);
+});
+
+test("formatTimestamp uses compact sortable datetime output", () => {
+  const date = new Date("2026-03-13T21:04:05.000Z");
+  const pad = (value: number) => String(value).padStart(2, "0");
+  const expected = `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(
+    date.getDate(),
+  )}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+
+  assert.equal(formatTimestamp(date), expected);
+});
+
+test("buildMarkdownDocumentMeta prefers frontmatter and falls back to markdown title and summary", () => {
+  const metaFromYaml = buildMarkdownDocumentMeta(
+    "# Markdown Title\n\nBody summary paragraph that should be ignored.",
+    {
+      title: `" YAML Title "`,
+      author: "'Baoyu'",
+      summary: `" YAML Summary "`,
+    },
+    "fallback",
+  );
+
+  assert.deepEqual(metaFromYaml, {
+    title: "YAML Title",
+    author: "Baoyu",
+    description: "YAML Summary",
+  });
+
+  const metaFromMarkdown = buildMarkdownDocumentMeta(
+    `## “Markdown Title”\n\nThis is the first body paragraph that should become the summary because it is long enough.`,
+    {},
+    "fallback",
+  );
+
+  assert.equal(metaFromMarkdown.title, "Markdown Title");
+  assert.match(metaFromMarkdown.description ?? "", /^This is the first body paragraph/);
+});
+
+test("resolveMarkdownStyle merges theme defaults with explicit overrides", () => {
+  const style = resolveMarkdownStyle({
+    theme: "modern",
+    primaryColor: "#112233",
+    fontFamily: "Custom Sans",
+  });
+
+  assert.equal(style.primaryColor, "#112233");
+  assert.equal(style.fontFamily, "Custom Sans");
+  assert.equal(style.fontSize, "15px");
+  assert.equal(style.containerBg, "rgba(250, 249, 245, 1)");
+});
+
+test("resolveRenderOptions loads workspace EXTEND settings and lets explicit options win", async (t) => {
+  const root = await makeTempDir("baoyu-md-render-options-");
+  useCwd(t, root);
+
+  const extendPath = path.join(
+    root,
+    ".baoyu-skills",
+    "baoyu-markdown-to-html",
+    "EXTEND.md",
+  );
+  await fs.mkdir(path.dirname(extendPath), { recursive: true });
+  await fs.writeFile(
+    extendPath,
+    `---
+default_theme: modern
+default_color: green
+default_font_family: mono
+default_font_size: 17
+default_code_theme: nord
+mac_code_block: false
+show_line_number: true
+cite: true
+count: true
+legend: title-alt
+keep_title: true
+---
+`,
+  );
+
+  const fromExtend = resolveRenderOptions();
+  assert.equal(fromExtend.theme, "modern");
+  assert.equal(fromExtend.primaryColor, COLOR_PRESETS.green);
+  assert.equal(fromExtend.fontFamily, FONT_FAMILY_MAP.mono);
+  assert.equal(fromExtend.fontSize, "17px");
+  assert.equal(fromExtend.codeTheme, "nord");
+  assert.equal(fromExtend.isMacCodeBlock, false);
+  assert.equal(fromExtend.isShowLineNumber, true);
+  assert.equal(fromExtend.citeStatus, true);
+  assert.equal(fromExtend.countStatus, true);
+  assert.equal(fromExtend.legend, "title-alt");
+  assert.equal(fromExtend.keepTitle, true);
+
+  const explicit = resolveRenderOptions({
+    theme: "simple",
+    fontSize: "18px",
+    keepTitle: false,
+  });
+  assert.equal(explicit.theme, "simple");
+  assert.equal(explicit.fontSize, "18px");
+  assert.equal(explicit.keepTitle, false);
+});
+
+test("renderMarkdownDocument layers default rules into grace theme before CSS inlining", async () => {
+  const { html } = await renderMarkdownDocument(
+    `## Section\n\nParagraph with **bold** text.`,
+    { keepTitle: true, theme: "grace" },
+  );
+
+  const h2Style = findInlineStyle(html, "h2", "Section");
+  assert.match(h2Style, /background: #92617E/);
+  assert.match(h2Style, /box-shadow: 0 4px 6px rgba\(0, 0, 0, 0\.1\)/);
+
+  const pMatch = html.match(/<p[^>]*style="([^"]*)"[^>]*>/);
+  assert.ok(pMatch, "Expected inline style on <p> tag");
+  assert.match(pMatch![1]!, /color:/);
+
+  const strongPattern = /<strong[^>]*style="([^"]*)"[^>]*>bold<\/strong>/;
+  const strongMatch = html.match(strongPattern);
+  assert.ok(strongMatch, "Expected inline style for <strong>bold</strong>");
+  assert.match(strongMatch![1]!, /font-weight:/);
+});

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/html-builder.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEFAULT_STYLE } from "./constants.ts";
+import {
+  buildCss,
+  buildHtmlDocument,
+  modifyHtmlStructure,
+  normalizeCssText,
+  normalizeInlineCss,
+  removeFirstHeading,
+} from "./html-builder.ts";
+
+test("buildCss injects style variables and concatenates base and theme CSS", () => {
+  const css = buildCss("body { color: red; }", ".theme { color: blue; }");
+
+  assert.match(css, /--md-primary-color: #0F4C81;/);
+  assert.match(css, /body \{ color: red; \}/);
+  assert.match(css, /\.theme \{ color: blue; \}/);
+});
+
+test("buildHtmlDocument includes optional meta tags and code theme CSS", () => {
+  const html = buildHtmlDocument(
+    {
+      title: "Doc",
+      author: "Baoyu",
+      description: "Summary",
+    },
+    "body { color: red; }",
+    "<article>Hello</article>",
+    ".hljs { color: blue; }",
+  );
+
+  assert.match(html, /<title>Doc<\/title>/);
+  assert.match(html, /meta name="author" content="Baoyu"/);
+  assert.match(html, /meta name="description" content="Summary"/);
+  assert.match(html, /<style>body \{ color: red; \}<\/style>/);
+  assert.match(html, /<style>\.hljs \{ color: blue; \}<\/style>/);
+  assert.match(html, /<article>Hello<\/article>/);
+});
+
+test("normalizeCssText and normalizeInlineCss replace variables and strip declarations", () => {
+  const rawCss = `
+:root { --md-primary-color: #000; --md-font-size: 12px; --foreground: 0 0% 5%; }
+.box { color: var(--md-primary-color); font-size: var(--md-font-size); background: hsl(var(--foreground)); }
+`;
+
+  const normalizedCss = normalizeCssText(rawCss, DEFAULT_STYLE);
+  assert.match(normalizedCss, /color: #0F4C81/);
+  assert.match(normalizedCss, /font-size: 16px/);
+  assert.match(normalizedCss, /background: #3f3f3f/);
+  assert.doesNotMatch(normalizedCss, /--md-primary-color/);
+
+  const normalizedHtml = normalizeInlineCss(
+    `<style>${rawCss}</style><div style="color: var(--md-primary-color)"></div>`,
+    DEFAULT_STYLE,
+  );
+  assert.match(normalizedHtml, /color: #0F4C81/);
+  assert.doesNotMatch(normalizedHtml, /var\(--md-primary-color\)/);
+});
+
+test("normalizeInlineCss removes quoted custom property values without leaving fragments behind", () => {
+  const normalizedHtml = normalizeInlineCss(
+    `<html style="--md-font-family: Menlo, Monaco, 'Courier New', monospace; color: var(--md-primary-color)"></html>`,
+    DEFAULT_STYLE,
+  );
+
+  assert.match(normalizedHtml, /style=" color: #0F4C81"/);
+  assert.doesNotMatch(normalizedHtml, /Courier New/);
+  assert.doesNotMatch(normalizedHtml, /--md-font-family/);
+});
+
+test("HTML structure helpers hoist nested lists and remove the first heading", () => {
+  const nestedList = `<ul><li>Parent<ul><li>Child</li></ul></li></ul>`;
+  assert.equal(
+    modifyHtmlStructure(nestedList),
+    `<ul><li>Parent</li><ul><li>Child</li></ul></ul>`,
+  );
+
+  const html = `<h1>Title</h1><p>Intro</p><h2>Sub</h2>`;
+  assert.equal(removeFirstHeading(html), `<p>Intro</p><h2>Sub</h2>`);
+});

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/html-builder.ts

@@ -100,13 +100,13 @@ export function normalizeCssText(cssText: string, style: StyleConfig = DEFAULT_S
     .replace(/var\(--md-accent-color\)/g, style.accentColor)
     .replace(/var\(--md-container-bg\)/g, style.containerBg)
     .replace(/hsl\(var\(--foreground\)\)/g, "#3f3f3f")
-    .replace(/--md-primary-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-family:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-size:\s*[^;"']+;?/g, "")
-    .replace(/--blockquote-background:\s*[^;"']+;?/g, "")
-    .replace(/--md-accent-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-container-bg:\s*[^;"']+;?/g, "")
-    .replace(/--foreground:\s*[^;"']+;?/g, "");
+    .replace(/--md-primary-color:\s*[^;]+;?/g, "")
+    .replace(/--md-font-family:\s*[^;]+;?/g, "")
+    .replace(/--md-font-size:\s*[^;]+;?/g, "")
+    .replace(/--blockquote-background:\s*[^;]+;?/g, "")
+    .replace(/--md-accent-color:\s*[^;]+;?/g, "")
+    .replace(/--md-container-bg:\s*[^;]+;?/g, "")
+    .replace(/--foreground:\s*[^;]+;?/g, "");
 }
 
 export function normalizeInlineCss(html: string, style: StyleConfig = DEFAULT_STYLE): string {

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/images.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  getImageExtension,
+  replaceMarkdownImagesWithPlaceholders,
+  resolveContentImages,
+  resolveImagePath,
+} from "./images.ts";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("replaceMarkdownImagesWithPlaceholders rewrites markdown and tracks image metadata", () => {
+  const result = replaceMarkdownImagesWithPlaceholders(
+    `![cover](images/cover.png)\n\nText\n\n![diagram](images/diagram.webp)`,
+    "IMG_",
+  );
+
+  assert.equal(result.markdown, `IMG_1\n\nText\n\nIMG_2`);
+  assert.deepEqual(result.images, [
+    { alt: "cover", originalPath: "images/cover.png", placeholder: "IMG_1" },
+    { alt: "diagram", originalPath: "images/diagram.webp", placeholder: "IMG_2" },
+  ]);
+});
+
+test("image extension and local fallback resolution handle common path variants", async (t) => {
+  assert.equal(getImageExtension("https://example.com/a.jpeg?x=1"), "jpeg");
+  assert.equal(getImageExtension("/tmp/figure"), "png");
+
+  const root = await makeTempDir("baoyu-md-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "figure.webp"), "webp");
+
+  const resolved = await resolveImagePath("figure.png", baseDir, tempDir, "test");
+  assert.equal(resolved, path.join(baseDir, "figure.webp"));
+});
+
+test("resolveContentImages resolves image placeholders against the content directory", async (t) => {
+  const root = await makeTempDir("baoyu-md-content-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "cover.png"), "png");
+
+  const resolved = await resolveContentImages(
+    [
+      {
+        alt: "cover",
+        originalPath: "cover.png",
+        placeholder: "IMG_1",
+      },
+    ],
+    baseDir,
+    tempDir,
+    "test",
+  );
+
+  assert.deepEqual(resolved, [
+    {
+      alt: "cover",
+      originalPath: "cover.png",
+      placeholder: "IMG_1",
+      localPath: path.join(baseDir, "cover.png"),
+    },
+  ]);
+});

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/renderer.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { initRenderer, renderMarkdown } from "./renderer.ts";
+
+const render = (md: string) => {
+  const r = initRenderer();
+  return renderMarkdown(md, r).html;
+};
+
+test("bold with inline code (no underscore)", () => {
+  const html = render("**算出 `logits`，算出 `loss`。**");
+  assert.match(html, /<code[^>]*>logits<\/code>/);
+  assert.match(html, /<code[^>]*>loss<\/code>/);
+});
+
+test("bold with inline code (contains underscore)", () => {
+  const html = render("**变成 `input_ids`。**");
+  assert.match(html, /<code[^>]*>input_ids<\/code>/);
+});
+
+test("emphasis with inline code", () => {
+  const html = render("*查看 `hidden_states`*");
+  assert.match(html, /<code[^>]*>hidden_states<\/code>/);
+});
+
+test("plain inline code (regression)", () => {
+  const html = render("`lm_head`");
+  assert.match(html, /<code[^>]*>lm_head<\/code>/);
+});
+
+test("bold without code (regression)", () => {
+  const html = render("**纯粗体文本**");
+  assert.match(html, /<strong[^>]*>纯粗体文本<\/strong>/);
+  assert.doesNotMatch(html, /<code/);
+});
+
+test("bold with inline code containing backticks", () => {
+  const html = render("**``a`b``**");
+  assert.match(html, /<code[^>]*>a&#96;b<\/code>/);
+});
+
+test("emphasis with inline code containing backticks", () => {
+  const html = render("*``a`b``*");
+  assert.match(html, /<em[^>]*><code[^>]*>a&#96;b<\/code><\/em>/);
+});
+
+test("bold with inline code containing consecutive backticks", () => {
+  const html = render("**```a``b```**");
+  assert.match(html, /<code[^>]*>a&#96;&#96;b<\/code>/);
+});
+
+test("bold with inline code containing only backticks", () => {
+  const html = render("**```` `` ````**");
+  assert.match(html, /<code[^>]*>&#96;&#96;<\/code>/);
+});
+
+test("bold with inline code containing only spaces", () => {
+  const oneSpace = render("**`` ``**");
+  assert.match(oneSpace, /<code[^>]*> <\/code>/);
+
+  const twoSpaces = render("**``  ``**");
+  assert.match(twoSpaces, /<code[^>]*>  <\/code>/);
+});

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/renderer.ts

@@ -109,6 +109,13 @@ function parseFrontMatterAndContent(markdownText: string): ParseResult {
   }
 }
 
+function wrapInlineCode(value: string): string {
+  const runs = value.match(/`+/g);
+  const fence = "`".repeat(Math.max(...(runs?.map((run) => run.length) ?? [0])) + 1);
+  const padding = /^ *$/.test(value) ? "" : " ";
+  return `${fence}${padding}${value}${padding}${fence}`;
+}
+
 export function initRenderer(opts: IOpts = {}): RendererAPI {
   const footnotes: [number, string, string][] = [];
   let footnoteIndex = 0;
@@ -369,6 +376,7 @@ function preprocessCjkEmphasis(markdown: string): string {
   const tree = processor.parse(markdown);
   const extractText = (node: any): string => {
     if (node.type === "text") return node.value;
+    if (node.type === "inlineCode") return wrapInlineCode(node.value);
     if (node.children) return node.children.map(extractText).join("");
     return "";
   };

skills/baoyu-markdown-to-html/scripts/vendor/baoyu-md/src/themes.ts

@@ -6,6 +6,7 @@ import type { ThemeName } from "./types.js";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const THEME_DIR = path.resolve(SCRIPT_DIR, "themes");
 const FALLBACK_THEMES: ThemeName[] = ["default", "grace", "simple"];
+const THEMES_EXTENDING_DEFAULT = new Set<ThemeName>(["grace", "simple"]);
 
 function stripOutputScope(cssContent: string): string {
   let css = cssContent;
@@ -41,6 +42,7 @@ export function loadThemeCss(theme: ThemeName): {
   themeCss: string;
 } {
   const basePath = path.join(THEME_DIR, "base.css");
+  const defaultThemePath = path.join(THEME_DIR, "default.css");
   const themePath = path.join(THEME_DIR, `${theme}.css`);
 
   if (!fs.existsSync(basePath)) {
@@ -51,9 +53,18 @@ export function loadThemeCss(theme: ThemeName): {
     throw new Error(`Missing theme CSS for "${theme}": ${themePath}`);
   }
 
+  const layeredThemeCss: string[] = [];
+  if (theme !== "default" && THEMES_EXTENDING_DEFAULT.has(theme)) {
+    if (!fs.existsSync(defaultThemePath)) {
+      throw new Error(`Missing default theme CSS: ${defaultThemePath}`);
+    }
+    layeredThemeCss.push(fs.readFileSync(defaultThemePath, "utf-8"));
+  }
+  layeredThemeCss.push(fs.readFileSync(themePath, "utf-8"));
+
   return {
     baseCss: fs.readFileSync(basePath, "utf-8"),
-    themeCss: fs.readFileSync(themePath, "utf-8"),
+    themeCss: layeredThemeCss.join("\n"),
   };
 }
 

skills/baoyu-post-to-wechat/scripts/bun.lock

@@ -4,32 +4,108 @@
     "": {
       "name": "baoyu-post-to-wechat-scripts",
       "dependencies": {
+        "@jsquash/webp": "^1.5.0",
         "baoyu-chrome-cdp": "file:./vendor/baoyu-chrome-cdp",
         "baoyu-md": "file:./vendor/baoyu-md",
+        "jimp": "^1.6.0",
       },
     },
   },
   "packages": {
+    "@jimp/core": ["@jimp/core@1.6.0", "", { "dependencies": { "@jimp/file-ops": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "await-to-js": "^3.0.0", "exif-parser": "^0.1.12", "file-type": "^16.0.0", "mime": "3" } }, "sha512-EQQlKU3s9QfdJqiSrZWNTxBs3rKXgO2W+GxNXDtwchF3a4IqxDheFX1ti+Env9hdJXDiYLp2jTRjlxhPthsk8w=="],
+
+    "@jimp/diff": ["@jimp/diff@1.6.0", "", { "dependencies": { "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "pixelmatch": "^5.3.0" } }, "sha512-+yUAQ5gvRC5D1WHYxjBHZI7JBRusGGSLf8AmPRPCenTzh4PA+wZ1xv2+cYqQwTfQHU5tXYOhA0xDytfHUf1Zyw=="],
+
+    "@jimp/file-ops": ["@jimp/file-ops@1.6.0", "", {}, "sha512-Dx/bVDmgnRe1AlniRpCKrGRm5YvGmUwbDzt+MAkgmLGf+jvBT75hmMEZ003n9HQI/aPnm/YKnXjg/hOpzNCpHQ=="],
+
+    "@jimp/js-bmp": ["@jimp/js-bmp@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "bmp-ts": "^1.0.9" } }, "sha512-FU6Q5PC/e3yzLyBDXupR3SnL3htU7S3KEs4e6rjDP6gNEOXRFsWs6YD3hXuXd50jd8ummy+q2WSwuGkr8wi+Gw=="],
+
+    "@jimp/js-gif": ["@jimp/js-gif@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "gifwrap": "^0.10.1", "omggif": "^1.0.10" } }, "sha512-N9CZPHOrJTsAUoWkWZstLPpwT5AwJ0wge+47+ix3++SdSL/H2QzyMqxbcDYNFe4MoI5MIhATfb0/dl/wmX221g=="],
+
+    "@jimp/js-jpeg": ["@jimp/js-jpeg@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "jpeg-js": "^0.4.4" } }, "sha512-6vgFDqeusblf5Pok6B2DUiMXplH8RhIKAryj1yn+007SIAQ0khM1Uptxmpku/0MfbClx2r7pnJv9gWpAEJdMVA=="],
+
+    "@jimp/js-png": ["@jimp/js-png@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "pngjs": "^7.0.0" } }, "sha512-AbQHScy3hDDgMRNfG0tPjL88AV6qKAILGReIa3ATpW5QFjBKpisvUaOqhzJ7Reic1oawx3Riyv152gaPfqsBVg=="],
+
+    "@jimp/js-tiff": ["@jimp/js-tiff@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "utif2": "^4.1.0" } }, "sha512-zhReR8/7KO+adijj3h0ZQUOiun3mXUv79zYEAKvE0O+rP7EhgtKvWJOZfRzdZSNv0Pu1rKtgM72qgtwe2tFvyw=="],
+
+    "@jimp/plugin-blit": ["@jimp/plugin-blit@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-M+uRWl1csi7qilnSK8uxK4RJMSuVeBiO1AY0+7APnfUbQNZm6hCe0CCFv1Iyw1D/Dhb8ph8fQgm5mwM0eSxgVA=="],
+
+    "@jimp/plugin-blur": ["@jimp/plugin-blur@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/utils": "1.6.0" } }, "sha512-zrM7iic1OTwUCb0g/rN5y+UnmdEsT3IfuCXCJJNs8SZzP0MkZ1eTvuwK9ZidCuMo4+J3xkzCidRwYXB5CyGZTw=="],
+
+    "@jimp/plugin-circle": ["@jimp/plugin-circle@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-xt1Gp+LtdMKAXfDp3HNaG30SPZW6AQ7dtAtTnoRKorRi+5yCJjKqXRgkewS5bvj8DEh87Ko1ydJfzqS3P2tdWw=="],
+
+    "@jimp/plugin-color": ["@jimp/plugin-color@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "tinycolor2": "^1.6.0", "zod": "^3.23.8" } }, "sha512-J5q8IVCpkBsxIXM+45XOXTrsyfblyMZg3a9eAo0P7VPH4+CrvyNQwaYatbAIamSIN1YzxmO3DkIZXzRjFSz1SA=="],
+
+    "@jimp/plugin-contain": ["@jimp/plugin-contain@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-oN/n+Vdq/Qg9bB4yOBOxtY9IPAtEfES8J1n9Ddx+XhGBYT1/QTU/JYkGaAkIGoPnyYvmLEDqMz2SGihqlpqfzQ=="],
+
+    "@jimp/plugin-cover": ["@jimp/plugin-cover@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-Iow0h6yqSC269YUJ8HC3Q/MpCi2V55sMlbkkTTx4zPvd8mWZlC0ykrNDeAy9IJegrQ7v5E99rJwmQu25lygKLA=="],
+
+    "@jimp/plugin-crop": ["@jimp/plugin-crop@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-KqZkEhvs+21USdySCUDI+GFa393eDIzbi1smBqkUPTE+pRwSWMAf01D5OC3ZWB+xZsNla93BDS9iCkLHA8wang=="],
+
+    "@jimp/plugin-displace": ["@jimp/plugin-displace@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-4Y10X9qwr5F+Bo5ME356XSACEF55485j5nGdiyJ9hYzjQP9nGgxNJaZ4SAOqpd+k5sFaIeD7SQ0Occ26uIng5Q=="],
+
+    "@jimp/plugin-dither": ["@jimp/plugin-dither@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0" } }, "sha512-600d1RxY0pKwgyU0tgMahLNKsqEcxGdbgXadCiVCoGd6V6glyCvkNrnnwC0n5aJ56Htkj88PToSdF88tNVZEEQ=="],
+
+    "@jimp/plugin-fisheye": ["@jimp/plugin-fisheye@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-E5QHKWSCBFtpgZarlmN3Q6+rTQxjirFqo44ohoTjzYVrDI6B6beXNnPIThJgPr0Y9GwfzgyarKvQuQuqCnnfbA=="],
+
+    "@jimp/plugin-flip": ["@jimp/plugin-flip@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-/+rJVDuBIVOgwoyVkBjUFHtP+wmW0r+r5OQ2GpatQofToPVbJw1DdYWXlwviSx7hvixTWLKVgRWQ5Dw862emDg=="],
+
+    "@jimp/plugin-hash": ["@jimp/plugin-hash@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/js-bmp": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/js-tiff": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "any-base": "^1.1.0" } }, "sha512-wWzl0kTpDJgYVbZdajTf+4NBSKvmI3bRI8q6EH9CVeIHps9VWVsUvEyb7rpbcwVLWYuzDtP2R0lTT6WeBNQH9Q=="],
+
+    "@jimp/plugin-mask": ["@jimp/plugin-mask@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-Cwy7ExSJMZszvkad8NV8o/Z92X2kFUFM8mcDAhNVxU0Q6tA0op2UKRJY51eoK8r6eds/qak3FQkXakvNabdLnA=="],
+
+    "@jimp/plugin-print": ["@jimp/plugin-print@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/types": "1.6.0", "parse-bmfont-ascii": "^1.0.6", "parse-bmfont-binary": "^1.0.6", "parse-bmfont-xml": "^1.1.6", "simple-xml-to-json": "^1.2.2", "zod": "^3.23.8" } }, "sha512-zarTIJi8fjoGMSI/M3Xh5yY9T65p03XJmPsuNet19K/Q7mwRU6EV2pfj+28++2PV2NJ+htDF5uecAlnGyxFN2A=="],
+
+    "@jimp/plugin-quantize": ["@jimp/plugin-quantize@1.6.0", "", { "dependencies": { "image-q": "^4.0.0", "zod": "^3.23.8" } }, "sha512-EmzZ/s9StYQwbpG6rUGBCisc3f64JIhSH+ncTJd+iFGtGo0YvSeMdAd+zqgiHpfZoOL54dNavZNjF4otK+mvlg=="],
+
+    "@jimp/plugin-resize": ["@jimp/plugin-resize@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/types": "1.6.0", "zod": "^3.23.8" } }, "sha512-uSUD1mqXN9i1SGSz5ov3keRZ7S9L32/mAQG08wUwZiEi5FpbV0K8A8l1zkazAIZi9IJzLlTauRNU41Mi8IF9fA=="],
+
+    "@jimp/plugin-rotate": ["@jimp/plugin-rotate@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-JagdjBLnUZGSG4xjCLkIpQOZZ3Mjbg8aGCCi4G69qR+OjNpOeGI7N2EQlfK/WE8BEHOW5vdjSyglNqcYbQBWRw=="],
+
+    "@jimp/plugin-threshold": ["@jimp/plugin-threshold@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-hash": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0", "zod": "^3.23.8" } }, "sha512-M59m5dzLoHOVWdM41O8z9SyySzcDn43xHseOH0HavjsfQsT56GGCC4QzU1banJidbUrePhzoEdS42uFE8Fei8w=="],
+
+    "@jimp/types": ["@jimp/types@1.6.0", "", { "dependencies": { "zod": "^3.23.8" } }, "sha512-7UfRsiKo5GZTAATxm2qQ7jqmUXP0DxTArztllTcYdyw6Xi5oT4RaoXynVtCD4UyLK5gJgkZJcwonoijrhYFKfg=="],
+
+    "@jimp/utils": ["@jimp/utils@1.6.0", "", { "dependencies": { "@jimp/types": "1.6.0", "tinycolor2": "^1.6.0" } }, "sha512-gqFTGEosKbOkYF/WFj26jMHOI5OH2jeP1MmC/zbK6BF6VJBf8rIC5898dPfSzZEbSA0wbbV5slbntWVc5PKLFA=="],
+
+    "@jsquash/webp": ["@jsquash/webp@1.5.0", "", { "dependencies": { "wasm-feature-detect": "^1.2.11" } }, "sha512-KggLoj2MnRSfIqTeKe1EmbljTX2vuV7mh79k89PCL1pyqiDULcPM1L47twxXt0hkb68F70bXiL31MxsuoZtKFw=="],
+
+    "@tokenizer/token": ["@tokenizer/token@0.3.0", "", {}, "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A=="],
+
     "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
 
     "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
 
     "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
 
+    "@types/node": ["@types/node@16.9.1", "", {}, "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g=="],
+
     "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
 
+    "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
+
     "ansi-colors": ["ansi-colors@4.1.3", "", {}, "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="],
 
+    "any-base": ["any-base@1.1.0", "", {}, "sha512-uMgjozySS8adZZYePpaWs8cxB9/kdzmpX6SgJZ+wbz1K5eYk5QMYDVJaZKhxyIHUdnnJkfR7SVgStgH7LkGUyg=="],
+
     "argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="],
 
+    "await-to-js": ["await-to-js@3.0.0", "", {}, "sha512-zJAaP9zxTcvTHRlejau3ZOY4V7SRpiByf3/dxx2uyKxxor19tpmpV2QRsTKikckwhaPmr2dVpxxMr7jOCYVp5g=="],
+
     "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
 
     "baoyu-chrome-cdp": ["baoyu-chrome-cdp@file:vendor/baoyu-chrome-cdp", {}],
 
     "baoyu-md": ["baoyu-md@file:vendor/baoyu-md", { "dependencies": { "fflate": "^0.8.2", "front-matter": "^4.0.2", "highlight.js": "^11.11.1", "juice": "^11.0.1", "marked": "^15.0.6", "reading-time": "^1.5.0", "remark-cjk-friendly": "^1.1.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "unified": "^11.0.5" } }],
 
+    "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
+
+    "bmp-ts": ["bmp-ts@1.0.9", "", {}, "sha512-cTEHk2jLrPyi+12M3dhpEbnnPOsaZuq7C45ylbbQIiWgDFZq4UVYPEY5mlqjvsj/6gJv9qX5sa+ebDzLXT28Vw=="],
+
     "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
 
+    "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
+
     "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
 
     "cheerio": ["cheerio@1.0.0", "", { "dependencies": { "cheerio-select": "^2.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.3", "domutils": "^3.1.0", "encoding-sniffer": "^0.2.0", "htmlparser2": "^9.1.0", "parse5": "^7.1.2", "parse5-htmlparser2-tree-adapter": "^7.0.0", "parse5-parser-stream": "^7.1.2", "undici": "^6.19.5", "whatwg-mimetype": "^4.0.0" } }, "sha512-quS9HgjQpdaXOvsZz82Oz7uxtXiy6UIsIQcpBj7HRw2M63Skasm9qlDocAM7jNuaxdhpPU7c4kJN+gA5MCu4ww=="],
@@ -66,22 +142,40 @@
 
     "esprima": ["esprima@4.0.1", "", { "bin": { "esparse": "./bin/esparse.js", "esvalidate": "./bin/esvalidate.js" } }, "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="],
 
+    "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
+
+    "events": ["events@3.3.0", "", {}, "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q=="],
+
+    "exif-parser": ["exif-parser@0.1.12", "", {}, "sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw=="],
+
     "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
 
     "fflate": ["fflate@0.8.2", "", {}, "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="],
 
+    "file-type": ["file-type@16.5.4", "", { "dependencies": { "readable-web-to-node-stream": "^3.0.0", "strtok3": "^6.2.4", "token-types": "^4.1.1" } }, "sha512-/yFHK0aGjFEgDJjEKP0pWCplsPFPhwyfwevf/pVxiN0tmE4L9LmwWxWukdJSHdoCli4VgQLehjJtwQBnqmsKcw=="],
+
     "front-matter": ["front-matter@4.0.2", "", { "dependencies": { "js-yaml": "^3.13.1" } }, "sha512-I8ZuJ/qG92NWX8i5x1Y8qyj3vizhXS31OxjKDu3LKP+7/qBgfIKValiZIEwoVoJKUHlhWtYrktkxV1XsX+pPlg=="],
 
     "get-east-asian-width": ["get-east-asian-width@1.5.0", "", {}, "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA=="],
 
+    "gifwrap": ["gifwrap@0.10.1", "", { "dependencies": { "image-q": "^4.0.0", "omggif": "^1.0.10" } }, "sha512-2760b1vpJHNmLzZ/ubTtNnEx5WApN/PYWJvXvgS+tL1egTTthayFYIQQNi136FLEDcN/IyEY2EcGpIITD6eYUw=="],
+
     "highlight.js": ["highlight.js@11.11.1", "", {}, "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w=="],
 
     "htmlparser2": ["htmlparser2@9.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.1.0", "entities": "^4.5.0" } }, "sha512-5zfg6mHUoaer/97TxnGpxmbR7zJtPwIYFMZ/H5ucTlPZhKvtum05yiPK3Mgai3a0DyVxv7qYqoweaEd2nrYQzQ=="],
 
     "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
 
+    "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
+
+    "image-q": ["image-q@4.0.0", "", { "dependencies": { "@types/node": "16.9.1" } }, "sha512-PfJGVgIfKQJuq3s0tTDOKtztksibuUEbJQIYT3by6wctQo+Rdlh7ef4evJ5NCdxY4CfMbvFkocEwbl4BF8RlJw=="],
+
     "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
 
+    "jimp": ["jimp@1.6.0", "", { "dependencies": { "@jimp/core": "1.6.0", "@jimp/diff": "1.6.0", "@jimp/js-bmp": "1.6.0", "@jimp/js-gif": "1.6.0", "@jimp/js-jpeg": "1.6.0", "@jimp/js-png": "1.6.0", "@jimp/js-tiff": "1.6.0", "@jimp/plugin-blit": "1.6.0", "@jimp/plugin-blur": "1.6.0", "@jimp/plugin-circle": "1.6.0", "@jimp/plugin-color": "1.6.0", "@jimp/plugin-contain": "1.6.0", "@jimp/plugin-cover": "1.6.0", "@jimp/plugin-crop": "1.6.0", "@jimp/plugin-displace": "1.6.0", "@jimp/plugin-dither": "1.6.0", "@jimp/plugin-fisheye": "1.6.0", "@jimp/plugin-flip": "1.6.0", "@jimp/plugin-hash": "1.6.0", "@jimp/plugin-mask": "1.6.0", "@jimp/plugin-print": "1.6.0", "@jimp/plugin-quantize": "1.6.0", "@jimp/plugin-resize": "1.6.0", "@jimp/plugin-rotate": "1.6.0", "@jimp/plugin-threshold": "1.6.0", "@jimp/types": "1.6.0", "@jimp/utils": "1.6.0" } }, "sha512-YcwCHw1kiqEeI5xRpDlPPBGL2EOpBKLwO4yIBJcXWHPj5PnA5urGq0jbyhM5KoNpypQ6VboSoxc9D8HyfvngSg=="],
+
+    "jpeg-js": ["jpeg-js@0.4.4", "", {}, "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg=="],
+
     "js-yaml": ["js-yaml@3.14.2", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg=="],
 
     "juice": ["juice@11.1.1", "", { "dependencies": { "cheerio": "1.0.0", "commander": "^12.1.0", "entities": "^7.0.0", "mensch": "^0.3.4", "slick": "^1.12.2", "web-resource-inliner": "^8.0.0" }, "bin": { "juice": "bin/juice" } }, "sha512-4SBfZqKcc6DrIS+5b/WiGoWaZsdUPBH+e6SbRlNjJpaIRtfoBhYReAtobIEW6mcLeFFDXLBJMuZwkJLkBJjs2w=="],
@@ -146,18 +240,40 @@
 
     "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="],
 
-    "mime": ["mime@2.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg=="],
+    "mime": ["mime@3.0.0", "", { "bin": { "mime": "cli.js" } }, "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A=="],
 
     "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
     "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
 
+    "omggif": ["omggif@1.0.10", "", {}, "sha512-LMJTtvgc/nugXj0Vcrrs68Mn2D1r0zf630VNtqtpI1FEO7e+O9FP4gqs9AcnBaSEeoHIPm28u6qgPR0oyEpGSw=="],
+
+    "pako": ["pako@1.0.11", "", {}, "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw=="],
+
+    "parse-bmfont-ascii": ["parse-bmfont-ascii@1.0.6", "", {}, "sha512-U4RrVsUFCleIOBsIGYOMKjn9PavsGOXxbvYGtMOEfnId0SVNsgehXh1DxUdVPLoxd5mvcEtvmKs2Mmf0Mpa1ZA=="],
+
+    "parse-bmfont-binary": ["parse-bmfont-binary@1.0.6", "", {}, "sha512-GxmsRea0wdGdYthjuUeWTMWPqm2+FAd4GI8vCvhgJsFnoGhTrLhXDDupwTo7rXVAgaLIGoVHDZS9p/5XbSqeWA=="],
+
+    "parse-bmfont-xml": ["parse-bmfont-xml@1.1.6", "", { "dependencies": { "xml-parse-from-string": "^1.0.0", "xml2js": "^0.5.0" } }, "sha512-0cEliVMZEhrFDwMh4SxIyVJpqYoOWDJ9P895tFuS+XuNzI5UBmBk5U5O4KuJdTnZpSBI4LFA2+ZiJaiwfSwlMA=="],
+
     "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
 
     "parse5-htmlparser2-tree-adapter": ["parse5-htmlparser2-tree-adapter@7.1.0", "", { "dependencies": { "domhandler": "^5.0.3", "parse5": "^7.0.0" } }, "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g=="],
 
     "parse5-parser-stream": ["parse5-parser-stream@7.1.2", "", { "dependencies": { "parse5": "^7.0.0" } }, "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow=="],
 
+    "peek-readable": ["peek-readable@4.1.0", "", {}, "sha512-ZI3LnwUv5nOGbQzD9c2iDG6toheuXSZP5esSHBjopsXH4dg19soufvpUGA3uohi5anFtGb2lhAVdHzH6R/Evvg=="],
+
+    "pixelmatch": ["pixelmatch@5.3.0", "", { "dependencies": { "pngjs": "^6.0.0" }, "bin": { "pixelmatch": "bin/pixelmatch" } }, "sha512-o8mkY4E/+LNUf6LzX96ht6k6CEDi65k9G2rjMtBe9Oo+VPKSvl+0GKHuH/AlG+GA5LPG/i5hrekkxUc3s2HU+Q=="],
+
+    "pngjs": ["pngjs@7.0.0", "", {}, "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow=="],
+
+    "process": ["process@0.11.10", "", {}, "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A=="],
+
+    "readable-stream": ["readable-stream@4.7.0", "", { "dependencies": { "abort-controller": "^3.0.0", "buffer": "^6.0.3", "events": "^3.3.0", "process": "^0.11.10", "string_decoder": "^1.3.0" } }, "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg=="],
+
+    "readable-web-to-node-stream": ["readable-web-to-node-stream@3.0.4", "", { "dependencies": { "readable-stream": "^4.7.0" } }, "sha512-9nX56alTf5bwXQ3ZDipHJhusu9NTQJ/CVPtb/XHAJCXihZeitfJvIRS4GqQ/mfIoOE3IelHMrpayVrosdHBuLw=="],
+
     "reading-time": ["reading-time@1.5.0", "", {}, "sha512-onYyVhBNr4CmAxFsKS7bz+uTLRakypIe4R+5A824vBSkQy/hB3fZepoVEf8OVAxzLvK+H/jm9TzpI3ETSm64Kg=="],
 
     "remark-cjk-friendly": ["remark-cjk-friendly@1.2.3", "", { "dependencies": { "micromark-extension-cjk-friendly": "1.2.3" }, "peerDependencies": { "@types/mdast": "^4.0.0", "unified": "^11.0.0" }, "optionalPeers": ["@types/mdast"] }, "sha512-UvAgxwlNk+l9Oqgl/9MWK2eWRS7zgBW/nXX9AthV7nd/3lNejF138E7Xbmk9Zs4WjTJGs721r7fAEc7tNFoH7g=="],
@@ -166,12 +282,26 @@
 
     "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
 
+    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
     "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
 
+    "sax": ["sax@1.6.0", "", {}, "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA=="],
+
+    "simple-xml-to-json": ["simple-xml-to-json@1.2.4", "", {}, "sha512-3MY16e0ocMHL7N1ufpdObURGyX+lCo0T/A+y6VCwosLdH1HSda4QZl1Sdt/O+2qWp48WFi26XEp5rF0LoaL0Dg=="],
+
     "slick": ["slick@1.12.2", "", {}, "sha512-4qdtOGcBjral6YIBCWJ0ljFSKNLz9KkhbWtuGvUyRowl1kxfuE1x/Z/aJcaiilpb3do9bl5K7/1h9XC5wWpY/A=="],
 
     "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],
 
+    "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
+
+    "strtok3": ["strtok3@6.3.0", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "peek-readable": "^4.1.0" } }, "sha512-fZtbhtvI9I48xDSywd/somNqgUHl2L2cstmXCCif0itOf96jeW18MBSyrLuNicYQVkvpOxkZtkzujiTJ9LW5Jw=="],
+
+    "tinycolor2": ["tinycolor2@1.6.0", "", {}, "sha512-XPaBkWQJdsf3pLKJV9p4qN/S+fm2Oj8AIPo1BTUhg5oxkvm9+SVEGFdhyOz7tTdUTfvxMiAs4sp6/eZO2Ew+pw=="],
+
+    "token-types": ["token-types@4.2.1", "", { "dependencies": { "@tokenizer/token": "^0.3.0", "ieee754": "^1.2.1" } }, "sha512-6udB24Q737UD/SDsKAHI9FCRP7Bqc9D/MQUV02ORQg5iskjtLJlZJNdN4kKtcdtwCeWIwIHDGaUsTsCCAa8sFQ=="],
+
     "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
 
     "undici": ["undici@6.24.0", "", {}, "sha512-lVLNosgqo5EkGqh5XUDhGfsMSoO8K0BAN0TyJLvwNRSl4xWGZlCVYsAIpa/OpA3TvmnM01GWcoKmc3ZWo5wKKA=="],
@@ -186,18 +316,30 @@
 
     "unist-util-visit-parents": ["unist-util-visit-parents@6.0.2", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ=="],
 
+    "utif2": ["utif2@4.1.0", "", { "dependencies": { "pako": "^1.0.11" } }, "sha512-+oknB9FHrJ7oW7A2WZYajOcv4FcDR4CfoGB0dPNfxbi4GO05RRnFmt5oa23+9w32EanrYcSJWspUiJkLMs+37w=="],
+
     "valid-data-url": ["valid-data-url@3.0.1", "", {}, "sha512-jOWVmzVceKlVVdwjNSenT4PbGghU0SBIizAev8ofZVgivk/TVHXSbNL8LP6M3spZvkR9/QolkyJavGSX5Cs0UA=="],
 
     "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="],
 
     "vfile-message": ["vfile-message@4.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw=="],
 
+    "wasm-feature-detect": ["wasm-feature-detect@1.8.0", "", {}, "sha512-zksaLKM2fVlnB5jQQDqKXXwYHLQUVH9es+5TOOHwGOVJOCeRBCiPjwSg+3tN2AdTCzjgli4jijCH290kXb/zWQ=="],
+
     "web-resource-inliner": ["web-resource-inliner@8.0.0", "", { "dependencies": { "ansi-colors": "^4.1.1", "escape-goat": "^3.0.0", "htmlparser2": "^9.1.0", "mime": "^2.4.6", "valid-data-url": "^3.0.0" } }, "sha512-Ezr98sqXW/+OCGoUEXuOKVR+oVFlSdn1tIySEEJdiSAw4IjrW8hQkwARSSBJTSB5Us5dnytDgL0ZDliAYBhaNA=="],
 
     "whatwg-encoding": ["whatwg-encoding@3.1.1", "", { "dependencies": { "iconv-lite": "0.6.3" } }, "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ=="],
 
     "whatwg-mimetype": ["whatwg-mimetype@4.0.0", "", {}, "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg=="],
 
+    "xml-parse-from-string": ["xml-parse-from-string@1.0.1", "", {}, "sha512-ErcKwJTF54uRzzNMXq2X5sMIy88zJvfN2DmdoQvy7PAFJ+tPRU6ydWuOKNMyfmOjdyBQTFREi60s0Y0SyI0G0g=="],
+
+    "xml2js": ["xml2js@0.5.0", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA=="],
+
+    "xmlbuilder": ["xmlbuilder@11.0.1", "", {}, "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="],
+
+    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
     "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
     "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
@@ -205,5 +347,9 @@
     "htmlparser2/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
     "parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
+
+    "pixelmatch/pngjs": ["pngjs@6.0.0", "", {}, "sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg=="],
+
+    "web-resource-inliner/mime": ["mime@2.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg=="],
   }
 }

skills/baoyu-post-to-wechat/scripts/package.json

@@ -3,7 +3,9 @@
   "private": true,
   "type": "module",
   "dependencies": {
+    "@jsquash/webp": "^1.5.0",
     "baoyu-chrome-cdp": "file:./vendor/baoyu-chrome-cdp",
-    "baoyu-md": "file:./vendor/baoyu-md"
+    "baoyu-md": "file:./vendor/baoyu-md",
+    "jimp": "^1.6.0"
   }
 }

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/content.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  extractSummaryFromBody,
+  extractTitleFromMarkdown,
+  parseFrontmatter,
+  pickFirstString,
+  serializeFrontmatter,
+  stripWrappingQuotes,
+  toFrontmatterString,
+} from "./content.ts";
+
+test("parseFrontmatter extracts YAML fields and strips wrapping quotes", () => {
+  const input = `---
+title: "Hello World"
+author: ‘Baoyu’
+summary: plain text
+---
+# Heading
+
+Body`;
+
+  const result = parseFrontmatter(input);
+
+  assert.deepEqual(result.frontmatter, {
+    title: "Hello World",
+    author: "Baoyu",
+    summary: "plain text",
+  });
+  assert.match(result.body, /^# Heading/);
+});
+
+test("parseFrontmatter returns original content when no frontmatter exists", () => {
+  const input = "# No frontmatter";
+  assert.deepEqual(parseFrontmatter(input), {
+    frontmatter: {},
+    body: input,
+  });
+});
+
+test("serializeFrontmatter renders YAML only when fields exist", () => {
+  assert.equal(serializeFrontmatter({}), "");
+  assert.equal(
+    serializeFrontmatter({ title: "Hello", author: "Baoyu" }),
+    "---\ntitle: Hello\nauthor: Baoyu\n---\n",
+  );
+});
+
+test("quote and frontmatter string helpers normalize mixed scalar values", () => {
+  assert.equal(stripWrappingQuotes(`" quoted "`), "quoted");
+  assert.equal(stripWrappingQuotes("“ 中文标题 ”"), "中文标题");
+  assert.equal(stripWrappingQuotes("plain"), "plain");
+
+  assert.equal(toFrontmatterString("'hello'"), "hello");
+  assert.equal(toFrontmatterString(42), "42");
+  assert.equal(toFrontmatterString(false), "false");
+  assert.equal(toFrontmatterString({}), undefined);
+
+  assert.equal(
+    pickFirstString({ summary: 123, title: "" }, ["title", "summary"]),
+    "123",
+  );
+});
+
+test("markdown title and summary extraction skip non-body content and clean formatting", () => {
+  const markdown = `
+![cover](cover.png)
+## “My Title”
+
+Body paragraph
+`;
+  assert.equal(extractTitleFromMarkdown(markdown), "My Title");
+
+  const summary = extractSummaryFromBody(
+    `
+# Heading
+> quote
+- list
+1. ordered
+\`\`\`
+code
+\`\`\`
+This is **the first paragraph** with [a link](https://example.com) and \`inline code\` that should be summarized cleanly.
+`,
+    70,
+  );
+
+  assert.equal(
+    summary,
+    "This is the first paragraph with a link and inline code that should...",
+  );
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/document.test.ts

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import { COLOR_PRESETS, FONT_FAMILY_MAP } from "./constants.ts";
+import {
+  buildMarkdownDocumentMeta,
+  formatTimestamp,
+  renderMarkdownDocument,
+  resolveColorToken,
+  resolveFontFamilyToken,
+  resolveMarkdownStyle,
+  resolveRenderOptions,
+} from "./document.ts";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`);
+}
+
+function findInlineStyle(html: string, tagName: string, text: string): string {
+  const pattern = new RegExp(
+    `<${tagName}[^>]*style="([^"]*)"[^>]*>${escapeRegExp(text)}</${tagName}>`,
+  );
+  const match = html.match(pattern);
+  assert.ok(match, `Expected inline style for <${tagName}>${text}</${tagName}>`);
+  return match![1]!;
+}
+
+function useCwd(t: TestContext, cwd: string): void {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  t.after(() => {
+    process.chdir(previous);
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("document token resolvers map known presets and allow passthrough values", () => {
+  assert.equal(resolveColorToken("green"), COLOR_PRESETS.green);
+  assert.equal(resolveColorToken("#123456"), "#123456");
+  assert.equal(resolveColorToken(), undefined);
+
+  assert.equal(resolveFontFamilyToken("mono"), FONT_FAMILY_MAP.mono);
+  assert.equal(resolveFontFamilyToken("Custom Font"), "Custom Font");
+  assert.equal(resolveFontFamilyToken(), undefined);
+});
+
+test("formatTimestamp uses compact sortable datetime output", () => {
+  const date = new Date("2026-03-13T21:04:05.000Z");
+  const pad = (value: number) => String(value).padStart(2, "0");
+  const expected = `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(
+    date.getDate(),
+  )}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+
+  assert.equal(formatTimestamp(date), expected);
+});
+
+test("buildMarkdownDocumentMeta prefers frontmatter and falls back to markdown title and summary", () => {
+  const metaFromYaml = buildMarkdownDocumentMeta(
+    "# Markdown Title\n\nBody summary paragraph that should be ignored.",
+    {
+      title: `" YAML Title "`,
+      author: "'Baoyu'",
+      summary: `" YAML Summary "`,
+    },
+    "fallback",
+  );
+
+  assert.deepEqual(metaFromYaml, {
+    title: "YAML Title",
+    author: "Baoyu",
+    description: "YAML Summary",
+  });
+
+  const metaFromMarkdown = buildMarkdownDocumentMeta(
+    `## “Markdown Title”\n\nThis is the first body paragraph that should become the summary because it is long enough.`,
+    {},
+    "fallback",
+  );
+
+  assert.equal(metaFromMarkdown.title, "Markdown Title");
+  assert.match(metaFromMarkdown.description ?? "", /^This is the first body paragraph/);
+});
+
+test("resolveMarkdownStyle merges theme defaults with explicit overrides", () => {
+  const style = resolveMarkdownStyle({
+    theme: "modern",
+    primaryColor: "#112233",
+    fontFamily: "Custom Sans",
+  });
+
+  assert.equal(style.primaryColor, "#112233");
+  assert.equal(style.fontFamily, "Custom Sans");
+  assert.equal(style.fontSize, "15px");
+  assert.equal(style.containerBg, "rgba(250, 249, 245, 1)");
+});
+
+test("resolveRenderOptions loads workspace EXTEND settings and lets explicit options win", async (t) => {
+  const root = await makeTempDir("baoyu-md-render-options-");
+  useCwd(t, root);
+
+  const extendPath = path.join(
+    root,
+    ".baoyu-skills",
+    "baoyu-markdown-to-html",
+    "EXTEND.md",
+  );
+  await fs.mkdir(path.dirname(extendPath), { recursive: true });
+  await fs.writeFile(
+    extendPath,
+    `---
+default_theme: modern
+default_color: green
+default_font_family: mono
+default_font_size: 17
+default_code_theme: nord
+mac_code_block: false
+show_line_number: true
+cite: true
+count: true
+legend: title-alt
+keep_title: true
+---
+`,
+  );
+
+  const fromExtend = resolveRenderOptions();
+  assert.equal(fromExtend.theme, "modern");
+  assert.equal(fromExtend.primaryColor, COLOR_PRESETS.green);
+  assert.equal(fromExtend.fontFamily, FONT_FAMILY_MAP.mono);
+  assert.equal(fromExtend.fontSize, "17px");
+  assert.equal(fromExtend.codeTheme, "nord");
+  assert.equal(fromExtend.isMacCodeBlock, false);
+  assert.equal(fromExtend.isShowLineNumber, true);
+  assert.equal(fromExtend.citeStatus, true);
+  assert.equal(fromExtend.countStatus, true);
+  assert.equal(fromExtend.legend, "title-alt");
+  assert.equal(fromExtend.keepTitle, true);
+
+  const explicit = resolveRenderOptions({
+    theme: "simple",
+    fontSize: "18px",
+    keepTitle: false,
+  });
+  assert.equal(explicit.theme, "simple");
+  assert.equal(explicit.fontSize, "18px");
+  assert.equal(explicit.keepTitle, false);
+});
+
+test("renderMarkdownDocument layers default rules into grace theme before CSS inlining", async () => {
+  const { html } = await renderMarkdownDocument(
+    `## Section\n\nParagraph with **bold** text.`,
+    { keepTitle: true, theme: "grace" },
+  );
+
+  const h2Style = findInlineStyle(html, "h2", "Section");
+  assert.match(h2Style, /background: #92617E/);
+  assert.match(h2Style, /box-shadow: 0 4px 6px rgba\(0, 0, 0, 0\.1\)/);
+
+  const pMatch = html.match(/<p[^>]*style="([^"]*)"[^>]*>/);
+  assert.ok(pMatch, "Expected inline style on <p> tag");
+  assert.match(pMatch![1]!, /color:/);
+
+  const strongPattern = /<strong[^>]*style="([^"]*)"[^>]*>bold<\/strong>/;
+  const strongMatch = html.match(strongPattern);
+  assert.ok(strongMatch, "Expected inline style for <strong>bold</strong>");
+  assert.match(strongMatch![1]!, /font-weight:/);
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/html-builder.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEFAULT_STYLE } from "./constants.ts";
+import {
+  buildCss,
+  buildHtmlDocument,
+  modifyHtmlStructure,
+  normalizeCssText,
+  normalizeInlineCss,
+  removeFirstHeading,
+} from "./html-builder.ts";
+
+test("buildCss injects style variables and concatenates base and theme CSS", () => {
+  const css = buildCss("body { color: red; }", ".theme { color: blue; }");
+
+  assert.match(css, /--md-primary-color: #0F4C81;/);
+  assert.match(css, /body \{ color: red; \}/);
+  assert.match(css, /\.theme \{ color: blue; \}/);
+});
+
+test("buildHtmlDocument includes optional meta tags and code theme CSS", () => {
+  const html = buildHtmlDocument(
+    {
+      title: "Doc",
+      author: "Baoyu",
+      description: "Summary",
+    },
+    "body { color: red; }",
+    "<article>Hello</article>",
+    ".hljs { color: blue; }",
+  );
+
+  assert.match(html, /<title>Doc<\/title>/);
+  assert.match(html, /meta name="author" content="Baoyu"/);
+  assert.match(html, /meta name="description" content="Summary"/);
+  assert.match(html, /<style>body \{ color: red; \}<\/style>/);
+  assert.match(html, /<style>\.hljs \{ color: blue; \}<\/style>/);
+  assert.match(html, /<article>Hello<\/article>/);
+});
+
+test("normalizeCssText and normalizeInlineCss replace variables and strip declarations", () => {
+  const rawCss = `
+:root { --md-primary-color: #000; --md-font-size: 12px; --foreground: 0 0% 5%; }
+.box { color: var(--md-primary-color); font-size: var(--md-font-size); background: hsl(var(--foreground)); }
+`;
+
+  const normalizedCss = normalizeCssText(rawCss, DEFAULT_STYLE);
+  assert.match(normalizedCss, /color: #0F4C81/);
+  assert.match(normalizedCss, /font-size: 16px/);
+  assert.match(normalizedCss, /background: #3f3f3f/);
+  assert.doesNotMatch(normalizedCss, /--md-primary-color/);
+
+  const normalizedHtml = normalizeInlineCss(
+    `<style>${rawCss}</style><div style="color: var(--md-primary-color)"></div>`,
+    DEFAULT_STYLE,
+  );
+  assert.match(normalizedHtml, /color: #0F4C81/);
+  assert.doesNotMatch(normalizedHtml, /var\(--md-primary-color\)/);
+});
+
+test("normalizeInlineCss removes quoted custom property values without leaving fragments behind", () => {
+  const normalizedHtml = normalizeInlineCss(
+    `<html style="--md-font-family: Menlo, Monaco, 'Courier New', monospace; color: var(--md-primary-color)"></html>`,
+    DEFAULT_STYLE,
+  );
+
+  assert.match(normalizedHtml, /style=" color: #0F4C81"/);
+  assert.doesNotMatch(normalizedHtml, /Courier New/);
+  assert.doesNotMatch(normalizedHtml, /--md-font-family/);
+});
+
+test("HTML structure helpers hoist nested lists and remove the first heading", () => {
+  const nestedList = `<ul><li>Parent<ul><li>Child</li></ul></li></ul>`;
+  assert.equal(
+    modifyHtmlStructure(nestedList),
+    `<ul><li>Parent</li><ul><li>Child</li></ul></ul>`,
+  );
+
+  const html = `<h1>Title</h1><p>Intro</p><h2>Sub</h2>`;
+  assert.equal(removeFirstHeading(html), `<p>Intro</p><h2>Sub</h2>`);
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/html-builder.ts

@@ -100,13 +100,13 @@ export function normalizeCssText(cssText: string, style: StyleConfig = DEFAULT_S
     .replace(/var\(--md-accent-color\)/g, style.accentColor)
     .replace(/var\(--md-container-bg\)/g, style.containerBg)
     .replace(/hsl\(var\(--foreground\)\)/g, "#3f3f3f")
-    .replace(/--md-primary-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-family:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-size:\s*[^;"']+;?/g, "")
-    .replace(/--blockquote-background:\s*[^;"']+;?/g, "")
-    .replace(/--md-accent-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-container-bg:\s*[^;"']+;?/g, "")
-    .replace(/--foreground:\s*[^;"']+;?/g, "");
+    .replace(/--md-primary-color:\s*[^;]+;?/g, "")
+    .replace(/--md-font-family:\s*[^;]+;?/g, "")
+    .replace(/--md-font-size:\s*[^;]+;?/g, "")
+    .replace(/--blockquote-background:\s*[^;]+;?/g, "")
+    .replace(/--md-accent-color:\s*[^;]+;?/g, "")
+    .replace(/--md-container-bg:\s*[^;]+;?/g, "")
+    .replace(/--foreground:\s*[^;]+;?/g, "");
 }
 
 export function normalizeInlineCss(html: string, style: StyleConfig = DEFAULT_STYLE): string {

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/images.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  getImageExtension,
+  replaceMarkdownImagesWithPlaceholders,
+  resolveContentImages,
+  resolveImagePath,
+} from "./images.ts";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("replaceMarkdownImagesWithPlaceholders rewrites markdown and tracks image metadata", () => {
+  const result = replaceMarkdownImagesWithPlaceholders(
+    `![cover](images/cover.png)\n\nText\n\n![diagram](images/diagram.webp)`,
+    "IMG_",
+  );
+
+  assert.equal(result.markdown, `IMG_1\n\nText\n\nIMG_2`);
+  assert.deepEqual(result.images, [
+    { alt: "cover", originalPath: "images/cover.png", placeholder: "IMG_1" },
+    { alt: "diagram", originalPath: "images/diagram.webp", placeholder: "IMG_2" },
+  ]);
+});
+
+test("image extension and local fallback resolution handle common path variants", async (t) => {
+  assert.equal(getImageExtension("https://example.com/a.jpeg?x=1"), "jpeg");
+  assert.equal(getImageExtension("/tmp/figure"), "png");
+
+  const root = await makeTempDir("baoyu-md-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "figure.webp"), "webp");
+
+  const resolved = await resolveImagePath("figure.png", baseDir, tempDir, "test");
+  assert.equal(resolved, path.join(baseDir, "figure.webp"));
+});
+
+test("resolveContentImages resolves image placeholders against the content directory", async (t) => {
+  const root = await makeTempDir("baoyu-md-content-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "cover.png"), "png");
+
+  const resolved = await resolveContentImages(
+    [
+      {
+        alt: "cover",
+        originalPath: "cover.png",
+        placeholder: "IMG_1",
+      },
+    ],
+    baseDir,
+    tempDir,
+    "test",
+  );
+
+  assert.deepEqual(resolved, [
+    {
+      alt: "cover",
+      originalPath: "cover.png",
+      placeholder: "IMG_1",
+      localPath: path.join(baseDir, "cover.png"),
+    },
+  ]);
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/renderer.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { initRenderer, renderMarkdown } from "./renderer.ts";
+
+const render = (md: string) => {
+  const r = initRenderer();
+  return renderMarkdown(md, r).html;
+};
+
+test("bold with inline code (no underscore)", () => {
+  const html = render("**算出 `logits`，算出 `loss`。**");
+  assert.match(html, /<code[^>]*>logits<\/code>/);
+  assert.match(html, /<code[^>]*>loss<\/code>/);
+});
+
+test("bold with inline code (contains underscore)", () => {
+  const html = render("**变成 `input_ids`。**");
+  assert.match(html, /<code[^>]*>input_ids<\/code>/);
+});
+
+test("emphasis with inline code", () => {
+  const html = render("*查看 `hidden_states`*");
+  assert.match(html, /<code[^>]*>hidden_states<\/code>/);
+});
+
+test("plain inline code (regression)", () => {
+  const html = render("`lm_head`");
+  assert.match(html, /<code[^>]*>lm_head<\/code>/);
+});
+
+test("bold without code (regression)", () => {
+  const html = render("**纯粗体文本**");
+  assert.match(html, /<strong[^>]*>纯粗体文本<\/strong>/);
+  assert.doesNotMatch(html, /<code/);
+});
+
+test("bold with inline code containing backticks", () => {
+  const html = render("**``a`b``**");
+  assert.match(html, /<code[^>]*>a&#96;b<\/code>/);
+});
+
+test("emphasis with inline code containing backticks", () => {
+  const html = render("*``a`b``*");
+  assert.match(html, /<em[^>]*><code[^>]*>a&#96;b<\/code><\/em>/);
+});
+
+test("bold with inline code containing consecutive backticks", () => {
+  const html = render("**```a``b```**");
+  assert.match(html, /<code[^>]*>a&#96;&#96;b<\/code>/);
+});
+
+test("bold with inline code containing only backticks", () => {
+  const html = render("**```` `` ````**");
+  assert.match(html, /<code[^>]*>&#96;&#96;<\/code>/);
+});
+
+test("bold with inline code containing only spaces", () => {
+  const oneSpace = render("**`` ``**");
+  assert.match(oneSpace, /<code[^>]*> <\/code>/);
+
+  const twoSpaces = render("**``  ``**");
+  assert.match(twoSpaces, /<code[^>]*>  <\/code>/);
+});

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/renderer.ts

@@ -109,6 +109,13 @@ function parseFrontMatterAndContent(markdownText: string): ParseResult {
   }
 }
 
+function wrapInlineCode(value: string): string {
+  const runs = value.match(/`+/g);
+  const fence = "`".repeat(Math.max(...(runs?.map((run) => run.length) ?? [0])) + 1);
+  const padding = /^ *$/.test(value) ? "" : " ";
+  return `${fence}${padding}${value}${padding}${fence}`;
+}
+
 export function initRenderer(opts: IOpts = {}): RendererAPI {
   const footnotes: [number, string, string][] = [];
   let footnoteIndex = 0;
@@ -369,6 +376,7 @@ function preprocessCjkEmphasis(markdown: string): string {
   const tree = processor.parse(markdown);
   const extractText = (node: any): string => {
     if (node.type === "text") return node.value;
+    if (node.type === "inlineCode") return wrapInlineCode(node.value);
     if (node.children) return node.children.map(extractText).join("");
     return "";
   };

skills/baoyu-post-to-wechat/scripts/vendor/baoyu-md/src/themes.ts

@@ -6,6 +6,7 @@ import type { ThemeName } from "./types.js";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const THEME_DIR = path.resolve(SCRIPT_DIR, "themes");
 const FALLBACK_THEMES: ThemeName[] = ["default", "grace", "simple"];
+const THEMES_EXTENDING_DEFAULT = new Set<ThemeName>(["grace", "simple"]);
 
 function stripOutputScope(cssContent: string): string {
   let css = cssContent;
@@ -41,6 +42,7 @@ export function loadThemeCss(theme: ThemeName): {
   themeCss: string;
 } {
   const basePath = path.join(THEME_DIR, "base.css");
+  const defaultThemePath = path.join(THEME_DIR, "default.css");
   const themePath = path.join(THEME_DIR, `${theme}.css`);
 
   if (!fs.existsSync(basePath)) {
@@ -51,9 +53,18 @@ export function loadThemeCss(theme: ThemeName): {
     throw new Error(`Missing theme CSS for "${theme}": ${themePath}`);
   }
 
+  const layeredThemeCss: string[] = [];
+  if (theme !== "default" && THEMES_EXTENDING_DEFAULT.has(theme)) {
+    if (!fs.existsSync(defaultThemePath)) {
+      throw new Error(`Missing default theme CSS: ${defaultThemePath}`);
+    }
+    layeredThemeCss.push(fs.readFileSync(defaultThemePath, "utf-8"));
+  }
+  layeredThemeCss.push(fs.readFileSync(themePath, "utf-8"));
+
   return {
     baseCss: fs.readFileSync(basePath, "utf-8"),
-    themeCss: fs.readFileSync(themePath, "utf-8"),
+    themeCss: layeredThemeCss.join("\n"),
   };
 }
 

skills/baoyu-post-to-wechat/scripts/wechat-api.ts

@@ -3,6 +3,11 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { loadWechatExtendConfig, resolveAccount, loadCredentials } from "./wechat-extend-config.ts";
+import {
+  type WechatUploadAsset,
+  prepareWechatBodyImageUpload,
+  needsWechatBodyImageProcessing,
+} from "./wechat-image-processor.ts";
 
 interface AccessTokenResponse {
   access_token?: string;
@@ -52,10 +57,10 @@ interface ArticleOptions {
 }
 
 const TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token";
-const UPLOAD_URL = "https://api.weixin.qq.com/cgi-bin/material/add_material";
+const UPLOAD_BODY_IMG_URL = "https://api.weixin.qq.com/cgi-bin/media/uploadimg";
+const UPLOAD_MATERIAL_URL = "https://api.weixin.qq.com/cgi-bin/material/add_material";
 const DRAFT_URL = "https://api.weixin.qq.com/cgi-bin/draft/add";
 
-
 async function fetchAccessToken(appId: string, appSecret: string): Promise<string> {
   const url = `${TOKEN_URL}?grant_type=client_credential&appid=${appId}&secret=${appSecret}`;
   const res = await fetch(url);
@@ -72,14 +77,20 @@ async function fetchAccessToken(appId: string, appSecret: string): Promise<strin
   return data.access_token;
 }
 
-async function uploadImage(
+function toHttpsUrl(url: string | undefined): string {
+  if (!url) return "";
+  return url.startsWith("http://") ? url.replace(/^http:\/\//i, "https://") : url;
+}
+
+async function loadUploadAsset(
   imagePath: string,
-  accessToken: string,
-  baseDir?: string
-): Promise<UploadResponse> {
+  baseDir?: string,
+): Promise<WechatUploadAsset> {
   let fileBuffer: Buffer;
   let filename: string;
   let contentType: string;
+  let fileSize = 0;
+  let fileExt = "";
 
   if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
     const response = await fetch(imagePath);
@@ -91,8 +102,10 @@ async function uploadImage(
       throw new Error(`Remote image is empty: ${imagePath}`);
     }
     fileBuffer = Buffer.from(buffer);
+    fileSize = buffer.byteLength;
     const urlPath = imagePath.split("?")[0];
     filename = path.basename(urlPath) || "image.jpg";
+    fileExt = path.extname(filename).toLowerCase();
     contentType = response.headers.get("content-type") || "image/jpeg";
   } else {
     const resolvedPath = path.isAbsolute(imagePath)
@@ -106,19 +119,85 @@ async function uploadImage(
     if (stats.size === 0) {
       throw new Error(`Local image is empty: ${resolvedPath}`);
     }
+    fileSize = stats.size;
     fileBuffer = fs.readFileSync(resolvedPath);
     filename = path.basename(resolvedPath);
-    const ext = path.extname(filename).toLowerCase();
+    fileExt = path.extname(filename).toLowerCase();
     const mimeTypes: Record<string, string> = {
       ".jpg": "image/jpeg",
       ".jpeg": "image/jpeg",
       ".png": "image/png",
       ".gif": "image/gif",
       ".webp": "image/webp",
+      ".bmp": "image/bmp",
+      ".tiff": "image/tiff",
+      ".tif": "image/tiff",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
     };
-    contentType = mimeTypes[ext] || "image/jpeg";
+    contentType = mimeTypes[fileExt] || "image/jpeg";
   }
 
+  return {
+    buffer: fileBuffer,
+    filename,
+    contentType,
+    fileExt,
+    fileSize,
+  };
+}
+
+async function uploadImage(
+  imagePath: string,
+  accessToken: string,
+  baseDir?: string,
+  uploadType: "body" | "material" = "body"
+): Promise<UploadResponse> {
+  const asset = await loadUploadAsset(imagePath, baseDir);
+  let uploadAsset = asset;
+
+  if (uploadType === "body" && needsWechatBodyImageProcessing(asset)) {
+    const prepared = await prepareWechatBodyImageUpload(asset);
+    uploadAsset = {
+      ...asset,
+      buffer: prepared.buffer,
+      filename: prepared.filename,
+      contentType: prepared.contentType,
+      fileExt: path.extname(prepared.filename).toLowerCase(),
+      fileSize: prepared.buffer.length,
+    };
+    const note = prepared.processingNotes.join(", ");
+    console.error(`[wechat-api] Processed ${asset.filename} for body upload: ${note}`);
+  }
+
+  const result = await uploadToWechat(
+    uploadAsset.buffer,
+    uploadAsset.filename,
+    uploadAsset.contentType,
+    accessToken,
+    uploadType,
+  );
+
+  // media/uploadimg 接口只返回 URL，material/add_material 返回 media_id
+  if (uploadType === "body") {
+    return {
+      url: toHttpsUrl(result.url),
+      media_id: "",
+    } as UploadResponse;
+  } else {
+    result.url = toHttpsUrl(result.url);
+    return result;
+  }
+}
+
+// 实际的微信上传函数
+async function uploadToWechat(
+  fileBuffer: Buffer,
+  filename: string,
+  contentType: string,
+  accessToken: string,
+  uploadType: "body" | "material"
+): Promise<UploadResponse> {
   const boundary = `----WebKitFormBoundary${Date.now().toString(16)}`;
   const header = [
     `--${boundary}`,
@@ -133,7 +212,8 @@ async function uploadImage(
   const footerBuffer = Buffer.from(footer, "utf-8");
   const body = Buffer.concat([headerBuffer, fileBuffer, footerBuffer]);
 
-  const url = `${UPLOAD_URL}?access_token=${accessToken}&type=image`;
+  const uploadUrl = uploadType === "body" ? UPLOAD_BODY_IMG_URL : UPLOAD_MATERIAL_URL;
+  const url = `${uploadUrl}?type=image&access_token=${accessToken}`;
   const res = await fetch(url, {
     method: "POST",
     headers: {
@@ -147,10 +227,6 @@ async function uploadImage(
     throw new Error(`Upload failed ${data.errcode}: ${data.errmsg}`);
   }
 
-  if (data.url?.startsWith("http://")) {
-    data.url = data.url.replace(/^http:\/\//i, "https://");
-  }
-
   return data;
 }
 
@@ -159,17 +235,19 @@ async function uploadImagesInHtml(
   accessToken: string,
   baseDir: string,
   contentImages: ImageInfo[] = [],
-): Promise<{ html: string; firstMediaId: string; allMediaIds: string[] }> {
+  articleType: ArticleType = "news",
+  collectNewsCoverFallback: boolean = false,
+): Promise<{ html: string; firstCoverMediaId: string; imageMediaIds: string[] }> {
   const imgRegex = /<img[^>]*\ssrc=["']([^"']+)["'][^>]*>/gi;
   const matches = [...html.matchAll(imgRegex)];
 
   if (matches.length === 0 && contentImages.length === 0) {
-    return { html, firstMediaId: "", allMediaIds: [] };
+    return { html, firstCoverMediaId: "", imageMediaIds: [] };
   }
 
-  let firstMediaId = "";
+  let firstCoverMediaId = "";
   let updatedHtml = html;
-  const allMediaIds: string[] = [];
+  const imageMediaIds: string[] = [];
   const uploadedBySource = new Map<string, UploadResponse>();
 
   for (const match of matches) {
@@ -177,8 +255,13 @@ async function uploadImagesInHtml(
     if (!src) continue;
 
     if (src.startsWith("https://mmbiz.qpic.cn")) {
-      if (!firstMediaId) {
-        firstMediaId = src;
+      if (collectNewsCoverFallback && !firstCoverMediaId) {
+        try {
+          const coverResp = await uploadImage(src, accessToken, baseDir, "material");
+          firstCoverMediaId = coverResp.media_id;
+        } catch (err) {
+          console.error(`[wechat-api] Failed to reuse existing WeChat image as cover: ${src}`, err);
+        }
       }
       continue;
     }
@@ -186,20 +269,31 @@ async function uploadImagesInHtml(
     const localPathMatch = fullTag.match(/data-local-path=["']([^"']+)["']/);
     const imagePath = localPathMatch ? localPathMatch[1]! : src;
 
-    console.error(`[wechat-api] Uploading image: ${imagePath}`);
+    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
     try {
       let resp = uploadedBySource.get(imagePath);
       if (!resp) {
-        resp = await uploadImage(imagePath, accessToken, baseDir);
+        // 正文图片使用 media/uploadimg 接口获取 URL
+        resp = await uploadImage(imagePath, accessToken, baseDir, "body");
         uploadedBySource.set(imagePath, resp);
       }
       const newTag = fullTag
         .replace(/\ssrc=["'][^"']+["']/, ` src="${resp.url}"`)
         .replace(/\sdata-local-path=["'][^"']+["']/, "");
       updatedHtml = updatedHtml.replace(fullTag, newTag);
-      allMediaIds.push(resp.media_id);
-      if (!firstMediaId) {
-        firstMediaId = resp.media_id;
+      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
+      if (shouldUploadMaterial) {
+        let materialResp = uploadedBySource.get(`${imagePath}:material`);
+        if (!materialResp) {
+          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material");
+          uploadedBySource.set(`${imagePath}:material`, materialResp);
+        }
+        if (articleType === "newspic" && materialResp.media_id) {
+          imageMediaIds.push(materialResp.media_id);
+        }
+        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
+          firstCoverMediaId = materialResp.media_id;
+        }
       }
     } catch (err) {
       console.error(`[wechat-api] Failed to upload ${imagePath}:`, err);
@@ -210,27 +304,38 @@ async function uploadImagesInHtml(
     if (!updatedHtml.includes(image.placeholder)) continue;
 
     const imagePath = image.localPath || image.originalPath;
-    console.error(`[wechat-api] Uploading placeholder image: ${imagePath}`);
+    console.error(`[wechat-api] Uploading body image: ${imagePath}`);
 
     try {
       let resp = uploadedBySource.get(imagePath);
       if (!resp) {
-        resp = await uploadImage(imagePath, accessToken, baseDir);
+        // 正文图片使用 media/uploadimg 接口获取 URL
+        resp = await uploadImage(imagePath, accessToken, baseDir, "body");
         uploadedBySource.set(imagePath, resp);
       }
 
       const replacementTag = `<img src="${resp.url}" style="display: block; width: 100%; margin: 1.5em auto;">`;
       updatedHtml = replaceAllPlaceholders(updatedHtml, image.placeholder, replacementTag);
-      allMediaIds.push(resp.media_id);
-      if (!firstMediaId) {
-        firstMediaId = resp.media_id;
+      const shouldUploadMaterial = articleType === "newspic" || (collectNewsCoverFallback && !firstCoverMediaId);
+      if (shouldUploadMaterial) {
+        let materialResp = uploadedBySource.get(`${imagePath}:material`);
+        if (!materialResp) {
+          materialResp = await uploadImage(imagePath, accessToken, baseDir, "material");
+          uploadedBySource.set(`${imagePath}:material`, materialResp);
+        }
+        if (articleType === "newspic" && materialResp.media_id) {
+          imageMediaIds.push(materialResp.media_id);
+        }
+        if (collectNewsCoverFallback && !firstCoverMediaId && materialResp.media_id) {
+          firstCoverMediaId = materialResp.media_id;
+        }
       }
     } catch (err) {
       console.error(`[wechat-api] Failed to upload placeholder ${image.placeholder}:`, err);
     }
   }
 
-  return { html: updatedHtml, firstMediaId, allMediaIds };
+  return { html: updatedHtml, firstCoverMediaId, imageMediaIds };
 }
 
 async function publishToDraft(
@@ -345,7 +450,7 @@ function renderMarkdownWithPlaceholders(
 
 function replaceAllPlaceholders(html: string, placeholder: string, replacement: string): string {
   const escapedPlaceholder = placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return html.replace(new RegExp(escapedPlaceholder, "g"), replacement);
+  return html.replace(new RegExp(escapedPlaceholder + "(?!\\d)", "g"), replacement);
 }
 
 function extractHtmlContent(htmlPath: string): string {
@@ -592,16 +697,6 @@ async function main(): Promise<void> {
   console.error("[wechat-api] Fetching access token...");
   const accessToken = await fetchAccessToken(creds.appId, creds.appSecret);
 
-  console.error("[wechat-api] Uploading images...");
-  const { html: processedHtml, firstMediaId, allMediaIds } = await uploadImagesInHtml(
-    htmlContent,
-    accessToken,
-    baseDir,
-    contentImages,
-  );
-  htmlContent = processedHtml;
-
-  let thumbMediaId = "";
   const rawCoverPath = args.cover ||
     frontmatter.coverImage ||
     frontmatter.featureImage ||
@@ -610,19 +705,31 @@ async function main(): Promise<void> {
   const coverPath = rawCoverPath && !path.isAbsolute(rawCoverPath) && args.cover
     ? path.resolve(process.cwd(), rawCoverPath)
     : rawCoverPath;
+  const needNewsCoverFallback = args.articleType === "news" && !coverPath;
+
+  console.error("[wechat-api] Uploading body images...");
+  const { html: processedHtml, firstCoverMediaId, imageMediaIds } = await uploadImagesInHtml(
+    htmlContent,
+    accessToken,
+    baseDir,
+    contentImages,
+    args.articleType,
+    needNewsCoverFallback,
+  );
+  htmlContent = processedHtml;
+
+  let thumbMediaId = "";
 
   if (coverPath) {
     console.error(`[wechat-api] Uploading cover: ${coverPath}`);
-    const coverResp = await uploadImage(coverPath, accessToken, baseDir);
+    // 封面图片使用 material/add_material 接口
+    const coverResp = await uploadImage(coverPath, accessToken, baseDir, "material");
     thumbMediaId = coverResp.media_id;
-  } else if (firstMediaId) {
-    if (firstMediaId.startsWith("https://")) {
-      console.error(`[wechat-api] Uploading first image as cover: ${firstMediaId}`);
-      const coverResp = await uploadImage(firstMediaId, accessToken, baseDir);
-      thumbMediaId = coverResp.media_id;
-    } else {
-      thumbMediaId = firstMediaId;
-    }
+    console.error(`[wechat-api] Cover uploaded successfully, media_id: ${thumbMediaId}`);
+  } else if (firstCoverMediaId && args.articleType === "news") {
+    // news 类型没有封面时，使用第一张正文图的 media_id 作为封面（兜底逻辑）
+    thumbMediaId = firstCoverMediaId;
+    console.error(`[wechat-api] Using first body image as cover (fallback), media_id: ${thumbMediaId}`);
   }
 
   if (args.articleType === "news" && !thumbMediaId) {
@@ -630,7 +737,7 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  if (args.articleType === "newspic" && allMediaIds.length === 0) {
+  if (args.articleType === "newspic" && imageMediaIds.length === 0) {
     console.error("Error: newspic requires at least one image in content.");
     process.exit(1);
   }
@@ -643,7 +750,7 @@ async function main(): Promise<void> {
     content: htmlContent,
     thumbMediaId,
     articleType: args.articleType,
-    imageMediaIds: args.articleType === "newspic" ? allMediaIds : undefined,
+    imageMediaIds: args.articleType === "newspic" ? imageMediaIds : undefined,
     needOpenComment: resolved.need_open_comment,
     onlyFansCanComment: resolved.only_fans_can_comment,
   }, accessToken);

skills/baoyu-post-to-wechat/scripts/wechat-article.ts

@@ -51,32 +51,42 @@ async function waitForElement(session: ChromeSession, selector: string, timeoutM
   return false;
 }
 
-async function clickMenuByText(session: ChromeSession, text: string): Promise<void> {
+async function clickMenuByText(session: ChromeSession, text: string, maxRetries = 5): Promise<void> {
   console.log(`[wechat] Clicking "${text}" menu...`);
-  const posResult = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
-    expression: `
-      (function() {
-        const items = document.querySelectorAll('.new-creation__menu .new-creation__menu-item');
-        for (const item of items) {
-          const title = item.querySelector('.new-creation__menu-title');
-          if (title && title.textContent?.trim() === '${text}') {
-            item.scrollIntoView({ block: 'center' });
-            const rect = item.getBoundingClientRect();
-            return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 });
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const posResult = await session.cdp.send<{ result: { value: string } }>('Runtime.evaluate', {
+      expression: `
+        (function() {
+          const items = document.querySelectorAll('.new-creation__menu .new-creation__menu-item');
+          for (const item of items) {
+            const title = item.querySelector('.new-creation__menu-title');
+            if (title && title.textContent?.trim() === '${text}') {
+              item.scrollIntoView({ block: 'center' });
+              const rect = item.getBoundingClientRect();
+              return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 });
+            }
           }
-        }
-        return 'null';
-      })()
-    `,
-    returnByValue: true,
-  }, { sessionId: session.sessionId });
+          return 'null';
+        })()
+      `,
+      returnByValue: true,
+    }, { sessionId: session.sessionId });
 
-  if (posResult.result.value === 'null') throw new Error(`Menu "${text}" not found`);
-  const pos = JSON.parse(posResult.result.value);
+    if (posResult.result.value !== 'null') {
+      const pos = JSON.parse(posResult.result.value);
+      await session.cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
+      await sleep(100);
+      await session.cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
+      return;
+    }
 
-  await session.cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
-  await sleep(100);
-  await session.cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1 }, { sessionId: session.sessionId });
+    if (attempt < maxRetries) {
+      const delay = Math.min(1000 * attempt, 3000);
+      console.log(`[wechat] Menu "${text}" not found, retrying in ${delay}ms (${attempt}/${maxRetries})...`);
+      await sleep(delay);
+    }
+  }
+  throw new Error(`Menu "${text}" not found after ${maxRetries} attempts`);
 }
 
 async function copyImageToClipboard(imagePath: string): Promise<void> {
@@ -495,10 +505,10 @@ export async function postArticle(options: ArticleOptions): Promise<void> {
       if (!loggedIn) throw new Error('Login timeout');
     }
     console.log('[wechat] Logged in.');
-    await sleep(2000);
+    await sleep(5000);
 
     // Wait for menu to be ready
-    const menuReady = await waitForElement(session, '.new-creation__menu', 20_000);
+    const menuReady = await waitForElement(session, '.new-creation__menu', 40_000);
     if (!menuReady) throw new Error('Home page menu did not load');
 
     const targets = await cdp.send<{ targetInfos: Array<{ targetId: string; url: string; type: string }> }>('Target.getTargets');
@@ -517,16 +527,21 @@ export async function postArticle(options: ArticleOptions): Promise<void> {
     await cdp.send('Runtime.enable', {}, { sessionId });
     await cdp.send('DOM.enable', {}, { sessionId });
 
-    await sleep(3000);
+    // Wait for editor elements to fully load
+    console.log('[wechat] Waiting for editor to load...');
+    const editorLoaded = await waitForElement(session, '#title', 30_000);
+    if (!editorLoaded) throw new Error('Editor did not load (#title not found)');
+    await waitForElement(session, '.ProseMirror', 15_000);
+    await sleep(2000);
 
     if (effectiveTitle) {
       console.log('[wechat] Filling title...');
-      await evaluate(session, `document.querySelector('#title').value = ${JSON.stringify(effectiveTitle)}; document.querySelector('#title').dispatchEvent(new Event('input', { bubbles: true }));`);
+      await evaluate(session, `(function() { const el = document.querySelector('#title'); el.focus(); el.value = ${JSON.stringify(effectiveTitle)}; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); })()`);
     }
 
     if (effectiveAuthor) {
       console.log('[wechat] Filling author...');
-      await evaluate(session, `document.querySelector('#author').value = ${JSON.stringify(effectiveAuthor)}; document.querySelector('#author').dispatchEvent(new Event('input', { bubbles: true }));`);
+      await evaluate(session, `(function() { const el = document.querySelector('#author'); el.focus(); el.value = ${JSON.stringify(effectiveAuthor)}; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); })()`);
     }
 
     await sleep(500);

skills/baoyu-post-to-wechat/scripts/wechat-image-processor.ts

@@ -0,0 +1,252 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Jimp, JimpMime } from "jimp";
+import decodeWebp, { init as initWebpDecode } from "@jsquash/webp/decode.js";
+
+export interface WechatUploadAsset {
+  buffer: Buffer;
+  filename: string;
+  contentType: string;
+  fileExt: string;
+  fileSize: number;
+}
+
+export interface PreparedWechatUploadAsset {
+  buffer: Buffer;
+  filename: string;
+  contentType: string;
+  wasProcessed: boolean;
+  processingNotes: string[];
+}
+
+export const WECHAT_BODY_IMAGE_MAX_SIZE = 1024 * 1024; // 1MB
+export const WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS = new Set([
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".tif",
+  ".svg",
+  ".ico",
+]);
+
+const BODY_UPLOAD_ALLOWED_MIME_TYPES = new Set([
+  JimpMime.jpeg,
+  JimpMime.png,
+]);
+
+const MIME_TO_EXT: Record<string, string> = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/bmp": ".bmp",
+  "image/x-ms-bmp": ".bmp",
+  "image/tiff": ".tiff",
+  "image/svg+xml": ".svg",
+  "image/x-icon": ".ico",
+  "image/vnd.microsoft.icon": ".ico",
+};
+
+const JPEG_QUALITY_STEPS = [82, 74, 66, 58, 50, 42, 34];
+const MAX_WIDTH_STEPS = [2560, 2048, 1600, 1280, 1024, 800, 640, 480];
+
+let webpDecoderReady: Promise<void> | undefined;
+
+type JimpImage = Awaited<ReturnType<typeof Jimp.read>>;
+
+function normalizeMimeType(contentType: string): string {
+  return contentType.split(";")[0]!.trim().toLowerCase();
+}
+
+function extFromMimeType(contentType: string): string {
+  return MIME_TO_EXT[normalizeMimeType(contentType)] || "";
+}
+
+function ensureFileExt(asset: WechatUploadAsset): string {
+  return asset.fileExt || extFromMimeType(asset.contentType);
+}
+
+function basenameWithoutExt(filename: string): string {
+  const base = path.basename(filename, path.extname(filename));
+  return base || "image";
+}
+
+function renameWithExt(filename: string, ext: string): string {
+  return `${basenameWithoutExt(filename)}${ext}`;
+}
+
+export function needsWechatBodyImageProcessing(asset: WechatUploadAsset): boolean {
+  if (asset.fileSize > WECHAT_BODY_IMAGE_MAX_SIZE) {
+    return true;
+  }
+
+  const normalizedMimeType = normalizeMimeType(asset.contentType);
+  if (BODY_UPLOAD_ALLOWED_MIME_TYPES.has(normalizedMimeType)) {
+    return false;
+  }
+
+  const fileExt = ensureFileExt(asset);
+  return WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS.has(fileExt) || !fileExt;
+}
+
+async function ensureWebpDecoder(): Promise<void> {
+  if (!webpDecoderReady) {
+    webpDecoderReady = (async () => {
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path.dirname(__filename);
+      const wasmPath = path.resolve(__dirname, "node_modules/@jsquash/webp/codec/dec/webp_dec.wasm");
+      const wasmModule = await WebAssembly.compile(await fs.readFile(wasmPath));
+      await initWebpDecode(wasmModule, {});
+    })();
+  }
+
+  await webpDecoderReady;
+}
+
+async function loadImageForProcessing(asset: WechatUploadAsset): Promise<JimpImage> {
+  const fileExt = ensureFileExt(asset);
+  const normalizedMimeType = normalizeMimeType(asset.contentType);
+
+  if (fileExt === ".webp" || normalizedMimeType === "image/webp") {
+    await ensureWebpDecoder();
+    const decoded = await decodeWebp(asset.buffer);
+    return new Jimp({
+      data: Buffer.from(decoded.data.buffer, decoded.data.byteOffset, decoded.data.byteLength),
+      width: decoded.width,
+      height: decoded.height,
+    });
+  }
+
+  if (fileExt === ".svg" || fileExt === ".ico") {
+    throw new Error(`Cannot convert ${fileExt} image for WeChat body upload; provide a PNG or JPG instead.`);
+  }
+
+  return Jimp.read(asset.buffer);
+}
+
+function imageHasTransparency(image: JimpImage): boolean {
+  const { data } = image.bitmap;
+  for (let i = 3; i < data.length; i += 4) {
+    if (data[i] !== 255) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function buildCandidateWidths(width: number): number[] {
+  const candidates = new Set<number>([width]);
+
+  for (const maxWidth of MAX_WIDTH_STEPS) {
+    if (width > maxWidth) {
+      candidates.add(maxWidth);
+    }
+  }
+
+  return [...candidates].sort((a, b) => b - a);
+}
+
+function resizeToWidth(image: JimpImage, width: number): JimpImage {
+  const cloned = image.clone();
+  if (width < image.bitmap.width) {
+    cloned.resize({ w: width });
+  }
+  return cloned;
+}
+
+function flattenOnWhite(image: JimpImage): JimpImage {
+  const flattened = new Jimp({
+    width: image.bitmap.width,
+    height: image.bitmap.height,
+    color: 0xffffffff,
+  });
+  flattened.composite(image, 0, 0);
+  return flattened;
+}
+
+async function encodePng(image: JimpImage): Promise<Buffer> {
+  return image.getBuffer(JimpMime.png);
+}
+
+async function encodeJpeg(image: JimpImage, quality: number): Promise<Buffer> {
+  const jpegSource = imageHasTransparency(image) ? flattenOnWhite(image) : image;
+  return jpegSource.getBuffer(JimpMime.jpeg, { quality });
+}
+
+function buildProcessingNotes(asset: WechatUploadAsset): string[] {
+  const notes: string[] = [];
+  const fileExt = ensureFileExt(asset);
+
+  if (fileExt && WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS.has(fileExt)) {
+    notes.push(`converted unsupported ${fileExt} source`);
+  }
+
+  if (asset.fileSize > WECHAT_BODY_IMAGE_MAX_SIZE) {
+    notes.push(`compressed ${(asset.fileSize / 1024 / 1024).toFixed(2)}MB source below 1MB`);
+  }
+
+  if (notes.length === 0) {
+    notes.push("re-encoded for WeChat body upload");
+  }
+
+  return notes;
+}
+
+export async function prepareWechatBodyImageUpload(
+  asset: WechatUploadAsset,
+): Promise<PreparedWechatUploadAsset> {
+  if (!needsWechatBodyImageProcessing(asset)) {
+    return {
+      buffer: asset.buffer,
+      filename: asset.filename,
+      contentType: asset.contentType,
+      wasProcessed: false,
+      processingNotes: [],
+    };
+  }
+
+  const image = await loadImageForProcessing(asset);
+  const widths = buildCandidateWidths(image.bitmap.width);
+  const preferPng = imageHasTransparency(image) || ensureFileExt(asset) === ".png";
+  const processingNotes = buildProcessingNotes(asset);
+
+  for (const width of widths) {
+    const resized = resizeToWidth(image, width);
+
+    if (preferPng) {
+      const pngBuffer = await encodePng(resized);
+      if (pngBuffer.length <= WECHAT_BODY_IMAGE_MAX_SIZE) {
+        return {
+          buffer: pngBuffer,
+          filename: renameWithExt(asset.filename, ".png"),
+          contentType: JimpMime.png,
+          wasProcessed: true,
+          processingNotes: width < image.bitmap.width
+            ? [...processingNotes, `resized to ${width}px wide`]
+            : processingNotes,
+        };
+      }
+    }
+
+    for (const quality of JPEG_QUALITY_STEPS) {
+      const jpegBuffer = await encodeJpeg(resized, quality);
+      if (jpegBuffer.length <= WECHAT_BODY_IMAGE_MAX_SIZE) {
+        const notes = [...processingNotes, `encoded as JPEG (${quality} quality)`];
+        if (width < image.bitmap.width) {
+          notes.push(`resized to ${width}px wide`);
+        }
+        return {
+          buffer: jpegBuffer,
+          filename: renameWithExt(asset.filename, ".jpg"),
+          contentType: JimpMime.jpeg,
+          wasProcessed: true,
+          processingNotes: notes,
+        };
+      }
+    }
+  }
+
+  throw new Error(`Unable to reduce ${asset.filename} below 1MB for WeChat body upload.`);
+}

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/content.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  extractSummaryFromBody,
+  extractTitleFromMarkdown,
+  parseFrontmatter,
+  pickFirstString,
+  serializeFrontmatter,
+  stripWrappingQuotes,
+  toFrontmatterString,
+} from "./content.ts";
+
+test("parseFrontmatter extracts YAML fields and strips wrapping quotes", () => {
+  const input = `---
+title: "Hello World"
+author: ‘Baoyu’
+summary: plain text
+---
+# Heading
+
+Body`;
+
+  const result = parseFrontmatter(input);
+
+  assert.deepEqual(result.frontmatter, {
+    title: "Hello World",
+    author: "Baoyu",
+    summary: "plain text",
+  });
+  assert.match(result.body, /^# Heading/);
+});
+
+test("parseFrontmatter returns original content when no frontmatter exists", () => {
+  const input = "# No frontmatter";
+  assert.deepEqual(parseFrontmatter(input), {
+    frontmatter: {},
+    body: input,
+  });
+});
+
+test("serializeFrontmatter renders YAML only when fields exist", () => {
+  assert.equal(serializeFrontmatter({}), "");
+  assert.equal(
+    serializeFrontmatter({ title: "Hello", author: "Baoyu" }),
+    "---\ntitle: Hello\nauthor: Baoyu\n---\n",
+  );
+});
+
+test("quote and frontmatter string helpers normalize mixed scalar values", () => {
+  assert.equal(stripWrappingQuotes(`" quoted "`), "quoted");
+  assert.equal(stripWrappingQuotes("“ 中文标题 ”"), "中文标题");
+  assert.equal(stripWrappingQuotes("plain"), "plain");
+
+  assert.equal(toFrontmatterString("'hello'"), "hello");
+  assert.equal(toFrontmatterString(42), "42");
+  assert.equal(toFrontmatterString(false), "false");
+  assert.equal(toFrontmatterString({}), undefined);
+
+  assert.equal(
+    pickFirstString({ summary: 123, title: "" }, ["title", "summary"]),
+    "123",
+  );
+});
+
+test("markdown title and summary extraction skip non-body content and clean formatting", () => {
+  const markdown = `
+![cover](cover.png)
+## “My Title”
+
+Body paragraph
+`;
+  assert.equal(extractTitleFromMarkdown(markdown), "My Title");
+
+  const summary = extractSummaryFromBody(
+    `
+# Heading
+> quote
+- list
+1. ordered
+\`\`\`
+code
+\`\`\`
+This is **the first paragraph** with [a link](https://example.com) and \`inline code\` that should be summarized cleanly.
+`,
+    70,
+  );
+
+  assert.equal(
+    summary,
+    "This is the first paragraph with a link and inline code that should...",
+  );
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/document.test.ts

@@ -0,0 +1,174 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import { COLOR_PRESETS, FONT_FAMILY_MAP } from "./constants.ts";
+import {
+  buildMarkdownDocumentMeta,
+  formatTimestamp,
+  renderMarkdownDocument,
+  resolveColorToken,
+  resolveFontFamilyToken,
+  resolveMarkdownStyle,
+  resolveRenderOptions,
+} from "./document.ts";
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`);
+}
+
+function findInlineStyle(html: string, tagName: string, text: string): string {
+  const pattern = new RegExp(
+    `<${tagName}[^>]*style="([^"]*)"[^>]*>${escapeRegExp(text)}</${tagName}>`,
+  );
+  const match = html.match(pattern);
+  assert.ok(match, `Expected inline style for <${tagName}>${text}</${tagName}>`);
+  return match![1]!;
+}
+
+function useCwd(t: TestContext, cwd: string): void {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  t.after(() => {
+    process.chdir(previous);
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("document token resolvers map known presets and allow passthrough values", () => {
+  assert.equal(resolveColorToken("green"), COLOR_PRESETS.green);
+  assert.equal(resolveColorToken("#123456"), "#123456");
+  assert.equal(resolveColorToken(), undefined);
+
+  assert.equal(resolveFontFamilyToken("mono"), FONT_FAMILY_MAP.mono);
+  assert.equal(resolveFontFamilyToken("Custom Font"), "Custom Font");
+  assert.equal(resolveFontFamilyToken(), undefined);
+});
+
+test("formatTimestamp uses compact sortable datetime output", () => {
+  const date = new Date("2026-03-13T21:04:05.000Z");
+  const pad = (value: number) => String(value).padStart(2, "0");
+  const expected = `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(
+    date.getDate(),
+  )}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+
+  assert.equal(formatTimestamp(date), expected);
+});
+
+test("buildMarkdownDocumentMeta prefers frontmatter and falls back to markdown title and summary", () => {
+  const metaFromYaml = buildMarkdownDocumentMeta(
+    "# Markdown Title\n\nBody summary paragraph that should be ignored.",
+    {
+      title: `" YAML Title "`,
+      author: "'Baoyu'",
+      summary: `" YAML Summary "`,
+    },
+    "fallback",
+  );
+
+  assert.deepEqual(metaFromYaml, {
+    title: "YAML Title",
+    author: "Baoyu",
+    description: "YAML Summary",
+  });
+
+  const metaFromMarkdown = buildMarkdownDocumentMeta(
+    `## “Markdown Title”\n\nThis is the first body paragraph that should become the summary because it is long enough.`,
+    {},
+    "fallback",
+  );
+
+  assert.equal(metaFromMarkdown.title, "Markdown Title");
+  assert.match(metaFromMarkdown.description ?? "", /^This is the first body paragraph/);
+});
+
+test("resolveMarkdownStyle merges theme defaults with explicit overrides", () => {
+  const style = resolveMarkdownStyle({
+    theme: "modern",
+    primaryColor: "#112233",
+    fontFamily: "Custom Sans",
+  });
+
+  assert.equal(style.primaryColor, "#112233");
+  assert.equal(style.fontFamily, "Custom Sans");
+  assert.equal(style.fontSize, "15px");
+  assert.equal(style.containerBg, "rgba(250, 249, 245, 1)");
+});
+
+test("resolveRenderOptions loads workspace EXTEND settings and lets explicit options win", async (t) => {
+  const root = await makeTempDir("baoyu-md-render-options-");
+  useCwd(t, root);
+
+  const extendPath = path.join(
+    root,
+    ".baoyu-skills",
+    "baoyu-markdown-to-html",
+    "EXTEND.md",
+  );
+  await fs.mkdir(path.dirname(extendPath), { recursive: true });
+  await fs.writeFile(
+    extendPath,
+    `---
+default_theme: modern
+default_color: green
+default_font_family: mono
+default_font_size: 17
+default_code_theme: nord
+mac_code_block: false
+show_line_number: true
+cite: true
+count: true
+legend: title-alt
+keep_title: true
+---
+`,
+  );
+
+  const fromExtend = resolveRenderOptions();
+  assert.equal(fromExtend.theme, "modern");
+  assert.equal(fromExtend.primaryColor, COLOR_PRESETS.green);
+  assert.equal(fromExtend.fontFamily, FONT_FAMILY_MAP.mono);
+  assert.equal(fromExtend.fontSize, "17px");
+  assert.equal(fromExtend.codeTheme, "nord");
+  assert.equal(fromExtend.isMacCodeBlock, false);
+  assert.equal(fromExtend.isShowLineNumber, true);
+  assert.equal(fromExtend.citeStatus, true);
+  assert.equal(fromExtend.countStatus, true);
+  assert.equal(fromExtend.legend, "title-alt");
+  assert.equal(fromExtend.keepTitle, true);
+
+  const explicit = resolveRenderOptions({
+    theme: "simple",
+    fontSize: "18px",
+    keepTitle: false,
+  });
+  assert.equal(explicit.theme, "simple");
+  assert.equal(explicit.fontSize, "18px");
+  assert.equal(explicit.keepTitle, false);
+});
+
+test("renderMarkdownDocument layers default rules into grace theme before CSS inlining", async () => {
+  const { html } = await renderMarkdownDocument(
+    `## Section\n\nParagraph with **bold** text.`,
+    { keepTitle: true, theme: "grace" },
+  );
+
+  const h2Style = findInlineStyle(html, "h2", "Section");
+  assert.match(h2Style, /background: #92617E/);
+  assert.match(h2Style, /box-shadow: 0 4px 6px rgba\(0, 0, 0, 0\.1\)/);
+
+  const pMatch = html.match(/<p[^>]*style="([^"]*)"[^>]*>/);
+  assert.ok(pMatch, "Expected inline style on <p> tag");
+  assert.match(pMatch![1]!, /color:/);
+
+  const strongPattern = /<strong[^>]*style="([^"]*)"[^>]*>bold<\/strong>/;
+  const strongMatch = html.match(strongPattern);
+  assert.ok(strongMatch, "Expected inline style for <strong>bold</strong>");
+  assert.match(strongMatch![1]!, /font-weight:/);
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/html-builder.test.ts

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEFAULT_STYLE } from "./constants.ts";
+import {
+  buildCss,
+  buildHtmlDocument,
+  modifyHtmlStructure,
+  normalizeCssText,
+  normalizeInlineCss,
+  removeFirstHeading,
+} from "./html-builder.ts";
+
+test("buildCss injects style variables and concatenates base and theme CSS", () => {
+  const css = buildCss("body { color: red; }", ".theme { color: blue; }");
+
+  assert.match(css, /--md-primary-color: #0F4C81;/);
+  assert.match(css, /body \{ color: red; \}/);
+  assert.match(css, /\.theme \{ color: blue; \}/);
+});
+
+test("buildHtmlDocument includes optional meta tags and code theme CSS", () => {
+  const html = buildHtmlDocument(
+    {
+      title: "Doc",
+      author: "Baoyu",
+      description: "Summary",
+    },
+    "body { color: red; }",
+    "<article>Hello</article>",
+    ".hljs { color: blue; }",
+  );
+
+  assert.match(html, /<title>Doc<\/title>/);
+  assert.match(html, /meta name="author" content="Baoyu"/);
+  assert.match(html, /meta name="description" content="Summary"/);
+  assert.match(html, /<style>body \{ color: red; \}<\/style>/);
+  assert.match(html, /<style>\.hljs \{ color: blue; \}<\/style>/);
+  assert.match(html, /<article>Hello<\/article>/);
+});
+
+test("normalizeCssText and normalizeInlineCss replace variables and strip declarations", () => {
+  const rawCss = `
+:root { --md-primary-color: #000; --md-font-size: 12px; --foreground: 0 0% 5%; }
+.box { color: var(--md-primary-color); font-size: var(--md-font-size); background: hsl(var(--foreground)); }
+`;
+
+  const normalizedCss = normalizeCssText(rawCss, DEFAULT_STYLE);
+  assert.match(normalizedCss, /color: #0F4C81/);
+  assert.match(normalizedCss, /font-size: 16px/);
+  assert.match(normalizedCss, /background: #3f3f3f/);
+  assert.doesNotMatch(normalizedCss, /--md-primary-color/);
+
+  const normalizedHtml = normalizeInlineCss(
+    `<style>${rawCss}</style><div style="color: var(--md-primary-color)"></div>`,
+    DEFAULT_STYLE,
+  );
+  assert.match(normalizedHtml, /color: #0F4C81/);
+  assert.doesNotMatch(normalizedHtml, /var\(--md-primary-color\)/);
+});
+
+test("normalizeInlineCss removes quoted custom property values without leaving fragments behind", () => {
+  const normalizedHtml = normalizeInlineCss(
+    `<html style="--md-font-family: Menlo, Monaco, 'Courier New', monospace; color: var(--md-primary-color)"></html>`,
+    DEFAULT_STYLE,
+  );
+
+  assert.match(normalizedHtml, /style=" color: #0F4C81"/);
+  assert.doesNotMatch(normalizedHtml, /Courier New/);
+  assert.doesNotMatch(normalizedHtml, /--md-font-family/);
+});
+
+test("HTML structure helpers hoist nested lists and remove the first heading", () => {
+  const nestedList = `<ul><li>Parent<ul><li>Child</li></ul></li></ul>`;
+  assert.equal(
+    modifyHtmlStructure(nestedList),
+    `<ul><li>Parent</li><ul><li>Child</li></ul></ul>`,
+  );
+
+  const html = `<h1>Title</h1><p>Intro</p><h2>Sub</h2>`;
+  assert.equal(removeFirstHeading(html), `<p>Intro</p><h2>Sub</h2>`);
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/html-builder.ts

@@ -100,13 +100,13 @@ export function normalizeCssText(cssText: string, style: StyleConfig = DEFAULT_S
     .replace(/var\(--md-accent-color\)/g, style.accentColor)
     .replace(/var\(--md-container-bg\)/g, style.containerBg)
     .replace(/hsl\(var\(--foreground\)\)/g, "#3f3f3f")
-    .replace(/--md-primary-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-family:\s*[^;"']+;?/g, "")
-    .replace(/--md-font-size:\s*[^;"']+;?/g, "")
-    .replace(/--blockquote-background:\s*[^;"']+;?/g, "")
-    .replace(/--md-accent-color:\s*[^;"']+;?/g, "")
-    .replace(/--md-container-bg:\s*[^;"']+;?/g, "")
-    .replace(/--foreground:\s*[^;"']+;?/g, "");
+    .replace(/--md-primary-color:\s*[^;]+;?/g, "")
+    .replace(/--md-font-family:\s*[^;]+;?/g, "")
+    .replace(/--md-font-size:\s*[^;]+;?/g, "")
+    .replace(/--blockquote-background:\s*[^;]+;?/g, "")
+    .replace(/--md-accent-color:\s*[^;]+;?/g, "")
+    .replace(/--md-container-bg:\s*[^;]+;?/g, "")
+    .replace(/--foreground:\s*[^;]+;?/g, "");
 }
 
 export function normalizeInlineCss(html: string, style: StyleConfig = DEFAULT_STYLE): string {

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/images.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  getImageExtension,
+  replaceMarkdownImagesWithPlaceholders,
+  resolveContentImages,
+  resolveImagePath,
+} from "./images.ts";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test("replaceMarkdownImagesWithPlaceholders rewrites markdown and tracks image metadata", () => {
+  const result = replaceMarkdownImagesWithPlaceholders(
+    `![cover](images/cover.png)\n\nText\n\n![diagram](images/diagram.webp)`,
+    "IMG_",
+  );
+
+  assert.equal(result.markdown, `IMG_1\n\nText\n\nIMG_2`);
+  assert.deepEqual(result.images, [
+    { alt: "cover", originalPath: "images/cover.png", placeholder: "IMG_1" },
+    { alt: "diagram", originalPath: "images/diagram.webp", placeholder: "IMG_2" },
+  ]);
+});
+
+test("image extension and local fallback resolution handle common path variants", async (t) => {
+  assert.equal(getImageExtension("https://example.com/a.jpeg?x=1"), "jpeg");
+  assert.equal(getImageExtension("/tmp/figure"), "png");
+
+  const root = await makeTempDir("baoyu-md-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "figure.webp"), "webp");
+
+  const resolved = await resolveImagePath("figure.png", baseDir, tempDir, "test");
+  assert.equal(resolved, path.join(baseDir, "figure.webp"));
+});
+
+test("resolveContentImages resolves image placeholders against the content directory", async (t) => {
+  const root = await makeTempDir("baoyu-md-content-images-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const baseDir = path.join(root, "article");
+  const tempDir = path.join(root, "tmp");
+  await fs.mkdir(baseDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+  await fs.writeFile(path.join(baseDir, "cover.png"), "png");
+
+  const resolved = await resolveContentImages(
+    [
+      {
+        alt: "cover",
+        originalPath: "cover.png",
+        placeholder: "IMG_1",
+      },
+    ],
+    baseDir,
+    tempDir,
+    "test",
+  );
+
+  assert.deepEqual(resolved, [
+    {
+      alt: "cover",
+      originalPath: "cover.png",
+      placeholder: "IMG_1",
+      localPath: path.join(baseDir, "cover.png"),
+    },
+  ]);
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/renderer.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { initRenderer, renderMarkdown } from "./renderer.ts";
+
+const render = (md: string) => {
+  const r = initRenderer();
+  return renderMarkdown(md, r).html;
+};
+
+test("bold with inline code (no underscore)", () => {
+  const html = render("**算出 `logits`，算出 `loss`。**");
+  assert.match(html, /<code[^>]*>logits<\/code>/);
+  assert.match(html, /<code[^>]*>loss<\/code>/);
+});
+
+test("bold with inline code (contains underscore)", () => {
+  const html = render("**变成 `input_ids`。**");
+  assert.match(html, /<code[^>]*>input_ids<\/code>/);
+});
+
+test("emphasis with inline code", () => {
+  const html = render("*查看 `hidden_states`*");
+  assert.match(html, /<code[^>]*>hidden_states<\/code>/);
+});
+
+test("plain inline code (regression)", () => {
+  const html = render("`lm_head`");
+  assert.match(html, /<code[^>]*>lm_head<\/code>/);
+});
+
+test("bold without code (regression)", () => {
+  const html = render("**纯粗体文本**");
+  assert.match(html, /<strong[^>]*>纯粗体文本<\/strong>/);
+  assert.doesNotMatch(html, /<code/);
+});
+
+test("bold with inline code containing backticks", () => {
+  const html = render("**``a`b``**");
+  assert.match(html, /<code[^>]*>a&#96;b<\/code>/);
+});
+
+test("emphasis with inline code containing backticks", () => {
+  const html = render("*``a`b``*");
+  assert.match(html, /<em[^>]*><code[^>]*>a&#96;b<\/code><\/em>/);
+});
+
+test("bold with inline code containing consecutive backticks", () => {
+  const html = render("**```a``b```**");
+  assert.match(html, /<code[^>]*>a&#96;&#96;b<\/code>/);
+});
+
+test("bold with inline code containing only backticks", () => {
+  const html = render("**```` `` ````**");
+  assert.match(html, /<code[^>]*>&#96;&#96;<\/code>/);
+});
+
+test("bold with inline code containing only spaces", () => {
+  const oneSpace = render("**`` ``**");
+  assert.match(oneSpace, /<code[^>]*> <\/code>/);
+
+  const twoSpaces = render("**``  ``**");
+  assert.match(twoSpaces, /<code[^>]*>  <\/code>/);
+});

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/renderer.ts

@@ -109,6 +109,13 @@ function parseFrontMatterAndContent(markdownText: string): ParseResult {
   }
 }
 
+function wrapInlineCode(value: string): string {
+  const runs = value.match(/`+/g);
+  const fence = "`".repeat(Math.max(...(runs?.map((run) => run.length) ?? [0])) + 1);
+  const padding = /^ *$/.test(value) ? "" : " ";
+  return `${fence}${padding}${value}${padding}${fence}`;
+}
+
 export function initRenderer(opts: IOpts = {}): RendererAPI {
   const footnotes: [number, string, string][] = [];
   let footnoteIndex = 0;
@@ -369,6 +376,7 @@ function preprocessCjkEmphasis(markdown: string): string {
   const tree = processor.parse(markdown);
   const extractText = (node: any): string => {
     if (node.type === "text") return node.value;
+    if (node.type === "inlineCode") return wrapInlineCode(node.value);
     if (node.children) return node.children.map(extractText).join("");
     return "";
   };

skills/baoyu-post-to-weibo/scripts/vendor/baoyu-md/src/themes.ts

@@ -6,6 +6,7 @@ import type { ThemeName } from "./types.js";
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const THEME_DIR = path.resolve(SCRIPT_DIR, "themes");
 const FALLBACK_THEMES: ThemeName[] = ["default", "grace", "simple"];
+const THEMES_EXTENDING_DEFAULT = new Set<ThemeName>(["grace", "simple"]);
 
 function stripOutputScope(cssContent: string): string {
   let css = cssContent;
@@ -41,6 +42,7 @@ export function loadThemeCss(theme: ThemeName): {
   themeCss: string;
 } {
   const basePath = path.join(THEME_DIR, "base.css");
+  const defaultThemePath = path.join(THEME_DIR, "default.css");
   const themePath = path.join(THEME_DIR, `${theme}.css`);
 
   if (!fs.existsSync(basePath)) {
@@ -51,9 +53,18 @@ export function loadThemeCss(theme: ThemeName): {
     throw new Error(`Missing theme CSS for "${theme}": ${themePath}`);
   }
 
+  const layeredThemeCss: string[] = [];
+  if (theme !== "default" && THEMES_EXTENDING_DEFAULT.has(theme)) {
+    if (!fs.existsSync(defaultThemePath)) {
+      throw new Error(`Missing default theme CSS: ${defaultThemePath}`);
+    }
+    layeredThemeCss.push(fs.readFileSync(defaultThemePath, "utf-8"));
+  }
+  layeredThemeCss.push(fs.readFileSync(themePath, "utf-8"));
+
   return {
     baseCss: fs.readFileSync(basePath, "utf-8"),
-    themeCss: fs.readFileSync(themePath, "utf-8"),
+    themeCss: layeredThemeCss.join("\n"),
   };
 }
 

skills/baoyu-post-to-x/scripts/vendor/baoyu-chrome-cdp/src/index.test.ts

@@ -0,0 +1,307 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test, { type TestContext } from "node:test";
+
+import {
+  discoverRunningChromeDebugPort,
+  findChromeExecutable,
+  findExistingChromeDebugPort,
+  getFreePort,
+  openPageSession,
+  resolveSharedChromeProfileDir,
+  waitForChromeDebugPort,
+} from "./index.ts";
+
+function useEnv(
+  t: TestContext,
+  values: Record<string, string | null>,
+): void {
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key]);
+    if (value == null) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  t.after(() => {
+    for (const [key, value] of previous.entries()) {
+      if (value == null) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+}
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+async function startDebugServer(port: number): Promise<http.Server> {
+  const server = http.createServer((req, res) => {
+    if (req.url === "/json/version") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+      }));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+
+  return server;
+}
+
+async function closeServer(server: http.Server): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function shellPathForPlatform(): string | null {
+  if (process.platform === "win32") return null;
+  return "/bin/bash";
+}
+
+async function startFakeChromiumProcess(port: number): Promise<ChildProcess | null> {
+  const shell = shellPathForPlatform();
+  if (!shell) return null;
+
+  const child = spawn(
+    shell,
+    [
+      "-lc",
+      `exec -a chromium-mock ${JSON.stringify(process.execPath)} -e 'setInterval(() => {}, 1000)' -- --remote-debugging-port=${port}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  return child;
+}
+
+async function stopProcess(child: ChildProcess | null): Promise<void> {
+  if (!child) return;
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  child.kill("SIGTERM");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolve) => child.once("exit", resolve));
+}
+
+test("getFreePort honors a fixed environment override and otherwise allocates a TCP port", async (t) => {
+  useEnv(t, { TEST_FIXED_PORT: "45678" });
+  assert.equal(await getFreePort("TEST_FIXED_PORT"), 45678);
+
+  const dynamicPort = await getFreePort();
+  assert.ok(Number.isInteger(dynamicPort));
+  assert.ok(dynamicPort > 0);
+});
+
+test("findChromeExecutable prefers env overrides and falls back to candidate paths", async (t) => {
+  const root = await makeTempDir("baoyu-chrome-bin-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const envChrome = path.join(root, "env-chrome");
+  const fallbackChrome = path.join(root, "fallback-chrome");
+  await fs.writeFile(envChrome, "");
+  await fs.writeFile(fallbackChrome, "");
+
+  useEnv(t, { BAOYU_CHROME_PATH: envChrome });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    envChrome,
+  );
+
+  useEnv(t, { BAOYU_CHROME_PATH: null });
+  assert.equal(
+    findChromeExecutable({
+      envNames: ["BAOYU_CHROME_PATH"],
+      candidates: { default: [fallbackChrome] },
+    }),
+    fallbackChrome,
+  );
+});
+
+test("resolveSharedChromeProfileDir supports env overrides, WSL paths, and default suffixes", (t) => {
+  useEnv(t, { BAOYU_SHARED_PROFILE: "/tmp/custom-profile" });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      envNames: ["BAOYU_SHARED_PROFILE"],
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.resolve("/tmp/custom-profile"),
+  );
+
+  useEnv(t, { BAOYU_SHARED_PROFILE: null });
+  assert.equal(
+    resolveSharedChromeProfileDir({
+      wslWindowsHome: "/mnt/c/Users/demo",
+      appDataDirName: "demo-app",
+      profileDirName: "demo-profile",
+    }),
+    path.join("/mnt/c/Users/demo", ".local", "share", "demo-app", "demo-profile"),
+  );
+
+  const fallback = resolveSharedChromeProfileDir({
+    appDataDirName: "demo-app",
+    profileDirName: "demo-profile",
+  });
+  assert.match(fallback, /demo-app[\\/]demo-profile$/);
+});
+
+test("findExistingChromeDebugPort reads DevToolsActivePort and validates it against a live endpoint", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-profile-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await findExistingChromeDebugPort({ profileDir: root, timeoutMs: 1000 });
+  assert.equal(found, port);
+});
+
+test("discoverRunningChromeDebugPort reads DevToolsActivePort from the provided user-data dir", async (t) => {
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  await fs.writeFile(path.join(root, "DevToolsActivePort"), `${port}\n/devtools/browser/demo\n`);
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.deepEqual(found, {
+    port,
+    wsUrl: `ws://127.0.0.1:${port}/devtools/browser/demo`,
+  });
+});
+
+test("discoverRunningChromeDebugPort ignores unrelated debugging processes", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("Process discovery fallback is not used on Windows.");
+    return;
+  }
+
+  const root = await makeTempDir("baoyu-cdp-user-data-");
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+
+  const port = await getFreePort();
+  const server = await startDebugServer(port);
+  t.after(() => closeServer(server));
+
+  const fakeChromium = await startFakeChromiumProcess(port);
+  t.after(async () => { await stopProcess(fakeChromium); });
+
+  const found = await discoverRunningChromeDebugPort({
+    userDataDirs: [root],
+    timeoutMs: 1000,
+  });
+  assert.equal(found, null);
+});
+
+test("openPageSession reports whether it created a new target", async () => {
+  const calls: string[] = [];
+  const cdpExisting = {
+    send: async <T>(method: string): Promise<T> => {
+      calls.push(method);
+      if (method === "Target.getTargets") {
+        return {
+          targetInfos: [{ targetId: "existing-target", type: "page", url: "https://gemini.google.com/app" }],
+        } as T;
+      }
+      if (method === "Target.attachToTarget") return { sessionId: "session-existing" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const existing = await openPageSession({
+    cdp: cdpExisting as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(existing, {
+    sessionId: "session-existing",
+    targetId: "existing-target",
+    createdTarget: false,
+  });
+  assert.deepEqual(calls, ["Target.getTargets", "Target.attachToTarget"]);
+
+  const createCalls: string[] = [];
+  const cdpCreated = {
+    send: async <T>(method: string): Promise<T> => {
+      createCalls.push(method);
+      if (method === "Target.getTargets") return { targetInfos: [] } as T;
+      if (method === "Target.createTarget") return { targetId: "created-target" } as T;
+      if (method === "Target.attachToTarget") return { sessionId: "session-created" } as T;
+      throw new Error(`Unexpected method: ${method}`);
+    },
+  };
+
+  const created = await openPageSession({
+    cdp: cdpCreated as never,
+    reusing: false,
+    url: "https://gemini.google.com/app",
+    matchTarget: (target) => target.url.includes("gemini.google.com"),
+    activateTarget: false,
+  });
+
+  assert.deepEqual(created, {
+    sessionId: "session-created",
+    targetId: "created-target",
+    createdTarget: true,
+  });
+  assert.deepEqual(createCalls, ["Target.getTargets", "Target.createTarget", "Target.attachToTarget"]);
+});
+
+test("waitForChromeDebugPort retries until the debug endpoint becomes available", async (t) => {
+  const port = await getFreePort();
+
+  const serverPromise = (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const server = await startDebugServer(port);
+    t.after(() => closeServer(server));
+  })();
+
+  const websocketUrl = await waitForChromeDebugPort(port, 4000, {
+    includeLastError: true,
+  });
+  await serverPromise;
+
+  assert.equal(websocketUrl, `ws://127.0.0.1:${port}/devtools/browser/demo`);
+});

skills/baoyu-post-to-x/scripts/vendor/baoyu-chrome-cdp/src/index.ts

@@ -43,6 +43,19 @@ type FindExistingChromeDebugPortOptions = {
   timeoutMs?: number;
 };
 
+export type ChromeChannel = "stable" | "beta" | "canary" | "dev";
+
+export type DiscoveredChrome = {
+  port: number;
+  wsUrl: string;
+};
+
+type DiscoverRunningChromeOptions = {
+  channels?: ChromeChannel[];
+  userDataDirs?: string[];
+  timeoutMs?: number;
+};
+
 type LaunchChromeOptions = {
   chromePath: string;
   profileDir: string;
@@ -73,6 +86,7 @@ type OpenPageSessionOptions = {
 export type PageSession = {
   sessionId: string;
   targetId: string;
+  createdTarget: boolean;
 };
 
 export function sleep(ms: number): Promise<void> {
@@ -173,16 +187,32 @@ async function isDebugPortReady(port: number, timeoutMs = 3_000): Promise<boolea
   }
 }
 
+function isPortListening(port: number, timeoutMs = 3_000): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.once("connect", () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.once("error", () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+
+function parseDevToolsActivePort(filePath: string): { port: number; wsPath: string } | null {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
+    const wsPath = lines[1]?.trim();
+    if (port > 0 && wsPath) return { port, wsPath };
+  } catch {}
+  return null;
+}
+
 export async function findExistingChromeDebugPort(options: FindExistingChromeDebugPortOptions): Promise<number | null> {
   const timeoutMs = options.timeoutMs ?? 3_000;
-  const portFile = path.join(options.profileDir, "DevToolsActivePort");
+  const parsed = parseDevToolsActivePort(path.join(options.profileDir, "DevToolsActivePort"));
 
-  try {
-    const content = fs.readFileSync(portFile, "utf-8");
-    const [portLine] = content.split(/\r?\n/);
-    const port = Number.parseInt(portLine?.trim() ?? "", 10);
-    if (port > 0 && await isDebugPortReady(port, timeoutMs)) return port;
-  } catch {}
+  if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs)) return parsed.port;
 
   if (process.platform === "win32") return null;
 
@@ -204,6 +234,88 @@ export async function findExistingChromeDebugPort(options: FindExistingChromeDeb
   return null;
 }
 
+export function getDefaultChromeUserDataDirs(channels: ChromeChannel[] = ["stable"]): string[] {
+  const home = os.homedir();
+  const dirs: string[] = [];
+
+  const channelDirs: Record<string, { darwin: string; linux: string; win32: string }> = {
+    stable: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome"),
+      linux: path.join(home, ".config", "google-chrome"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome", "User Data"),
+    },
+    beta: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Beta"),
+      linux: path.join(home, ".config", "google-chrome-beta"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Beta", "User Data"),
+    },
+    canary: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Canary"),
+      linux: path.join(home, ".config", "google-chrome-canary"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome SxS", "User Data"),
+    },
+    dev: {
+      darwin: path.join(home, "Library", "Application Support", "Google", "Chrome Dev"),
+      linux: path.join(home, ".config", "google-chrome-dev"),
+      win32: path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Google", "Chrome Dev", "User Data"),
+    },
+  };
+
+  const platform = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+
+  for (const ch of channels) {
+    const entry = channelDirs[ch];
+    if (entry) dirs.push(entry[platform]);
+  }
+
+  return dirs;
+}
+
+// Best-effort reuse of an already-running local CDP session discovered from
+// known Chrome user-data dirs. This is distinct from Chrome DevTools MCP's
+// prompt-based --autoConnect flow.
+export async function discoverRunningChromeDebugPort(options: DiscoverRunningChromeOptions = {}): Promise<DiscoveredChrome | null> {
+  const channels = options.channels ?? ["stable", "beta", "canary", "dev"];
+  const timeoutMs = options.timeoutMs ?? 3_000;
+
+  const userDataDirs = (options.userDataDirs ?? getDefaultChromeUserDataDirs(channels))
+    .map((dir) => path.resolve(dir));
+  for (const dir of userDataDirs) {
+    const parsed = parseDevToolsActivePort(path.join(dir, "DevToolsActivePort"));
+    if (!parsed) continue;
+    if (await isPortListening(parsed.port, timeoutMs)) {
+      return { port: parsed.port, wsUrl: `ws://127.0.0.1:${parsed.port}${parsed.wsPath}` };
+    }
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      const result = spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5_000 });
+      if (result.status === 0 && result.stdout) {
+        const lines = result.stdout
+          .split("\n")
+          .filter((line) =>
+            line.includes("--remote-debugging-port=") &&
+            userDataDirs.some((dir) => line.includes(dir))
+          );
+
+        for (const line of lines) {
+          const portMatch = line.match(/--remote-debugging-port=(\d+)/);
+          const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+          if (port > 0 && await isDebugPortReady(port, timeoutMs)) {
+            try {
+              const version = await fetchJson<{ webSocketDebuggerUrl?: string }>(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
+              if (version.webSocketDebuggerUrl) return { port, wsUrl: version.webSocketDebuggerUrl };
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
 export async function waitForChromeDebugPort(
   port: number,
   timeoutMs: number,
@@ -376,10 +488,12 @@ export function killChrome(chrome: ChildProcess): void {
 
 export async function openPageSession(options: OpenPageSessionOptions): Promise<PageSession> {
   let targetId: string;
+  let createdTarget = false;
 
   if (options.reusing) {
     const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
     targetId = created.targetId;
+    createdTarget = true;
   } else {
     const targets = await options.cdp.send<{ targetInfos: ChromeTargetInfo[] }>("Target.getTargets");
     const existing = targets.targetInfos.find(options.matchTarget);
@@ -388,6 +502,7 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
     } else {
       const created = await options.cdp.send<{ targetId: string }>("Target.createTarget", { url: options.url });
       targetId = created.targetId;
+      createdTarget = true;
     }
   }
 
@@ -404,5 +519,5 @@ export async function openPageSession(options: OpenPageSessionOptions): Promise<
   if (options.enableDom) await options.cdp.send("DOM.enable", {}, { sessionId });
   if (options.enableNetwork) await options.cdp.send("Network.enable", {}, { sessionId });
 
-  return { sessionId, targetId };
+  return { sessionId, targetId, createdTarget };
 }