@anyul/koishi-plugin-rss 5.2.2 → 5.2.4

package/lib/commands/index.js

@@ -1,4 +1,396 @@
 "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.createCommandRuntimeDeps = exports.registerWebMonitorCommands = exports.registerSubscriptionCreateCommand = 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; } });
+var subscription_create_1 = require("./subscription-create");
+Object.defineProperty(exports, "registerSubscriptionCreateCommand", { enumerable: true, get: function () { return subscription_create_1.registerSubscriptionCreateCommand; } });
+var web_monitor_1 = require("./web-monitor");
+Object.defineProperty(exports, "registerWebMonitorCommands", { enumerable: true, get: function () { return web_monitor_1.registerWebMonitorCommands; } });
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "createCommandRuntimeDeps", { enumerable: true, get: function () { return runtime_1.createCommandRuntimeDeps; } });

package/lib/commands/runtime.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'koishi';
+import type { Config, rssArg } from '../types';
+import { RssItemProcessor } from '../core/item-processor';
+type DebugType = 'disable' | 'error' | 'info' | 'details';
+export interface CommandRuntimeDeps {
+    debug: (message: any, name?: string, type?: DebugType, context?: Record<string, any>) => void;
+    parseQuickUrl: (url: string) => string;
+    parsePubDate: (pubDate: any) => Date;
+    getRssData: (url: string, arg: Record<string, any>) => Promise<any[]>;
+    parseRssItem: (item: any, arg: Record<string, any>, authorId: string | number) => Promise<string>;
+    formatArg: (options: Record<string, any>) => rssArg;
+    mixinArg: (arg: Record<string, any>) => rssArg;
+    generateSelectorByAI: (url: string, instruction: string, html: string) => Promise<string>;
+    fetchUrl: (url: string, arg?: Record<string, any>) => Promise<string>;
+}
+export declare function createCommandRuntimeDeps(ctx: Context, config: Config, $http: any, processor: RssItemProcessor): CommandRuntimeDeps;
+export {};

package/lib/commands/runtime.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandRuntimeDeps = createCommandRuntimeDeps;
+const constants_1 = require("../constants");
+const ai_1 = require("../core/ai");
+const feeder_1 = require("../core/feeder");
+const parser_1 = require("../core/parser");
+const common_1 = require("../utils/common");
+const logger_1 = require("../utils/logger");
+function createCommandRuntimeDeps(ctx, config, $http, processor) {
+    return {
+        debug: (message, name = '', type = 'details', context) => {
+            (0, logger_1.debug)(config, message, name, type, context);
+        },
+        parseQuickUrl: (url) => (0, common_1.parseQuickUrl)(url, config.msg?.rssHubUrl, constants_1.quickList),
+        parsePubDate: (pubDate) => (0, common_1.parsePubDate)(config, pubDate),
+        getRssData: (url, arg) => (0, parser_1.getRssData)(ctx, config, $http, url, arg),
+        parseRssItem: (item, arg, authorId) => processor.parseRssItem(item, arg, authorId),
+        formatArg: (options) => (0, feeder_1.formatArg)(options, config),
+        mixinArg: (arg) => (0, feeder_1.mixinArg)(arg, config),
+        generateSelectorByAI: (url, instruction, html) => (0, ai_1.generateSelectorByAI)(config, url, instruction, html),
+        fetchUrl: async (url, arg = {}) => {
+            const response = await $http(url, arg);
+            return String(response?.data ?? '');
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+import { Context } from 'koishi';
+import type { Config } from '../types';
+export interface SubscriptionCreateCommandDeps {
+    ctx: Context;
+    config: Config;
+    usage: string;
+    quickList: Array<{
+        name: string;
+        detail: string;
+        example: string;
+    }>;
+    parseQuickUrl: (url: string) => string;
+    parsePubDate: (pubDate: any) => Date;
+    getRssData: (url: string, arg: any) => Promise<any[]>;
+    parseRssItem: (item: any, arg: any, authorId: string | number) => Promise<string>;
+    formatArg: (options: Record<string, any>) => any;
+    mixinArg: (arg: any) => any;
+    debug: (message: any, name?: string, type?: 'disable' | 'error' | 'info' | 'details', context?: Record<string, any>) => void;
+}
+/**
+ * 注册主订阅命令。
+ */
+export declare function registerSubscriptionCreateCommand(deps: SubscriptionCreateCommandDeps): void;

package/lib/commands/subscription-create.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionCreateCommand = registerSubscriptionCreateCommand;
+const common_1 = require("../utils/common");
+const error_handler_1 = require("../utils/error-handler");
+const utils_1 = require("./utils");
+/**
+ * 注册主订阅命令。
+ */
+function registerSubscriptionCreateCommand(deps) {
+    deps.ctx.guild()
+        .command('rssowl <url:text>', '订阅 RSS/源')
+        .alias('rsso')
+        .usage(deps.usage)
+        .option('list', '-l [content] 查看订阅列表(详情) [已移至 rsso.list 子命令，使用列表序号]')
+        .option('remove', '-r <序号> 删除订阅 [已移至 rsso.remove 子命令，使用列表序号]')
+        .option('removeAll', '删除全部订阅 [已移至 rsso.remove --all 子命令]')
+        .option('follow', '-f <序号> 关注订阅 [已移至 rsso.follow 子命令，使用列表序号]')
+        .option('followAll', '<序号> 在该订阅更新时提醒所有人 [已移至 rsso.follow --all 子命令，使用列表序号]')
+        .option('target', '--target <platform:guildId> 跨群订阅（高级权限）')
+        .option('arg', '-a <content> 自定义配置')
+        .option('template', '-i <content> 消息模板')
+        .option('title', '-t <content> 自定义命名')
+        .option('pull', '-p <序号> 拉取订阅最新更新 [已移至 rsso.pull 子命令，使用列表序号]')
+        .option('force', '强行写入')
+        .option('daily', '-d <content>')
+        .option('test', '-T 测试')
+        .option('quick', '-q [content] 查询快速订阅列表')
+        .example('rsso https://hub.slarker.me/qqorw')
+        .action(async ({ session, options }, url) => {
+        const logContext = (0, utils_1.buildCommandLogContext)(session, 'rsso', 'create');
+        deps.debug(options, 'options', 'info', logContext);
+        const { guildId, platform, authorId: userId, authority } = (0, utils_1.extractSessionInfo)(session);
+        const botSelfId = session.bot?.selfId;
+        deps.debug(`${platform}:${userId}:${guildId}, bot:${botSelfId}`, '', 'info', logContext);
+        if (options?.quick === '') {
+            return '输入 rsso -q [id] 查询详情\n' + deps.quickList.map((v, i) => `${i + 1}.${v.name}`).join('\n');
+        }
+        if (options?.quick) {
+            const currentQuickObj = deps.quickList[parseInt(options.quick) - 1];
+            if (!currentQuickObj)
+                return `快速订阅编号不存在: ${options.quick}`;
+            return `${currentQuickObj.name}\n${currentQuickObj.detail}\n例:rsso -T ${currentQuickObj.example}\n(${deps.parseQuickUrl(currentQuickObj.example)})`;
+        }
+        if (platform.includes('sandbox') && !options.test && url) {
+            session.send('沙盒中无法推送更新，但RSS依然会被订阅，建议使用 -T 选项进行测试');
+        }
+        const rssList = await deps.ctx.database.get('rssOwl', { platform, guildId });
+        if (options?.list === '' || options?.list)
+            return '💡 提示：请使用子命令查看订阅\n\nrsso.list              - 查看所有订阅（显示序号）\nrsso.list 1            - 查看订阅详情\n\n（旧选项 -l 仍可使用，但建议迁移到新命令）';
+        if (options?.remove)
+            return '💡 提示：请使用子命令删除订阅\n\nrsso.remove 1           - 删除订阅 #1（使用列表序号）\nrsso.remove --all       - 删除全部订阅\n\n（旧选项 -r 仍可使用，但建议迁移到新命令）';
+        if (options?.removeAll)
+            return '💡 提示：请使用子命令删除订阅\n\nrsso.remove --all       - 删除全部订阅\n\n（旧选项仍可使用，但建议迁移到新命令）';
+        if (options?.follow)
+            return '💡 提示：请使用子命令关注订阅\n\nrsso.follow 1           - 关注订阅 #1（使用列表序号）\n\n（旧选项 -f 仍可使用，但建议迁移到新命令）';
+        if (options?.followAll)
+            return '💡 提示：请使用子命令设置全员提醒\n\nrsso.follow 1 --all     - 设置全员提醒（使用列表序号）\n\n（旧选项仍可使用，但建议迁移到新命令）';
+        if (options?.pull)
+            return '💡 提示：请使用子命令拉取订阅\n\nrsso.pull 1             - 拉取订阅 #1 的最新更新（使用列表序号）\n\n（旧选项 -p 仍可使用，但建议迁移到新命令）';
+        if (!url)
+            return deps.usage;
+        if (rssList.find(item => item.url === url))
+            return '该订阅已存在';
+        const rawArg = deps.formatArg(options);
+        const arg = deps.mixinArg(rawArg);
+        let targetPlatform = platform;
+        let targetGuildId = guildId;
+        if (options?.target) {
+            const authorityCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.advancedAuthority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.advancedAuthority} 或以上`);
+            if (!authorityCheck.success)
+                return authorityCheck.message;
+            const parsedTarget = (0, utils_1.parseTarget)(options.target);
+            if (!parsedTarget) {
+                return '请输入正确的群号，格式为 platform:guildId 或 platform：guildId\n示例: onebot:123456';
+            }
+            targetPlatform = parsedTarget.platform;
+            targetGuildId = parsedTarget.guildId;
+            if (options.test) {
+                try {
+                    await deps.ctx.broadcast([`${targetPlatform}:${targetGuildId}`], '📤 跨群订阅测试消息');
+                    return `✅ 测试消息已发送到目标群组\n目标: ${targetPlatform}:${targetGuildId}\n\n说明：Bot 可以访问该群组，跨群订阅可以正常工作。\n去掉 --test 选项完成订阅。`;
+                }
+                catch (error) {
+                    return `❌ 无法发送到目标群组\n目标: ${targetPlatform}:${targetGuildId}\n错误: ${error.message}\n\n请确认：\n1. Bot 是否在该群组中\n2. 群组ID 是否正确\n3. 平台名称是否正确（如 onebot, telegram 等）`;
+                }
+            }
+        }
+        let title = options?.title || '';
+        try {
+            url = deps.parseQuickUrl(url);
+            const rssItemList = await deps.getRssData((0, common_1.ensureUrlProtocol)(url), arg);
+            if (options.test) {
+                const testItem = rssItemList[0];
+                if (!testItem)
+                    return '未获取到数据';
+                const testArg = { ...arg, url: title || testItem.rss.channel.title, title: title || testItem.rss.channel.title };
+                if (!testArg.template)
+                    testArg.template = deps.config.basic.defaultTemplate;
+                return deps.parseRssItem(testItem, testArg, userId);
+            }
+            if (!title) {
+                title = rssItemList[0]?.rss.channel.title;
+                if (!title)
+                    return '无法获取标题，请使用 -t 指定标题';
+            }
+            const lastPubDate = deps.parsePubDate(rssItemList[0]?.pubDate);
+            const rssItem = {
+                url,
+                platform: targetPlatform,
+                guildId: targetGuildId,
+                author: botSelfId,
+                rssId: rssItemList[0]?.rss?.channel?.title ? rssItemList[0].rss.channel.title : title,
+                arg: rawArg,
+                title,
+                lastPubDate,
+                lastContent: [],
+                followers: []
+            };
+            if (options.force) {
+                const forceCheck = (0, utils_1.checkAuthority)(authority, deps.config.basic.authority, `权限不足！当前权限: ${authority}，需要权限: ${deps.config.basic.authority} 或以上`);
+                if (!forceCheck.success)
+                    return forceCheck.message;
+            }
+            else if (deps.config.basic.urlDeduplication && rssList.find(item => item.rssId === rssItem.rssId)) {
+                return `订阅已存在: ${rssItem.rssId}`;
+            }
+            await deps.ctx.database.create('rssOwl', rssItem);
+            if (deps.config.basic.firstLoad && arg.firstLoad !== false && rssItemList.length > 0) {
+                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 mergedArg = deps.mixinArg(rssItem.arg);
+                const messageList = await Promise.all(itemArray.filter((_, index) => index < maxItem).map(async (item) => deps.parseRssItem(item, { ...rssItem, ...mergedArg }, rssItem.author)));
+                await deps.ctx.broadcast([`${targetPlatform}:${targetGuildId}`], messageList.join(''));
+            }
+            return `订阅成功: ${title}`;
+        }
+        catch (error) {
+            deps.debug(error, 'add error', 'error', logContext);
+            return `订阅失败: ${(0, error_handler_1.getFriendlyErrorMessage)(error, '添加订阅')}`;
+        }
+    });
+}

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;