koishi-plugin-wordpress-notifier 2.9.1 → 2.9.4

package/lib/wordpress.js

@@ -1,23 +1,103 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordPressService = void 0;
+exports.WordPressService = exports.AuthCooldownError = void 0;
 const axios_1 = __importDefault(require("axios"));
+// 动态导入 p-limit
+let pLimit = null;
+// 异步初始化 p-limit
+async function initPLimit() {
+    try {
+        const module = await Promise.resolve().then(() => __importStar(require('p-limit')));
+        pLimit = module.default || module;
+    }
+    catch (error) {
+        // 降级为内部队列实现
+        pLimit = null;
+    }
+}
+// 立即初始化
+initPLimit();
+// 自定义认证冷却错误
+class AuthCooldownError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthCooldownError';
+    }
+}
+exports.AuthCooldownError = AuthCooldownError;
 // 简化实现，避免继承 Service 类的问题
 class WordPressService {
     constructor(ctx, config) {
         this.ctx = ctx;
-        this.isAuthenticated = true; // 认证状态缓存
-        this.authFailureTime = 0; // 认证失败时间戳
-        this.AUTH_FAILURE_COOLDOWN = 5 * 60 * 1000; // 认证失败冷却时间（5分钟）
-        this.interceptorRegistered = false; // 拦截器注册状态
-        this.MAX_RETRIES = 2; // 最大重试次数
-        this.retryCounts = new WeakMap(); // 用于跟踪请求重试次数
+        this.isAuthenticated = true;
+        this.authFailureTime = 0;
+        this.AUTH_FAILURE_COOLDOWN = 5 * 60 * 1000;
+        this.interceptorId = null;
+        this.MAX_RETRIES = 2;
+        this.MAX_CONCURRENT_REQUESTS = 5;
+        this.activeRequests = 0;
+        this.requestQueue = [];
+        this.cache = new Map();
+        this.CACHE_DURATION = 10 * 1000; // 10s 缓存
+        this.cacheCleanupInterval = null;
+        // 监控统计
+        this.stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            commandCount: 0
+        };
         this.config = config;
+        // 初始化时使用内部队列实现，p-limit 会在异步初始化后替换
+        this.limit = null;
+        this.ctx.logger.info('初始化 WordPressService，使用内部队列实现');
         this.client = this.createClient();
         this.setupResponseInterceptor();
+        this.setupCacheCleanup();
+        // 等待 p-limit 初始化完成
+        initPLimit().then(() => {
+            if (pLimit) {
+                this.limit = pLimit(this.MAX_CONCURRENT_REQUESTS);
+                this.ctx.logger.info('p-limit 初始化成功，切换到 p-limit 实现');
+            }
+        });
     }
     createClient() {
         const { wordpressUrl, authType, username, password } = this.config;
@@ -25,33 +105,6 @@ class WordPressService {
             baseURL: wordpressUrl,
             timeout: 10000,
         });
-        // 添加响应重试拦截器
-        client.interceptors.response.use((response) => {
-            // 请求成功，清除重试计数
-            this.retryCounts.delete(response.config);
-            return response;
-        }, async (error) => {
-            const { config } = error;
-            // 如果不是网络错误或超时，不重试
-            if (!error.code || !['ECONNABORTED', 'ETIMEDOUT', 'ECONNREFUSED', 'NETWORK_ERROR'].includes(error.code)) {
-                return Promise.reject(error);
-            }
-            // 检查是否已经达到最大重试次数
-            const currentRetryCount = this.retryCounts.get(config) || 0;
-            const newRetryCount = currentRetryCount + 1;
-            if (newRetryCount > this.MAX_RETRIES) {
-                // 达到最大重试次数，清除计数并拒绝
-                this.retryCounts.delete(config);
-                return Promise.reject(error);
-            }
-            // 更新重试计数
-            this.retryCounts.set(config, newRetryCount);
-            // 指数退避策略
-            const delay = Math.pow(2, newRetryCount - 1) * 1000;
-            this.ctx.logger.info(`Retrying request (${newRetryCount}/${this.MAX_RETRIES}) after ${delay}ms...`);
-            await new Promise(resolve => setTimeout(resolve, delay));
-            return client(config);
-        });
         // 配置认证
         if (authType === 'basic' && username && password) {
             client.defaults.auth = {
@@ -60,67 +113,219 @@ class WordPressService {
             };
         }
         else if (authType === 'application-password' && username && password) {
-            // Use btoa for better compatibility instead of Buffer
             const credentials = `${username}:${password}`;
-            const encodedCredentials = typeof btoa === 'function'
-                ? btoa(credentials)
-                : Buffer.from(credentials).toString('base64');
-            client.defaults.headers.common['Authorization'] = `Basic ${encodedCredentials}`;
+            let encodedCredentials;
+            try {
+                if (typeof Buffer !== 'undefined') {
+                    encodedCredentials = Buffer.from(credentials).toString('base64');
+                }
+                else if (typeof btoa === 'function') {
+                    encodedCredentials = btoa(credentials);
+                }
+                else {
+                    throw new Error('No Base64 encoding method available');
+                }
+                client.defaults.headers.common['Authorization'] = `Basic ${encodedCredentials}`;
+            }
+            catch (error) {
+                this.ctx.logger.error('Failed to configure authentication:', error);
+            }
         }
         return client;
     }
     // 设置响应拦截器
     setupResponseInterceptor() {
-        if (this.interceptorRegistered) {
-            return; // 拦截器已经注册，避免重复注册
+        if (this.interceptorId !== null) {
+            return;
         }
-        this.client.interceptors.response.use((response) => {
-            // 认证成功，重置认证状态
+        this.interceptorId = this.client.interceptors.response.use((response) => {
             this.isAuthenticated = true;
             this.authFailureTime = 0;
             return response;
         }, (error) => {
-            // 检测认证失败
-            if (error.response && (error.response.status === 401 || error.response.status === 403)) {
-                this.isAuthenticated = false;
-                this.authFailureTime = Date.now();
-                this.ctx.logger.warn('WordPress API authentication failed, blocking subsequent requests');
+            if (error.response) {
+                const status = error.response.status;
+                const url = error.config?.url || '';
+                if (status === 401 && (url.includes('/posts') || url.includes('/users'))) {
+                    this.isAuthenticated = false;
+                    this.authFailureTime = Date.now();
+                    this.ctx.logger.warn('WordPress API authentication failed for public endpoint, blocking subsequent requests');
+                }
+                else if (status === 403) {
+                    this.ctx.logger.warn(`WordPress API permission denied for resource: ${url}`);
+                }
             }
             return Promise.reject(error);
         });
-        this.interceptorRegistered = true;
+    }
+    // 移除响应拦截器
+    removeResponseInterceptor() {
+        if (this.interceptorId !== null) {
+            this.client.interceptors.response.eject(this.interceptorId);
+            this.interceptorId = null;
+        }
     }
     // 检查认证状态
     checkAuthStatus() {
-        // 如果未认证且在冷却期内，阻止请求
         if (!this.isAuthenticated && (Date.now() - this.authFailureTime) < this.AUTH_FAILURE_COOLDOWN) {
             this.ctx.logger.warn('Skipping request due to authentication failure cooldown');
             return false;
         }
-        // 冷却期过后，尝试重新认证
         if (!this.isAuthenticated && (Date.now() - this.authFailureTime) >= this.AUTH_FAILURE_COOLDOWN) {
             this.isAuthenticated = true;
             this.ctx.logger.info('Authentication failure cooldown expired, allowing new requests');
         }
         return true;
     }
-    // 获取最新文章
-    async getLatestPosts(perPage = 10, page = 1) {
+    // 执行请求（带并发控制和重试）
+    async executeWithConcurrencyControl(requestFn, config) {
         if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
+            throw new AuthCooldownError('Authentication failed and in cooldown period');
         }
-        try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts`, {
-                params: {
-                    per_page: Math.min(perPage, 100), // 限制每页最多100条
-                    page: Math.max(1, page), // 确保页码至少为1
-                    orderby: 'date',
-                    order: 'desc',
-                    _embed: true // 包含关联数据，如作者信息
+        // 使用 p-limit 或内部队列实现
+        if (this.limit) {
+            return this.limit(async () => {
+                return this.executeWithRetry(requestFn, config);
+            });
+        }
+        else {
+            // 使用内部队列实现
+            return new Promise((resolve, reject) => {
+                const executeRequest = async () => {
+                    try {
+                        this.activeRequests++;
+                        const result = await this.executeWithRetry(requestFn, config);
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                        this.activeRequests--;
+                        this.processNextRequest();
+                    }
+                };
+                if (this.activeRequests < this.MAX_CONCURRENT_REQUESTS) {
+                    executeRequest();
+                }
+                else {
+                    this.ctx.logger.info(`Request queued. Active: ${this.activeRequests}, Queue: ${this.requestQueue.length + 1}`);
+                    this.requestQueue.push(executeRequest);
                 }
             });
-            // 处理响应数据，确保数据结构一致
-            return response.data.map((post) => ({
+        }
+    }
+    // 执行请求（带重试）
+    async executeWithRetry(requestFn, config) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.MAX_RETRIES; attempt++) {
+            const startTime = Date.now();
+            this.stats.totalRequests++;
+            try {
+                const result = await requestFn();
+                const endTime = Date.now();
+                this.stats.successfulRequests++;
+                this.stats.totalResponseTime += endTime - startTime;
+                return result;
+            }
+            catch (error) {
+                const endTime = Date.now();
+                this.stats.failedRequests++;
+                this.stats.totalResponseTime += endTime - startTime;
+                lastError = error;
+                // 仅对 GET 请求进行重试，防止重复写操作
+                const isGetRequest = !config || (config.method?.toUpperCase() ?? 'GET') === 'GET';
+                if (attempt < this.MAX_RETRIES && this.isNetworkError(error) && isGetRequest) {
+                    const delay = Math.pow(2, attempt) * 1000;
+                    this.ctx.logger.info(`Retrying request (${attempt + 1}/${this.MAX_RETRIES}) after ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    // 处理下一个请求
+    processNextRequest() {
+        if (this.requestQueue.length > 0 && this.activeRequests < this.MAX_CONCURRENT_REQUESTS) {
+            const nextRequest = this.requestQueue.shift();
+            if (nextRequest) {
+                this.ctx.logger.info(`Processing next request. Active: ${this.activeRequests}, Queue: ${this.requestQueue.length}`);
+                nextRequest();
+            }
+        }
+    }
+    // 检查是否为网络错误
+    isNetworkError(error) {
+        const axiosError = error;
+        return !axiosError.response && (axiosError.code === 'ECONNABORTED' ||
+            axiosError.code === 'ETIMEDOUT' ||
+            axiosError.code === 'ECONNREFUSED' ||
+            axiosError.code === 'NETWORK_ERROR');
+    }
+    // 获取缓存
+    getCache(key) {
+        const item = this.cache.get(key);
+        if (item && (Date.now() - item.timestamp) < this.CACHE_DURATION) {
+            return item.data;
+        }
+        this.cache.delete(key);
+        return null;
+    }
+    // 设置缓存
+    setCache(key, data) {
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now()
+        });
+        // 清理过期缓存
+        this.cleanupCache();
+    }
+    // 设置缓存定时清理
+    setupCacheCleanup() {
+        // 每30秒清理一次过期缓存
+        this.cacheCleanupInterval = setInterval(() => {
+            this.cleanupCache();
+        }, 30 * 1000);
+    }
+    // 清理过期缓存
+    cleanupCache() {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [key, item] of this.cache.entries()) {
+            if (now - item.timestamp >= this.CACHE_DURATION) {
+                this.cache.delete(key);
+                cleanedCount++;
+            }
+        }
+        if (cleanedCount > 0) {
+            this.ctx.logger.debug(`Cleaned ${cleanedCount} expired cache items`);
+        }
+    }
+    // 获取最新文章
+    async getLatestPosts(perPage = 10, page = 1) {
+        this.stats.commandCount++;
+        const cacheKey = `latest-posts-${perPage}-${page}`;
+        const cachedData = this.getCache(cacheKey);
+        if (cachedData) {
+            return cachedData;
+        }
+        try {
+            // 简化 config，只保留 params
+            const requestParams = {
+                per_page: Math.min(perPage, 100),
+                page: Math.max(1, page),
+                orderby: 'date',
+                order: 'desc',
+                _embed: true
+            };
+            // 修复：axios.get 第二个参数只传 params
+            const response = await this.executeWithConcurrencyControl(() => this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts`, {
+                params: requestParams
+            }), { method: 'GET', params: requestParams }); // 仅传递必要的 config 信息
+            const posts = response.data.map((post) => ({
                 id: post.id,
                 date: post.date,
                 modified: post.modified,
@@ -137,6 +342,8 @@ class WordPressService {
                 author_name: post._embedded?.author?.[0]?.name || '未知作者',
                 featured_image: post._embedded?.['wp:featuredmedia']?.[0]?.source_url
             }));
+            this.setCache(cacheKey, posts);
+            return posts;
         }
         catch (error) {
             this.logError('Failed to get latest posts:', error);
@@ -145,17 +352,23 @@ class WordPressService {
     }
     // 获取文章详情
     async getPostById(id) {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
+        this.stats.commandCount++;
+        const cacheKey = `post-${id}`;
+        const cachedData = this.getCache(cacheKey);
+        if (cachedData) {
+            return cachedData;
         }
         try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts/${id}`, {
-                params: {
-                    _embed: true // 包含关联数据
-                }
-            });
+            // 简化 config，只保留 params
+            const requestParams = {
+                _embed: true
+            };
+            // 修复：axios.get 第二个参数只传 params
+            const response = await this.executeWithConcurrencyControl(() => this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts/${id}`, {
+                params: requestParams
+            }), { method: 'GET', params: requestParams }); // 仅传递必要的 config 信息
             const post = response.data;
-            return {
+            const result = {
                 id: post.id,
                 date: post.date,
                 modified: post.modified,
@@ -172,129 +385,117 @@ class WordPressService {
                 author_name: post._embedded?.author?.[0]?.name || '未知作者',
                 featured_image: post._embedded?.['wp:featuredmedia']?.[0]?.source_url
             };
+            this.setCache(cacheKey, result);
+            return result;
         }
         catch (error) {
             this.logError(`Failed to get post ${id}:`, error);
             throw error;
         }
     }
-    // 获取用户列表
-    async getUsers() {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
+    // 获取最新注册的用户
+    async getLatestUsers(perPage = 10, page = 1) {
+        this.stats.commandCount++;
+        const cacheKey = `latest-users-${perPage}-${page}`;
+        const cachedData = this.getCache(cacheKey);
+        if (cachedData) {
+            return cachedData;
         }
         try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/users`, {
-                params: {
-                    per_page: 100 // 限制最多100个用户
-                }
-            });
-            return response.data.map((user) => ({
+            // 获取最新注册的用户
+            const requestParams = {
+                per_page: Math.min(perPage, 100),
+                page: Math.max(1, page),
+                orderby: 'registered_date',
+                order: 'desc'
+            };
+            const response = await this.executeWithConcurrencyControl(() => this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/users`, {
+                params: requestParams
+            }), { method: 'GET', params: requestParams });
+            const users = response.data.map((user) => ({
                 id: user.id,
                 name: user.name,
-                username: user.username,
+                registered_date: user.registered_date,
                 email: user.email,
-                registered_date: user.register_date || user.registered_date,
-                updated_date: user.updated_date || user.modified || user.register_date || user.registered_date,
-                display_name: user.display_name || user.name
+                link: user.link
             }));
+            this.setCache(cacheKey, users);
+            return users;
         }
         catch (error) {
-            this.logError('Failed to get users:', error);
+            this.logError('Failed to get latest users:', error);
             throw error;
         }
     }
-    // 获取单个用户信息
-    async getUser(userId) {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
-        }
-        try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/users/${userId}`);
-            const user = response.data;
-            return {
-                id: user.id,
-                name: user.name,
-                username: user.username,
-                email: user.email,
-                registered_date: user.register_date || user.registered_date,
-                updated_date: user.updated_date || user.modified || user.register_date || user.registered_date,
-                display_name: user.display_name || user.name
-            };
-        }
-        catch (error) {
-            this.logError(`Failed to get user ${userId}:`, error);
-            return null;
-        }
+    // 获取服务状态
+    getStatus() {
+        const successRate = this.stats.totalRequests > 0
+            ? (this.stats.successfulRequests / this.stats.totalRequests * 100).toFixed(2)
+            : '0.00';
+        const avgResponseTime = this.stats.successfulRequests > 0
+            ? (this.stats.totalResponseTime / this.stats.successfulRequests).toFixed(2)
+            : '0.00';
+        return {
+            wordpressUrl: this.config.wordpressUrl,
+            apiEndpoint: this.config.apiEndpoint || '/wp-json/wp/v2',
+            isAuthenticated: this.isAuthenticated,
+            inCooldown: !this.isAuthenticated && (Date.now() - this.authFailureTime) < this.AUTH_FAILURE_COOLDOWN,
+            cooldownTimeRemaining: Math.max(0, Math.floor((this.AUTH_FAILURE_COOLDOWN - (Date.now() - this.authFailureTime)) / 1000)),
+            stats: {
+                totalRequests: this.stats.totalRequests,
+                successfulRequests: this.stats.successfulRequests,
+                failedRequests: this.stats.failedRequests,
+                successRate: `${successRate}%`,
+                averageResponseTime: `${avgResponseTime}ms`,
+                commandCount: this.stats.commandCount
+            },
+            cache: {
+                size: this.cache.size,
+                duration: this.CACHE_DURATION / 1000,
+                cleanupInterval: 30 // 30秒
+            },
+            concurrency: {
+                max: this.MAX_CONCURRENT_REQUESTS
+            },
+            features: {
+                retryEnabled: true,
+                retryLimit: this.MAX_RETRIES,
+                cacheEnabled: true,
+                concurrencyControl: true
+            }
+        };
     }
-    // 搜索文章
-    async searchPosts(query, perPage = 10) {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
-        }
-        try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts`, {
-                params: {
-                    search: query,
-                    per_page: Math.min(perPage, 100),
-                    orderby: 'relevance',
-                    _embed: true
-                }
-            });
-            return response.data.map((post) => ({
-                id: post.id,
-                date: post.date,
-                modified: post.modified,
-                slug: post.slug,
-                status: post.status,
-                type: post.type,
-                title: post.title,
-                content: post.content,
-                excerpt: post.excerpt,
-                author: post.author,
-                featured_media: post.featured_media,
-                link: post.link,
-                _embedded: post._embedded,
-                author_name: post._embedded?.author?.[0]?.name || '未知作者',
-                featured_image: post._embedded?.['wp:featuredmedia']?.[0]?.source_url
-            }));
+    // 清理资源
+    cleanup() {
+        this.removeResponseInterceptor();
+        this.cache.clear();
+        // 清理定时任务
+        if (this.cacheCleanupInterval) {
+            clearInterval(this.cacheCleanupInterval);
+            this.cacheCleanupInterval = null;
         }
-        catch (error) {
-            this.logError('Failed to search posts:', error);
-            throw error;
+        // 重置所有并发相关状态
+        this.requestQueue = [];
+        this.activeRequests = 0;
+        // 重置 p-limit（可选）
+        if (pLimit) {
+            this.limit = pLimit(this.MAX_CONCURRENT_REQUESTS);
         }
+        this.ctx.logger.info('WordPressService resources cleaned up');
     }
-    // 获取分类列表
-    async getCategories() {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
-        }
-        try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/categories`);
-            return response.data;
-        }
-        catch (error) {
-            this.logError('Failed to get categories:', error);
-            throw error;
-        }
-    }
-    // 获取标签列表
-    async getTags() {
-        if (!this.checkAuthStatus()) {
-            throw new Error('Authentication failed and in cooldown period');
-        }
-        try {
-            const response = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/tags`);
-            return response.data;
-        }
-        catch (error) {
-            this.logError('Failed to get tags:', error);
-            throw error;
-        }
+    // 重置统计数据
+    resetStats() {
+        this.stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            commandCount: 0
+        };
+        this.ctx.logger.info('Statistics reset');
     }
     // 脱敏日志记录
     logError(message, error) {
-        // 检查并脱敏错误对象中的敏感信息
         const sanitizedError = this.sanitizeError(error);
         this.ctx.logger.error(message, sanitizedError);
     }
@@ -302,9 +503,7 @@ class WordPressService {
     sanitizeError(error) {
         if (!error)
             return error;
-        // 创建错误副本
         const sanitized = { ...error };
-        // 脱敏 config 中的敏感信息
         if (sanitized.config) {
             sanitized.config = {
                 ...sanitized.config,
@@ -315,7 +514,6 @@ class WordPressService {
                 } : undefined
             };
         }
-        // 脱敏 response 中的敏感信息
         if (sanitized.response) {
             sanitized.response = {
                 ...sanitized.response,
@@ -324,72 +522,5 @@ class WordPressService {
         }
         return sanitized;
     }
-    // 重置认证状态
-    resetAuthStatus() {
-        this.isAuthenticated = true;
-        this.authFailureTime = 0;
-        this.ctx.logger.info('Authentication status reset');
-    }
-    // 获取认证状态
-    getAuthStatus() {
-        return this.isAuthenticated;
-    }
-    // 检查 WordPress 连接状态
-    async checkConnection() {
-        try {
-            // 尝试访问 WordPress 站点的根目录
-            const rootResponse = await this.client.get('/', {
-                timeout: 5000
-            });
-            // 尝试访问 WordPress REST API
-            const apiResponse = await this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/posts`, {
-                params: {
-                    per_page: 1,
-                    _embed: false
-                },
-                timeout: 5000
-            });
-            return {
-                success: true,
-                message: 'WordPress site is accessible and API is working',
-                details: {
-                    rootStatus: rootResponse.status,
-                    apiStatus: apiResponse.status,
-                    apiVersion: this.config.apiEndpoint || 'wp/v2'
-                }
-            };
-        }
-        catch (error) {
-            this.logError('Connection check failed:', error);
-            if (error.code === 'ECONNREFUSED') {
-                return {
-                    success: false,
-                    message: 'Connection refused: WordPress site is not reachable'
-                };
-            }
-            else if (error.code === 'ETIMEDOUT') {
-                return {
-                    success: false,
-                    message: 'Connection timed out: WordPress site is slow or unresponsive'
-                };
-            }
-            else if (error.response?.status === 401 || error.response?.status === 403) {
-                return {
-                    success: false,
-                    message: 'Authentication failed: Invalid credentials or insufficient permissions'
-                };
-            }
-            else if (error.response?.status === 404) {
-                return {
-                    success: false,
-                    message: 'API endpoint not found: WordPress REST API may not be enabled'
-                };
-            }
-            return {
-                success: false,
-                message: `Connection failed: ${error.message || 'Unknown error'}`
-            };
-        }
-    }
 }
 exports.WordPressService = WordPressService;