multi-publisher 1.1.2 → 1.1.3

package/README.md

@@ -2,7 +2,7 @@
 
 **一行命令，Markdown 发布到全网。**
 
-将排版好的 Markdown 文章一键发布到微信公众号、知乎、掘金、CSDN 等 20+ 平台，无需手动复制粘贴。支持浏览器自动登录获取 Cookie，14 套渲染主题，是内容创作者的效率神器。
+将排版好的 Markdown 文章一键发布到微信公众号、知乎、掘金、CSDN 等 20+ 平台，无需手动复制粘贴。支持浏览器自动登录获取 Cookie，4 套精排渲染主题（按平台自动匹配），是内容创作者的效率神器。
 
 ---
 
@@ -12,7 +12,7 @@
 |------|------|
 | **多平台支持** | 微信公众号、知乎、掘金、CSDN、微博、小红书、B站等 20+ 平台 |
 | **浏览器自动登录** | Playwright 驱动扫码/账号登录，Cookie 自动获取保存 |
-| **14 套渲染主题** | default、wechat、modern、minimal、cyberpunk、nord、paper、darkelite、sunset、zen、retro、midnight、brutalism、neumorphism |
+| **4 套精排主题** | default（通用）、wechat（公众号）、modern（技术/知乎）、minimal（轻阅读/头条），均按平台自动匹配 |
 | **自动封面图生成** | AI 根据标题生成封面图，自动上传到微信 CDN |
 | **Markdown 直发** | front-matter 元数据、代码高亮、LaTeX 公式 |
 | **CI/CD 友好** | 纯命令行无需浏览器，配置文件统一管理 |
@@ -39,7 +39,7 @@ mpub --version
 ```bash
 # 在任意 Claude Code 对话中，直接描述你的需求：
 # "帮我把这篇 article.md 发布到微信公众号"
-# "用 cyberpunk 主题渲染预览一下"
+# "用 wechat 主题渲染预览一下"
 # AI 会调用 mpub 完成操作
 ```
 
@@ -95,7 +95,7 @@ mpub publish-all -f article.md
 mpub render -f article.md
 
 # 指定主题渲染
-mpub render -f article.md -t cyberpunk
+mpub render -f article.md -t wechat
 
 # 自动封面图（文章无封面时 AI 生成）
 mpub publish -f article.md -p weixin --auto-cover
@@ -152,37 +152,43 @@ mpub platforms
 
 ## 主题系统
 
-### 🎨 14 套内置主题
+### 🎨 4 套内置主题（按平台自动匹配）
 
-完整预览：[themes/all-themes-preview.html](themes/all-themes-preview.html)
+mpub 内置 4 套浅色阅读主题，均针对公众号 / 知乎 / 头条等白底平台的真实排版规范做了优化：
+
+| 主题 | 风格 | 适配平台 |
+|------|------|----------|
+| `default` | 通用简洁，绿调标题/引用 | 兜底，所有平台可用 |
+| `wechat` | 微信官方排版（微信蓝链接、浅灰代码块、圆角图） | 微信公众号 |
+| `modern` | 深色代码块、清晰层次（知乎/网页友好） | 知乎、技术博客 |
+| `minimal` | 极简留白、轻装饰 | 头条号等轻阅读平台 |
 
-**主题截图示例：**
+**平台自动匹配**：未用 `-t` 指定主题时，发布按平台自动选默认主题——
+微信 → `wechat`，知乎 → `modern`，头条 → `minimal`，其余回退 `default`。
+（手动 `-t` 仍可覆盖。）
 
-| 风格 | 代表主题 | 预览 |
-|------|----------|------|
-| 技术博客 | Cyberpunk | ![Cyberpunk](themes/previews/cyberpunk.png) |
-| 程序员 | Nord | ![Nord](themes/previews/nord.png) |
-| 微信风格 | Wechat | ![Wechat](themes/previews/wechat.png) |
-| 简约 | Minimal | ![Minimal](themes/previews/minimal.png) |
+完整预览：[themes/all-themes-preview.html](themes/all-themes-preview.html)
 
 **命令行预览：**
 ```bash
-mpub render -f article.md -t cyberpunk
-mpub render -f article.md -t nord
-mpub render -f article.md -t paper
+mpub render -f article.md -t wechat
+mpub render -f article.md -t modern
+mpub render -f article.md -t minimal
 ```
 
-**全部 14 主题：** default、wechat、modern、minimal、cyberpunk、nord、paper、darkelite、sunset、zen、retro、midnight、brutalism、neumorphism
+**全部 4 主题：** default、wechat、modern、minimal
 
 ### 使用主题
 
 ```bash
-# 渲染时指定主题
-mpub render -f article.md -t cyberpunk
-mpub render -f article.md -t nord
-mpub render -f article.md -t paper
+# 不指定主题：发布到微信自动用 wechat，知乎自动用 modern
+mpub publish -f article.md -p weixin
+mpub publish -f article.md -p zhihu
+
+# 渲染时手动指定主题
+mpub render -f article.md -t wechat
 
-# 发布时指定主题
+# 发布时手动覆盖主题
 mpub publish -f article.md -t modern -p zhihu
 ```
 

package/dist/adapters/csdn.js

@@ -1,5 +1,6 @@
 import { ConfigStore } from '../config.js';
 import { uploadCoverViaBrowser } from '../tools/browser-upload.js';
+import { downloadCoverUrl } from '../tools/cover-fetcher.js';
 import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -261,15 +262,30 @@ export class CSDNAdapter {
             }
             const postId = res.data.id;
             const draftUrl = `https://editor.csdn.net/md?articleId=${postId}`;
-            // 如果有封面图片，通过浏览器自动化上传
-            if (article.cover && existsSync(article.cover)) {
-                console.log(`[CSDN] 封面上传中...`);
-                const coverResult = await uploadCoverViaBrowser(postId, article.cover);
-                if (coverResult.success && coverResult.coverUrl) {
-                    console.log(`[CSDN] 封面 URL: ${coverResult.coverUrl}`);
+            // 如果有封面图片，先下载 URL 封面到本地，再通过浏览器上传
+            if (article.cover) {
+                let localCover = article.cover;
+                // 如果是 URL 封面，先下载到本地
+                if (!existsSync(article.cover)) {
+                    console.log(`[CSDN] 封面是 URL，正在下载到本地...`);
+                    const downloadResult = await downloadCoverUrl(article.cover);
+                    if (!downloadResult.success || !downloadResult.localPath) {
+                        console.warn(`[CSDN] 封面下载失败: ${downloadResult.error}，跳过封面上传`);
+                    }
+                    else {
+                        localCover = downloadResult.localPath;
+                        console.log(`[CSDN] 封面下载成功: ${localCover}`);
+                    }
                 }
-                else {
-                    console.warn(`[CSDN] 封面上传失败: ${coverResult.error}`);
+                if (existsSync(localCover)) {
+                    console.log(`[CSDN] 封面上传中...`);
+                    const coverResult = await uploadCoverViaBrowser(postId, localCover);
+                    if (coverResult.success && coverResult.coverUrl) {
+                        console.log(`[CSDN] 封面 URL: ${coverResult.coverUrl}`);
+                    }
+                    else {
+                        console.warn(`[CSDN] 封面上传失败: ${coverResult.error}`);
+                    }
                 }
             }
             return {

package/dist/adapters/interface.d.ts

@@ -36,9 +36,19 @@ export interface AuthResult {
     avatar?: string;
     error?: string;
 }
+export interface MermaidProcessResult {
+    html: string;
+    tempFiles: string[];
+}
 export interface IPlatformAdapter {
     readonly meta: PlatformMeta;
     init(runtime: RuntimeInterface): Promise<void>;
     checkAuth(): Promise<AuthResult>;
+    /**
+     * 可选钩子：自定义处理 Mermaid 代码块
+     * 如果平台不支持原生 Mermaid 渲染，实现此方法进行转换
+     * 返回处理后的 HTML 和需要清理的临时文件路径
+     */
+    processMermaid?(html: string): Promise<MermaidProcessResult>;
     publish(article: Article): Promise<SyncResult>;
 }

package/dist/adapters/qq.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 企鹅号适配器
+ * 认证方式: Cookie
+ * 发布方式: API (editorCache/update)
+ */
+import type { IPlatformAdapter, Article, SyncResult, AuthResult, PlatformMeta } from './interface.js';
+import type { RuntimeInterface } from '../runtime/index.js';
+export declare class QQAdapter implements IPlatformAdapter {
+    readonly meta: PlatformMeta;
+    private runtime;
+    init(runtime: RuntimeInterface): Promise<void>;
+    private getCookies;
+    checkAuth(): Promise<AuthResult>;
+    /**
+     * 上传封面图片到企鹅号，返回图片 URL
+     */
+    private uploadCover;
+    publish(article: Article): Promise<SyncResult>;
+}

package/dist/adapters/qq.js

@@ -0,0 +1,185 @@
+import { ConfigStore } from '../config.js';
+import { existsSync } from 'node:fs';
+export class QQAdapter {
+    meta = {
+        id: 'qq',
+        name: '企鹅号',
+        icon: 'https://inews.gtimg.com/news_lite/20210806/favicon.ico',
+        homepage: 'https://om.qq.com/',
+        capabilities: ['article', 'draft', 'image_upload'],
+    };
+    runtime;
+    async init(runtime) {
+        this.runtime = runtime;
+    }
+    async getCookies() {
+        return await ConfigStore.getQQCookies();
+    }
+    async checkAuth() {
+        const cookieData = await this.getCookies();
+        if (!cookieData || Object.keys(cookieData).length === 0) {
+            return { isAuthenticated: false, error: '未配置企鹅号 Cookie，请运行: mpub login --platform qq' };
+        }
+        if (!cookieData['userid']) {
+            return { isAuthenticated: false, error: 'Cookie 中缺少 userid，可能登录已失效' };
+        }
+        try {
+            return {
+                isAuthenticated: true,
+                userId: cookieData['userid'],
+                username: cookieData['pt2gguin'] ? `o${cookieData['pt2gguin']}` : undefined,
+            };
+        }
+        catch (err) {
+            return { isAuthenticated: false, error: err.message };
+        }
+    }
+    /**
+     * 上传封面图片到企鹅号，返回图片 URL
+     */
+    async uploadCover(imagePath, cookieStr) {
+        const FormData = require('form-data');
+        const fs = require('fs');
+        const form = new FormData();
+        const fileBuffer = fs.readFileSync(imagePath);
+        const fileName = imagePath.split(/[\\/]/).pop() || 'image.jpg';
+        form.append('file', fileBuffer, {
+            filename: fileName,
+            contentType: 'image/jpeg',
+        });
+        const response = await this.runtime.fetch('https://image.om.qq.com/cpom_pimage/ArchacaleUploadViaFile', {
+            method: 'POST',
+            headers: {
+                'Cookie': cookieStr,
+                'Referer': 'https://om.qq.com/',
+                'X-Requested-With': 'XMLHttpRequest',
+                ...form.getHeaders(),
+            },
+            body: form,
+        });
+        if (!response.ok) {
+            return null;
+        }
+        try {
+            const data = await response.json();
+            if (data.code === 0 && data.data?.url) {
+                const urlData = data.data.url;
+                return urlData['640']?.imageUrl || urlData['0']?.imageUrl || Object.values(urlData)[0]?.imageUrl || null;
+            }
+        }
+        catch { }
+        return null;
+    }
+    async publish(article) {
+        const start = Date.now();
+        try {
+            const cookieData = await this.getCookies();
+            if (!cookieData || Object.keys(cookieData).length === 0) {
+                throw new Error('未配置企鹅号 Cookie，请运行: mpub login --platform qq');
+            }
+            const cookieStr = Object.entries(cookieData)
+                .map(([k, v]) => `${k}=${v}`)
+                .join('; ');
+            const mediaId = cookieData['userid'];
+            // 上传封面（如果有）
+            let coverUrl = '';
+            if (article.cover && existsSync(article.cover)) {
+                try {
+                    coverUrl = await this.uploadCover(article.cover, cookieStr) || '';
+                    console.log(`[QQ] 封面上传结果: ${coverUrl || '失败'}`);
+                }
+                catch (err) {
+                    console.warn(`封面图上传失败: ${err.message}`);
+                }
+            }
+            // 构建文章数据
+            const articleData = {
+                title: article.title,
+                title2: '',
+                tag: '',
+                video: '',
+                cover_type: coverUrl ? '1' : '1',
+                imgurl_ext: '[]',
+                category_id: '',
+                content: `<p>${(article.markdown || article.html || '').replace(/<[^>]+>/g, '')}</p>`,
+                orignal: 0,
+                user_original: 0,
+                music: '',
+                activity: '',
+                apply_olympic_flag: 0,
+                apply_push_flag: 0,
+                apply_reward_flag: 0,
+                reward_flag: 0,
+                survey_id: '',
+                survey_name: '',
+                imgurlsrc: coverUrl || null,
+                om_activity_id: '',
+                om_activity_name: '',
+                activityInfo: '',
+                commercialization_source: '',
+                caiMaiInfo: '',
+                isHowto: '0',
+                howtoInfo: '',
+                daihuoInfo: '',
+                novel: '',
+                needpub: 1,
+                event_id: '',
+                event_name: '',
+                activity_scene_id: 0,
+                hotBreak: '',
+                self_declare: '',
+                resource_aigc_mark_info: '{}',
+                parent_article_id: '',
+                conclusion: '',
+                summary: article.summary || '',
+                failedImage: [],
+                adContentImgs: [],
+                mediaId: mediaId,
+                type: 0,
+                unmount: false,
+            };
+            // 发送保存请求
+            const postData = new URLSearchParams();
+            postData.append('cache', JSON.stringify(articleData));
+            postData.append('mediaid', mediaId);
+            const response = await this.runtime.fetch('https://om.qq.com/editorCache/update', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Cookie': cookieStr,
+                    'Referer': 'https://om.qq.com/main/creation/article',
+                },
+                body: postData.toString(),
+            });
+            const responseText = await response.text();
+            if (!response.ok) {
+                throw new Error(`保存文章失败: ${response.status} - ${responseText.substring(0, 100)}`);
+            }
+            let resultData;
+            try {
+                resultData = JSON.parse(responseText);
+            }
+            catch {
+                throw new Error(`保存响应无效: ${responseText.substring(0, 100)}`);
+            }
+            if (resultData.response?.code !== '0') {
+                throw new Error(resultData.response?.msg || '保存文章失败');
+            }
+            return {
+                platform: this.meta.id,
+                success: true,
+                draftOnly: true, // 企鹅号需要审核
+                timestamp: Date.now() - start,
+                postUrl: 'https://om.qq.com/main/creation/article',
+            };
+        }
+        catch (err) {
+            return {
+                platform: this.meta.id,
+                success: false,
+                error: err.message,
+                timestamp: Date.now() - start,
+            };
+        }
+    }
+}

package/dist/adapters/registry.js

@@ -18,6 +18,7 @@ import { YuqueAdapter } from './yuque.js';
 import { Cto51Adapter } from './cto51.js';
 import { ToutiaoAdapter } from './toutiao.js';
 import { XiaohongshuAdapter } from './xiaohongshu.js';
+import { QQAdapter } from './qq.js';
 // 所有适配器类
 const ADAPTER_CLASSES = {
     weixin: WeixinAdapter,
@@ -40,6 +41,7 @@ const ADAPTER_CLASSES = {
     cto51: Cto51Adapter,
     toutiao: ToutiaoAdapter,
     xiaohongshu: XiaohongshuAdapter,
+    qq: QQAdapter,
 };
 /**
  * 适配器注册表

package/dist/adapters/toutiao.d.ts

@@ -4,6 +4,10 @@ export declare class ToutiaoAdapter implements IPlatformAdapter {
     private cookieData;
     init(): Promise<void>;
     checkAuth(): Promise<AuthResult>;
+    processMermaid(html: string): Promise<{
+        html: string;
+        tempFiles: string[];
+    }>;
     publish(article: Article): Promise<SyncResult>;
 }
 import type { IPlatformAdapter } from './interface.js';

package/dist/adapters/toutiao.js

@@ -5,7 +5,12 @@
 import { chromium } from 'playwright';
 import { ConfigStore } from '../config.js';
 import { existsSync } from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import os from 'os';
+import { downloadCoverUrl } from '../tools/cover-fetcher.js';
+import { processMermaid } from '../core/renderer.js';
+import { uploadImageToPublicUrl } from '../tools/imgbb-uploader.js';
 export class ToutiaoAdapter {
     meta = {
         id: 'toutiao',
@@ -28,6 +33,27 @@ export class ToutiaoAdapter {
         }
         return { isAuthenticated: true };
     }
+    async processMermaid(html) {
+        const { html: processed, tempFiles } = await processMermaid(html, os.tmpdir());
+        // 上传图片到 ImgBB 获取公开 URL
+        let result = processed;
+        const imgPattern = /<img\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
+        for (const match of [...processed.matchAll(imgPattern)]) {
+            const original = match[0];
+            const src = match[1];
+            if (!src.startsWith('http://') && !src.startsWith('https://')) {
+                try {
+                    const url = await uploadImageToPublicUrl(src);
+                    result = result.replace(original, original.replace(src, url));
+                    console.log(`[toutiao] mermaid 图片已上传: ${url}`);
+                }
+                catch (err) {
+                    console.warn(`[toutiao] mermaid 图片上传失败 ${src}: ${err.message}`);
+                }
+            }
+        }
+        return { html: result, tempFiles };
+    }
     async publish(article) {
         const start = Date.now();
         if (!this.cookieData) {
@@ -38,6 +64,13 @@ export class ToutiaoAdapter {
                 timestamp: Date.now() - start,
             };
         }
+        // 处理 Mermaid 代码块（转换为图片并上传到公开 URL）
+        let processedArticle = article;
+        if (this.processMermaid && article.html) {
+            const { html: mermaidHtml, tempFiles } = await this.processMermaid(article.html);
+            processedArticle = { ...article, html: mermaidHtml };
+            await Promise.all(tempFiles.map(f => fs.unlink(f).catch(() => { })));
+        }
         const browser = await chromium.launch({
             headless: false,
             args: [
@@ -95,7 +128,7 @@ export class ToutiaoAdapter {
             catch { }
             // 填写标题
             const titleTextarea = page.locator('textarea').first();
-            await titleTextarea.fill(article.title);
+            await titleTextarea.fill(processedArticle.title);
             console.log('[toutiao] 已填写标题');
             // 填写内容
             const contentEl = page.locator('div[contenteditable="true"]').first();
@@ -103,7 +136,7 @@ export class ToutiaoAdapter {
                 await contentEl.click();
                 await page.keyboard.press('Control+a');
                 await page.waitForTimeout(200);
-                const htmlContent = article.html || article.markdown || '';
+                const htmlContent = processedArticle.html || processedArticle.markdown || '';
                 await page.evaluate((el) => {
                     const div = document.querySelector('[contenteditable="true"]');
                     if (div) {
@@ -114,58 +147,139 @@ export class ToutiaoAdapter {
                 console.log('[toutiao] 已填写内容');
                 await page.waitForTimeout(1000);
             }
-            // 如果有封面图片，先上传封面再发布
-            if (article.cover && existsSync(article.cover)) {
-                console.log('[toutiao] 检测到封面图片，准备上传...');
-                // 点击"预览并发布"按钮打开预览弹窗
-                const previewBtn = page.locator('button:has-text("预览并发布")');
-                if (await previewBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
-                    await previewBtn.click({ force: true });
-                    console.log('[toutiao] 点击预览并发布按钮');
-                    await page.waitForTimeout(2000);
-                    // 选择"单图"选项
-                    const singleImg = page.locator('text=单图').first();
-                    if (await singleImg.isVisible({ timeout: 2000 }).catch(() => false)) {
-                        await singleImg.click();
-                        console.log('[toutiao] 选择单图');
-                        await page.waitForTimeout(500);
-                    }
-                    // 设置 filechooser 监听
-                    const absolutePath = path.resolve(article.cover);
-                    page.on('filechooser', async (fileChooser) => {
-                        console.log('[toutiao] 收到 filechooser，设置封面文件');
-                        await fileChooser.setFiles(absolutePath);
-                    });
-                    // 点击封面添加区域
-                    const coverAdd = page.locator('.article-cover-add');
-                    if (await coverAdd.isVisible({ timeout: 2000 }).catch(() => false)) {
-                        await coverAdd.click({ force: true });
-                        console.log('[toutiao] 点击了封面添加区域');
-                        await page.waitForTimeout(1500);
+            // 如果有封面图片，先下载 URL 封面到本地，再上传
+            if (processedArticle.cover) {
+                let localCover = processedArticle.cover;
+                // 如果是 URL 封面，先下载到本地
+                if (!existsSync(processedArticle.cover)) {
+                    console.log('[toutiao] 封面是 URL，正在下载到本地...');
+                    const downloadResult = await downloadCoverUrl(processedArticle.cover);
+                    if (!downloadResult.success || !downloadResult.localPath) {
+                        console.warn(`[toutiao] 封面下载失败: ${downloadResult.error}，跳过封面上传`);
                     }
-                    // 点击"本地上传"
-                    const localUpload = page.locator('text=本地上传');
-                    if (await localUpload.isVisible({ timeout: 3000 }).catch(() => false)) {
-                        await localUpload.click();
-                        console.log('[toutiao] 点击本地上传');
-                        await page.waitForTimeout(1500);
+                    else {
+                        localCover = downloadResult.localPath;
+                        console.log(`[toutiao] 封面下载成功: ${localCover}`);
                     }
-                    // 点击"确定"按钮
-                    const confirmBtn = page.locator('button:has-text("确定")').filter({ visible: true });
-                    try {
-                        if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
-                            const disabled = await confirmBtn.first().isDisabled().catch(() => true);
-                            if (!disabled) {
-                                await confirmBtn.first().click();
-                                console.log('[toutiao] 点击确定按钮，封面上传完成');
+                }
+                if (existsSync(localCover)) {
+                    console.log('[toutiao] 检测到封面图片，准备上传...');
+                    // 设置 filechooser 监听（必须在点击之前设置）
+                    const absolutePath = path.resolve(localCover);
+                    console.log('[toutiao] 封面文件路径:', absolutePath);
+                    // 使用 promise 等待 filechooser 事件
+                    const fileChooserPromise = page.waitForEvent('filechooser', { timeout: 10000 });
+                    // 点击"预览并发布"按钮打开预览弹窗
+                    const previewBtn = page.locator('button:has-text("预览并发布")');
+                    if (await previewBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
+                        await previewBtn.click({ force: true });
+                        console.log('[toutiao] 点击预览并发布按钮');
+                        await page.waitForTimeout(2000);
+                        // 选择"单图"选项
+                        const singleImg = page.locator('text=单图').first();
+                        if (await singleImg.isVisible({ timeout: 2000 }).catch(() => false)) {
+                            await singleImg.click();
+                            console.log('[toutiao] 选择单图');
+                            await page.waitForTimeout(500);
+                        }
+                        // 点击封面添加区域
+                        const coverAdd = page.locator('.article-cover-add');
+                        if (await coverAdd.isVisible({ timeout: 2000 }).catch(() => false)) {
+                            await coverAdd.click({ force: true });
+                            console.log('[toutiao] 点击了封面添加区域');
+                            await page.waitForTimeout(1500);
+                        }
+                        // 点击"本地上传"
+                        const localUpload = page.locator('text=本地上传');
+                        if (await localUpload.isVisible({ timeout: 3000 }).catch(() => false)) {
+                            await localUpload.click();
+                            console.log('[toutiao] 点击本地上传');
+                            await page.waitForTimeout(1500);
+                        }
+                        let fileSet = false;
+                        // 直接查找文件输入框，不依赖 filechooser 事件
+                        console.log('[toutiao] 尝试直接设置文件输入框...');
+                        const fileInput = page.locator('input[type="file"]').first();
+                        if (await fileInput.isVisible({ timeout: 2000 }).catch(() => false)) {
+                            console.log('[toutiao] 找到文件输入框，直接设置文件');
+                            await fileInput.setInputFiles(absolutePath);
+                            fileSet = true;
+                        }
+                        else {
+                            // 文件输入框可能是 hidden，用 setInputFiles 即使不可见也可以设置
+                            console.log('[toutiao] 文件输入框不可见，尝试直接 setInputFiles');
+                            const allInputs = page.locator('input[type="file"]');
+                            const count = await allInputs.count();
+                            console.log(`[toutiao] 页面中有 ${count} 个 file 输入框`);
+                            if (count > 0) {
+                                await allInputs.first().setInputFiles(absolutePath);
+                                fileSet = true;
+                                console.log('[toutiao] 已对第一个 file 输入框设置文件');
                             }
                         }
+                        if (!fileSet) {
+                            // 尝试点击本地上传但使用另一种方式
+                            const localUpload = page.locator('text=本地上传');
+                            if (await localUpload.isVisible({ timeout: 3000 }).catch(() => false)) {
+                                await localUpload.click();
+                                console.log('[toutiao] 点击本地上传');
+                                await page.waitForTimeout(1500);
+                                // 点击后重新查找文件输入框
+                                const newInputs = page.locator('input[type="file"]');
+                                const newCount = await newInputs.count();
+                                console.log(`[toutiao] 点击后有 ${newCount} 个 file 输入框`);
+                                if (newCount > 0) {
+                                    await newInputs.first().setInputFiles(absolutePath);
+                                    fileSet = true;
+                                    console.log('[toutiao] 点击后设置文件成功');
+                                }
+                            }
+                        }
+                        if (fileSet) {
+                            // 等待封面上传
+                            console.log('[toutiao] 等待封面上传...');
+                            await page.waitForTimeout(5000);
+                            // 检测封面是否上传成功
+                            const coverFound = await page.evaluate(() => {
+                                const imgs = document.querySelectorAll('img');
+                                for (const img of imgs) {
+                                    const htmlImg = img;
+                                    if (htmlImg.src && htmlImg.naturalWidth > 0) {
+                                        // 检查是否是封面相关的图片
+                                        const parent = htmlImg.closest('[class*="cover"], [class*="preview"]');
+                                        if (parent)
+                                            return true;
+                                    }
+                                }
+                                return false;
+                            });
+                            if (coverFound) {
+                                console.log('[toutiao] 封面上传成功');
+                            }
+                            else {
+                                console.log('[toutiao] 未检测到明确的上传成功标志');
+                            }
+                        }
+                        else {
+                            console.log('[toutiao] 未能设置封面文件');
+                        }
+                        // 点击"确定"按钮
+                        const confirmBtn = page.locator('button:has-text("确定")').filter({ visible: true });
+                        try {
+                            if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+                                const disabled = await confirmBtn.first().isDisabled().catch(() => true);
+                                if (!disabled) {
+                                    await confirmBtn.first().click();
+                                    console.log('[toutiao] 点击确定按钮，封面上传完成');
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.log('[toutiao] 确定按钮点击失败:', e.message);
+                        }
+                        // 等待封面上传保存（头条号会自动保存）
+                        await page.waitForTimeout(5000);
                     }
-                    catch (e) {
-                        console.log('[toutiao] 确定按钮点击失败:', e.message);
-                    }
-                    // 等待封面上传保存（头条号会自动保存）
-                    await page.waitForTimeout(5000);
                 }
             }
             // 关闭预览弹窗（如果还在的话）