@anyul/koishi-plugin-rss 5.2.2 → 5.2.4

package/lib/commands/subscription-edit.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionEditCommand = registerSubscriptionEditCommand;
+const utils_1 = require("./utils");
+function registerSubscriptionEditCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.edit <id:number>', '修改订阅配置')
+        .alias('rsso.edit')
+        .usage(`修改订阅的配置项
+
+用法:
+  rsso.edit 1 -t "新标题"        - 修改标题
+  rsso.edit 1 -i content         - 修改模板
+  rsso.edit 1 -u https://...      - 修改URL
+  rsso.edit 1 -s ".item"         - 修改选择器（HTML监控）
+  rsso.edit 1 --target onebot:123  - 修改推送目标（高级权限）
+  rsso.edit 1 --target "onebot:123,telegram:456"  - 多个推送目标（高级权限）⭐
+  rsso.edit 1 -t "新标题" --test  - 测试修改（不保存）
+
+示例:
+  rsso.edit 1 -t "我的订阅"
+  rsso.edit 1 -i custom
+  rsso.edit 1 --target onebot:123456
+  rsso.edit 1 --target "onebot:123,telegram:456"
+
+💡 提示:
+  - 使用列表序号（1, 2, 3...）而不是数据库ID
+  - 推送目标格式: platform:guildId
+  - 多个目标用逗号分隔或多次使用 --target
+    `)
+        .option('title', '-t <title> 修改标题', { type: 'string' })
+        .option('url', '-u <url> 修改URL', { type: 'string' })
+        .option('template', '-i <template> 修改模板', { type: 'string' })
+        .option('selector', '-s <selector> 修改选择器（HTML监控）', { type: 'string' })
+        .option('target', '--target <target> 修改推送目标（高级权限）')
+        .option('test', '--test 测试修改（不保存）')
+        .example('rsso.edit 1 -t "新标题"')
+        .action(async ({ session, options }, id) => {
+        const { guildId, platform, authority } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await deps.ctx.database.get('rssOwl', { platform, guildId });
+        const listIndex = id - 1;
+        if (listIndex < 0 || listIndex >= rssList.length) {
+            return `❌ 序号 ${id} 不存在\n当前共有 ${rssList.length} 个订阅\n\n使用 rsso.list 查看完整列表`;
+        }
+        const rssItem = rssList[listIndex];
+        const baseAuthorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.authority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.authority} 或以上`);
+        if (!baseAuthorityCheck.success)
+            return baseAuthorityCheck.message;
+        if (options.target) {
+            const targetAuthorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.advancedAuthority, `❌ 修改推送目标需要高级权限\n当前权限: ${authority}，需要权限: ${deps.config.basic.advancedAuthority} 或以上`);
+            if (!targetAuthorityCheck.success)
+                return targetAuthorityCheck.message;
+        }
+        const hasChanges = options.title || options.url || options.template || options.selector || options.target;
+        if (!hasChanges) {
+            return '请指定要修改的内容\n可用选项: -t (标题), -u (URL), -i (模板), -s (选择器), --target (推送目标)\n使用 --help 查看详细帮助';
+        }
+        const parseResult = (0, utils_1.parseTargets)(options.target);
+        if (parseResult.invalidTarget) {
+            return `❌ 推送目标格式错误: "${parseResult.invalidTarget}"\n正确格式: platform:guildId\n示例: onebot:123456\n\n支持多个目标，用逗号分隔:\n  --target "onebot:123,telegram:456"`;
+        }
+        if (options.test) {
+            return buildEditPreview(rssItem, id, options, parseResult.targets);
+        }
+        return saveSubscriptionChanges(deps.ctx, rssItem, id, options, parseResult.targets);
+    });
+}
+function buildEditPreview(rssItem, id, options, parsedTargets) {
+    let testOutput = `📝 修改预览 [序号:${id} | ID:${rssItem.id}]\n\n`;
+    testOutput += `当前标题: ${rssItem.title}\n`;
+    testOutput += `当前URL: ${rssItem.url}\n`;
+    testOutput += `当前推送目标: ${rssItem.platform}:${rssItem.guildId}\n`;
+    if (options.title)
+        testOutput += `→ 新标题: ${options.title}\n`;
+    if (options.url)
+        testOutput += `→ 新URL: ${options.url}\n`;
+    if (options.template)
+        testOutput += `→ 新模板: ${options.template}\n`;
+    if (options.selector)
+        testOutput += `→ 新选择器: ${options.selector}\n`;
+    if (parsedTargets.length > 0) {
+        if (parsedTargets.length === 1) {
+            testOutput += `→ 新推送目标: ${parsedTargets[0]}\n`;
+        }
+        else {
+            testOutput += `→ 新推送目标:\n  ${parsedTargets.join('\n  ')}\n`;
+            testOutput += '\n⚠️ 注意: 多个推送目标会创建多个订阅记录\n每个目标会复制当前的订阅配置\n';
+        }
+    }
+    testOutput += '\n⚠️ 测试模式：不会保存修改\n去掉 --test 选项保存更改';
+    return testOutput;
+}
+async function saveSubscriptionChanges(ctx, rssItem, id, options, parsedTargets) {
+    const updates = {};
+    if (options.title)
+        updates.title = options.title;
+    if (options.url)
+        updates.url = options.url;
+    if (options.template) {
+        if (!rssItem.arg)
+            rssItem.arg = {};
+        rssItem.arg.template = options.template;
+        updates.arg = rssItem.arg;
+    }
+    if (options.selector) {
+        if (!rssItem.arg)
+            rssItem.arg = {};
+        rssItem.arg.selector = options.selector;
+        updates.arg = rssItem.arg;
+    }
+    try {
+        if (parsedTargets.length > 0) {
+            if (parsedTargets.length === 1) {
+                const [newPlatform, newGuildId] = parsedTargets[0].split(/[:：]/);
+                updates.platform = newPlatform;
+                updates.guildId = newGuildId;
+                await ctx.database.set('rssOwl', rssItem.id, updates);
+                let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
+                if (options.title)
+                    result += `标题: ${rssItem.title} → ${options.title}\n`;
+                if (options.url)
+                    result += `URL: ${rssItem.url} → ${options.url}\n`;
+                if (options.template)
+                    result += `模板: ${rssItem.arg?.template || 'default'} → ${options.template}\n`;
+                if (options.selector)
+                    result += `选择器: ${rssItem.arg?.selector || '无'} → ${options.selector}\n`;
+                result += `推送目标: ${rssItem.platform}:${rssItem.guildId} → ${parsedTargets[0]}\n`;
+                return result.trim();
+            }
+            const originalTarget = `${rssItem.platform}:${rssItem.guildId}`;
+            let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
+            result += `已创建 ${parsedTargets.length} 个推送目标:\n\n`;
+            result += `1️⃣ 原订阅 (本群): ${originalTarget}\n`;
+            await ctx.database.set('rssOwl', rssItem.id, updates);
+            for (let i = 0; i < parsedTargets.length; i++) {
+                const [newPlatform, newGuildId] = parsedTargets[i].split(/[:：]/);
+                const existing = await ctx.database.get('rssOwl', {
+                    platform: newPlatform,
+                    guildId: newGuildId,
+                    url: rssItem.url
+                });
+                if (existing.length > 0) {
+                    result += `${i + 2}. ⚠️ ${newPlatform}:${newGuildId} (订阅已存在，已跳过)\n`;
+                    continue;
+                }
+                const newSubscription = {
+                    ...rssItem,
+                    id: undefined,
+                    platform: newPlatform,
+                    guildId: newGuildId,
+                };
+                const created = await ctx.database.create('rssOwl', newSubscription);
+                result += `${i + 2}. ✅ ${newPlatform}:${newGuildId} (新订阅ID: ${created.id})\n`;
+            }
+            if (options.title)
+                result += `\n标题: ${rssItem.title} → ${options.title}\n`;
+            if (options.url)
+                result += `URL: ${rssItem.url} → ${options.url}\n`;
+            result += '\n💡 提示: 可以使用 rsso.list 查看所有订阅';
+            return result.trim();
+        }
+        await ctx.database.set('rssOwl', rssItem.id, updates);
+        let result = `✅ 订阅已更新 [序号:${id} | ID:${rssItem.id}]\n\n`;
+        if (options.title)
+            result += `标题: ${rssItem.title} → ${options.title}\n`;
+        if (options.url)
+            result += `URL: ${rssItem.url} → ${options.url}\n`;
+        if (options.template)
+            result += `模板: ${rssItem.arg?.template || 'default'} → ${options.template}\n`;
+        if (options.selector)
+            result += `选择器: ${rssItem.arg?.selector || '无'} → ${options.selector}\n`;
+        return result.trim();
+    }
+    catch (error) {
+        return `更新失败: ${error.message}`;
+    }
+}

package/lib/commands/subscription-management.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'koishi';
+import type { Config } from '../types';
+export interface SubscriptionCommandDeps {
+    ctx: Context;
+    config: Config;
+    parsePubDate: (pubDate: any) => Date;
+    parseQuickUrl: (url: string) => string;
+    getRssData: (url: string, arg: any) => Promise<any[]>;
+    parseRssItem: (item: any, arg: any, authorId: string | number) => Promise<string>;
+    mixinArg: (arg: any) => any;
+}
+export declare function registerSubscriptionManagementCommands(deps: SubscriptionCommandDeps): void;

package/lib/commands/subscription-management.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionManagementCommands = registerSubscriptionManagementCommands;
+const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("./utils");
+function registerSubscriptionManagementCommands(deps) {
+    registerListCommand(deps);
+    registerRemoveCommand(deps);
+    registerPullCommand(deps);
+    registerFollowCommand(deps);
+}
+function registerListCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.list [id:number]', '查看订阅列表')
+        .alias('rsso.list')
+        .usage(`查看订阅列表
+
+用法:
+  rsso.list              - 查看所有订阅
+  rsso.list 1            - 查看订阅 #1 的详情（使用列表序号）
+    `)
+        .example('rsso.list')
+        .action(async ({ session }, id) => {
+        const { guildId, platform } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        if (id === undefined) {
+            if (rssList.length === 0)
+                return '当前没有任何订阅';
+            return rssList.map((item, index) => {
+                const isCrossGroup = item.platform !== platform || item.guildId !== guildId;
+                return `${index + 1}. ${item.title}${isCrossGroup ? ' [跨群]' : ''} [ID:${item.id}]`;
+            }).join('\n');
+        }
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const followers = rssItem.followers?.length > 0 ? rssItem.followers.join(', ') : '无';
+        const pushTarget = `${rssItem.platform}:${rssItem.guildId}`;
+        const isCrossGroup = rssItem.platform !== platform || rssItem.guildId !== guildId;
+        const targetInfo = isCrossGroup
+            ? `📤 推送目标: ${pushTarget} (跨群订阅)`
+            : `📤 推送目标: ${pushTarget} (本群)`;
+        return `📰 订阅详情 [序号:${id} | ID:${rssItem.id}]
+标题: ${rssItem.title}
+链接: ${rssItem.url}
+类型: ${rssItem.arg?.type || 'RSS'}
+模板: ${rssItem.arg?.template || deps.config.basic.defaultTemplate}
+${targetInfo}
+更新时间: ${rssItem.lastPubDate ? deps.parsePubDate(rssItem.lastPubDate).toLocaleString('zh-CN', { hour12: false }) : '未知'}
+关注者: ${followers}`;
+    });
+}
+function registerRemoveCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.remove <id:number>', '删除订阅')
+        .alias('rsso.remove')
+        .usage(`删除订阅
+
+用法:
+  rsso.remove 1           - 删除订阅 #1（使用列表序号）
+  rsso.remove --all       - 删除全部订阅（需要权限）
+    `)
+        .option('all', '--all 删除全部订阅')
+        .example('rsso.remove 1')
+        .action(async ({ session, options }, id) => {
+        const { guildId, platform, authority } = (0, utils_1.extractSessionInfo)(session);
+        if (options.all) {
+            const authorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.authority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.authority} 或以上`);
+            if (!authorityCheck.success)
+                return authorityCheck.message;
+            await deps.ctx.database.remove('rssOwl', { platform, guildId });
+            return '✅ 已删除全部订阅';
+        }
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        await deps.ctx.database.remove('rssOwl', { id: rssItem.id });
+        return `✅ 已删除订阅: ${rssItem.title}`;
+    });
+}
+function registerPullCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.pull <id:number>', '拉取订阅最新内容')
+        .alias('rsso.pull')
+        .usage(`拉取订阅最新内容
+
+用法:
+  rsso.pull 1             - 拉取订阅 #1 的最新更新（使用列表序号）
+    `)
+        .example('rsso.pull 1')
+        .action(async ({ session }, id) => {
+        const { guildId, platform } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const logContext = {
+            ...(0, utils_1.buildCommandLogContext)(session, 'rsso.pull', 'pull'),
+            subscriptionIndex: id,
+            subscribeId: String(rssItem.id),
+            rssId: rssItem.rssId || rssItem.title,
+            url: rssItem.url,
+        };
+        try {
+            const arg = deps.mixinArg(rssItem.arg || {});
+            const rssItemList = (await Promise.all(String(rssItem.url).split('|')
+                .map(url => deps.parseQuickUrl(url))
+                .map(async (url) => await deps.getRssData(url, arg)))).flat(1);
+            let itemArray = rssItemList.sort((a, b) => deps.parsePubDate(b.pubDate).getTime() - deps.parsePubDate(a.pubDate).getTime());
+            if (arg.reverse)
+                itemArray = itemArray.reverse();
+            const maxItem = arg.forceLength || 1;
+            const messageList = await Promise.all(itemArray
+                .filter((_, index) => index < maxItem)
+                .map(async (item) => await deps.parseRssItem(item, { ...rssItem, ...arg }, rssItem.author)));
+            return messageList.join('');
+        }
+        catch (error) {
+            const normalizedError = (0, error_handler_1.normalizeError)(error);
+            (0, logger_1.debug)(deps.config, normalizedError, 'pull error', 'error', logContext);
+            (0, error_tracker_1.trackError)(normalizedError, logContext);
+            return `拉取失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, '获取订阅数据')}`;
+        }
+    });
+}
+function registerFollowCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl.follow <id:number>', '关注订阅')
+        .alias('rsso.follow')
+        .usage(`关注订阅，在该订阅更新时提醒你
+
+用法:
+  rsso.follow 1           - 关注订阅 #1（仅提醒你）
+  rsso.follow 1 --all     - 关注订阅 #1（提醒所有人，需要高级权限）
+    `)
+        .option('all', '--all 提醒所有人')
+        .example('rsso.follow 1')
+        .action(async ({ session, options }, id) => {
+        const { guildId, platform, authorId, authority } = (0, utils_1.extractSessionInfo)(session);
+        const rssList = await getGuildSubscriptions(deps.ctx, platform, guildId);
+        const rssItem = getSubscriptionByIndex(rssList, id);
+        if (!rssItem)
+            return getSubscriptionNotFoundMessage(id, rssList.length);
+        const followers = Array.isArray(rssItem.followers) ? [...rssItem.followers] : [];
+        if (options.all) {
+            const authorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.advancedAuthority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.advancedAuthority} 或以上`);
+            if (!authorityCheck.success)
+                return authorityCheck.message;
+            if (followers.includes('all'))
+                return '已经设置全员提醒';
+            followers.push('all');
+            await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+            return '✅ 已设置全员提醒';
+        }
+        if (followers.includes(authorId))
+            return '已经关注过了';
+        followers.push(authorId);
+        await deps.ctx.database.set('rssOwl', { id: rssItem.id }, { followers });
+        return '✅ 关注成功';
+    });
+}
+async function getGuildSubscriptions(ctx, platform, guildId) {
+    return ctx.database.get('rssOwl', { platform, guildId });
+}
+function getSubscriptionByIndex(rssList, id) {
+    const listIndex = id - 1;
+    if (listIndex < 0 || listIndex >= rssList.length)
+        return null;
+    return rssList[listIndex];
+}
+function getSubscriptionNotFoundMessage(id, total) {
+    return `❌ 序号 ${id} 不存在\n当前共有 ${total} 个订阅\n\n使用 rsso.list 查看完整列表`;
+}

package/lib/commands/utils.d.ts

@@ -21,15 +21,23 @@ export interface SessionInfo {
     authorId: string;
     authority: number;
 }
+export interface ParseTargetsResult {
+    targets: string[];
+    invalidTarget?: string;
+}
 /**
  * 从会话中提取信息
  */
 export declare function extractSessionInfo(session: Session): SessionInfo;
+/**
+ * 构建命令日志上下文
+ */
+export declare function buildCommandLogContext(session: Session, command?: string, operation?: string): Record<string, any>;
 /**
  * 命令错误处理包装器
  * 统一处理命令执行中的错误
  */
-export declare function withCommandErrorHandling(config: Config, operation: string, handler: () => Promise<string>): Promise<string>;
+export declare function withCommandErrorHandling(config: Config, operation: string, handler: () => Promise<string>, context?: Record<string, any>): Promise<string>;
 /**
  * 权限检查辅助函数
  */
@@ -44,6 +52,10 @@ export declare function parseTarget(target: string): {
     platform: string;
     guildId: string;
 } | null;
+/**
+ * 解析多个推送目标
+ */
+export declare function parseTargets(targetInput?: string): ParseTargetsResult;
 /**
  * 验证 URL 格式
  */

package/lib/commands/utils.js

@@ -5,11 +5,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractSessionInfo = extractSessionInfo;
+exports.buildCommandLogContext = buildCommandLogContext;
 exports.withCommandErrorHandling = withCommandErrorHandling;
 exports.checkAuthority = checkAuthority;
 exports.parseTarget = parseTarget;
+exports.parseTargets = parseTargets;
 exports.isValidUrl = isValidUrl;
 const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
 const logger_1 = require("../utils/logger");
 /**
  * 从会话中提取信息
@@ -21,13 +24,30 @@ function extractSessionInfo(session) {
     const { authority } = session.user;
     return { guildId, platform, authorId, authority };
 }
+/**
+ * 构建命令日志上下文
+ */
+function buildCommandLogContext(session, command, operation) {
+    const sessionInfo = extractSessionInfo(session);
+    const context = {
+        ...sessionInfo,
+        userId: sessionInfo.authorId,
+    };
+    if (command)
+        context.command = command;
+    if (operation)
+        context.operation = operation;
+    return context;
+}
 /**
  * 命令错误处理包装器
  * 统一处理命令执行中的错误
  */
-function withCommandErrorHandling(config, operation, handler) {
+function withCommandErrorHandling(config, operation, handler, context) {
     return handler().catch((error) => {
-        (0, logger_1.debug)(config, error, `${operation} error`, 'error');
+        const normalizedError = (0, error_handler_1.normalizeError)(error);
+        (0, logger_1.debug)(config, normalizedError, `${operation} error`, 'error', context);
+        (0, error_tracker_1.trackError)(normalizedError, context);
         return Promise.resolve(`${operation}失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, operation)}`);
     });
 }
@@ -56,6 +76,27 @@ function parseTarget(target) {
         guildId: parts[1]
     };
 }
+/**
+ * 解析多个推送目标
+ */
+function parseTargets(targetInput) {
+    if (!targetInput) {
+        return { targets: [] };
+    }
+    const targets = targetInput
+        .split(/[;,，；]/)
+        .map(target => target.trim())
+        .filter(Boolean);
+    for (const target of targets) {
+        if (!parseTarget(target)) {
+            return {
+                targets: [],
+                invalidTarget: target,
+            };
+        }
+    }
+    return { targets };
+}
 /**
  * 验证 URL 格式
  */

package/lib/commands/web-monitor.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'koishi';
+import type { Config, rssArg } from '../types';
+type DebugType = 'disable' | 'error' | 'info' | 'details';
+export interface WebMonitorCommandDeps {
+    ctx: Context;
+    config: Config;
+    debug: (message: any, name?: string, type?: DebugType, context?: Record<string, any>) => void;
+    mixinArg: (arg: Record<string, any>) => rssArg;
+    getRssData: (url: string, arg: Record<string, any>) => Promise<any[]>;
+    parseRssItem: (item: any, arg: Record<string, any>, authorId: string | number) => Promise<string>;
+    generateSelectorByAI: (url: string, instruction: string, html: string) => Promise<string>;
+    fetchUrl: (url: string, arg?: Record<string, any>) => Promise<string>;
+}
+export declare function registerWebMonitorCommands(deps: WebMonitorCommandDeps): void;
+export {};