@anyul/koishi-plugin-rss 5.2.3 → 5.2.4

package/lib/core/feeder-arg.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatArg = formatArg;
+exports.mixinArg = mixinArg;
+const legacy_config_1 = require("../utils/legacy-config");
+const logger_1 = require("../utils/logger");
+const ARG_ENTRY_KEYS = [
+    'forceLength',
+    'reverse',
+    'timeout',
+    'interval',
+    'merge',
+    'maxRssItem',
+    'firstLoad',
+    'bodyWidth',
+    'bodyPadding',
+    'bodyFontSize',
+    'split',
+    'filter',
+    'block',
+    'proxyAgent',
+];
+const BOOLEAN_ARG_KEYS = new Set(['firstLoad', 'reverse', 'merge']);
+const NUMBER_ARG_KEYS = new Set([
+    'forceLength',
+    'timeout',
+    'interval',
+    'maxRssItem',
+    'bodyWidth',
+    'bodyPadding',
+    'bodyFontSize',
+    'split',
+]);
+const ARRAY_ARG_KEYS = new Set(['filter', 'block']);
+const FALSE_CONTENT = new Set(['false', 'null', 'none', '']);
+function parseArrayArg(value) {
+    return value
+        .split('/')
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+function extractKnownArgEntries(arg) {
+    if (!arg)
+        return {};
+    const pattern = new RegExp(`(^|,)\\s*(${ARG_ENTRY_KEYS.join('|')})\\s*:`, 'g');
+    const matches = [...arg.matchAll(pattern)];
+    const result = {};
+    for (let index = 0; index < matches.length; index++) {
+        const currentMatch = matches[index];
+        const nextMatch = matches[index + 1];
+        const key = currentMatch[2];
+        const valueStart = (currentMatch.index ?? 0) + currentMatch[0].length;
+        const valueEnd = nextMatch?.index ?? arg.length;
+        result[key] = arg.slice(valueStart, valueEnd).replace(/,\s*$/, '').trim();
+    }
+    return result;
+}
+function parseBooleanArg(value) {
+    return !FALSE_CONTENT.has(String(value ?? '').trim().toLowerCase());
+}
+function parseNumberArg(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function normalizeScalarArgValue(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    return value.split(',')[0].trim();
+}
+function parseProxyAgentArg(value, auth) {
+    if (typeof value === 'object' && value !== null) {
+        return value;
+    }
+    const normalizedValue = String(normalizeScalarArgValue(value) ?? '').trim();
+    if (FALSE_CONTENT.has(normalizedValue.toLowerCase())) {
+        return { enabled: false };
+    }
+    const proxyUrl = normalizedValue.includes('://') ? normalizedValue : `http://${normalizedValue}`;
+    try {
+        const parsedUrl = new URL(proxyUrl);
+        const protocol = parsedUrl.protocol.replace(':', '') || 'http';
+        const host = parsedUrl.hostname;
+        const port = parsedUrl.port ? parseInt(parsedUrl.port, 10) : 7890;
+        if (!host)
+            return undefined;
+        const proxyAgent = {
+            enabled: true,
+            protocol,
+            host,
+            port,
+        };
+        if (auth) {
+            const [username = '', password = ''] = auth.split('/');
+            if (username) {
+                proxyAgent.auth = { enabled: true, username, password };
+            }
+        }
+        return proxyAgent;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeProxyAgent(argProxy, configProxy, config) {
+    (0, logger_1.debug)(config, `合并代理配置 - argProxy: ${JSON.stringify(argProxy)}, configProxy.enabled: ${configProxy?.enabled}`, 'proxy merge debug', 'details');
+    if (argProxy?.enabled === false) {
+        (0, logger_1.debug)(config, '订阅明确禁用代理', 'proxy merge', 'details');
+        return { enabled: false };
+    }
+    if (argProxy?.enabled === true && argProxy?.host) {
+        (0, logger_1.debug)(config, '使用订阅的代理配置', 'proxy merge', 'details');
+        return argProxy;
+    }
+    const shouldUseConfigProxy = !argProxy || Object.keys(argProxy || {}).length === 0 || argProxy?.enabled === undefined || argProxy?.enabled === null;
+    if (shouldUseConfigProxy) {
+        if (configProxy?.enabled) {
+            const result = {
+                enabled: true,
+                protocol: configProxy.protocol,
+                host: configProxy.host,
+                port: configProxy.port,
+                auth: configProxy.auth?.enabled ? configProxy.auth : undefined,
+            };
+            (0, logger_1.debug)(config, `使用全局代理: ${result.protocol}://${result.host}:${result.port}`, 'proxy merge', 'info');
+            return result;
+        }
+        (0, logger_1.debug)(config, '全局代理未启用', 'proxy merge', 'details');
+    }
+    if (argProxy?.enabled === true && !argProxy?.host) {
+        const result = {
+            ...configProxy,
+            ...argProxy,
+            auth: configProxy?.auth?.enabled ? configProxy.auth : undefined,
+        };
+        (0, logger_1.debug)(config, '订阅代理配置不完整，补充全局配置', 'proxy merge', 'details');
+        return result;
+    }
+    (0, logger_1.debug)(config, '代理未配置，使用默认(禁用)', 'proxy merge', 'details');
+    return { enabled: false };
+}
+function mergeProxyAgentWithLog(argProxy, configProxy, config) {
+    const result = mergeProxyAgent(argProxy, configProxy, config);
+    (0, logger_1.debug)(config, `[DEBUG_PROXY] mergeProxyAgent input: arg=${JSON.stringify(argProxy)} conf=${JSON.stringify(configProxy)} output=${JSON.stringify(result)}`, 'proxy merge', 'details');
+    return result;
+}
+/**
+ * 将命令选项解析为订阅参数对象。
+ *
+ * @param options - 命令选项
+ * @param config - 插件配置
+ * @returns 解析后的订阅参数
+ */
+function formatArg(options, config) {
+    const { arg, template, auth } = options || {};
+    const rawEntries = typeof arg === 'string'
+        ? extractKnownArgEntries(arg)
+        : (arg || {});
+    const json = {};
+    for (const [rawKey, rawValue] of Object.entries(rawEntries)) {
+        const key = rawKey;
+        if (!ARG_ENTRY_KEYS.includes(key))
+            continue;
+        if (key === 'proxyAgent') {
+            const proxyAgent = parseProxyAgentArg(rawValue, auth);
+            if (proxyAgent) {
+                json.proxyAgent = proxyAgent;
+            }
+            continue;
+        }
+        if (ARRAY_ARG_KEYS.has(key)) {
+            if (Array.isArray(rawValue)) {
+                json[key] = rawValue.filter(Boolean);
+            }
+            else {
+                const parsedArray = parseArrayArg(String(rawValue ?? ''));
+                if (parsedArray.length) {
+                    json[key] = parsedArray;
+                }
+            }
+            continue;
+        }
+        if (BOOLEAN_ARG_KEYS.has(key)) {
+            json[key] = parseBooleanArg(normalizeScalarArgValue(rawValue));
+            continue;
+        }
+        if (NUMBER_ARG_KEYS.has(key)) {
+            const parsedNumber = parseNumberArg(normalizeScalarArgValue(rawValue));
+            if (parsedNumber !== undefined) {
+                json[key] = parsedNumber;
+            }
+            continue;
+        }
+        if (rawValue !== undefined && rawValue !== null && String(rawValue).trim() !== '') {
+            json[key] = String(rawValue).trim();
+        }
+    }
+    if (template && config.template) {
+        json.template = template;
+    }
+    if (typeof json.interval === 'number')
+        json.interval *= 1000;
+    return json;
+}
+/**
+ * 合并全局配置与订阅级参数。
+ *
+ * @param arg - 订阅级参数
+ * @param config - 插件配置
+ * @returns 合并后的运行时参数
+ */
+function mixinArg(arg, config) {
+    const normalizedArg = (0, legacy_config_1.normalizeSubscriptionArg)(arg);
+    const mergedProxy = mergeProxyAgentWithLog(normalizedArg?.proxyAgent, config.net?.proxyAgent, config);
+    if (mergedProxy?.enabled) {
+        (0, logger_1.debug)(config, `使用代理: ${mergedProxy.protocol}://${mergedProxy.host}:${mergedProxy.port}`, 'proxy merge', 'details');
+    }
+    else {
+        (0, logger_1.debug)(config, '代理未启用', 'proxy merge', 'details');
+    }
+    const baseConfig = (0, legacy_config_1.normalizeBasicConfig)({
+        ...config.basic,
+    });
+    const result = (0, legacy_config_1.normalizeSubscriptionArg)({
+        ...baseConfig,
+        ...normalizedArg,
+        filter: [...(config.msg?.keywordFilter || []), ...(normalizedArg?.filter || [])],
+        block: [...(config.msg?.keywordBlock || []), ...(normalizedArg?.block || [])],
+        template: normalizedArg.template ?? baseConfig.defaultTemplate,
+        proxyAgent: mergedProxy,
+    });
+    (0, logger_1.debug)(config, `[DEBUG_PROXY] mixinArg return: ${JSON.stringify(result.proxyAgent)}`, 'mixin', 'details');
+    return result;
+}

package/lib/core/feeder-runtime.d.ts

@@ -0,0 +1,96 @@
+import { Context } from 'koishi';
+import { Config, rssArg } from '../types';
+import { createDebugWithContext } from '../utils/logger';
+import { RssItemProcessor } from './item-processor';
+type FeedDebugFn = ReturnType<typeof createDebugWithContext>;
+/**
+ * 构建订阅抓取日志上下文。
+ *
+ * @param rssItem - 订阅记录
+ * @returns 日志上下文
+ */
+export declare function buildFeedLogContext(rssItem: any): Record<string, any>;
+/**
+ * 创建带订阅上下文的调试函数。
+ *
+ * @param config - 插件配置
+ * @param rssItem - 订阅记录
+ * @returns 调试函数
+ */
+export declare function createFeedDebug(config: Config, rssItem: any): FeedDebugFn;
+/**
+ * 根据序号、URL 或标题查找订阅项。
+ *
+ * @param rssList - 订阅列表
+ * @param keyword - 查找关键字
+ * @returns 匹配到的订阅项
+ */
+export declare function findRssItem(rssList: any[], keyword: number | string): any;
+/**
+ * 提取用于去重的内容字段。
+ *
+ * @param item - RSS 条目
+ * @param _config - 插件配置（保留兼容签名）
+ * @returns 去重内容对象
+ */
+export declare function getLastContent(item: any, _config: Config): any;
+/**
+ * 抓取订阅的所有 RSS 条目。
+ *
+ * @param ctx - Koishi 上下文
+ * @param config - 插件配置
+ * @param $http - HTTP 函数
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 抓取到的条目列表
+ */
+export declare function fetchRssItems(ctx: Context, config: Config, $http: any, rssItem: any, arg: rssArg, feedDebug: FeedDebugFn): Promise<any[]>;
+/**
+ * 按过滤词过滤抓取结果。
+ *
+ * @param items - 原始条目列表
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 过滤后的条目列表
+ */
+export declare function filterItems(items: any[], arg: rssArg, feedDebug: FeedDebugFn): any[];
+/**
+ * 检查条目是否为新增或更新内容。
+ *
+ * @param config - 插件配置
+ * @param rssItem - 订阅记录
+ * @param items - 过滤后的条目列表
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 新条目、最新发布时间与当前去重内容
+ */
+export declare function checkForUpdates(config: Config, rssItem: any, items: any[], arg: rssArg, feedDebug: FeedDebugFn): {
+    newItems: any[];
+    latestPubDate: Date;
+    currentContent: any[];
+};
+/**
+ * 将 RSS 条目解析为待发送消息。
+ *
+ * @param processor - 条目处理器
+ * @param items - 待发送条目
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @returns 消息列表与发送顺序条目列表
+ */
+export declare function generateMessages(processor: RssItemProcessor, items: any[], rssItem: any, arg: rssArg): Promise<{
+    messageList: string[];
+    itemsToSend: any[];
+}>;
+/**
+ * 构建最终入队消息内容。
+ *
+ * @param config - 插件配置
+ * @param messageList - 消息片段列表
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @returns 最终发送消息
+ */
+export declare function buildFinalMessage(config: Config, messageList: string[], rssItem: any, arg: rssArg): string;
+export {};

package/lib/core/feeder-runtime.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFeedLogContext = buildFeedLogContext;
+exports.createFeedDebug = createFeedDebug;
+exports.findRssItem = findRssItem;
+exports.getLastContent = getLastContent;
+exports.fetchRssItems = fetchRssItems;
+exports.filterItems = filterItems;
+exports.checkForUpdates = checkForUpdates;
+exports.generateMessages = generateMessages;
+exports.buildFinalMessage = buildFinalMessage;
+const koishi_1 = require("koishi");
+const constants_1 = require("../constants");
+const common_1 = require("../utils/common");
+const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
+const legacy_config_1 = require("../utils/legacy-config");
+const logger_1 = require("../utils/logger");
+const parser_1 = require("./parser");
+/**
+ * 构建订阅抓取日志上下文。
+ *
+ * @param rssItem - 订阅记录
+ * @returns 日志上下文
+ */
+function buildFeedLogContext(rssItem) {
+    return {
+        subscribeId: String(rssItem.id),
+        rssId: rssItem.rssId || rssItem.title,
+        rssTitle: rssItem.title,
+        url: rssItem.url,
+        guildId: rssItem.guildId,
+        platform: rssItem.platform,
+    };
+}
+/**
+ * 创建带订阅上下文的调试函数。
+ *
+ * @param config - 插件配置
+ * @param rssItem - 订阅记录
+ * @returns 调试函数
+ */
+function createFeedDebug(config, rssItem) {
+    return (0, logger_1.createDebugWithContext)(config, buildFeedLogContext(rssItem));
+}
+/**
+ * 根据序号、URL 或标题查找订阅项。
+ *
+ * @param rssList - 订阅列表
+ * @param keyword - 查找关键字
+ * @returns 匹配到的订阅项
+ */
+function findRssItem(rssList, keyword) {
+    if (typeof keyword === 'number' || /^\d+$/.test(String(keyword))) {
+        const listIndex = parseInt(String(keyword)) - 1;
+        if (listIndex >= 0 && listIndex < rssList.length) {
+            return rssList[listIndex];
+        }
+    }
+    const index = ((rssList.findIndex(i => i.rssId === +keyword) + 1) ||
+        (rssList.findIndex(i => i.url == keyword) + 1) ||
+        (rssList.findIndex(i => i.url.indexOf(keyword) + 1) + 1) ||
+        (rssList.findIndex(i => i.title.indexOf(keyword) + 1) + 1)) - 1;
+    if (index < 0 || index >= rssList.length) {
+        return undefined;
+    }
+    return rssList[index];
+}
+/**
+ * 提取用于去重的内容字段。
+ *
+ * @param item - RSS 条目
+ * @param _config - 插件配置（保留兼容签名）
+ * @returns 去重内容对象
+ */
+function getLastContent(item, _config) {
+    const keys = ['title', 'description', 'link', 'guid'];
+    const obj = Object.assign({}, ...keys.map(key => (0, koishi_1.clone)(item?.[key]) ? { [key]: item[key] } : {}));
+    return { ...obj, description: String(obj?.description).replaceAll(/\s/g, '') };
+}
+/**
+ * 抓取订阅的所有 RSS 条目。
+ *
+ * @param ctx - Koishi 上下文
+ * @param config - 插件配置
+ * @param $http - HTTP 函数
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 抓取到的条目列表
+ */
+async function fetchRssItems(ctx, config, $http, rssItem, arg, feedDebug) {
+    const rssHubUrl = config.msg?.rssHubUrl || 'https://hub.slarker.me';
+    try {
+        const urls = rssItem.url.split('|').map((url) => (0, common_1.parseQuickUrl)(url, rssHubUrl, constants_1.quickList));
+        const results = await Promise.all(urls.map(async (url) => await (0, parser_1.getRssData)(ctx, config, $http, url, arg)));
+        return results.flat(1);
+    }
+    catch (error) {
+        const normalizedError = (0, error_handler_1.normalizeError)(error);
+        feedDebug(`Fetch failed for ${rssItem.title}: ${normalizedError.message}`, 'feeder', 'error', {
+            stage: 'fetch',
+        });
+        (0, error_tracker_1.trackError)(normalizedError, {
+            ...buildFeedLogContext(rssItem),
+            stage: 'fetch',
+        });
+        return [];
+    }
+}
+/**
+ * 按过滤词过滤抓取结果。
+ *
+ * @param items - 原始条目列表
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 过滤后的条目列表
+ */
+function filterItems(items, arg, feedDebug) {
+    return items.filter(item => {
+        const matchKeyword = arg.filter?.find((keyword) => new RegExp(keyword, 'im').test(item.title) || new RegExp(keyword, 'im').test(item.description));
+        if (matchKeyword) {
+            feedDebug(`filter:${matchKeyword}`, 'feeder', 'info', { matchedKeyword: matchKeyword });
+            feedDebug(item, 'filter rss item', 'info', { matchedKeyword: matchKeyword });
+        }
+        return !matchKeyword;
+    });
+}
+/**
+ * 检查条目是否为新增或更新内容。
+ *
+ * @param config - 插件配置
+ * @param rssItem - 订阅记录
+ * @param items - 过滤后的条目列表
+ * @param arg - 运行时参数
+ * @param feedDebug - 调试函数
+ * @returns 新条目、最新发布时间与当前去重内容
+ */
+function checkForUpdates(config, rssItem, items, arg, feedDebug) {
+    const resendUpdatedContent = (0, legacy_config_1.getResendUpdatedContent)(config);
+    let itemArray = items
+        .sort((a, b) => (0, common_1.parsePubDate)(config, b.pubDate).getTime() - (0, common_1.parsePubDate)(config, a.pubDate).getTime());
+    if (itemArray.length === 0) {
+        return { newItems: [], latestPubDate: new Date(), currentContent: [] };
+    }
+    const latestItem = itemArray[0];
+    const lastPubDate = (0, common_1.parsePubDate)(config, latestItem.pubDate);
+    feedDebug(`${rssItem.title}: Latest item date=${lastPubDate.toISOString()}, DB date=${rssItem.lastPubDate ? new Date(rssItem.lastPubDate).toISOString() : 'none'}`, 'feeder', 'details');
+    const currentContent = resendUpdatedContent === 'all'
+        ? itemArray.map((item) => getLastContent(item, config))
+        : [getLastContent(latestItem, config)];
+    if (arg.reverse) {
+        itemArray = itemArray.reverse();
+    }
+    let rssItemArray = [];
+    if (rssItem.arg.forceLength) {
+        rssItemArray = itemArray.slice(0, rssItem.arg.forceLength);
+        feedDebug(`${rssItem.title}: Force length mode, taking ${rssItemArray.length} items`, 'feeder', 'details');
+    }
+    else {
+        feedDebug(`${rssItem.title}: Checking ${itemArray.length} items for updates`, 'feeder', 'details');
+        rssItemArray = itemArray.filter((item, index) => {
+            const currentItemTime = (0, common_1.parsePubDate)(config, item.pubDate).getTime();
+            const lastTime = rssItem.lastPubDate ? (0, common_1.parsePubDate)(config, rssItem.lastPubDate).getTime() : 0;
+            feedDebug(`[${index}] ${item.title?.substring(0, 30)}: time=${new Date(currentItemTime).toISOString()} > last=${new Date(lastTime).toISOString()} ? ${currentItemTime > lastTime}`, 'feeder', 'details');
+            if (currentItemTime > lastTime) {
+                feedDebug(`[${index}] ✓ Item is new (time check)`, 'feeder', 'details');
+                return true;
+            }
+            if (resendUpdatedContent !== 'disable') {
+                const newItemContent = getLastContent(item, config);
+                const oldItemMatch = rssItem.lastContent?.itemArray?.find((old) => (newItemContent.guid && old.guid === newItemContent.guid) ||
+                    (old.link === newItemContent.link && old.title === newItemContent.title));
+                if (oldItemMatch) {
+                    const descriptionChanged = JSON.stringify(oldItemMatch.description) !== JSON.stringify(newItemContent.description);
+                    if (descriptionChanged) {
+                        feedDebug(`[${index}] ✓ Item is updated (content changed)`, 'feeder', 'details');
+                    }
+                    else {
+                        feedDebug(`[${index}] ✗ Item filtered (already sent)`, 'feeder', 'details');
+                    }
+                    return descriptionChanged;
+                }
+                feedDebug(`[${index}] ✗ Item filtered (no match in lastContent)`, 'feeder', 'details');
+            }
+            feedDebug(`[${index}] ✗ Item filtered (failed all checks)`, 'feeder', 'details');
+            return false;
+        });
+        if (arg.maxRssItem) {
+            rssItemArray = rssItemArray.slice(0, arg.maxRssItem);
+        }
+    }
+    return { newItems: rssItemArray, latestPubDate: lastPubDate, currentContent };
+}
+/**
+ * 将 RSS 条目解析为待发送消息。
+ *
+ * @param processor - 条目处理器
+ * @param items - 待发送条目
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @returns 消息列表与发送顺序条目列表
+ */
+async function generateMessages(processor, items, rssItem, arg) {
+    const itemsToSend = [...items].reverse();
+    const messageList = (await Promise.all(itemsToSend.map(async (item) => await processor.parseRssItem(item, { ...rssItem, ...arg }, rssItem.author)))).filter(message => message);
+    return { messageList, itemsToSend };
+}
+/**
+ * 构建最终入队消息内容。
+ *
+ * @param config - 插件配置
+ * @param messageList - 消息片段列表
+ * @param rssItem - 订阅记录
+ * @param arg - 运行时参数
+ * @returns 最终发送消息
+ */
+function buildFinalMessage(config, messageList, rssItem, arg) {
+    let message = '';
+    const shouldMerge = arg.merge === true || config.basic?.merge === '一直合并' || (config.basic?.merge === '有多条更新时合并' && messageList.length > 1);
+    const hasVideo = (0, legacy_config_1.shouldMergeVideo)(config) && messageList.some(msg => /<video/.test(msg));
+    if (shouldMerge || hasVideo) {
+        message = `<message forward><author id="${rssItem.author}"/>${messageList.map(msg => `<message>${msg}</message>`).join('')}</message>`;
+    }
+    else {
+        message = messageList.join('');
+    }
+    if (rssItem.followers && rssItem.followers.length > 0) {
+        const mentions = rssItem.followers.map((id) => `<at ${id === 'all' ? 'type="all"' : `id="${id}"`}/>`).join(' ');
+        message += `<message>${mentions}</message>`;
+    }
+    return message;
+}

package/lib/core/feeder.d.ts

@@ -1,5 +1,5 @@
 import { Context } from 'koishi';
-import { Config, rssArg } from '../types';
+import { Config } from '../types';
 import { RssItemProcessor } from './item-processor';
 import { NotificationQueueManager } from './notification-queue';
 export interface FeederDependencies {
@@ -8,10 +8,8 @@ export interface FeederDependencies {
     $http: any;
     queueManager: NotificationQueueManager;
 }
-export declare function findRssItem(rssList: any[], keyword: number | string): any;
-export declare function getLastContent(item: any, config: Config): any;
-export declare function formatArg(options: any, config: Config): rssArg;
-export declare function mixinArg(arg: any, config: Config): rssArg;
+export { formatArg, mixinArg } from './feeder-arg';
+export { findRssItem, getLastContent } from './feeder-runtime';
 /**
  * 生产者：抓取 RSS，发现新消息，存入队列
  */