xhs-mcp 0.6.0

package/dist/lib/publishing/publish.service.js

@@ -0,0 +1,942 @@
+/**
+ * Publishing service for XHS MCP Server
+ */
+import { PublishError, InvalidImageError } from '../shared/errors.js';
+import { BaseService } from '../shared/base.service.js';
+import { existsSync, statSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../shared/logger.js';
+import { sleep } from '../shared/utils.js';
+// Constants for video publishing
+const VIDEO_TIMEOUTS = {
+    PAGE_LOAD: 3000,
+    TAB_SWITCH: 2000,
+    VIDEO_PROCESSING: 10000,
+    CONTENT_WAIT: 1000,
+    UPLOAD_READY: 1000,
+    UPLOAD_START: 3000,
+    PROCESSING_CHECK: 3000,
+    COMPLETION_CHECK: 2000,
+    PROCESSING_TIMEOUT: 120000, // 2 minutes
+    COMPLETION_TIMEOUT: 300000, // 5 minutes
+};
+const SELECTORS = {
+    FILE_INPUT: [
+        'input[type=file]',
+        '.upload-input',
+        'input[accept*="video"]',
+        'input[accept*="mp4"]',
+        'input[class*="upload"]',
+        'input[class*="file"]'
+    ],
+    SUCCESS_INDICATORS: [
+        '.success-message',
+        '.publish-success',
+        '[data-testid="publish-success"]',
+        '.toast-success',
+        '.upload-success',
+        '.video-upload-success',
+        '.video-processing-complete',
+        '.upload-complete'
+    ],
+    ERROR_INDICATORS: [
+        '.error-message',
+        '.publish-error',
+        '[data-testid="publish-error"]',
+        '.toast-error',
+        '.error-toast',
+        '.upload-error',
+        '.video-upload-error'
+    ],
+    PROCESSING_INDICATORS: [
+        '.video-processing',
+        '.upload-progress',
+        '.processing-indicator',
+        '[class*="processing"]',
+        '[class*="uploading"]',
+        '.progress-bar',
+        '.upload-status'
+    ],
+    COMPLETION_INDICATORS: [
+        '.upload-complete',
+        '.processing-complete',
+        '.video-ready',
+        '[class*="complete"]',
+        '[class*="ready"]'
+    ],
+    TOAST_SELECTORS: [
+        '.toast',
+        '.message',
+        '.notification',
+        '[role="alert"]',
+        '.ant-message',
+        '.el-message'
+    ],
+    PUBLISH_PAGE_INDICATORS: [
+        'div.upload-content',
+        'div.submit',
+        '.creator-editor',
+        '.video-upload-container',
+        'input[type="file"]'
+    ]
+};
+const TEXT_PATTERNS = {
+    SUCCESS: ['成功', 'success', '完成'],
+    ERROR: ['失败', 'error', '错误'],
+    PROCESSING: ['处理中', '上传中', 'processing', 'uploading', '进度']
+};
+export class PublishService extends BaseService {
+    constructor(config) {
+        super(config);
+    }
+    // Helper methods for element detection and text matching
+    async findElementBySelectors(page, selectors) {
+        for (const selector of selectors) {
+            const element = await page.$(selector);
+            if (element) {
+                logger.debug(`Found element with selector: ${selector}`);
+                return element;
+            }
+        }
+        return null;
+    }
+    async getElementText(element) {
+        try {
+            return await element.page().evaluate((el) => el.textContent, element);
+        }
+        catch (error) {
+            logger.warn(`Failed to get element text: ${error}`);
+            return null;
+        }
+    }
+    async checkTextPatterns(text, patterns) {
+        if (!text)
+            return false;
+        return patterns.some(pattern => text.includes(pattern));
+    }
+    async checkElementForPatterns(page, selectors, patterns) {
+        for (const selector of selectors) {
+            const element = await page.$(selector);
+            if (element) {
+                const text = await this.getElementText(element);
+                if (text && await this.checkTextPatterns(text, patterns)) {
+                    return { found: true, text, element };
+                }
+            }
+        }
+        return { found: false };
+    }
+    async waitForCondition(condition, timeout, checkInterval = 1000, errorMessage) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            if (await condition()) {
+                return;
+            }
+            await sleep(checkInterval);
+        }
+        throw new PublishError(errorMessage);
+    }
+    async publishNote(title, content, imagePaths, tags = '', browserPath) {
+        // Validate inputs
+        if (!title?.trim()) {
+            throw new PublishError('Note title cannot be empty');
+        }
+        if (!content?.trim()) {
+            throw new PublishError('Note content cannot be empty');
+        }
+        if (!imagePaths || imagePaths.length === 0) {
+            throw new PublishError('At least one image is required');
+        }
+        // Validate and resolve image paths
+        const resolvedPaths = this.validateAndResolveImagePaths(imagePaths);
+        // Wait for upload container selector
+        const uploadSelector = 'div.upload-content';
+        try {
+            const page = await this.getBrowserManager().createPage(false, browserPath, true);
+            try {
+                await this.getBrowserManager().navigateWithRetry(page, this.getConfig().xhs.creatorPublishUrl);
+                // Wait for page to load
+                await sleep(3000);
+                // First, try to switch to the image/text upload tab
+                await this.clickUploadTab(page);
+                // Wait for tab switch to complete
+                await sleep(2000);
+                let hasUploadContainer = await this.getBrowserManager().waitForSelectorSafe(page, uploadSelector, 30000);
+                if (!hasUploadContainer) {
+                    // Try alternative selectors for upload container
+                    const alternativeSelectors = [
+                        'div.upload-content',
+                        '.upload-content',
+                        'div[class*="upload"]',
+                        'div[class*="image"]',
+                        'input[type="file"]'
+                    ];
+                    for (const selector of alternativeSelectors) {
+                        hasUploadContainer = await this.getBrowserManager().waitForSelectorSafe(page, selector, 10000);
+                        if (hasUploadContainer) {
+                            break;
+                        }
+                    }
+                }
+                if (!hasUploadContainer) {
+                    throw new PublishError('Could not find upload container on publish page');
+                }
+                // Upload images
+                await this.uploadImages(page, resolvedPaths);
+                // Wait for images to be processed
+                await sleep(3000);
+                // Wait a bit for the page to settle after image upload
+                await sleep(2000);
+                // Fill in title
+                await this.fillTitle(page, title);
+                // Wait a bit more for content area to appear
+                await sleep(1000);
+                // Fill in content
+                await this.fillContent(page, content);
+                // Add tags if provided
+                if (tags) {
+                    await this.addTags(page, tags);
+                }
+                // Submit the note
+                await this.submitPublish(page);
+                // Wait for completion and check result
+                await this.waitForPublishCompletion(page);
+                // Save cookies
+                await this.getBrowserManager().saveCookiesFromPage(page);
+                return {
+                    success: true,
+                    message: 'Note published successfully',
+                    title,
+                    content,
+                    imageCount: resolvedPaths.length,
+                    tags,
+                    url: this.getConfig().xhs.creatorPublishUrl
+                };
+            }
+            finally {
+                await page.close();
+            }
+        }
+        catch (error) {
+            logger.error(`Publish error: ${error}`);
+            throw error;
+        }
+    }
+    validateAndResolveImagePaths(imagePaths) {
+        const resolvedPaths = [];
+        for (const imagePath of imagePaths) {
+            const resolvedPath = join(process.cwd(), imagePath);
+            if (!existsSync(resolvedPath)) {
+                throw new InvalidImageError(`Image file not found: ${imagePath}`);
+            }
+            const stats = statSync(resolvedPath);
+            if (!stats.isFile()) {
+                throw new InvalidImageError(`Path is not a file: ${imagePath}`);
+            }
+            // Check file extension
+            const ext = imagePath.toLowerCase().split('.').pop();
+            const allowedExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp'];
+            if (!ext || !allowedExtensions.includes(ext)) {
+                throw new InvalidImageError(`Unsupported image format: ${imagePath}. Supported: ${allowedExtensions.join(', ')}`);
+            }
+            resolvedPaths.push(resolvedPath);
+        }
+        if (resolvedPaths.length > 18) {
+            throw new PublishError('Maximum 18 images allowed');
+        }
+        return resolvedPaths;
+    }
+    async clickUploadTab(page) {
+        try {
+            // Try multiple selectors for tabs
+            const tabSelectors = [
+                'div.creator-tab',
+                '.creator-tab',
+                '[role="tab"]',
+                '.tab',
+                'div[class*="tab"]'
+            ];
+            let tabs = [];
+            for (const selector of tabSelectors) {
+                const foundTabs = await page.$$(selector);
+                if (foundTabs.length > 0) {
+                    tabs = foundTabs;
+                    break;
+                }
+            }
+            if (tabs.length === 0) {
+                logger.warn('No tabs found');
+                return;
+            }
+            // Look for the "上传图文" (upload image/text) tab specifically
+            let imageTextTab = null;
+            for (let i = 0; i < tabs.length; i++) {
+                const tab = tabs[i];
+                try {
+                    const isVisible = await tab.isIntersectingViewport();
+                    if (!isVisible)
+                        continue;
+                    const text = await page.evaluate(el => el.textContent, tab);
+                    // Check if this is the image/text upload tab
+                    if (text && (text.includes('上传图文') || text.includes('图文') || text.includes('图片'))) {
+                        imageTextTab = tab;
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Ignore individual tab errors
+                }
+            }
+            if (imageTextTab) {
+                await imageTextTab.click();
+                await sleep(2000); // Wait for tab switch
+            }
+            else {
+                // Fallback: click the second tab (usually image/text upload)
+                const visibleTabs = [];
+                for (const tab of tabs) {
+                    const isVisible = await tab.isIntersectingViewport();
+                    if (isVisible) {
+                        visibleTabs.push(tab);
+                    }
+                }
+                if (visibleTabs.length > 1) {
+                    await visibleTabs[1].click(); // Usually the second tab is image/text
+                    await sleep(2000);
+                }
+                else if (visibleTabs.length > 0) {
+                    await visibleTabs[0].click();
+                    await sleep(2000);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to click upload tab: ${error}`);
+        }
+    }
+    async uploadImages(page, imagePaths) {
+        // Try primary file input selector
+        let fileInput = await page.$('input[type=file]');
+        if (!fileInput) {
+            // Fallback to alternative selector
+            fileInput = await page.$('.upload-input');
+            if (!fileInput) {
+                throw new PublishError('Could not find file upload input on page');
+            }
+        }
+        // Upload each image
+        for (const imagePath of imagePaths) {
+            try {
+                await fileInput.uploadFile(imagePath);
+                await sleep(1000); // Wait between uploads
+            }
+            catch (error) {
+                throw new PublishError(`Failed to upload image ${imagePath}: ${error}`);
+            }
+        }
+    }
+    async fillTitle(page, title) {
+        const titleSelectors = [
+            'input[placeholder*="标题"]',
+            'input[placeholder*="title"]',
+            'input[data-placeholder*="标题"]',
+            '.title-input input',
+            'input[type="text"]',
+            'input[placeholder*="请输入标题"]',
+            'input[placeholder*="标题"]',
+            'input[name="title"]',
+            'input[id*="title"]',
+            'input[class*="title"]',
+            'div[contenteditable="true"]',
+            'textarea[placeholder*="标题"]',
+            'textarea[placeholder*="title"]'
+        ];
+        for (const selector of titleSelectors) {
+            try {
+                const titleInput = await page.$(selector);
+                if (titleInput) {
+                    const isVisible = await titleInput.isIntersectingViewport();
+                    if (isVisible) {
+                        await titleInput.click();
+                        await sleep(500); // Wait for focus
+                        await titleInput.type(title);
+                        return;
+                    }
+                }
+            }
+            catch (error) {
+                // Continue to next selector
+            }
+        }
+        // If no input found, try to find any input or textarea on the page
+        try {
+            const allInputs = await page.$$('input, textarea, [contenteditable="true"]');
+            for (let i = 0; i < allInputs.length; i++) {
+                const input = allInputs[i];
+                try {
+                    const isVisible = await input.isIntersectingViewport();
+                    const tagName = await page.evaluate(el => el.tagName, input);
+                    if (isVisible && (tagName === 'INPUT' || tagName === 'TEXTAREA')) {
+                        await input.click();
+                        await sleep(500);
+                        await input.type(title);
+                        return;
+                    }
+                }
+                catch (error) {
+                    // Continue to next input
+                }
+            }
+        }
+        catch (error) {
+            // Fall through to error
+        }
+        throw new PublishError('Could not find title input field');
+    }
+    async findContentElement(page) {
+        // Strategy 1: Try div.ql-editor (primary selector)
+        const qlEditor = await page.$('div.ql-editor');
+        if (qlEditor) {
+            return qlEditor;
+        }
+        // Strategy 2: Try to find textarea or contenteditable
+        const contentSelectors = [
+            'textarea[placeholder*="正文"]',
+            'div[contenteditable="true"]',
+            'div[data-placeholder*="正文"]',
+            '.content-editor',
+            'div[role="textbox"]'
+        ];
+        for (const selector of contentSelectors) {
+            const element = await page.$(selector);
+            if (element) {
+                return element;
+            }
+        }
+        return null;
+    }
+    async findTextboxByPlaceholder(page) {
+        try {
+            // Find all p elements
+            const pElements = await page.$$('p');
+            // Look for element with data-placeholder containing "输入正文描述"
+            for (const p of pElements) {
+                const placeholder = await page.evaluate(el => el.getAttribute('data-placeholder'), p);
+                if (placeholder?.includes('输入正文描述')) {
+                    return p;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async findTextboxParent(page, element) {
+        try {
+            return await page.evaluateHandle(el => el.parentElement, element);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async fillContent(page, content) {
+        // Wait for content area to appear
+        try {
+            await page.waitForSelector('div[contenteditable="true"], textarea, [role="textbox"], .ql-editor', { timeout: 10000 });
+        }
+        catch (error) {
+            // Continue without waiting
+        }
+        let contentElement = await this.findContentElement(page);
+        if (!contentElement) {
+            // Try alternative approach
+            const textboxElement = await this.findTextboxByPlaceholder(page);
+            if (textboxElement) {
+                contentElement = await this.findTextboxParent(page, textboxElement);
+            }
+        }
+        if (!contentElement) {
+            // Try to find any contenteditable or textarea element
+            try {
+                const allContentElements = await page.$$('div[contenteditable="true"], textarea, [role="textbox"], .ql-editor, p[contenteditable="true"]');
+                for (let i = 0; i < allContentElements.length; i++) {
+                    const element = allContentElements[i];
+                    try {
+                        const isVisible = await element.isIntersectingViewport();
+                        const tagName = await page.evaluate(el => el.tagName, element);
+                        const contentEditable = await page.evaluate(el => el.getAttribute('contenteditable'), element);
+                        const role = await page.evaluate(el => el.getAttribute('role'), element);
+                        const className = await page.evaluate(el => el.className, element);
+                        if (isVisible && (contentEditable === 'true' || tagName === 'TEXTAREA' || role === 'textbox' || className.includes('ql-editor'))) {
+                            contentElement = element;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        // Continue to next element
+                    }
+                }
+            }
+            catch (error) {
+                // Continue to next strategy
+            }
+        }
+        if (!contentElement) {
+            // Last resort: try to find any element that might be for content
+            try {
+                const allElements = await page.$$('*');
+                for (let i = 0; i < Math.min(allElements.length, 50); i++) { // Limit to first 50 elements
+                    const element = allElements[i];
+                    try {
+                        const isVisible = await element.isIntersectingViewport();
+                        const tagName = await page.evaluate(el => el.tagName, element);
+                        const contentEditable = await page.evaluate(el => el.getAttribute('contenteditable'), element);
+                        const className = await page.evaluate(el => el.className, element);
+                        const placeholder = await page.evaluate(el => el.getAttribute('placeholder'), element);
+                        if (isVisible && (contentEditable === 'true' || tagName === 'TEXTAREA' ||
+                            className.includes('content') || className.includes('editor') ||
+                            placeholder?.includes('内容') || placeholder?.includes('正文'))) {
+                            contentElement = element;
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        // Ignore errors for individual elements
+                    }
+                }
+            }
+            catch (error) {
+                // Fall through to error
+            }
+        }
+        if (!contentElement) {
+            throw new PublishError('Could not find content input field');
+        }
+        try {
+            await contentElement.click();
+            await sleep(500); // Wait for focus
+            await contentElement.type(content);
+        }
+        catch (error) {
+            throw new PublishError(`Failed to fill content: ${error}`);
+        }
+    }
+    async inputTags(contentElement, tags) {
+        const tagList = tags.split(',').map(tag => tag.trim()).filter(tag => tag.length > 0);
+        for (const tag of tagList) {
+            await this.inputTag(contentElement, tag);
+        }
+    }
+    async inputTag(contentElement, tag) {
+        try {
+            // Try to find topic suggestion container
+            const page = contentElement.page();
+            const topicContainer = await page.$('#creator-editor-topic-container');
+            if (topicContainer) {
+                const firstItem = await topicContainer.$('.item');
+                if (firstItem) {
+                    await firstItem.click();
+                    await sleep(500);
+                }
+            }
+            // Type the tag
+            await contentElement.type(`#${tag}`);
+            await sleep(500);
+            // Press Enter to confirm the tag
+            await contentElement.press('Enter');
+            await sleep(500);
+        }
+        catch (error) {
+            logger.warn(`Failed to add tag ${tag}: ${error}`);
+        }
+    }
+    async addTags(page, tags) {
+        try {
+            const contentElement = await this.findContentElement(page);
+            if (contentElement) {
+                await this.inputTags(contentElement, tags);
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to add tags: ${error}`);
+        }
+    }
+    async submitPublish(page) {
+        const submitSelector = 'div.submit div.d-button-content';
+        const submitButton = await page.$(submitSelector);
+        if (!submitButton) {
+            throw new PublishError('Could not find submit button');
+        }
+        // Wait for submit button to be visible
+        await page.waitForSelector(submitSelector, { visible: true, timeout: 10000 });
+        try {
+            await submitButton.click();
+            await sleep(2000);
+        }
+        catch (error) {
+            throw new PublishError(`Failed to click submit button: ${error}`);
+        }
+    }
+    async isElementVisible(element) {
+        try {
+            return await element.isIntersectingViewport();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async waitForPublishCompletion(page) {
+        const maxWaitTime = 60000; // 60 seconds
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWaitTime) {
+            // Check for success indicators
+            const successIndicators = [
+                '.success-message',
+                '.publish-success',
+                '[data-testid="publish-success"]',
+                '.toast-success'
+            ];
+            for (const selector of successIndicators) {
+                const element = await page.$(selector);
+                if (element) {
+                    await sleep(2000); // Wait a bit more for any final processing
+                    return;
+                }
+            }
+            // Check for error indicators
+            const errorIndicators = [
+                '.error-message',
+                '.publish-error',
+                '[data-testid="publish-error"]',
+                '.toast-error',
+                '.error-toast'
+            ];
+            for (const selector of errorIndicators) {
+                const element = await page.$(selector);
+                if (element) {
+                    const errorText = await page.evaluate(el => el.textContent, element);
+                    throw new PublishError(`Publish failed with error: ${errorText}`);
+                }
+            }
+            // Check if we're still on the publish page
+            const publishPageIndicators = [
+                'div.upload-content',
+                'div.submit',
+                '.creator-editor'
+            ];
+            let stillOnPublishPage = false;
+            for (const selector of publishPageIndicators) {
+                const element = await page.$(selector);
+                if (element) {
+                    stillOnPublishPage = true;
+                    break;
+                }
+            }
+            if (!stillOnPublishPage) {
+                // We've left the publish page, likely successful
+                logger.debug('Left publish page, assuming success');
+                return;
+            }
+            // Check for toast messages
+            const toastSelectors = [
+                '.toast',
+                '.message',
+                '.notification',
+                '[role="alert"]'
+            ];
+            for (const selector of toastSelectors) {
+                const element = await page.$(selector);
+                if (element) {
+                    const toastText = await page.evaluate(el => el.textContent, element);
+                    if (toastText) {
+                        if (toastText.includes('成功') || toastText.includes('success')) {
+                            logger.debug(`Found success toast: ${toastText}`);
+                            return;
+                        }
+                        else if (toastText.includes('失败') || toastText.includes('error') || toastText.includes('错误')) {
+                            throw new PublishError(`Publish failed: ${toastText}`);
+                        }
+                    }
+                }
+            }
+            await sleep(1000); // Wait before next check
+        }
+        throw new PublishError('Publish completion timeout - could not determine result');
+    }
+    async waitForVideoPublishCompletion(page) {
+        logger.debug('Waiting for video publish completion...');
+        let isProcessing = false;
+        await this.waitForCondition(async () => {
+            // Check for success indicators
+            const successResult = await this.checkElementForPatterns(page, SELECTORS.SUCCESS_INDICATORS, TEXT_PATTERNS.SUCCESS);
+            if (successResult.found) {
+                logger.debug(`Found success indicator: ${successResult.text}`);
+                await sleep(VIDEO_TIMEOUTS.COMPLETION_CHECK);
+                return true;
+            }
+            // Check for error indicators
+            const errorResult = await this.checkElementForPatterns(page, SELECTORS.ERROR_INDICATORS, TEXT_PATTERNS.ERROR);
+            if (errorResult.found) {
+                throw new PublishError(`Video publish failed with error: ${errorResult.text}`);
+            }
+            // Check if we've left the publish page (likely success)
+            const stillOnPage = await this.findElementBySelectors(page, SELECTORS.PUBLISH_PAGE_INDICATORS);
+            if (!stillOnPage) {
+                logger.debug('Left publish page, assuming video publish success');
+                return true;
+            }
+            // Check for processing status
+            const processingResult = await this.checkElementForPatterns(page, SELECTORS.PROCESSING_INDICATORS, TEXT_PATTERNS.PROCESSING);
+            isProcessing = processingResult.found;
+            if (isProcessing) {
+                logger.debug(`Video still processing: ${processingResult.text}`);
+            }
+            // Check for toast messages
+            const toastResult = await this.checkElementForPatterns(page, SELECTORS.TOAST_SELECTORS, TEXT_PATTERNS.SUCCESS);
+            if (toastResult.found) {
+                logger.debug(`Found success toast: ${toastResult.text}`);
+                return true;
+            }
+            const errorToastResult = await this.checkElementForPatterns(page, SELECTORS.TOAST_SELECTORS, TEXT_PATTERNS.ERROR);
+            if (errorToastResult.found) {
+                throw new PublishError(`Video publish failed: ${errorToastResult.text}`);
+            }
+            return false;
+        }, VIDEO_TIMEOUTS.COMPLETION_TIMEOUT, isProcessing ? 5000 : VIDEO_TIMEOUTS.COMPLETION_CHECK, 'Video publish completion timeout - could not determine result after 5 minutes');
+    }
+    // Unified publish method for both images and videos
+    async publishContent(type, title, content, mediaPaths, tags = '', browserPath) {
+        // Validate inputs
+        this.validateContentInputs(type, title, content, mediaPaths);
+        if (type === 'image') {
+            return await this.publishNote(title, content, mediaPaths, tags, browserPath);
+        }
+        else {
+            // For videos, only take the first path
+            const videoPath = mediaPaths[0];
+            return await this.publishVideo(title, content, videoPath, tags, browserPath);
+        }
+    }
+    async publishVideo(title, content, videoPath, tags = '', browserPath) {
+        // Validate inputs
+        this.validateVideoInputs(title, content, videoPath);
+        // Validate and resolve video path
+        const resolvedVideoPath = this.validateAndResolveVideoPath(videoPath);
+        try {
+            const page = await this.getBrowserManager().createPage(false, browserPath, true);
+            try {
+                await this.executeVideoPublishWorkflow(page, title, content, resolvedVideoPath, tags);
+                // Save cookies
+                await this.getBrowserManager().saveCookiesFromPage(page);
+                return {
+                    success: true,
+                    message: 'Video published successfully',
+                    title,
+                    content,
+                    imageCount: 0, // Videos don't have image count
+                    tags,
+                    url: this.getConfig().xhs.creatorVideoPublishUrl
+                };
+            }
+            finally {
+                await page.close();
+            }
+        }
+        catch (error) {
+            logger.error(`Video publish error: ${error}`);
+            throw error;
+        }
+    }
+    validateContentInputs(type, title, content, mediaPaths) {
+        if (!title?.trim()) {
+            throw new PublishError(`${type === 'image' ? 'Image' : 'Video'} title cannot be empty`);
+        }
+        if (!content?.trim()) {
+            throw new PublishError(`${type === 'image' ? 'Image' : 'Video'} content cannot be empty`);
+        }
+        if (!mediaPaths || mediaPaths.length === 0) {
+            throw new PublishError(`${type === 'image' ? 'Image' : 'Video'} paths are required`);
+        }
+        if (type === 'image' && mediaPaths.length > 18) {
+            throw new PublishError('Maximum 18 images allowed for image posts');
+        }
+        if (type === 'video' && mediaPaths.length !== 1) {
+            throw new PublishError('Video publishing requires exactly one video file');
+        }
+    }
+    validateVideoInputs(title, content, videoPath) {
+        if (!title?.trim()) {
+            throw new PublishError('Video title cannot be empty');
+        }
+        if (!content?.trim()) {
+            throw new PublishError('Video content cannot be empty');
+        }
+        if (!videoPath?.trim()) {
+            throw new PublishError('Video path is required');
+        }
+    }
+    async executeVideoPublishWorkflow(page, title, content, videoPath, tags) {
+        // Navigate to video upload page
+        await this.getBrowserManager().navigateWithRetry(page, this.getConfig().xhs.creatorVideoPublishUrl);
+        // Wait for page to load
+        await sleep(VIDEO_TIMEOUTS.PAGE_LOAD);
+        // Switch to video upload tab if needed
+        await this.clickVideoUploadTab(page);
+        // Wait for tab switch to complete
+        await sleep(VIDEO_TIMEOUTS.TAB_SWITCH);
+        // Upload video
+        await this.uploadVideo(page, videoPath);
+        // Wait for video to be processed (videos take longer than images)
+        await sleep(VIDEO_TIMEOUTS.VIDEO_PROCESSING);
+        // Fill in title
+        await this.fillTitle(page, title);
+        // Wait a bit for content area to appear
+        await sleep(VIDEO_TIMEOUTS.CONTENT_WAIT);
+        // Fill in content
+        await this.fillContent(page, content);
+        // Add tags if provided
+        if (tags) {
+            await this.addTags(page, tags);
+        }
+        // Submit the video
+        await this.submitPublish(page);
+        // Wait for completion and check result (videos need longer timeout)
+        await this.waitForVideoPublishCompletion(page);
+    }
+    validateAndResolveVideoPath(videoPath) {
+        const resolvedPath = join(process.cwd(), videoPath);
+        if (!existsSync(resolvedPath)) {
+            throw new PublishError(`Video file not found: ${videoPath}`);
+        }
+        const stats = statSync(resolvedPath);
+        if (!stats.isFile()) {
+            throw new PublishError(`Path is not a file: ${videoPath}`);
+        }
+        // Check file extension
+        const ext = videoPath.toLowerCase().split('.').pop();
+        const allowedExtensions = ['mp4', 'mov', 'avi', 'mkv', 'webm', 'flv', 'wmv'];
+        if (!ext || !allowedExtensions.includes(ext)) {
+            throw new PublishError(`Unsupported video format: ${videoPath}. Supported: ${allowedExtensions.join(', ')}`);
+        }
+        // Check file size (XHS typically has limits)
+        const maxSizeInMB = 500; // 500MB limit
+        const fileSizeInMB = stats.size / (1024 * 1024);
+        if (fileSizeInMB > maxSizeInMB) {
+            throw new PublishError(`Video file too large: ${fileSizeInMB.toFixed(2)}MB. Maximum allowed: ${maxSizeInMB}MB`);
+        }
+        return resolvedPath;
+    }
+    async clickVideoUploadTab(page) {
+        try {
+            // Try multiple selectors for video tab
+            const videoTabSelectors = [
+                'div.creator-tab',
+                '.creator-tab',
+                '[role="tab"]',
+                '.tab',
+                'div[class*="tab"]'
+            ];
+            let tabs = [];
+            for (const selector of videoTabSelectors) {
+                const foundTabs = await page.$$(selector);
+                if (foundTabs.length > 0) {
+                    tabs = foundTabs;
+                    break;
+                }
+            }
+            if (tabs.length === 0) {
+                logger.warn('No tabs found for video upload');
+                return;
+            }
+            // Look for the video upload tab specifically
+            let videoTab = null;
+            for (let i = 0; i < tabs.length; i++) {
+                const tab = tabs[i];
+                try {
+                    const isVisible = await tab.isIntersectingViewport();
+                    if (!isVisible)
+                        continue;
+                    const text = await page.evaluate(el => el.textContent, tab);
+                    // Check if this is the video upload tab
+                    if (text && (text.includes('上传视频') || text.includes('视频') || text.includes('video'))) {
+                        videoTab = tab;
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Ignore individual tab errors
+                }
+            }
+            if (videoTab) {
+                await videoTab.click();
+                await sleep(2000); // Wait for tab switch
+            }
+            else {
+                // Fallback: click the first tab (usually video upload)
+                const visibleTabs = [];
+                for (const tab of tabs) {
+                    const isVisible = await tab.isIntersectingViewport();
+                    if (isVisible) {
+                        visibleTabs.push(tab);
+                    }
+                }
+                if (visibleTabs.length > 0) {
+                    await visibleTabs[0].click(); // Usually the first tab is video upload
+                    await sleep(2000);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to click video upload tab: ${error}`);
+        }
+    }
+    async uploadVideo(page, videoPath) {
+        logger.debug(`Uploading video: ${videoPath}`);
+        // Find file input element
+        const fileInput = await this.findElementBySelectors(page, SELECTORS.FILE_INPUT);
+        if (!fileInput) {
+            throw new PublishError('Could not find file upload input on video upload page');
+        }
+        try {
+            // Wait for the input to be ready
+            await sleep(VIDEO_TIMEOUTS.UPLOAD_READY);
+            // Upload the video file
+            await fileInput.uploadFile(videoPath);
+            logger.debug('Video file uploaded, waiting for processing...');
+            // Wait for upload to start and show progress
+            await sleep(VIDEO_TIMEOUTS.UPLOAD_START);
+            // Wait for video processing to complete (this can take a while)
+            await this.waitForVideoProcessing(page);
+        }
+        catch (error) {
+            throw new PublishError(`Failed to upload video ${videoPath}: ${error}`);
+        }
+    }
+    async waitForVideoProcessing(page) {
+        logger.debug('Waiting for video processing to complete...');
+        try {
+            await this.waitForCondition(async () => {
+                // Check if processing is complete
+                const completeResult = await this.checkElementForPatterns(page, SELECTORS.COMPLETION_INDICATORS, TEXT_PATTERNS.SUCCESS);
+                if (completeResult.found) {
+                    logger.debug(`Video processing complete: ${completeResult.text}`);
+                    return true;
+                }
+                // Check if still processing
+                const processingResult = await this.checkElementForPatterns(page, SELECTORS.PROCESSING_INDICATORS, TEXT_PATTERNS.PROCESSING);
+                if (processingResult.found) {
+                    logger.debug(`Video processing: ${processingResult.text}`);
+                    return false; // Still processing, continue waiting
+                }
+                // If not processing and no completion indicator, assume it's done
+                logger.debug('No processing indicators found, assuming video processing complete');
+                return true;
+            }, VIDEO_TIMEOUTS.PROCESSING_TIMEOUT, VIDEO_TIMEOUTS.PROCESSING_CHECK, 'Video processing timeout');
+        }
+        catch (error) {
+            logger.warn('Video processing timeout, continuing anyway...');
+        }
+    }
+}
+//# sourceMappingURL=publish.service.js.map