koishi-plugin-wordpress-notifier 2.9.0 → 2.9.1

package/lib/wordpress.js

@@ -0,0 +1,395 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordPressService = void 0;
+const axios_1 = __importDefault(require("axios"));
+// 简化实现，避免继承 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.config = config;
+        this.client = this.createClient();
+        this.setupResponseInterceptor();
+    }
+    createClient() {
+        const { wordpressUrl, authType, username, password } = this.config;
+        const client = axios_1.default.create({
+            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 = {
+                username,
+                password
+            };
+        }
+        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}`;
+        }
+        return client;
+    }
+    // 设置响应拦截器
+    setupResponseInterceptor() {
+        if (this.interceptorRegistered) {
+            return; // 拦截器已经注册，避免重复注册
+        }
+        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');
+            }
+            return Promise.reject(error);
+        });
+        this.interceptorRegistered = true;
+    }
+    // 检查认证状态
+    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) {
+        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: {
+                    per_page: Math.min(perPage, 100), // 限制每页最多100条
+                    page: Math.max(1, page), // 确保页码至少为1
+                    orderby: 'date',
+                    order: 'desc',
+                    _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
+            }));
+        }
+        catch (error) {
+            this.logError('Failed to get latest posts:', error);
+            throw error;
+        }
+    }
+    // 获取文章详情
+    async getPostById(id) {
+        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/${id}`, {
+                params: {
+                    _embed: true // 包含关联数据
+                }
+            });
+            const post = response.data;
+            return {
+                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
+            };
+        }
+        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');
+        }
+        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) => ({
+                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 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;
+        }
+    }
+    // 搜索文章
+    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
+            }));
+        }
+        catch (error) {
+            this.logError('Failed to search posts:', error);
+            throw error;
+        }
+    }
+    // 获取分类列表
+    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;
+        }
+    }
+    // 脱敏日志记录
+    logError(message, error) {
+        // 检查并脱敏错误对象中的敏感信息
+        const sanitizedError = this.sanitizeError(error);
+        this.ctx.logger.error(message, sanitizedError);
+    }
+    // 脱敏错误对象
+    sanitizeError(error) {
+        if (!error)
+            return error;
+        // 创建错误副本
+        const sanitized = { ...error };
+        // 脱敏 config 中的敏感信息
+        if (sanitized.config) {
+            sanitized.config = {
+                ...sanitized.config,
+                auth: sanitized.config.auth ? { username: '***', password: '***' } : undefined,
+                headers: sanitized.config.headers ? {
+                    ...sanitized.config.headers,
+                    Authorization: sanitized.config.headers.Authorization ? '***' : undefined
+                } : undefined
+            };
+        }
+        // 脱敏 response 中的敏感信息
+        if (sanitized.response) {
+            sanitized.response = {
+                ...sanitized.response,
+                config: sanitized.response.config ? this.sanitizeError(sanitized.response.config) : undefined
+            };
+        }
+        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;

package/package.json

@@ -1,46 +1,39 @@
 {
   "name": "koishi-plugin-wordpress-notifier",
-  "version": "2.9.0",
-  "description": "WordPress 文章自动推送到 QQ",
+  "version": "2.9.1",
+  "description": "WordPress 文章自动推送插件",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
-    "lib",
-    "data"
+    "lib"
   ],
-  "license": "MIT",
-  "author": "kate522@88.com",
-  "scripts": {
-    "build": "tsc",
-    "build:watch": "tsc --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "koishi": "^4.18.10"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
-  },
-  "peerDependencies": {
-    "koishi": "^4.18.10"
-  },
   "keywords": [
     "koishi",
     "plugin",
     "wordpress",
-    "notifier",
-    "qq"
+    "push"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Lexo0522/koishi-plugin-wordpress-notifier.git"
+  "author": {
+    "name": "kate522",
+    "email": "kate522@88.com",
+    "url": "https://github.com/Lexo0522/koishi-plugin-wordpress-notifier"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "koishi": "^4.15.0"
+  },
+  "dependencies": {
+    "axios": "^1.13.5"
   },
-  "homepage": "https://github.com/Lexo0522/koishi-plugin-wordpress-notifier#readme",
-  "bugs": {
-    "url": "https://github.com/Lexo0522/koishi-plugin-wordpress-notifier/issues"
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "koishi": "^4.15.0",
+    "koishi-test-utils": "^3.0.0",
+    "typescript": "^5.0.0"
   },
-  "engines": {
-    "node": ">=14.0.0"
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest"
   }
 }