@jackwener/opencli 1.7.7 → 1.7.9

package/clis/weibo/publish.js

@@ -0,0 +1,282 @@
+/**
+ * Weibo publish — post a new Weibo update via browser UI automation.
+ *
+ * Flow:
+ *   1. Navigate to weibo.com and wait for the feed
+ *   2. Check login state (getSelfUid)
+ *   3. Click "发微博" button to open the inline compose editor
+ *   4. Wait for textarea editor to appear
+ *   5. Fill text content via CDP type
+ *   6. Optionally upload images via CDP setFileInput
+ *   7. Click the publish button
+ *   8. Poll for success/failure feedback
+ *
+ * Usage:
+ *   opencli weibo publish "Hello from OpenCLI! #opencli"  # publishes immediately
+ *   opencli weibo publish "Check this out" --images /path/a.jpg,/path/b.jpg
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getSelfUid } from './utils.js';
+
+const MAX_IMAGES = 9;
+const UPLOAD_POLL_MS = 1500;
+const UPLOAD_TIMEOUT_MS = 30_000;
+const COMPOSE_POLL_MS = 300;
+const COMPOSE_TIMEOUT_MS = 10_000;
+const SUBMIT_POLL_MS = 500;
+const SUBMIT_TIMEOUT_MS = 20_000;
+const SUPPORTED_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+
+// Weibo PC UI selectors
+const TEXTAREA_SELECTOR = 'textarea._input_13iqr_8';
+const FILE_INPUT_SELECTOR = 'input[type="file"][class*="_file_"]';
+
+function validateText(text) {
+    const t = String(text ?? '').trim();
+    if (!t) throw new ArgumentError('weibo publish text cannot be empty');
+    if (t.length > 2000) throw new ArgumentError('weibo publish text exceeds 2000 characters');
+    return t;
+}
+
+function validateImagePaths(raw) {
+    if (!raw) return [];
+    const paths = raw.split(',').map(s => s.trim()).filter(Boolean);
+    if (paths.length > MAX_IMAGES) {
+        throw new ArgumentError(`Too many images: ${paths.length} (max ${MAX_IMAGES})`);
+    }
+    return paths.map(p => {
+        const absPath = path.resolve(p);
+        const ext = path.extname(absPath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            throw new ArgumentError(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+        }
+        const stat = fs.statSync(absPath, { throwIfNoEntry: false });
+        if (!stat || !stat.isFile()) {
+            throw new ArgumentError(`Not a valid file: ${absPath}`);
+        }
+        return absPath;
+    });
+}
+
+cli({
+    site: 'weibo',
+    name: 'publish',
+    description: 'Publish a new Weibo post immediately',
+    domain: 'weibo.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        {
+            name: 'text',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: 'Weibo text content (max 2000 chars)',
+        },
+        {
+            name: 'images',
+            type: 'string',
+            required: false,
+            help: `Image paths, comma-separated, max ${MAX_IMAGES} (jpg/png/gif/webp)`,
+        },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page) throw new CommandExecutionError('Browser session required for weibo publish');
+
+        const text = validateText(kwargs.text);
+        const absPaths = validateImagePaths(kwargs.images);
+
+        // Step 1: Navigate to weibo.com and wait for feed to load
+        await page.goto('https://weibo.com', { waitUntil: 'load', settleMs: 2000 });
+        await page.wait({ time: 2 });
+
+        // Step 2: Check login
+        try {
+            await getSelfUid(page);
+        } catch (err) {
+            if (err instanceof AuthRequiredError) throw err;
+            throw new CommandExecutionError('Not logged into Weibo. Please login at weibo.com in your Chrome browser.');
+        }
+
+        // Step 3: Click "发微博" button to open inline compose editor
+        const clickResult = await page.evaluate(`
+            () => {
+                const visible = el => !!el && el.offsetParent !== null && !el.disabled;
+                const buttons = document.querySelectorAll('button[title="发微博"], button[title="写微博"]');
+                for (const btn of buttons) {
+                    if (visible(btn)) {
+                        btn.click();
+                        return { ok: true };
+                    }
+                }
+                return { ok: false, message: 'Could not find 发微博 button' };
+            }
+        `);
+        if (!clickResult?.ok) {
+            throw new CommandExecutionError(clickResult?.message ?? 'Could not open compose editor.');
+        }
+
+        // Step 4: Wait for the textarea editor to appear (visible, not just in DOM)
+        let editorFound = false;
+        for (let i = 0; i < Math.ceil(COMPOSE_TIMEOUT_MS / COMPOSE_POLL_MS); i++) {
+            const result = await page.evaluate(`
+                () => {
+                    const ta = document.querySelector('textarea._input_13iqr_8');
+                    if (!ta) return { found: false };
+                    const visible = ta.offsetParent !== null;
+                    return { found: true, visible, rectTop: visible ? ta.getBoundingClientRect().top : -1 };
+                }
+            `);
+            if (result?.found && result.visible && result.rectTop >= 0) {
+                editorFound = true;
+                break;
+            }
+            await page.wait({ time: COMPOSE_POLL_MS / 1000 });
+        }
+        if (!editorFound) {
+            throw new CommandExecutionError('Weibo compose editor did not appear');
+        }
+
+        // Step 5: Upload images first (before text to avoid editor reset)
+        if (absPaths.length > 0) {
+            if (!page.setFileInput) {
+                throw new CommandExecutionError('Browser extension does not support file upload. Please update the extension.');
+            }
+
+            // Find the file input
+            const fileInputFound = await page.evaluate(`
+                () => {
+                    const input = document.querySelector('input[type="file"][class*="_file_"]');
+                    return !!input;
+                }
+            `);
+            if (!fileInputFound) {
+                throw new CommandExecutionError('Could not find image file input on Weibo compose page. UI may have changed.');
+            }
+
+            await page.setFileInput(absPaths, FILE_INPUT_SELECTOR);
+
+            // Wait for upload to complete
+            let uploadResult = null;
+            for (let i = 0; i < Math.ceil(UPLOAD_TIMEOUT_MS / UPLOAD_POLL_MS); i++) {
+                await page.wait({ time: UPLOAD_POLL_MS / 1000 });
+                uploadResult = await page.evaluateWithArgs(`
+                    (() => {
+                        const expectedCount = expected;
+                        const uploading = document.querySelector('[class*="upload"], [class*="progress"]');
+                        if (uploading && uploading.offsetParent !== null) return null;
+                        const pics = document.querySelectorAll('img[class*="pic"], [class*="imgItem"], [class*="picture"] img');
+                        if (pics.length >= expectedCount) return { ok: true, count: pics.length };
+                        return null;
+                    })()
+                `, { expected: absPaths.length });
+                if (uploadResult !== null) break;
+            }
+
+            if (!uploadResult?.ok) {
+                throw new CommandExecutionError(uploadResult?.message ?? 'Image upload did not complete before timeout');
+            }
+        }
+
+        // Step 6: Insert text using native DOM setter (preserves Weibo internal state)
+        // IMPORTANT: Using nativeSetter preserves the textarea's reactive/internal state.
+        // Direct ta.value= assignment bypasses Weibo's Vue reactivity and causes "undefined" content.
+        const insertResult = await page.evaluateWithArgs(`
+            (() => {
+                const ta = document.querySelector('textarea._input_13iqr_8');
+                if (!ta || ta.offsetParent === null) return { ok: false, message: 'textarea not visible' };
+                ta.focus();
+                const nativeSetter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
+                if (nativeSetter) {
+                    nativeSetter.call(ta, textContent);
+                } else {
+                    ta.value = textContent;
+                }
+                ta.dispatchEvent(new Event('input', { bubbles: true }));
+                ta.dispatchEvent(new Event('change', { bubbles: true }));
+                return { ok: true, valueLength: ta.value.length };
+            })()
+        `, { textContent: text });
+
+        if (!insertResult?.ok) {
+            throw new CommandExecutionError(insertResult?.message ?? 'Could not insert text.');
+        }
+
+
+        // Step 7: Click the send button inside the compose editor
+        // Try 发送 first (compose editor's submit), then 发布 (fallback)
+        await page.wait({ time: 0.5 });
+        const publishResult = await page.evaluate(`
+            () => {
+                const visible = el => !!el && el.offsetParent !== null && !el.disabled;
+                const labels = ['发送', '发布'];
+                for (const label of labels) {
+                    const allBtns = document.querySelectorAll('button, [role="button"]');
+                    for (const btn of allBtns) {
+                        const t = (btn.innerText || btn.textContent || '').trim();
+                        if (t === label && visible(btn)) {
+                            btn.click();
+                            return { ok: true, label };
+                        }
+                    }
+                }
+                return { ok: false, message: 'Could not find send button' };
+            }
+        `);
+        if (!publishResult?.ok) {
+            throw new CommandExecutionError(publishResult?.message ?? 'Could not click publish.');
+        }
+
+        // Step 8: Wait for success/failure result
+        let finalResult = null;
+        for (let i = 0; i < Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS); i++) {
+            await page.wait({ time: SUBMIT_POLL_MS / 1000 });
+            finalResult = await page.evaluateWithArgs(`
+                (() => {
+                    const successMarkers = ['发布成功', '已发布', '发送成功'];
+                    const errorMarkers = ['发布失败', '发送失败', '内容违规', '请稍后再试', '频繁'];
+                    for (const el of document.querySelectorAll('*')) {
+                        if (el.children.length > 3) continue;
+                        const txt = (el.innerText || '').trim();
+                        if (!txt || txt.length > 100) continue;
+                        for (const m of successMarkers) {
+                            if (txt.includes(m) && (txt.includes('成功') || txt.includes('微博'))) {
+                                return { ok: true, message: txt };
+                            }
+                        }
+                        for (const m of errorMarkers) {
+                            if (txt.includes(m)) {
+                                return { ok: false, message: txt };
+                            }
+                        }
+                    }
+                    return null;
+                })()
+            `, { maxIterations: Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS), currentIndex: i });
+            if (finalResult !== null) break;
+        }
+
+        if (!finalResult) {
+            throw new CommandExecutionError('Publish button clicked but result was unclear. Check Weibo manually.');
+        }
+
+        if (!finalResult.ok) {
+            throw new CommandExecutionError(finalResult.message || 'Weibo publish failed');
+        }
+
+        return [{
+            status: 'success',
+            message: finalResult.message || 'Published successfully',
+            text,
+        }];
+    },
+});
+
+export const __test__ = {
+    validateText,
+    validateImagePaths,
+};

package/clis/weibo/publish.test.js

@@ -0,0 +1,183 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    statSync: vi.fn((p) => {
+      if (String(p).includes('missing')) return undefined;
+      return { isFile: () => !String(p).includes('directory') };
+    }),
+  };
+});
+
+vi.mock('node:path', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    resolve: vi.fn((p) => `/abs/${p}`),
+    extname: vi.fn((p) => {
+      const m = String(p).match(/\.[^.]+$/);
+      return m ? m[0] : '';
+    }),
+  };
+});
+
+import './publish.js';
+
+function makePage({ evaluateResults = [], evaluateWithArgsResults = [], overrides = {} } = {}) {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) {
+    evaluate.mockResolvedValueOnce(result);
+  }
+  evaluate.mockResolvedValue({ ok: true });
+
+  const evaluateWithArgs = vi.fn();
+  for (const result of evaluateWithArgsResults) {
+    evaluateWithArgs.mockResolvedValueOnce(result);
+  }
+  evaluateWithArgs.mockResolvedValue(null);
+
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    evaluateWithArgs,
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+describe('weibo publish command', () => {
+  const getCommand = () => getRegistry().get('weibo/publish');
+
+  it('publishes a text-only post when the UI reports success', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, valueLength: 5 },
+        { ok: true, message: '发送成功' },
+      ],
+    });
+
+    const result = await command.func(page, { text: 'hello' });
+
+    expect(result).toEqual([{ status: 'success', message: '发送成功', text: 'hello' }]);
+    expect(page.goto).toHaveBeenCalledWith('https://weibo.com', { waitUntil: 'load', settleMs: 2000 });
+  });
+
+  it('uploads up to nine images before publishing', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        true,
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, count: 2 },
+        { ok: true, valueLength: 11 },
+        { ok: true, message: '发送成功' },
+      ],
+    });
+
+    await command.func(page, { text: 'with images', images: 'a.png,b.webp' });
+
+    expect(page.setFileInput).toHaveBeenCalledWith(
+      ['/abs/a.png', '/abs/b.webp'],
+      'input[type="file"][class*="_file_"]',
+    );
+  });
+
+  it('maps auth failures to AuthRequiredError', async () => {
+    const command = getCommand();
+    const page = makePage({ evaluateResults: [null, null] });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('validates text and image arguments before navigation', async () => {
+    const command = getCommand();
+    const page = makePage();
+
+    await expect(command.func(page, { text: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: 'a.bmp' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(command.func(page, { text: 'hi', images: '1.png,2.png,3.png,4.png,5.png,6.png,7.png,8.png,9.png,10.png' })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('throws CommandExecutionError when compose cannot be opened', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: ['123456', { ok: false, message: 'Could not find 发微博 button' }],
+    });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError when upload readiness is not proven', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        true,
+      ],
+      evaluateWithArgsResults: [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null],
+    });
+
+    await expect(command.func(page, { text: 'hello', images: 'a.png' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('throws CommandExecutionError when publish result is unclear or failed', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, valueLength: 5 },
+        { ok: false, message: '内容违规' },
+      ],
+    });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
+  });
+
+  it('does not treat editor close as positive publish proof', async () => {
+    const command = getCommand();
+    const page = makePage({
+      evaluateResults: [
+        '123456',
+        { ok: true },
+        { found: true, visible: true, rectTop: 100 },
+        { ok: true, label: '发送' },
+      ],
+      evaluateWithArgsResults: [
+        { ok: true, valueLength: 5 },
+        null,
+      ],
+    });
+
+    await expect(command.func(page, { text: 'hello' })).rejects.toBeInstanceOf(CommandExecutionError);
+
+    const submitScript = page.evaluateWithArgs.mock.calls.at(-1)[0];
+    expect(submitScript).not.toContain('Editor closed after publish');
+    expect(submitScript).toContain('发布成功');
+  });
+});

package/clis/weixin/create-draft.js

@@ -0,0 +1,225 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
+const WEIXIN_HOME = 'https://mp.weixin.qq.com/';
+
+async function getToken(page) {
+    return page.evaluate(`(window.location.href.match(/token=(\\d+)/)||[])[1]`);
+}
+
+async function navigateToEditor(page) {
+    await page.goto(WEIXIN_HOME);
+    await page.wait(3);
+    const token = await getToken(page);
+    if (!token) {
+        throw new CommandExecutionError('Could not extract session token. Please log in to mp.weixin.qq.com');
+    }
+    await page.goto(`https://mp.weixin.qq.com/cgi-bin/appmsg?t=media/appmsg_edit_v2&action=edit&isNew=1&type=77&token=${token}&lang=zh_CN`);
+    await page.wait(4);
+    const hasTitle = await page.evaluate('!!document.querySelector("textarea#title")');
+    if (!hasTitle) {
+        throw new CommandExecutionError('Article editor did not load. Session may have expired');
+    }
+}
+
+async function fillField(page, selector, value) {
+    return page.evaluate(`(() => {
+        var el = document.querySelector('${selector}');
+        if (!el) return { ok: false, reason: 'not found: ${selector}' };
+        el.focus();
+        var proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+        var setter = Object.getOwnPropertyDescriptor(proto, 'value');
+        if (setter && setter.set) setter.set.call(el, ${JSON.stringify(value)});
+        else el.value = ${JSON.stringify(value)};
+        el.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(value)} }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+        el.blur();
+        return { ok: true };
+    })()`);
+}
+
+async function fillContent(page, text) {
+    return page.evaluate(`(() => {
+        var editors = document.querySelectorAll('div[contenteditable="true"]');
+        var editor = editors[editors.length - 1];
+        if (!editor) return { ok: false, reason: 'content editor not found' };
+        editor.focus();
+        if (editor.querySelector('[contenteditable="false"]')) editor.innerHTML = '';
+        document.execCommand('selectAll', false, null);
+        document.execCommand('insertText', false, ${JSON.stringify(text)});
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true }));
+        return { ok: true };
+    })()`);
+}
+
+async function uploadContentImage(page, imagePath) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const absPath = path.default.resolve(imagePath);
+    if (!fs.default.existsSync(absPath)) {
+        throw new CommandExecutionError(`Image not found: ${absPath}`);
+    }
+    if (!page.setFileInput) {
+        throw new CommandExecutionError('Image upload requires Browser Bridge with CDP support');
+    }
+
+    await page.evaluate(`(() => {
+        var li = document.querySelector('#js_editor_insertimage');
+        if (li) li.click();
+    })()`);
+    await page.wait(1);
+    await page.evaluate(`(() => {
+        var items = document.querySelectorAll('.js_img_dropdown_menu .tpl_dropdown_menu_item');
+        if (items[0]) items[0].click();
+    })()`);
+    await page.wait(1);
+
+    await page.setFileInput([absPath], 'input[type="file"][name="file"]');
+    await page.wait(8);
+
+    const cdnCount = await page.evaluate(`(() => {
+        var editor = document.querySelector('#ueditor_0');
+        return editor ? editor.querySelectorAll('img[src*="mmbiz"]').length : 0;
+    })()`);
+    if (cdnCount === 0) {
+        throw new CommandExecutionError('Image did not upload to WeChat CDN');
+    }
+}
+
+async function selectCoverFromContent(page) {
+    await page.evaluate('document.querySelector("#js_cover_description_area")?.scrollIntoView()');
+    await page.wait(1);
+
+    await page.evaluate('document.querySelector(".js_cover_btn_area")?.click()');
+    await page.wait(1);
+
+    await page.evaluate(`(() => {
+        var links = document.querySelectorAll('a.pop-opr__button');
+        for (var i = 0; i < links.length; i++) {
+            if (links[i].textContent.trim() === '从正文选择') { links[i].click(); return; }
+        }
+    })()`);
+    await page.wait(2);
+
+    await page.evaluate(`(() => {
+        var img = document.querySelector('.weui-desktop-dialog_img-picker .appmsg_content_img');
+        if (img) img.click();
+    })()`);
+    await page.wait(1);
+
+    await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('.weui-desktop-dialog_img-picker button');
+        for (var i = 0; i < btns.length; i++) {
+            if (btns[i].textContent.trim() === '下一步' && !btns[i].disabled) { btns[i].click(); return; }
+        }
+    })()`);
+
+    // Crop dialog image rendering can be slow
+    for (let attempt = 0; attempt < 8; attempt++) {
+        await page.wait(2);
+        const ready = await page.evaluate(`(() => {
+            var btns = document.querySelectorAll('button');
+            for (var i = 0; i < btns.length; i++) {
+                if (btns[i].textContent.trim() === '确认' && btns[i].offsetHeight > 0 && !btns[i].disabled) return true;
+            }
+            return false;
+        })()`);
+        if (ready) break;
+    }
+
+    await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('button');
+        for (var i = 0; i < btns.length; i++) {
+            if (btns[i].textContent.trim() === '确认' && btns[i].offsetHeight > 0 && !btns[i].disabled) { btns[i].click(); return; }
+        }
+    })()`);
+    await page.wait(2);
+    const hasCover = await page.evaluate(`(() => {
+        var area = document.querySelector('#js_cover_area');
+        if (!area) return false;
+        var found = false;
+        area.querySelectorAll('*').forEach(function(el) {
+            var bg = window.getComputedStyle(el).backgroundImage;
+            if (bg && bg.includes('mmbiz')) found = true;
+        });
+        return found;
+    })()`);
+    return hasCover;
+}
+
+async function clickSaveDraft(page) {
+    const result = await page.evaluate(`(() => {
+        var btns = document.querySelectorAll('span, button, a');
+        for (var i = 0; i < btns.length; i++) {
+            if ((btns[i].textContent || '').trim() === '保存为草稿') { btns[i].click(); return { ok: true }; }
+        }
+        return { ok: false };
+    })()`);
+    if (!result?.ok) throw new CommandExecutionError('Save draft button not found');
+
+    for (let attempt = 0; attempt < 5; attempt++) {
+        await page.wait(2);
+        const saved = await page.evaluate(`(() => {
+            var el = document.querySelector('#js_save_success');
+            if (el && window.getComputedStyle(el).display !== 'none') return true;
+            return document.body.innerText.includes('已保存');
+        })()`);
+        if (saved) return true;
+    }
+    return false;
+}
+
+export const createDraftCommand = cli({
+    site: 'weixin',
+    name: 'create-draft',
+    description: '创建微信公众号图文草稿',
+    domain: WEIXIN_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 180,
+    args: [
+        { name: 'title', required: true, help: '文章标题 (最长64字)' },
+        { name: 'content', required: true, positional: true, help: '文章正文' },
+        { name: 'author', help: '作者名 (最长8字)' },
+        { name: 'cover-image', help: '封面图片路径 (会先上传到正文再设为封面)' },
+        { name: 'summary', help: '文章摘要' },
+    ],
+    columns: ['status', 'detail'],
+
+    func: async (page, kwargs) => {
+        await navigateToEditor(page);
+
+        const titleResult = await fillField(page, 'textarea#title', kwargs.title);
+        if (!titleResult?.ok) throw new CommandExecutionError('Failed to fill title');
+
+        if (kwargs.author) {
+            const authorResult = await fillField(page, 'input#author', kwargs.author);
+            if (!authorResult?.ok) throw new CommandExecutionError('Failed to fill author');
+        }
+
+        const contentResult = await fillContent(page, kwargs.content);
+        if (!contentResult?.ok) throw new CommandExecutionError('Failed to fill content');
+
+        if (kwargs['cover-image']) {
+            await uploadContentImage(page, kwargs['cover-image']);
+            const coverSet = await selectCoverFromContent(page);
+            if (!coverSet) {
+                // Non-fatal: draft can be saved without cover
+            }
+        }
+
+        if (kwargs.summary) {
+            await fillField(page, 'textarea#js_description', kwargs.summary);
+        }
+
+        await page.wait(1);
+        const success = await clickSaveDraft(page);
+
+        return [{
+            status: success ? 'draft saved' : 'save attempted, check browser to confirm',
+            detail: `"${kwargs.title}"${kwargs.author ? ` by ${kwargs.author}` : ''}${kwargs['cover-image'] ? ' (with cover)' : ''}`,
+        }];
+    },
+});