multi-publisher 1.1.1 → 1.1.2

package/dist/adapters/csdn.d.ts

@@ -24,6 +24,21 @@ export declare class CSDNAdapter implements IPlatformAdapter {
      * 生成 CSDN API 签名
      */
     private signRequest;
+    /**
+     * 上传图片到 CSDN
+     * 流程：1. 调用签名 API 获取 policy 2. 直接上传到华为云 OBS
+     * @param imagePath 本地文件路径或网络 URL
+     * @returns CSDN 图片 URL
+     */
+    uploadImage(imagePath: string): Promise<string>;
+    /**
+     * 获取华为云 OBS 上传签名
+     */
+    private getUploadSignature;
+    /**
+     * 处理封面图：上传本地文件或使用网络 URL
+     */
+    private processCover;
     checkAuth(): Promise<AuthResult>;
     publish(article: Article): Promise<SyncResult>;
 }

package/dist/adapters/csdn.js

@@ -1,8 +1,15 @@
 import { ConfigStore } from '../config.js';
+import { uploadCoverViaBrowser } from '../tools/browser-upload.js';
 import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
 // CSDN API 签名密钥
 const API_KEY = '203803574';
 const API_SECRET = '9znpamsyl2c7cdrr9sas0le9vbc3r6ba';
+// 封面图上传 API 的 key 和 secret
+const COVER_API_KEY = '260196572';
+const COVER_API_SECRET = 't5PaqxVQpWoHgLGt7XPIvd5ipJcwJTU7';
 export class CSDNAdapter {
     meta = {
         id: 'csdn',
@@ -75,6 +82,106 @@ export class CSDNAdapter {
         }
         return headers;
     }
+    /**
+     * 上传图片到 CSDN
+     * 流程：1. 调用签名 API 获取 policy 2. 直接上传到华为云 OBS
+     * @param imagePath 本地文件路径或网络 URL
+     * @returns CSDN 图片 URL
+     */
+    async uploadImage(imagePath) {
+        if (!this.cookieData?.cookies) {
+            throw new Error('未配置 CSDN Cookie');
+        }
+        // 如果是网络 URL，直接返回
+        if (imagePath.startsWith('http://') || imagePath.startsWith('https://')) {
+            return imagePath;
+        }
+        // 读取本地文件
+        const fileBuffer = await fs.readFile(imagePath);
+        const filename = path.basename(imagePath);
+        const ext = path.extname(filename).toLowerCase();
+        const imageSuffix = ext.replace('.', '');
+        try {
+            // 步骤 1: 获取上传签名 (policy)
+            const signatureData = await this.getUploadSignature(imageSuffix);
+            const { accessId, policy, signature, host, dir } = signatureData;
+            // 步骤 2: 直接上传到华为云 OBS
+            const objectKey = `${dir}${filename}`;
+            const obsUrl = `${host}/${objectKey}`;
+            const formData = new FormData();
+            formData.append('key', objectKey);
+            formData.append('OSSAccessKeyId', accessId);
+            formData.append('policy', policy);
+            formData.append('signature', signature);
+            formData.append('expire', signatureData.expire);
+            formData.append('file', new Blob([fileBuffer]), filename);
+            const response = await this.runtime.fetch(obsUrl, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`OBS 上传失败: ${response.status}`);
+            }
+            // 返回 CSDN 图片 URL
+            return `https://csdn-img-blog.obs.cn-north-4.myhuaweicloud.com/${objectKey}`;
+        }
+        catch (apiError) {
+            throw new Error(`封面 API 上传失败: ${apiError.message}`);
+        }
+    }
+    /**
+     * 获取华为云 OBS 上传签名
+     */
+    async getUploadSignature(imageSuffix) {
+        const cookieStr = this.buildCookieString(this.cookieData);
+        // CSDN 封面图签名 API 使用的 key 和之前的不同
+        const coverApiKey = '260196572';
+        const nonce = this.createUuid();
+        const timestamp = Date.now().toString();
+        const apiPath = '/resource-api/v1/image/direct/upload/signature';
+        // 按照 Lt 函数格式: method\naccept\n\ncontentType\ntimestamp\n(sorted headers)\nurl
+        const signStr = `POST\n*/*\n\napplication/json\n${timestamp}\nx-ca-key:${coverApiKey}\nx-ca-nonce:${nonce}\nx-ca-timestamp:${timestamp}\n${apiPath}`;
+        // 封面签名使用专用的 secret
+        const signature = await this.hmacSha256(signStr, COVER_API_SECRET);
+        const response = await this.runtime.fetch(`https://bizapi.csdn.net${apiPath}`, {
+            method: 'POST',
+            headers: {
+                'accept': 'application/json',
+                'x-ca-key': coverApiKey,
+                'x-ca-nonce': nonce,
+                'x-ca-timestamp': timestamp,
+                'x-ca-signature': signature,
+                'x-ca-signature-headers': 'x-ca-key,x-ca-nonce,x-ca-timestamp',
+                'content-type': 'application/json',
+                'Cookie': cookieStr,
+            },
+            body: JSON.stringify({
+                imageTemplate: '',
+                appName: 'direct_blog_coverimage',
+                imageSuffix,
+            }),
+        });
+        const res = await response.json();
+        if (res.code !== 200 || !res.data) {
+            throw new Error(res.message || '获取上传签名失败');
+        }
+        return res.data;
+    }
+    /**
+     * 处理封面图：上传本地文件或使用网络 URL
+     */
+    async processCover(cover) {
+        if (!cover)
+            return [];
+        try {
+            const coverUrl = await this.uploadImage(cover);
+            return [coverUrl];
+        }
+        catch (err) {
+            console.warn(`[CSDN] 封面上传失败: ${err.message}`);
+            return [];
+        }
+    }
     async checkAuth() {
         if (!this.cookieData?.cookies) {
             return { isAuthenticated: false, error: '未配置 CSDN Cookie，请运行: mpub cookie --platform csdn --set' };
@@ -118,6 +225,7 @@ export class CSDNAdapter {
             // 生成签名
             const apiPath = '/blog-console-api/v3/mdeditor/saveArticle';
             const headers = await this.signRequest(apiPath);
+            // 先发布文章（不带封面，因为 API 签名有问题）
             const response = await this.runtime.fetch(`https://bizapi.csdn.net${apiPath}`, {
                 method: 'POST',
                 headers: {
@@ -139,7 +247,7 @@ export class CSDNAdapter {
                     not_auto_saved: '1',
                     source: 'pc_mdeditor',
                     cover_images: [],
-                    cover_type: 1,
+                    cover_type: 0,
                     is_new: 1,
                     vote_id: 0,
                     resource_id: '',
@@ -153,6 +261,17 @@ 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}`);
+                }
+                else {
+                    console.warn(`[CSDN] 封面上传失败: ${coverResult.error}`);
+                }
+            }
             return {
                 platform: this.meta.id,
                 success: true,

package/dist/adapters/toutiao.js

@@ -4,6 +4,8 @@
  */
 import { chromium } from 'playwright';
 import { ConfigStore } from '../config.js';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
 export class ToutiaoAdapter {
     meta = {
         id: 'toutiao',
@@ -22,7 +24,7 @@ export class ToutiaoAdapter {
         }
         const hasSession = this.cookieData['sessionid'] || this.cookieData['sid_tt'];
         if (!hasSession) {
-            return { isAuthenticated: false, error: '未登录或登录已过期' };
+            return { isAuthenticated: false, error: '登录已过期' };
         }
         return { isAuthenticated: true };
     }
@@ -99,7 +101,6 @@ export class ToutiaoAdapter {
             const contentEl = page.locator('div[contenteditable="true"]').first();
             if (await contentEl.isVisible({ timeout: 2000 }).catch(() => false)) {
                 await contentEl.click();
-                // 使用 Ctrl+A 全选，然后输入内容（模拟用户输入）
                 await page.keyboard.press('Control+a');
                 await page.waitForTimeout(200);
                 const htmlContent = article.html || article.markdown || '';
@@ -107,59 +108,109 @@ export class ToutiaoAdapter {
                     const div = document.querySelector('[contenteditable="true"]');
                     if (div) {
                         div.innerHTML = el;
-                        // 触发 input 事件
                         div.dispatchEvent(new InputEvent('input', { bubbles: true }));
                     }
                 }, htmlContent);
                 console.log('[toutiao] 已填写内容');
                 await page.waitForTimeout(1000);
             }
-            // 等待编辑器自动保存（最多5秒）
-            console.log('[toutiao] 等待编辑器自动保存（5秒）...');
-            for (let i = 0; i < 5; i++) {
-                const url = page.url();
-                if (url.includes('id=')) {
-                    console.log('[toutiao] 检测到文章 ID，保存完成');
-                    break;
+            // 如果有封面图片，先上传封面再发布
+            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);
+                    }
+                    // 点击"本地上传"
+                    const localUpload = page.locator('text=本地上传');
+                    if (await localUpload.isVisible({ timeout: 3000 }).catch(() => false)) {
+                        await localUpload.click();
+                        console.log('[toutiao] 点击本地上传');
+                        await page.waitForTimeout(1500);
+                    }
+                    // 点击"确定"按钮
+                    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);
                 }
-                await page.waitForTimeout(1000);
-            }
-            // 检查 URL 是否包含文章 ID
-            let currentUrl = page.url();
-            let idMatch = currentUrl.match(/[?&]id=(\d+)/);
-            let savedId = idMatch ? idMatch[1] : null;
-            if (idMatch) {
-                console.log('[toutiao] 检测到文章 ID:', idMatch[1]);
             }
-            else {
-                console.log('[toutiao] URL 仍未变化:', currentUrl);
-            }
-            // 尝试点击"发布"按钮触发保存
-            console.log('[toutiao] 尝试点击发布按钮...');
+            // 关闭预览弹窗（如果还在的话）
             try {
-                // 查找发布按钮（可能在右上角或底部）
-                const publishBtn = page.locator('button').filter({ hasText: /^发布$/ }).first();
-                if (await publishBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
-                    await publishBtn.click({ force: true });
-                    console.log('[toutiao] 已点击发布按钮');
-                    // 等待保存完成
-                    await page.waitForTimeout(10000);
+                const continueBtn = page.locator('button:has-text("继续编辑")');
+                if (await continueBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+                    await continueBtn.click({ force: true });
+                    await page.waitForTimeout(2000);
                 }
                 else {
-                    // 如果没找到发布按钮，尝试保存按钮
-                    const saveBtn = page.locator('button').filter({ hasText: /保存草稿|保存/ }).first();
-                    if (await saveBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
-                        await saveBtn.click({ force: true });
-                        console.log('[toutiao] 已点击保存按钮');
-                        await page.waitForTimeout(10000);
+                    const closeIcon = page.locator('[class*="close"], .ai-assistant-drawer-wrapper [class*="close"]');
+                    if (await closeIcon.isVisible({ timeout: 1000 }).catch(() => false)) {
+                        await closeIcon.click({ force: true });
+                        await page.waitForTimeout(1000);
+                    }
+                }
+            }
+            catch (e) {
+                // 关闭弹窗失败，继续
+            }
+            // 等待编辑器稳定
+            await page.waitForTimeout(2000);
+            // 点击发布按钮
+            console.log('[toutiao] 查找发布按钮...');
+            try {
+                // 尝试多种发布按钮选择器
+                const publishSelectors = [
+                    'button:has-text("发布")',
+                    'button:has-text("预览并发布")',
+                ];
+                for (const selector of publishSelectors) {
+                    const btn = page.locator(selector);
+                    if (await btn.isVisible({ timeout: 2000 }).catch(() => false)) {
+                        await btn.click({ force: true });
+                        console.log('[toutiao] 点击了:', selector);
+                        break;
                     }
                 }
+                await page.waitForTimeout(10000);
             }
             catch (e) {
-                console.log('[toutiao] 按钮点击失败:', e.message);
+                console.log('[toutiao] 发布按钮点击失败:', e.message);
             }
             const finalUrl = page.url();
-            idMatch = finalUrl.match(/[?&]id=(\d+)/);
+            const idMatch = finalUrl.match(/[?&]id=(\d+)/);
             if (idMatch) {
                 console.log('[toutiao] 保存成功，文章 ID:', idMatch[1]);
                 return {

package/dist/cli/capture.d.ts

@@ -0,0 +1,6 @@
+interface CaptureOptions {
+    platform?: string;
+    timeout?: string;
+}
+export declare function runCapture(options: CaptureOptions): Promise<void>;
+export {};

package/dist/cli/capture.js

@@ -0,0 +1,49 @@
+/**
+ * capture 命令入口
+ */
+import { capture } from '../tools/capture.js';
+import fs from 'fs/promises';
+import path from 'path';
+export async function runCapture(options) {
+    const platform = options.platform || 'csdn';
+    const timeoutSeconds = parseInt(options.timeout || '60', 10);
+    const timeoutMs = timeoutSeconds * 1000;
+    const data = await capture(platform, timeoutMs);
+    if (!data) {
+        console.error('抓包失败');
+        process.exit(1);
+    }
+    // 保存到临时文件
+    const timestamp = Date.now();
+    const filename = `temp/capture-${platform}-${timestamp}.json`;
+    const filepath = path.resolve(process.cwd(), filename);
+    // 确保 temp 目录存在
+    await fs.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.writeFile(filepath, JSON.stringify(data, null, 2), 'utf-8');
+    console.log(`
+========================================
+  抓包完成
+========================================
+文件: ${filepath}
+
+📊 统计:
+   总请求数: ${data.summary.totalRequests}
+   命中请求: ${data.summary.matchedRequests}
+   上传端点: ${data.summary.uploadEndpoints.join(', ') || '无'}
+
+========================================
+`);
+    if (data.summary.uploadEndpoints.length > 0) {
+        console.log('🎯 检测到上传请求！');
+        console.log('   把这个文件路径告诉 AI，让它分析签名格式');
+    }
+    else {
+        console.log('⚠️  未检测到上传请求');
+        console.log('   可能原因:');
+        console.log('   1. 没有执行上传操作');
+        console.log('   2. 上传功能需要先登录');
+        console.log('   3. 平台上传 API 不在拦截范围内');
+    }
+    console.log('\n运行 AI 分析:');
+    console.log(`   帮我分析 ${platform} 的抓包数据: ${filepath}`);
+}

package/dist/cli/index.js

@@ -11,6 +11,7 @@ import { runCredential } from './credential.js';
 import { runCookie } from './cookie.js';
 import { runLogin } from './login.js';
 import { runPublishAll } from './publish-all.js';
+import { runCapture } from './capture.js';
 export function createProgram() {
     const program = new Command();
     program
@@ -68,6 +69,12 @@ export function createProgram() {
         .option('--mac-style', '启用 Mac 风格代码块', true)
         .option('--no-mac-style', '禁用 Mac 风格代码块')
         .action(runPublishAll);
+    // capture 命令
+    const captureCmd = program.command('capture')
+        .description('抓包工具 - 打开浏览器并拦截上传请求')
+        .option('-p, --platform <platform>', '平台名称 (csdn|juejin|zhihu|toutiao|jianshu|weibo)', 'csdn')
+        .option('-t, --timeout <seconds>', '超时时间（秒）', '60')
+        .action(runCapture);
     return program;
 }
 const program = createProgram();

package/dist/tools/browser-upload.d.ts

@@ -0,0 +1,13 @@
+export interface BrowserUploadResult {
+    success: boolean;
+    coverUrl?: string;
+    error?: string;
+}
+/**
+ * 通过浏览器自动化上传封面图片
+ * 流程：打开文章编辑页 -> 在右侧设置面板上传封面
+ * @param articleId 文章ID（发布后返回的）
+ * @param imagePath 本地图片路径
+ * @returns 上传后的封面 URL
+ */
+export declare function uploadCoverViaBrowser(articleId: string, imagePath: string): Promise<BrowserUploadResult>;

package/dist/tools/browser-upload.js

@@ -0,0 +1,349 @@
+/**
+ * 浏览器自动化上传封面图片
+ * 在文章编辑页面右侧设置面板中上传封面
+ */
+import { chromium } from 'playwright';
+import { ConfigStore } from '../config.js';
+import path from 'path';
+/**
+ * 通过浏览器自动化上传封面图片
+ * 流程：打开文章编辑页 -> 在右侧设置面板上传封面
+ * @param articleId 文章ID（发布后返回的）
+ * @param imagePath 本地图片路径
+ * @returns 上传后的封面 URL
+ */
+export async function uploadCoverViaBrowser(articleId, imagePath) {
+    const browser = await chromium.launch({
+        headless: false,
+        channel: 'chromium',
+    });
+    try {
+        const context = await browser.newContext({
+            viewport: { width: 1280, height: 720 },
+        });
+        const page = await context.newPage();
+        // 加载 CSDN cookies
+        const cookies = await ConfigStore.getCSDNCookies();
+        if (!cookies || Object.keys(cookies).length === 0) {
+            return { success: false, error: '未配置 CSDN Cookie，请先登录' };
+        }
+        // 设置 cookies
+        const csdnCookies = Object.entries(cookies).map(([name, value]) => ({
+            name,
+            value,
+            domain: '.csdn.net',
+            path: '/',
+        }));
+        await context.addCookies(csdnCookies);
+        // 打开文章编辑页
+        console.log('[BrowserUpload] 打开文章编辑页...');
+        const articleUrl = `https://editor.csdn.net/md/?articleId=${articleId}`;
+        await page.goto(articleUrl, { waitUntil: 'networkidle', timeout: 60000 });
+        await page.waitForTimeout(2000);
+        // 先查找并点击"发布"按钮
+        console.log('[BrowserUpload] 查找发布按钮...');
+        const publishSelectors = [
+            'button:has-text("发布")',
+            'button:has-text("立即发布")',
+            '[class*="publish"] button',
+        ];
+        let publishButton = null;
+        for (const selector of publishSelectors) {
+            try {
+                const btn = page.locator(selector).first();
+                if (await btn.isVisible({ timeout: 1000 })) {
+                    publishButton = btn;
+                    console.log(`[BrowserUpload] 找到发布按钮: ${selector}`);
+                    break;
+                }
+            }
+            catch {
+                // continue
+            }
+        }
+        if (!publishButton) {
+            console.log('[BrowserUpload] 未找到发布按钮');
+            return { success: false, error: '未找到发布按钮' };
+        }
+        await publishButton.click();
+        console.log('[BrowserUpload] 点击发布按钮');
+        await page.waitForTimeout(2000);
+        // 查找弹窗/对话框中的"添加封面"
+        console.log('[BrowserUpload] 查找发布设置弹窗...');
+        // 等待弹窗出现
+        const dialogSelectors = [
+            '[class*="dialog"]',
+            '[class*="modal"]',
+            '[class*="popup"]',
+            '[class*="publish-dialog"]',
+            '[class*="publishModal"]',
+        ];
+        for (const selector of dialogSelectors) {
+            try {
+                const dialog = page.locator(selector).first();
+                if (await dialog.isVisible({ timeout: 2000 })) {
+                    console.log(`[BrowserUpload] 找到弹窗: ${selector}`);
+                    break;
+                }
+            }
+            catch {
+                // continue
+            }
+        }
+        // 截图看看弹窗内容
+        await page.screenshot({ path: `temp/csdn-publish-dialog-${Date.now()}.png` });
+        // 查找"添加封面"标签后面的上传框
+        console.log('[BrowserUpload] 查找"添加封面"后面的上传框...');
+        let coverInput = null;
+        let foundSelector = '';
+        // 尝试查找包含"添加封面"文字的元素
+        const addCoverLabel = page.locator('text=/添加封面|设置封面|上传封面/i');
+        if (await addCoverLabel.count() > 0) {
+            console.log(`[BrowserUpload] 找到 ${await addCoverLabel.count()} 个"添加封面"相关元素`);
+            // 查找这个元素附近的 file input
+            // 尝试找包含"添加封面"的父元素下的 file input
+            const parentFileInput = await addCoverLabel.evaluate((el) => {
+                // 往上找父元素
+                let parent = el.parentElement;
+                for (let i = 0; i < 5 && parent; i++) {
+                    // 找这个父元素下的 input[type="file"]
+                    const fileInput = parent.querySelector('input[type="file"]');
+                    if (fileInput) {
+                        return 'found';
+                    }
+                    parent = parent.parentElement;
+                }
+                return 'not-found';
+            });
+            console.log(`[BrowserUpload] 父元素下有 file input: ${parentFileInput}`);
+        }
+        // 查找弹窗中的 file input
+        const dialogFileInputs = page.locator('[class*="dialog"] input[type="file"], [class*="modal"] input[type="file"], [class*="popup"] input[type="file"]');
+        const dialogInputCount = await dialogFileInputs.count();
+        console.log(`[BrowserUpload] 弹窗中有 ${dialogInputCount} 个 file input`);
+        if (dialogInputCount > 0) {
+            const firstInput = dialogFileInputs.first();
+            coverInput = firstInput;
+            foundSelector = 'dialog file input';
+            console.log(`[BrowserUpload] 使用弹窗中的 file input`);
+        }
+        // 通用方式：在页面中查找所有 file input
+        if (!coverInput) {
+            const allFileInputs = page.locator('input[type="file"]');
+            const count = await allFileInputs.count();
+            console.log(`[BrowserUpload] 页面上共有 ${count} 个 file input`);
+            // 优先查找容器封面上传的 input (.el-upload__input)
+            const coverUploadInput = page.locator('.el-upload__input');
+            if (await coverUploadInput.count() > 0) {
+                coverInput = coverUploadInput.first();
+                foundSelector = 'el-upload__input';
+                console.log(`[BrowserUpload] 使用封面上传 input`);
+            }
+            else {
+                // 回退到可见的 file input
+                for (let i = 0; i < count; i++) {
+                    const element = allFileInputs.nth(i);
+                    if (await element.isVisible({ timeout: 500 }).catch(() => false)) {
+                        coverInput = element;
+                        foundSelector = `file input ${i}`;
+                        console.log(`[BrowserUpload] 使用 file input ${i}`);
+                        break;
+                    }
+                }
+            }
+        }
+        // 最后的尝试：直接查找 input[type="file"] 并检查其容器
+        if (!coverInput) {
+            console.log('[BrowserUpload] 最后尝试: 查找所有 file input...');
+            const allFileInputs = page.locator('input[type="file"]');
+            const count = await allFileInputs.count();
+            console.log(`[BrowserUpload] 共有 ${count} 个 file input`);
+            for (let i = 0; i < count; i++) {
+                const element = allFileInputs.nth(i);
+                try {
+                    // 检查这个 input 是否可见
+                    if (await element.isVisible({ timeout: 500 })) {
+                        // 检查父元素是否和封面相关
+                        const parentCover = await element.evaluate((el) => {
+                            let parent = el.closest('[class*="cover"]') || el.parentElement?.closest('[class*="cover"]');
+                            return parent ? 'found' : 'not-found';
+                        });
+                        if (parentCover === 'found') {
+                            coverInput = element;
+                            foundSelector = `file input ${i} (parent is cover)`;
+                            console.log(`[BrowserUpload] 找到封面 input: ${foundSelector}`);
+                            break;
+                        }
+                        // 尝试直接使用这个 input（如果页面上只有 1 个）
+                        if (count === 1) {
+                            coverInput = element;
+                            foundSelector = `file input ${i} (only one on page)`;
+                            console.log(`[BrowserUpload] 使用唯一的 file input`);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // continue
+                }
+            }
+        }
+        // 如果还是没找到，尝试查找"封面"文字并点击
+        if (!coverInput) {
+            console.log('[BrowserUpload] 尝试点击包含"封面"的元素...');
+            const coverText = page.locator('text=/封面|cover/i');
+            const textCount = await coverText.count();
+            console.log(`[BrowserUpload] 找到 ${textCount} 个包含"封面"的元素`);
+            for (let i = 0; i < textCount; i++) {
+                const el = coverText.nth(i);
+                try {
+                    // 点击这个元素
+                    await el.click();
+                    await page.waitForTimeout(1000);
+                    console.log(`[BrowserUpload] 点击了包含封面的元素 ${i}`);
+                    // 点击后重新查找 file input
+                    const newFileInputs = page.locator('input[type="file"]');
+                    const newCount = await newFileInputs.count();
+                    for (let j = 0; j < newCount; j++) {
+                        const fi = newFileInputs.nth(j);
+                        if (await fi.isVisible({ timeout: 500 }).catch(() => false)) {
+                            coverInput = fi;
+                            foundSelector = `file input after clicking cover text`;
+                            console.log(`[BrowserUpload] 点击后找到 file input`);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // continue
+                }
+                if (coverInput)
+                    break;
+            }
+        }
+        if (!coverInput) {
+            console.log('[BrowserUpload] 未找到封面上传入口');
+            return { success: false, error: '未找到封面上传入口' };
+        }
+        // 上传文件
+        console.log(`[BrowserUpload] 上传封面: ${imagePath}`);
+        const absolutePath = path.resolve(imagePath);
+        try {
+            // 先点击"从本地上传"按钮来激活上传
+            const uploadBtn = page.locator('.upload-img-box').first();
+            try {
+                if (await uploadBtn.isVisible({ timeout: 1000 })) {
+                    await uploadBtn.click();
+                    console.log('[BrowserUpload] 点击了从本地上传按钮');
+                    await page.waitForTimeout(1000);
+                }
+            }
+            catch {
+                // ignore
+            }
+            // 如果找不到上传按钮，点击封面区域
+            if (!(await uploadBtn.isVisible({ timeout: 500 }).catch(() => false))) {
+                const coverArea = page.locator('[class*="cover"], [class*="add-cover"]').first();
+                try {
+                    if (await coverArea.isVisible({ timeout: 1000 })) {
+                        await coverArea.click();
+                        console.log('[BrowserUpload] 点击了封面区域');
+                        await page.waitForTimeout(500);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch (err) {
+            console.error('[BrowserUpload] 点击上传按钮失败:', err);
+        }
+        // 执行文件上传
+        try {
+            await coverInput.setInputFiles(absolutePath);
+            console.log('[BrowserUpload] setInputFiles 执行成功');
+            // 触发 change 事件
+            await coverInput.dispatchEvent('change');
+            console.log('[BrowserUpload] 触发 change 事件');
+        }
+        catch (err) {
+            console.error('[BrowserUpload] setInputFiles 失败:', err);
+            return { success: false, error: `上传失败: ${err.message}` };
+        }
+        // 等待裁剪弹窗出现
+        console.log('[BrowserUpload] 等待裁剪弹窗...');
+        await page.waitForTimeout(2000);
+        // 点击"确认上传"按钮
+        const confirmBtn = page.locator('.vicp-operate-btn:has-text("确认上传"), .el-upload__confirm-upload');
+        try {
+            if (await confirmBtn.isVisible({ timeout: 3000 })) {
+                await confirmBtn.click();
+                console.log('[BrowserUpload] 点击确认上传按钮');
+            }
+        }
+        catch {
+            console.log('[BrowserUpload] 未找到确认上传按钮，继续');
+        }
+        // 等待裁剪弹窗关闭
+        await page.waitForTimeout(2000);
+        // 点击"保存为草稿"按钮来保存封面设置
+        const saveDraftBtn = page.locator('button:has-text("保存为草稿")');
+        try {
+            if (await saveDraftBtn.isVisible({ timeout: 3000 })) {
+                await saveDraftBtn.click();
+                console.log('[BrowserUpload] 点击保存为草稿按钮');
+                await page.waitForTimeout(2000);
+            }
+        }
+        catch {
+            console.log('[BrowserUpload] 未找到保存为草稿按钮，继续');
+        }
+        // 等待上传
+        console.log('[BrowserUpload] 等待上传...');
+        await page.waitForTimeout(5000);
+        // 截图看看上传后的状态
+        await page.screenshot({ path: `temp/csdn-after-upload-${Date.now()}.png` });
+        // 等待上传
+        console.log('[BrowserUpload] 等待上传...');
+        await page.waitForTimeout(3000);
+        // 检查封面预览
+        const previewSelectors = [
+            'img[src*="obs"]',
+            'img[src*="csdn-img"]',
+            '[class*="cover"] img[src]',
+            '[class*="coverPreview"] img',
+            'img.cover',
+            // 弹窗中的预览图
+            '[class*="modal"] img[src]',
+            '[class*="dialog"] img[src]',
+        ];
+        for (const selector of previewSelectors) {
+            try {
+                const imgs = page.locator(selector);
+                const count = await imgs.count();
+                for (let i = 0; i < count; i++) {
+                    const img = imgs.nth(i);
+                    const src = await img.getAttribute('src').catch(() => '');
+                    if (src && (src.includes('obs') || src.includes('csdn-img') || src.includes('https'))) {
+                        console.log(`[BrowserUpload] 封面上传成功: ${src}`);
+                        return { success: true, coverUrl: src };
+                    }
+                }
+            }
+            catch {
+                // continue
+            }
+        }
+        // 如果没找到特定 URL，但上传操作执行了，就认为成功
+        console.log('[BrowserUpload] 封面上传完成（未检测到预览 URL）');
+        return { success: true, coverUrl: 'uploaded' };
+    }
+    catch (err) {
+        console.error('[BrowserUpload] 上传失败:', err);
+        return { success: false, error: err.message };
+    }
+    finally {
+        await browser.close();
+    }
+}

package/dist/tools/capture.d.ts

@@ -0,0 +1,26 @@
+interface CapturedRequest {
+    id: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    postData?: string;
+    responseStatus?: number;
+    responseBody?: string;
+    matched: boolean;
+}
+interface CaptureData {
+    platform: string;
+    captureTime: string;
+    timeout: number;
+    editorUrl: string;
+    uploadApiUrl?: string;
+    requests: CapturedRequest[];
+    summary: {
+        totalRequests: number;
+        matchedRequests: number;
+        uploadEndpoints: string[];
+    };
+}
+export declare function capture(platform: string, timeoutMs?: number): Promise<CaptureData | null>;
+export {};

package/dist/tools/capture.js

@@ -0,0 +1,324 @@
+/**
+ * 通用抓包工具
+ *
+ * 使用方式:
+ *   node dist/tools/capture.js <platform> [timeout]
+ *
+ * 示例:
+ *   node dist/tools/capture.js csdn        # 抓取 CSDN (60s 超时)
+ *   node dist/tools/capture.js csdn 120    # 抓取 CSDN (120s 超时)
+ *   node dist/tools/capture.js juejin      # 抓取掘金
+ */
+import { chromium } from 'playwright';
+import { ConfigStore } from '../config.js';
+import fs from 'fs/promises';
+import path from 'path';
+// 平台配置
+const PLATFORM_CONFIGS = {
+    csdn: {
+        editorUrl: 'https://editor.csdn.net/md/',
+        uploadPatterns: [/uploadImg/i, /upload/i, /file/i, /image/i],
+    },
+    juejin: {
+        editorUrl: 'https://editor.juejin.cn/',
+        uploadPatterns: [/upload/i, /file/i, /image/i, /img/i],
+    },
+    zhihu: {
+        editorUrl: 'https://zhuanlan.zhihu.com/write',
+        uploadPatterns: [/upload/i, /file/i, /image/i, /img/i],
+    },
+    toutiao: {
+        editorUrl: 'https://mp.toutiao.com/',
+        uploadPatterns: [/upload/i, /file/i, /image/i, /img/i],
+    },
+    jianshu: {
+        editorUrl: 'https://www.jianshu.com/writer',
+        uploadPatterns: [/upload/i, /file/i, /image/i, /img/i],
+    },
+    weibo: {
+        editorUrl: 'https://weibo.com/compose',
+        uploadPatterns: [/upload/i, /file/i, /image/i, /img/i],
+    },
+};
+function isUploadRequest(url, headers, postData) {
+    const contentType = headers['content-type'] || '';
+    const isMultipart = contentType.includes('multipart/form-data');
+    const isUploadUrl = PLATFORM_CONFIGS[Object.keys(PLATFORM_CONFIGS)[0]]?.uploadPatterns.some(p => p.test(url));
+    // 检查 URL 是否匹配上传模式
+    for (const config of Object.values(PLATFORM_CONFIGS)) {
+        if (config.uploadPatterns.some(p => p.test(url))) {
+            return true;
+        }
+    }
+    // 如果是 multipart/form-data，很可能是上传
+    if (isMultipart) {
+        return true;
+    }
+    return false;
+}
+async function loadCookies(platform) {
+    try {
+        switch (platform) {
+            case 'csdn': return await ConfigStore.getCSDNCookies() || {};
+            case 'zhihu': return await ConfigStore.getZhihuCookies() || {};
+            case 'juejin': return await ConfigStore.getJuejinCookies() || {};
+            case 'toutiao': return await ConfigStore.getToutiaoCookies() || {};
+            case 'jianshu': return await ConfigStore.getJianshuCookies() || {};
+            case 'weibo': return await ConfigStore.getWeiboCookies() || {};
+            default: return {};
+        }
+    }
+    catch {
+        return {};
+    }
+}
+function getCookieDomains(platform) {
+    const domains = {
+        csdn: ['.csdn.net', '.bizapi.csdn.net'],
+        zhihu: ['.zhihu.com'],
+        juejin: ['.juejin.cn', '.掘金.com'],
+        toutiao: ['.toutiao.com'],
+        jianshu: ['.jianshu.com'],
+        weibo: ['.weibo.com', '.sina.com.cn'],
+    };
+    return domains[platform] || [];
+}
+export async function capture(platform, timeoutMs = 60000) {
+    const config = PLATFORM_CONFIGS[platform];
+    if (!config) {
+        console.error(`不支持的平台: ${platform}`);
+        console.error(`支持的平台: ${Object.keys(PLATFORM_CONFIGS).join(', ')}`);
+        return null;
+    }
+    console.log(`
+========================================
+  通用抓包工具 - ${platform.toUpperCase()}
+========================================
+平台: ${platform}
+编辑器: ${config.editorUrl}
+超时: ${timeoutMs / 1000}秒
+========================================
+`);
+    // 加载 cookies
+    const cookies = await loadCookies(platform);
+    if (Object.keys(cookies).length === 0) {
+        console.warn(`⚠️  未找到 ${platform} 的 cookies，可能需要先登录`);
+        console.warn(`   运行: node dist/cli/index.js login --platform ${platform}`);
+    }
+    else {
+        console.log(`✅ 已加载 ${Object.keys(cookies).length} 个 cookies`);
+    }
+    // 启动浏览器
+    const browser = await chromium.launch({
+        headless: false,
+        channel: 'chromium',
+    });
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    // 设置 cookies
+    const cookieDomains = getCookieDomains(platform);
+    for (const [name, value] of Object.entries(cookies)) {
+        for (const domain of cookieDomains) {
+            try {
+                await context.addCookies([{
+                        name,
+                        value,
+                        domain,
+                        path: '/',
+                    }]);
+                break;
+            }
+            catch {
+                // 忽略无效 cookie
+            }
+        }
+    }
+    // 抓包数据
+    const requests = [];
+    let lastActivityTime = Date.now();
+    // 拦截所有请求
+    page.on('request', async (request) => {
+        const url = request.url();
+        const headers = request.headers();
+        const method = request.method();
+        const contentType = headers['content-type'] || '';
+        // 只记录 API 请求
+        if (!url.includes('api') && !url.includes('bizapi')) {
+            return;
+        }
+        const captured = {
+            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            method,
+            url,
+            headers,
+            matched: isUploadRequest(url, headers),
+        };
+        // 获取 post data
+        try {
+            const postData = await request.postData();
+            if (postData) {
+                captured.postData = postData;
+            }
+        }
+        catch {
+            // ignore
+        }
+        requests.push(captured);
+        lastActivityTime = Date.now();
+        // 打印关键请求
+        if (captured.matched || url.includes('upload')) {
+            console.log(`\n📤 [${method}] ${url}`);
+            if (contentType) {
+                console.log(`   Content-Type: ${contentType.substring(0, 50)}...`);
+            }
+        }
+    });
+    // 拦截响应
+    page.on('response', async (response) => {
+        const url = response.url();
+        const status = response.status();
+        // 找到对应的请求并更新
+        const captured = requests.find(r => r.url === url);
+        if (captured) {
+            captured.responseStatus = status;
+            // 尝试获取响应体
+            try {
+                const body = await response.text();
+                if (body && body.length < 10000) {
+                    captured.responseBody = body;
+                }
+            }
+            catch {
+                // ignore
+            }
+            // 打印上传响应
+            if (captured.matched) {
+                console.log(`   ← ${status} ${captured.responseBody?.substring(0, 100) || ''}...`);
+            }
+        }
+    });
+    // 监听浏览器关闭
+    const browserClosedPromise = new Promise((resolve) => {
+        browser.on('disconnected', () => {
+            console.log('\n🔌 浏览器已关闭，停止抓包...');
+            resolve();
+        });
+    });
+    // 超时 Promise
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            console.log(`\n⏱️  超时 (${timeoutMs / 1000}秒)，停止抓包...`);
+            resolve();
+        }, timeoutMs);
+    });
+    // 无操作超时检测
+    const activityCheckPromise = new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+            if (Date.now() - lastActivityTime > timeoutMs) {
+                console.log('\n⏱️  长时间无活动，停止抓包...');
+                clearInterval(checkInterval);
+                resolve();
+            }
+        }, 5000);
+    });
+    // 打开编辑器
+    console.log(`\n🌐 打开编辑器: ${config.editorUrl}`);
+    await page.goto(config.editorUrl, { waitUntil: 'networkidle', timeout: 30000 });
+    console.log('✅ 编辑器已加载');
+    console.log('\n📋 操作提示:');
+    console.log('   1. 在编辑器中找到上传图片功能');
+    console.log('   2. 上传一张图片');
+    console.log('   3. 完成后关闭浏览器');
+    console.log('\n🕐 开始抓包，等待操作...\n');
+    // 等待浏览器关闭或超时
+    await Promise.race([
+        browserClosedPromise,
+        Promise.race([timeoutPromise, activityCheckPromise]),
+    ]);
+    // 关闭浏览器
+    try {
+        await browser.close();
+    }
+    catch {
+        // ignore
+    }
+    // 分析抓包数据
+    const uploadEndpoints = [...new Set(requests.filter(r => r.matched).map(r => {
+            try {
+                return new URL(r.url).pathname;
+            }
+            catch {
+                return r.url;
+            }
+        }))];
+    const captureData = {
+        platform,
+        captureTime: new Date().toISOString(),
+        timeout: timeoutMs,
+        editorUrl: config.editorUrl,
+        uploadApiUrl: uploadEndpoints[0],
+        requests: requests.map(r => ({
+            ...r,
+            responseBody: r.responseBody?.substring(0, 500), // 截断响应体
+        })),
+        summary: {
+            totalRequests: requests.length,
+            matchedRequests: requests.filter(r => r.matched).length,
+            uploadEndpoints,
+        },
+    };
+    return captureData;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const platform = args[0] || 'csdn';
+    const timeout = parseInt(args[1] || '60', 10) * 1000;
+    if (!PLATFORM_CONFIGS[platform]) {
+        console.error(`不支持的平台: ${platform}`);
+        console.error(`支持的平台: ${Object.keys(PLATFORM_CONFIGS).join(', ')}`);
+        process.exit(1);
+    }
+    const data = await capture(platform, timeout);
+    if (!data) {
+        process.exit(1);
+    }
+    // 保存到临时文件
+    const timestamp = Date.now();
+    const filename = `temp/capture-${platform}-${timestamp}.json`;
+    const filepath = path.resolve(process.cwd(), filename);
+    // 确保 temp 目录存在
+    await fs.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.writeFile(filepath, JSON.stringify(data, null, 2), 'utf-8');
+    console.log(`
+========================================
+  抓包完成
+========================================
+文件: ${filepath}
+
+📊 统计:
+   总请求数: ${data.summary.totalRequests}
+   命中请求: ${data.summary.matchedRequests}
+   上传端点: ${data.summary.uploadEndpoints.join(', ') || '无'}
+
+========================================
+`);
+    if (data.summary.uploadEndpoints.length > 0) {
+        console.log('🎯 检测到上传请求！');
+        console.log('   把这个文件路径告诉 AI，让它分析签名格式');
+    }
+    else {
+        console.log('⚠️  未检测到上传请求');
+        console.log('   可能原因:');
+        console.log('   1. 没有执行上传操作');
+        console.log('   2. 上传功能需要先登录');
+        console.log('   3. 平台上传 API 不在拦截范围内');
+    }
+    console.log('\n运行 AI 分析:');
+    console.log(`   帮我分析 ${platform} 的抓包数据: ${filepath}`);
+}
+// 仅在直接运行时执行（不在被 import 时执行）
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    main().catch(console.error);
+}

package/dist/tools/toutiao-upload.d.ts

@@ -0,0 +1,10 @@
+export interface ToutiaoUploadResult {
+    success: boolean;
+    coverUrl?: string;
+    error?: string;
+}
+/**
+ * 通过浏览器自动化上传头条号封面
+ * 流程：打开发布页 -> 填写内容 -> 点击预览并发布 -> 在预览弹窗中上传封面 -> 确认
+ */
+export declare function uploadCoverViaBrowser(imagePath: string): Promise<ToutiaoUploadResult>;

package/dist/tools/toutiao-upload.js

@@ -0,0 +1,166 @@
+/**
+ * 头条号封面图片浏览器上传
+ */
+import { chromium } from 'playwright';
+import { ConfigStore } from '../config.js';
+import path from 'path';
+/**
+ * 通过浏览器自动化上传头条号封面
+ * 流程：打开发布页 -> 填写内容 -> 点击预览并发布 -> 在预览弹窗中上传封面 -> 确认
+ */
+export async function uploadCoverViaBrowser(imagePath) {
+    const browser = await chromium.launch({
+        headless: false,
+        args: [
+            '--disable-blink-features=AutomationControlled',
+            '--disable-devtools-shm-usage',
+            '--no-sandbox',
+        ]
+    });
+    try {
+        const context = await browser.newContext({
+            viewport: { width: 1280, height: 900 },
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        });
+        const page = await context.newPage();
+        // CDP 隐藏自动化特征
+        const cdp = await context.newCDPSession(page);
+        await cdp.send('Page.addScriptToEvaluateOnNewDocument', {
+            source: `
+        Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+        Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+        Object.defineProperty(navigator, 'languages', { get: () => ['zh-CN', 'zh', 'en'] });
+        window.chrome = { runtime: {}, loadTimes: () => {}, csi: () => {} };
+      `
+        });
+        // 加载 cookies
+        const cookies = await ConfigStore.getToutiaoCookies();
+        if (!cookies || Object.keys(cookies).length === 0) {
+            return { success: false, error: '未配置头条号 Cookie' };
+        }
+        const toutiaoCookies = Object.entries(cookies).map(([name, value]) => ({
+            name,
+            value,
+            domain: '.toutiao.com',
+            path: '/',
+        }));
+        await context.addCookies(toutiaoCookies);
+        console.log('[ToutiaoUpload] 打开发布页...');
+        await page.goto('https://mp.toutiao.com/profile_v4/graphic/publish', {
+            waitUntil: 'networkidle',
+            timeout: 60000
+        });
+        await page.waitForTimeout(2000);
+        // 关闭可能存在的遮罩层
+        try {
+            const mask = page.locator('.byte-drawer-mask').first();
+            if (await mask.isVisible({ timeout: 1000 })) {
+                await mask.click({ force: true });
+                await page.waitForTimeout(500);
+            }
+        }
+        catch { }
+        // 截图
+        await page.screenshot({ path: `temp/toutiao-upload-start-${Date.now()}.png` });
+        // 填写标题和内容（让用户之前已经填好了，这里只做演示）
+        const titleInput = page.locator('textarea').first();
+        if (await titleInput.isVisible({ timeout: 2000 }).catch(() => false)) {
+            const currentTitle = await titleInput.inputValue().catch(() => '');
+            if (!currentTitle) {
+                await titleInput.fill('临时标题-封面测试');
+                console.log('[ToutiaoUpload] 填写了临时标题');
+            }
+        }
+        // 填写内容（如果为空）
+        const contentEl = page.locator('div[contenteditable="true"]').first();
+        if (await contentEl.isVisible({ timeout: 2000 }).catch(() => false)) {
+            const currentContent = await contentEl.textContent().catch(() => '');
+            if (!currentContent || currentContent.trim() === '') {
+                await contentEl.click();
+                await page.keyboard.press('Control+a');
+                await page.keyboard.type('临时内容-封面测试');
+                console.log('[ToutiaoUpload] 填写了临时内容');
+            }
+        }
+        // 点击"预览并发布"按钮
+        console.log('[ToutiaoUpload] 点击预览并发布按钮...');
+        const publishBtn = page.locator('button:has-text("预览并发布")');
+        if (await publishBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
+            await publishBtn.click({ force: true });
+            console.log('[ToutiaoUpload] 已点击预览并发布');
+            await page.waitForTimeout(3000);
+        }
+        else {
+            return { success: false, error: '未找到预览并发布按钮' };
+        }
+        // 在预览弹窗中选择"单图"选项
+        console.log('[ToutiaoUpload] 选择单图选项...');
+        const singleImageOption = page.locator('text=单图').first();
+        if (await singleImageOption.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await singleImageOption.click();
+            console.log('[ToutiaoUpload] 点击了单图');
+            await page.waitForTimeout(500);
+        }
+        // 截图
+        await page.screenshot({ path: `temp/toutiao-upload-select-cover-${Date.now()}.png` });
+        // 设置 filechooser 监听
+        const absolutePath = path.resolve(imagePath);
+        console.log(`[ToutiaoUpload] 准备上传: ${absolutePath}`);
+        page.on('filechooser', async (fileChooser) => {
+            console.log('[ToutiaoUpload] 收到 filechooser，设置文件');
+            await fileChooser.setFiles(absolutePath);
+        });
+        // 点击封面添加区域触发 filechooser
+        console.log('[ToutiaoUpload] 点击封面添加区域...');
+        const coverAdd = page.locator('.article-cover-add');
+        if (await coverAdd.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await coverAdd.click({ force: true });
+            console.log('[ToutiaoUpload] 点击了 article-cover-add');
+        }
+        else {
+            return { success: false, error: '未找到封面添加区域' };
+        }
+        // 等待文件选择
+        await page.waitForTimeout(2000);
+        // 点击"本地上传"按钮
+        console.log('[ToutiaoUpload] 点击本地上传按钮...');
+        const localUploadBtn = page.locator('text=本地上传');
+        if (await localUploadBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
+            await localUploadBtn.click();
+            console.log('[ToutiaoUpload] 点击了本地上传');
+            await page.waitForTimeout(2000);
+        }
+        // 截图看预览
+        await page.screenshot({ path: `temp/toutiao-upload-preview-${Date.now()}.png` });
+        // 点击"确定"按钮
+        console.log('[ToutiaoUpload] 点击确定按钮...');
+        const confirmBtn = page.locator('button:has-text("确定")').filter({ visible: true });
+        try {
+            if (await confirmBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
+                const disabled = await confirmBtn.first().isDisabled().catch(() => true);
+                if (!disabled) {
+                    await confirmBtn.first().click();
+                    console.log('[ToutiaoUpload] 点击了确定按钮');
+                }
+                else {
+                    console.log('[ToutiaoUpload] 确定按钮被禁用');
+                }
+            }
+        }
+        catch {
+            console.log('[ToutiaoUpload] 未找到确定按钮');
+        }
+        // 等待保存
+        await page.waitForTimeout(3000);
+        await page.screenshot({ path: `temp/toutiao-upload-finish-${Date.now()}.png` });
+        console.log('[ToutiaoUpload] 封面上传流程完成');
+        return { success: true, coverUrl: 'uploaded' };
+    }
+    catch (err) {
+        console.error('[ToutiaoUpload] 上传失败:', err);
+        return { success: false, error: err.message };
+    }
+    finally {
+        await browser.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-publisher",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Markdown → 微信公众号 / 知乎 / 掘金等多平台 CLI 发布工具",
   "type": "module",
   "repository": {