multi-publisher 1.1.1 → 1.1.3

package/dist/adapters/toutiao.js

@@ -4,6 +4,13 @@
  */
 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',
@@ -22,10 +29,31 @@ 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 };
     }
+    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) {
@@ -36,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: [
@@ -93,73 +128,203 @@ 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();
             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 || '';
+                const htmlContent = processedArticle.html || processedArticle.markdown || '';
                 await page.evaluate((el) => {
                     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;
+            // 如果有封面图片，先下载 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}，跳过封面上传`);
+                    }
+                    else {
+                        localCover = downloadResult.localPath;
+                        console.log(`[toutiao] 封面下载成功: ${localCover}`);
+                    }
+                }
+                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);
+                    }
                 }
-                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/adapters/wechat-publisher.d.ts

@@ -15,6 +15,10 @@ export declare class WechatPublisher {
      * 下载图片并以指定文件名上传到微信 CDN
      */
     uploadImageFromUrl(imageUrl: string): Promise<string>;
+    /**
+     * 上传图片到微信 CDN（图文消息专用接口，返回可直接访问的 URL）
+     */
+    uploadImageForArticle(filePath: string): Promise<string>;
     /**
      * 上传本地图片到微信 CDN（临时素材，用于正文嵌入）
      */
@@ -35,11 +39,12 @@ export declare class WechatPublisher {
     uploadPermanentImageFromUrl(imageUrl: string): Promise<string>;
     /**
      * 处理 HTML 中的图片：本地图片上传到微信 CDN，外部图片保留原 URL
-     * 返回处理后的 HTML 和第一张可用的 media_id（用作封面）
+     * 返回处理后的 HTML、第一张 media_id（临时）和第一张本地路径（用于封面永久上传）
      */
     processImages(html: string): Promise<{
         html: string;
         firstMediaId?: string;
+        firstLocalPath?: string;
     }>;
     /**
      * 发布到微信公众号草稿箱

package/dist/adapters/wechat-publisher.js

@@ -10,7 +10,14 @@ function extFromUrl(url) {
     return ext || '.jpg';
 }
 function nameFromUrl(url) {
-    return path.basename(new URL(url).pathname) || `image${extFromUrl(url)}`;
+    const ext = extFromUrl(url);
+    const pathname = new URL(url).pathname;
+    const basename = path.basename(pathname);
+    // If basename has no extension (or is just numbers like "720"), generate a proper name
+    if (!path.extname(basename) || /^\d+$/.test(basename)) {
+        return `cover${ext}`;
+    }
+    return basename;
 }
 export class WechatPublisher {
     runtime;
@@ -65,6 +72,21 @@ export class WechatPublisher {
         this.uploadCache[imageUrl] = mediaId;
         return mediaId;
     }
+    /**
+     * 上传图片到微信 CDN（图文消息专用接口，返回可直接访问的 URL）
+     */
+    async uploadImageForArticle(filePath) {
+        const token = await this.getAccessToken();
+        const name = path.basename(filePath);
+        const form = new FormData();
+        form.append('media', readFileSync(filePath), { filename: name, contentType: 'image/png' });
+        const res = await axios.post(`https://api.weixin.qq.com/cgi-bin/media/uploadimg?access_token=${token}`, form, { headers: form.getHeaders(), maxBodyLength: Infinity, maxContentLength: Infinity });
+        const data = res.data;
+        if (!data.url) {
+            throw new Error(`图片上传失败: ${data.errmsg || JSON.stringify(data)}`);
+        }
+        return data.url;
+    }
     /**
      * 上传本地图片到微信 CDN（临时素材，用于正文嵌入）
      */
@@ -142,11 +164,12 @@ export class WechatPublisher {
     }
     /**
      * 处理 HTML 中的图片：本地图片上传到微信 CDN，外部图片保留原 URL
-     * 返回处理后的 HTML 和第一张可用的 media_id（用作封面）
+     * 返回处理后的 HTML、第一张 media_id（临时）和第一张本地路径（用于封面永久上传）
      */
     async processImages(html) {
         const imgPattern = /<img\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
         let firstMediaId;
+        let firstLocalPath;
         let replaced = html;
         for (const match of [...html.matchAll(imgPattern)]) {
             const original = match[0];
@@ -160,24 +183,35 @@ export class WechatPublisher {
                 continue;
             }
             try {
-                const mediaId = await this.uploadImageFromUrl(src);
-                if (!firstMediaId)
-                    firstMediaId = mediaId;
-                const cdnUrl = `https://mmbiz.qpic.cn/mmbiz_png/${mediaId}/0`;
-                replaced = replaced.replace(original, original.replace(src, cdnUrl));
+                const isLocalPath = !src.startsWith('http://') && !src.startsWith('https://');
+                if (isLocalPath) {
+                    // 本地文件用 uploadimg 接口，返回直接可访问的 URL
+                    const url = await this.uploadImageForArticle(src);
+                    if (!firstLocalPath)
+                        firstLocalPath = src;
+                    replaced = replaced.replace(original, original.replace(src, url));
+                }
+                else {
+                    // 外部 URL 下载后上传
+                    const mediaId = await this.uploadImageFromUrl(src);
+                    if (!firstMediaId)
+                        firstMediaId = mediaId;
+                    const cdnUrl = `https://mmbiz.qpic.cn/mmbiz_png/${mediaId}/0`;
+                    replaced = replaced.replace(original, original.replace(src, cdnUrl));
+                }
             }
             catch (err) {
                 console.warn(`[WechatPublisher] 上传图片失败 ${src}: ${err.message}，保留原 URL`);
             }
         }
-        return { html: replaced, firstMediaId };
+        return { html: replaced, firstMediaId, firstLocalPath };
     }
     /**
      * 发布到微信公众号草稿箱
      */
     async publishToDraft(options) {
         const token = await this.getAccessToken();
-        const { html: processedHtml, firstMediaId } = await this.processImages(options.content);
+        const { html: processedHtml, firstMediaId, firstLocalPath } = await this.processImages(options.content);
         // 上传封面图：优先用 front-matter 指定的封面图，其次用正文第一张图片的 media_id
         let thumbMediaId;
         try {
@@ -185,10 +219,15 @@ export class WechatPublisher {
         }
         catch (err) {
             console.warn(`[WechatPublisher] 封面上传失败: ${err.message}`);
-            // 用 processImages 返回的第一张图片 media_id 作为封面
-            if (firstMediaId) {
+            // 用 processImages 返回的第一张图片（本地路径需要用永久素材接口）
+            if (firstLocalPath) {
+                thumbMediaId = await this.uploadPermanentImageFromPath(firstLocalPath);
+                console.log('[WechatPublisher] 使用正文第一张图片作为封面（永久素材）');
+            }
+            else if (firstMediaId) {
+                // 外部 URL 图片用临时素材
                 thumbMediaId = firstMediaId;
-                console.log('[WechatPublisher] 使用正文第一张图片作为封面');
+                console.log('[WechatPublisher] 使用正文第一张图片作为封面（临时素材）');
             }
             else {
                 // fallback：直接从 processedHtml 中查找 img 标签
@@ -197,12 +236,14 @@ export class WechatPublisher {
                     const src = m[1];
                     if (src.includes('mmbiz.qpic.cn') || src.includes('mmbiz.qlogo.cn'))
                         continue;
-                    try {
-                        thumbMediaId = await this.uploadImageFromUrl(src);
-                        console.log(`[WechatPublisher] 用正文图片作封面: ${src}`);
-                        break;
+                    if (src.startsWith('http')) {
+                        try {
+                            thumbMediaId = await this.uploadPermanentImageFromUrl(src);
+                            console.log(`[WechatPublisher] 用正文图片作封面: ${src}`);
+                            break;
+                        }
+                        catch { /* continue */ }
                     }
-                    catch { /* continue */ }
                 }
             }
         }

package/dist/adapters/weixin.d.ts

@@ -8,7 +8,12 @@ export declare class WeixinAdapter implements IPlatformAdapter {
     readonly meta: PlatformMeta;
     private runtime;
     private publisher;
+    private getPublisher;
     init(runtime: RuntimeInterface): Promise<void>;
     checkAuth(): Promise<AuthResult>;
+    processMermaid(html: string): Promise<{
+        html: string;
+        tempFiles: string[];
+    }>;
     publish(article: Article): Promise<SyncResult>;
 }

package/dist/adapters/weixin.js

@@ -1,4 +1,6 @@
 import { WechatPublisher } from './wechat-publisher.js';
+import os from 'os';
+import fs from 'node:fs/promises';
 export class WeixinAdapter {
     meta = {
         id: 'weixin',
@@ -9,13 +11,18 @@ export class WeixinAdapter {
     };
     runtime;
     publisher;
+    getPublisher() {
+        if (!this.publisher) {
+            this.publisher = new WechatPublisher(this.runtime);
+        }
+        return this.publisher;
+    }
     async init(runtime) {
         this.runtime = runtime;
-        this.publisher = new WechatPublisher(runtime);
     }
     async checkAuth() {
         try {
-            const token = await this.publisher.getAccessToken();
+            const token = this.getPublisher().getAccessToken();
             return {
                 isAuthenticated: !!token,
                 userId: 'authenticated',
@@ -26,20 +33,49 @@ export class WeixinAdapter {
             return { isAuthenticated: false, error: msg };
         }
     }
+    async processMermaid(html) {
+        const { processMermaid: convert } = await import('../core/renderer.js');
+        const { html: processed, tempFiles } = await convert(html, os.tmpdir());
+        // 上传图片到微信 CDN 并替换 URL
+        const imgPattern = /<img\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
+        let result = processed;
+        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 this.getPublisher().uploadImageForArticle(src);
+                    result = result.replace(original, original.replace(src, url));
+                }
+                catch (err) {
+                    console.warn(`[weixin] mermaid 图片上传失败 ${src}: ${err.message}`);
+                }
+            }
+        }
+        return { html: result, tempFiles };
+    }
     async publish(article) {
         const start = Date.now();
         try {
             if (!article.html) {
                 throw new Error('article.html is required for WeChat publishing');
             }
-            const result = await this.publisher.publishToDraft({
+            // 处理 Mermaid 代码块（转换为图片并上传 CDN）
+            let processedHtml = article.html;
+            if (this.processMermaid) {
+                const { html: mermaidHtml, tempFiles } = await this.processMermaid(article.html);
+                processedHtml = mermaidHtml;
+                // 清理临时文件
+                await Promise.all(tempFiles.map(f => fs.unlink(f).catch(() => { })));
+            }
+            const result = await this.getPublisher().publishToDraft({
                 title: article.title,
-                content: article.html,
+                content: processedHtml,
                 cover: article.cover ?? '',
                 author: article.author ?? '',
                 source_url: article.source_url ?? '',
             });
-            const token = await this.publisher.getAccessToken();
+            const token = await this.getPublisher().getAccessToken();
             const draftUrl = `https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit&action=edit&type=77&appmsgid=${result.media_id}&token=${token}&lang=zh_CN`;
             return {
                 platform: this.meta.id,

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
@@ -23,6 +24,7 @@ export function createProgram() {
         .requiredOption('-f, --file <path>', 'Markdown 文件路径（支持本地文件和 URL）')
         .option('-p, --platform <platform>', '目标平台 (weixin|zhihu|juejin|csdn)', 'weixin')
         .option('-t, --theme <theme-id>', '主题 ID', 'default')
+        .option('-m, --cover-mode <mode>', '封面模式 (sharp|network|auto)', 'auto')
         .option('--app-id <appId>', '微信公众号 AppID（可省略，从配置文件读取）')
         .option('--no-mac-style', '禁用 Mac 风格代码块')
         .option('--auto-cover', '当文章无封面图时，根据标题自动从网络获取封面')
@@ -68,6 +70,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/cli/login.js

@@ -95,6 +95,9 @@ async function saveCookies(platformId, cookies) {
         case 'cto51':
             await ConfigStore.setCto51Cookies(cookies);
             break;
+        case 'qq':
+            await ConfigStore.setQQCookies(cookies);
+            break;
         default:
             console.warn(`⚠️  尚未为 ${platformId} 实现 Cookie 保存，请手动保存`);
     }