@anyul/koishi-plugin-rss 5.2.2 → 5.2.3

package/lib/commands/error-handler.js

@@ -10,9 +10,8 @@ exports.permissionDenied = permissionDenied;
 exports.invalidArgument = invalidArgument;
 exports.notFound = notFound;
 exports.alreadyExists = alreadyExists;
-const koishi_1 = require("koishi");
 const error_handler_1 = require("../utils/error-handler");
-const logger = new koishi_1.Logger('rss-owl-command');
+const logger_1 = require("../utils/logger");
 /**
  * 命令错误类型
  */
@@ -62,9 +61,7 @@ async function executeCommand(ctx, config, operationName, handler) {
  * 记录命令错误
  */
 function logError(config, operation, error) {
-    if (config.debug === 'details' || config.debug === 'error') {
-        logger.error(`[${operation}]`, error);
-    }
+    (0, logger_1.debugError)(config, error, operation);
 }
 /**
  * 格式化命令错误消息

package/lib/commands/index.d.ts

@@ -1 +1,17 @@
-export {};
+import { Context } from 'koishi';
+import type { Config } from '../types';
+import { NotificationQueueManager } from '../core/notification-queue';
+/**
+ * 管理类命令依赖
+ */
+export interface ManagementCommandDeps {
+    ctx: Context;
+    config: Config;
+    queueManager: NotificationQueueManager;
+}
+/**
+ * 注册管理类命令
+ */
+export declare function registerManagementCommands(deps: ManagementCommandDeps): void;
+export { registerSubscriptionManagementCommands } from './subscription-management';
+export { registerSubscriptionEditCommand } from './subscription-edit';

package/lib/commands/index.js

@@ -1,4 +1,390 @@
 "use strict";
-// Commands module placeholder - commands are registered in the main index.ts for now
-// This file can be used to export command registration functions in future refactoring
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionEditCommand = exports.registerSubscriptionManagementCommands = void 0;
+exports.registerManagementCommands = registerManagementCommands;
+const error_handler_1 = require("../utils/error-handler");
+const error_tracker_1 = require("../utils/error-tracker");
+const message_cache_1 = require("../utils/message-cache");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("./utils");
+/**
+ * 注册管理类命令
+ */
+function registerManagementCommands(deps) {
+    registerCacheCommands(deps.ctx, deps.config);
+    registerQueueCommands(deps.ctx, deps.config, deps.queueManager);
+}
+function registerCacheCommands(ctx, config) {
+    ctx.guild()
+        .command('rssowl.cache', '消息缓存管理')
+        .alias('rsso.cache')
+        .usage(`
+消息缓存管理功能，查看和管理已推送的 RSS 消息缓存。
+
+用法:
+  rsso.cache list [页数]              - 查看缓存消息列表
+  rsso.cache search <关键词>          - 搜索缓存消息
+  rsso.cache stats                    - 查看缓存统计
+  rsso.cache message <序号>           - 查看消息详情
+  rsso.cache pull <序号>             - 重新推送缓存消息
+  rsso.cache clear                    - 清空所有缓存
+  rsso.cache cleanup [保留数量]       - 清理缓存（保留最新N条）
+
+示例:
+  rsso.cache list                     - 查看第1页（每页10条）
+  rsso.cache list 2                   - 查看第2页
+  rsso.cache search 新闻              - 搜索包含"新闻"的消息
+  rsso.cache stats                    - 查看统计信息
+  rsso.cache message 1                - 查看序号1的消息详情
+  rsso.cache pull 1                  - 推送序号1的消息
+  rsso.cache cleanup 50               - 清理并保留最新50条
+
+注意：序号从1开始，会在列表中显示对应的真实数据库ID
+    `)
+        .action(async ({ session }, subcommand, ...args) => {
+        const { authority } = session.user;
+        const cache = (0, message_cache_1.getMessageCache)();
+        if (!cache) {
+            return '消息缓存功能未启用，请在配置中启用 cache.enabled';
+        }
+        if (!subcommand) {
+            return `消息缓存管理
+
+可用指令:
+  rsso.cache list [页数]              - 查看缓存消息列表
+  rsso.cache search <关键词>          - 搜索缓存消息
+  rsso.cache stats                    - 查看缓存统计
+  rsso.cache message <序号>           - 查看消息详情
+  rsso.cache pull <序号>             - 重新推送缓存消息
+  rsso.cache clear                    - 清空所有缓存
+  rsso.cache cleanup [保留数量]       - 清理缓存（保留最新N条）
+
+详细信息请使用: rsso.cache --help`;
+        }
+        const logContext = (0, utils_1.buildCommandLogContext)(session, 'rsso.cache', subcommand);
+        switch (subcommand) {
+            case 'list':
+                return handleCacheList(cache, args, config, logContext);
+            case 'message':
+                return handleCacheMessage(cache, args, config, logContext);
+            case 'search':
+                return handleCacheSearch(cache, args, config, logContext);
+            case 'stats':
+                return handleCacheStats(cache, config, logContext);
+            case 'clear':
+                if (authority < config.basic.authority) {
+                    return `权限不足！当前权限: ${authority}，需要权限: ${config.basic.authority} 或以上`;
+                }
+                return handleCacheClear(cache, config, logContext);
+            case 'cleanup':
+                if (authority < config.basic.authority) {
+                    return `权限不足！当前权限: ${authority}，需要权限: ${config.basic.authority} 或以上`;
+                }
+                return handleCacheCleanup(cache, args, config, logContext);
+            case 'pull':
+                return handleCachePull(ctx, session, cache, args, config, logContext);
+            default:
+                return `未知的子命令: ${subcommand}\n使用 "rsso.cache" 查看可用指令`;
+        }
+    });
+}
+function registerQueueCommands(ctx, config, queueManager) {
+    ctx.guild()
+        .command('rssowl.queue', '发送队列管理')
+        .alias('rsso.queue')
+        .usage(`
+发送队列管理功能，查看和管理待发送的消息队列。
+
+用法:
+  rsso.queue stats                - 查看队列统计
+  rsso.queue retry [id]            - 重试失败的任务
+  rsso.queue retry --all           - 重试所有失败任务
+  rsso.queue cleanup [hours]       - 清理旧的成功任务（默认24小时）
+
+示例:
+  rsso.queue stats                 - 查看队列状态
+  rsso.queue retry 5               - 重试ID为5的任务
+  rsso.queue retry --all           - 重试所有失败任务
+  rsso.queue cleanup 48            - 清理48小时前的成功任务
+
+说明:
+  - PENDING: 待发送
+  - RETRY: 等待重试
+  - FAILED: 发送失败
+  - SUCCESS: 发送成功
+    `)
+        .action(async ({ session }, subcommand, ...args) => {
+        const { authority } = session.user;
+        if (!subcommand) {
+            return `发送队列管理
+
+可用指令:
+  rsso.queue stats                - 查看队列统计
+  rsso.queue retry [id]            - 重试失败的任务
+  rsso.queue retry --all           - 重试所有失败任务
+  rsso.queue cleanup [hours]       - 清理旧的成功任务（默认24小时）
+
+详细信息请使用: rsso.queue --help`;
+        }
+        const logContext = (0, utils_1.buildCommandLogContext)(session, 'rsso.queue', subcommand);
+        switch (subcommand) {
+            case 'stats':
+                return handleQueueStats(queueManager, config, logContext);
+            case 'retry':
+                if (authority < config.basic.authority) {
+                    return `权限不足！当前权限: ${authority}，需要权限: ${config.basic.authority} 或以上`;
+                }
+                return handleQueueRetry(queueManager, args, config, logContext);
+            case 'cleanup':
+                if (authority < config.basic.authority) {
+                    return `权限不足！当前权限: ${authority}，需要权限: ${config.basic.authority} 或以上`;
+                }
+                return handleQueueCleanup(queueManager, args, config, logContext);
+            default:
+                return `未知的子命令: ${subcommand}\n使用 "rsso.queue" 查看可用指令`;
+        }
+    });
+}
+async function handleCacheList(cache, args, config, logContext) {
+    const page = parseInt(args[0]) || 1;
+    const limit = 10;
+    const offset = (page - 1) * limit;
+    try {
+        const messages = await cache.getMessages({ limit, offset });
+        if (messages.length === 0) {
+            return '暂无缓存消息';
+        }
+        const stats = await cache.getStats();
+        let output = `📋 缓存消息列表 (第${page}页，共${Math.ceil(stats.totalMessages / limit)}页，总计${stats.totalMessages}条)\n\n`;
+        output += messages.map((msg, index) => {
+            const date = new Date(msg.createdAt).toLocaleString('zh-CN', {
+                month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
+            });
+            const title = msg.title.length > 30 ? msg.title.substring(0, 30) + '...' : msg.title;
+            return `${index + 1}. [ID:${msg.id}] [${msg.rssId}] ${title}\n   时间: ${date}\n   链接: ${msg.link}`;
+        }).join('\n\n');
+        output += `\n\n💡 使用 "rsso.cache list ${page + 1}" 查看下一页`;
+        output += '\n💡 使用 "rsso.cache pull <序号>" 推送消息（注意：序号基于当前页）';
+        output += '\n💡 使用 "rsso.cache message <序号>" 查看详情';
+        return output;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache list error', { ...logContext, page, limit });
+        return `获取消息列表失败: ${error.message}`;
+    }
+}
+async function handleCacheMessage(cache, args, config, logContext) {
+    const serialNumber = parseInt(args[0]);
+    if (!serialNumber || serialNumber < 1) {
+        return '请提供序号\n使用方法: rsso.cache message <序号>\n示例: rsso.cache message 1\n💡 提示：使用 "rsso.cache list" 查看序号';
+    }
+    try {
+        const found = await findCachedMessageBySerial(cache, serialNumber);
+        if (!found.message) {
+            return `❌ 未找到序号为 ${args[0]} 的消息\n💡 使用 "rsso.cache list" 查看可用的序号`;
+        }
+        const pubDate = new Date(found.message.pubDate).toLocaleString('zh-CN', {
+            year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
+        });
+        const createdAt = new Date(found.message.createdAt).toLocaleString('zh-CN', {
+            year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
+        });
+        let output = `📰 消息详情 (第${found.page}页序号${args[0]}，真实ID:${found.message.id})\n\n`;
+        output += `📰 标题: ${found.message.title}\n📡 订阅: ${found.message.rssId}\n👥 群组: ${found.message.platform}:${found.message.guildId}\n🔗 链接: ${found.message.link}\n📅 发布时间: ${pubDate}\n💾 缓存时间: ${createdAt}\n`;
+        if (found.message.content) {
+            const content = found.message.content.length > 200 ? found.message.content.substring(0, 200) + '...' : found.message.content;
+            output += `\n📝 内容:\n${content}`;
+        }
+        if (found.message.imageUrl)
+            output += `\n\n🖼️ 图片: ${found.message.imageUrl}`;
+        if (found.message.videoUrl)
+            output += `\n\n🎬 视频: ${found.message.videoUrl}`;
+        return output;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache message error', { ...logContext, serialNumber });
+        return `获取消息详情失败: ${error.message}`;
+    }
+}
+async function handleCacheSearch(cache, args, config, logContext) {
+    const keyword = args[0];
+    if (!keyword) {
+        return '请提供搜索关键词\n使用方法: rsso.cache search <关键词>';
+    }
+    try {
+        const messages = await cache.searchMessages({ keyword, limit: 10 });
+        if (messages.length === 0) {
+            return `未找到包含 "${keyword}" 的消息`;
+        }
+        let output = `🔍 搜索结果 "${keyword}" (找到${messages.length}条)\n\n`;
+        output += messages.map((msg, index) => {
+            const date = new Date(msg.createdAt).toLocaleString('zh-CN', {
+                month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
+            });
+            const title = msg.title.length > 30 ? msg.title.substring(0, 30) + '...' : msg.title;
+            return `${index + 1}. [ID:${msg.id}] [${msg.rssId}] ${title}\n   时间: ${date}`;
+        }).join('\n\n');
+        output += '\n\n💡 使用 "rsso.cache message <真实ID>" 查看详情';
+        return output;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache search error', { ...logContext, keyword });
+        return `搜索失败: ${error.message}`;
+    }
+}
+async function handleCacheStats(cache, config, logContext) {
+    try {
+        const stats = await cache.getStats();
+        let output = `📊 缓存统计信息\n\n📦 总消息数: ${stats.totalMessages}\n`;
+        if (stats.oldestMessage)
+            output += `📅 最早消息: ${new Date(stats.oldestMessage).toLocaleString('zh-CN')}\n`;
+        if (stats.newestMessage)
+            output += `📅 最新消息: ${new Date(stats.newestMessage).toLocaleString('zh-CN')}\n`;
+        output += '\n📡 按订阅统计:\n';
+        Object.entries(stats.bySubscription).sort(([, a], [, b]) => b - a).slice(0, 10).forEach(([rssId, count]) => {
+            output += `  ${rssId}: ${count}条\n`;
+        });
+        output += '\n👥 按群组统计:\n';
+        Object.entries(stats.byGuild).sort(([, a], [, b]) => b - a).slice(0, 10).forEach(([guild, count]) => {
+            output += `  ${guild}: ${count}条\n`;
+        });
+        output += `\n⚙️ 最大缓存限制: ${cache.getMaxCacheSize()}条`;
+        return output;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache stats error', logContext);
+        return `获取统计信息失败: ${error.message}`;
+    }
+}
+async function handleCacheClear(cache, config, logContext) {
+    try {
+        const deletedCount = await cache.clearAll();
+        return `✅ 已清空所有缓存，共删除 ${deletedCount} 条消息`;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache clear error', logContext);
+        return `清空缓存失败: ${error.message}`;
+    }
+}
+async function handleCacheCleanup(cache, args, config, logContext) {
+    const keepLatest = parseInt(args[0]) || cache.getMaxCacheSize();
+    try {
+        const deletedCount = await cache.cleanup({ keepLatest });
+        if (deletedCount === 0) {
+            return '✅ 当前缓存数量未超过限制，无需清理';
+        }
+        return `✅ 已清理缓存，保留最新 ${keepLatest} 条，删除 ${deletedCount} 条消息`;
+    }
+    catch (error) {
+        logCommandError(config, error, 'cache cleanup error', { ...logContext, keepLatest });
+        return `清理缓存失败: ${error.message}`;
+    }
+}
+async function handleCachePull(ctx, session, cache, args, config, logContext) {
+    const serialNumber = parseInt(args[0]);
+    if (!serialNumber || serialNumber < 1) {
+        return '请提供有效的序号\n使用方法: rsso.cache pull <序号>\n示例: rsso.cache pull 1\n💡 提示：使用 "rsso.cache list" 查看序号';
+    }
+    let found = null;
+    const targetContext = {
+        ...logContext,
+        serialNumber,
+    };
+    try {
+        found = await findCachedMessageBySerial(cache, serialNumber);
+        if (!found.message) {
+            return `❌ 未找到序号为 ${args[0]} 的消息\n💡 使用 "rsso.cache list" 查看可用的序号`;
+        }
+        if (!found.message.finalMessage) {
+            return '❌ 该消息没有缓存的最终消息\n💡 这条消息可能是旧版本缓存，请重新订阅后重试';
+        }
+        const { id: guildId } = session.event.guild;
+        const { platform } = session.event;
+        const target = `${platform}:${guildId}`;
+        await ctx.broadcast([target], found.message.finalMessage);
+        return '';
+    }
+    catch (error) {
+        const { id: guildId } = session.event.guild;
+        const { platform } = session.event;
+        logCommandError(config, error, 'cache pull error', {
+            ...targetContext,
+            guildId,
+            platform,
+            target: `${platform}:${guildId}`,
+            cachedMessageId: found?.message?.id,
+            rssId: found?.message?.rssId,
+        });
+        return `推送消息失败: ${error.message}`;
+    }
+}
+async function handleQueueStats(queueManager, config, logContext) {
+    try {
+        const stats = await queueManager.getStats();
+        const total = stats.pending + stats.retry + stats.failed + stats.success;
+        return `📊 发送队列统计\n\n⏳ 待发送: ${stats.pending}\n🔄 等待重试: ${stats.retry}\n❌ 发送失败: ${stats.failed}\n✅ 发送成功: ${stats.success}\n\n📦 总计: ${total} 个任务`;
+    }
+    catch (error) {
+        logCommandError(config, error, 'queue stats error', logContext);
+        return `获取统计信息失败: ${error.message}`;
+    }
+}
+async function handleQueueRetry(queueManager, args, config, logContext) {
+    try {
+        const taskId = args[0];
+        if (taskId === '--all') {
+            const count = await queueManager.retryFailedTasks();
+            return `✅ 已重置 ${count} 个失败任务为 PENDING 状态`;
+        }
+        if (taskId) {
+            const id = parseInt(taskId);
+            if (isNaN(id)) {
+                return `❌ 无效的任务ID: ${taskId}`;
+            }
+            const count = await queueManager.retryFailedTasks(id);
+            return count > 0 ? `✅ 已重置任务 ${id}` : `❌ 未找到任务 ${id}`;
+        }
+        return '请指定任务ID或使用 --all 重试所有失败任务\n使用方法: rsso.queue retry <id|--all>';
+    }
+    catch (error) {
+        logCommandError(config, error, 'queue retry error', { ...logContext, taskId: args[0] });
+        return `重试失败: ${error.message}`;
+    }
+}
+async function handleQueueCleanup(queueManager, args, config, logContext) {
+    try {
+        const hours = parseInt(args[0]) || 24;
+        const count = await queueManager.cleanupSuccessTasks(hours);
+        if (count === 0) {
+            return '✅ 没有需要清理的成功任务';
+        }
+        return `✅ 已清理 ${count} 个超过 ${hours} 小时的成功任务`;
+    }
+    catch (error) {
+        logCommandError(config, error, 'queue cleanup error', { ...logContext, hours: parseInt(args[0]) || 24 });
+        return `清理失败: ${error.message}`;
+    }
+}
+async function findCachedMessageBySerial(cache, serialNumber, limit = 10, maxPagesToSearch = 10) {
+    let targetSerialNumber = serialNumber;
+    for (let page = 1; page <= maxPagesToSearch; page++) {
+        const offset = (page - 1) * limit;
+        const messages = await cache.getMessages({ limit, offset });
+        if (messages.length === 0)
+            break;
+        if (targetSerialNumber <= messages.length) {
+            return { message: messages[targetSerialNumber - 1], page };
+        }
+        targetSerialNumber -= messages.length;
+    }
+    return { message: null, page: 1 };
+}
+function logCommandError(config, error, scope, context) {
+    const normalizedError = (0, error_handler_1.normalizeError)(error);
+    (0, logger_1.debug)(config, normalizedError, scope, 'error', context);
+    (0, error_tracker_1.trackError)(normalizedError, context);
+}
+var subscription_management_1 = require("./subscription-management");
+Object.defineProperty(exports, "registerSubscriptionManagementCommands", { enumerable: true, get: function () { return subscription_management_1.registerSubscriptionManagementCommands; } });
+var subscription_edit_1 = require("./subscription-edit");
+Object.defineProperty(exports, "registerSubscriptionEditCommand", { enumerable: true, get: function () { return subscription_edit_1.registerSubscriptionEditCommand; } });

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

@@ -0,0 +1,7 @@
+import { Context } from 'koishi';
+import type { Config } from '../types';
+export interface SubscriptionEditCommandDeps {
+    ctx: Context;
+    config: Config;
+}
+export declare function registerSubscriptionEditCommand(deps: SubscriptionEditCommandDeps): void;

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;