@zhin.js/plugin-rss 1.1.9 → 1.1.10

package/src/admin-tasks.ts

@@ -1,3 +1,6 @@
+import { adminText, taskDetail, formatTaskDetail, isAdminTextKey, LocalizedTaskError, type AdminTextKey } from './admin-i18n.js';
+import { rssMessages as t } from './i18n.js';
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
 import { createHash, randomUUID } from 'node:crypto';
 import { createDeliveryTarget, type DeliveryTarget, type OutboundHost, type PluginStateStore } from 'zhin.js';
 import { EndpointDeliveryError } from '@zhin.js/im-contract';
@@ -6,7 +9,7 @@ import { createGenerationAdmissionGate, generationAdmissionSource, PluginTaskErr
   type PluginTaskProvider, type PluginTaskSnapshot } from 'zhin.js/plugin-runtime';
 import { fetchFeed, stripHtml, type FeedItem, type RssConfig } from './feed.js';
 import { formatNewItems } from './poll.js';
-import { isRssQuietMinute, parseQuietHours, type RssQuietHours } from './quiet-hours.js';
+import { isRssQuietMinute, parseQuietHours, LocalizedQuietHoursError, type RssQuietHours } from './quiet-hours.js';
 
 export const ADMIN_RSS_STATE_KEY = 'admin-rss/v1';
 const MAX_TASKS = 8;
@@ -18,10 +21,10 @@ const UUID = /^[\da-f]{8}-(?:[\da-f]{4}-){3}[\da-f]{12}$/iu;
 const DIGEST = /^[\da-f]{64}$/u;
 type Task = {
   readonly id: string; readonly creation: string; readonly version: string; readonly url: string;
-  readonly target: DeliveryTarget; readonly createdAt: number;
+  readonly target: DeliveryTarget; readonly locale?: Locale; readonly createdAt: number;
   readonly state: 'scheduled' | 'paused' | 'unknown' | 'failed' | 'cancelled';
   readonly seen: readonly string[] | null; readonly claimId: string | null;
-  readonly lastCheckAt: number | null; readonly lastRunAt: number | null; readonly detail: string;
+  readonly lastCheckAt: number | null; readonly lastRunAt: number | null; readonly detail: string; readonly detailKey?: AdminTextKey;
   readonly quiet?: RssQuietHours;
   readonly pending?: PendingSummary | null;
 };
@@ -33,13 +36,27 @@ type FeedLoader = typeof fetchFeed;
 
 /** Administrator subscriptions use their own owner-bound durable pool and per-task cursors. */
 export class AdministratorRssTasks implements PluginTaskProvider {
+  readonly i18n = {
+  "en": {
+    "title": "Administrator RSS subscriptions",
+    "description": "Deliver new articles to an exact account, conversation and thread, independently of chat subscriptions.",
+    "effects": [
+      "Fetches the feed on the instance pollCron schedule. The first successful fetch after creation or resuming only establishes a baseline; historical articles are not sent.",
+      "New articles use the unified send pipeline and the complete selected target. Pausing or cancelling cannot recall a delivery already in progress.",
+      "Unconfirmed delivery is never retried or resumed automatically. Check the target conversation before cancelling and creating another subscription.",
+      "Each instance supports 8 tasks and retains 32 operation receipts and 64 recent article identifiers. An article that disappears for a long time may be treated as new when it returns.",
+      "Only administrator subscriptions with all three quiet-hours fields defer and summarize delivery. The first poll after quiet hours sends the pending summary; the next poll fetches the feed. Reminders and chat subscriptions are unaffected.",
+      "A summary stores up to 3 short items, further limited by maxItems, and counts up to 10000 updates before showing “at least”. Pausing, editing or cancelling clears pending summaries; resuming establishes a new baseline without backfilling."
+    ]
+  }
+} as const;
   readonly title = '管理员 RSS 订阅';
   readonly description = '向精确账号、会话与线程推送新文章，独立于聊天创建的 RSS 订阅';
   readonly schema = { type: 'object', additionalProperties: false, required: ['url'], properties: {
-    url: { type: 'string', minLength: 1, maxLength: 2048, title: 'RSS / Atom 地址', description: 'HTTP(S) 地址，不接受 URL 用户名或密码' },
-    quietTimezone: { type: 'string', maxLength: 128, title: '静默时区（可选）', description: '如 Asia/Shanghai；三项全部留空关闭静默，启用须全部填写' },
-    quietStart: { type: 'string', maxLength: 5, title: '静默开始（可选）', description: 'HH:mm，包含此分钟，如 22:00；须同时填写时区和结束时间' },
-    quietEnd: { type: 'string', maxLength: 5, title: '静默结束（可选）', description: 'HH:mm，不包含此分钟，如 08:00；开始和结束不能相同' },
+    url: { type: 'string', minLength: 1, maxLength: 2048, 'x-i18n': {"en": {"title": "RSS / Atom URL", "description": "HTTP(S) URL without a username or password"}}, title: 'RSS / Atom 地址', description: 'HTTP(S) 地址，不接受 URL 用户名或密码' },
+    quietTimezone: { type: 'string', maxLength: 128, 'x-i18n': {"en": {"title": "Quiet timezone (optional)", "description": "For example Asia/Shanghai. Fill in all three quiet-hours fields to enable, or leave all empty to disable."}}, title: '静默时区（可选）', description: '如 Asia/Shanghai；三项全部留空关闭静默，启用须全部填写' },
+    quietStart: { type: 'string', maxLength: 5, 'x-i18n': {"en": {"title": "Quiet start (optional)", "description": "HH:mm, inclusive, such as 22:00. Timezone and end time are also required."}}, title: '静默开始（可选）', description: 'HH:mm，包含此分钟，如 22:00；须同时填写时区和结束时间' },
+    quietEnd: { type: 'string', maxLength: 5, 'x-i18n': {"en": {"title": "Quiet end (optional)", "description": "HH:mm, exclusive, such as 08:00. Start and end must be different."}}, title: '静默结束（可选）', description: 'HH:mm，不包含此分钟，如 08:00；开始和结束不能相同' },
   } } as const;
   readonly effects = [
     '保存后按实例 pollCron 定时访问源站；新建及暂停后恢复的首次成功抓取只建立基线，不发送历史文章',
@@ -53,51 +70,52 @@ export class AdministratorRssTasks implements PluginTaskProvider {
   readonly #outbound: OutboundHost;
   readonly #config: Readonly<RssConfig>;
   readonly #load: FeedLoader;
+  readonly projectLocale: Locale;
   readonly #admission = createGenerationAdmissionGate();
   #stopped = false;
   #working = false;
   get [generationAdmissionSource]() { return [this.#admission]; }
 
-  constructor(state: PluginStateStore, outbound: OutboundHost, config: Readonly<RssConfig>, load: FeedLoader = fetchFeed) {
-    if (!outbound.sendTarget) throw unavailable('管理员 RSS 需要支持精确目标的 Outbound Host');
-    this.#state = state; this.#outbound = outbound; this.#config = config; this.#load = load;
+  constructor(state: PluginStateStore, outbound: OutboundHost, config: Readonly<RssConfig>, load: FeedLoader = fetchFeed, projectLocale: Locale = 'zh-CN') {
+    if (!outbound.sendTarget) throw unavailable('exactTarget');
+    this.projectLocale = projectLocale; this.#state = state; this.#outbound = outbound; this.#config = config; this.#load = load;
   }
   stop(): void { this.#stopped = true; }
 
-  async read(): Promise<PluginTaskSnapshot> {
-    return this.#admit(async () => this.#snapshot(readBook(await this.#state.get<AdministratorRssBook>(ADMIN_RSS_STATE_KEY))));
+  async read(options?: { readonly locale?: Locale }): Promise<PluginTaskSnapshot> {
+    return this.#admit(async () => this.#snapshot(readBook(await this.#state.get<AdministratorRssBook>(ADMIN_RSS_STATE_KEY)), options?.locale), options?.locale);
   }
   async create(input: PluginTaskMutation & Readonly<{ target: DeliveryTarget; parameters: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
     return this.#admit(async () => {
       assertMutation(input);
       let target: DeliveryTarget;
-      try { target = createDeliveryTarget({ conversation: input.target }); } catch { throw invalid('请提供完整有效的目标账号、会话、父容器和线程'); }
+      try { target = createDeliveryTarget({ conversation: input.target }); } catch { throw invalid('invalidTarget'); }
       const parameters = parseParameters(input.parameters), { url, quiet } = parameters;
       const fingerprint = digest({ operation: 'create', target, url, ...(quiet ? { quiet } : {}) });
-      const task: Task = { id: input.requestId, creation: fingerprint, version: randomUUID(), url, target, createdAt: Date.now(), state: 'scheduled',
-        seen: null, claimId: null, lastCheckAt: null, lastRunAt: null, detail: '等待首次抓取建立基线，不发送历史文章', ...(quiet ? { quiet, pending: null } : {}) };
+      const task: Task = { id: input.requestId, creation: fingerprint, version: randomUUID(), url, target, locale: this.projectLocale, createdAt: Date.now(), state: 'scheduled',
+        seen: null, claimId: null, lastCheckAt: null, lastRunAt: null, ...taskDetail('waiting'), ...(quiet ? { quiet, pending: null } : {}) };
       const revision = randomUUID();
       const book = await this.#state.update<AdministratorRssBook>(ADMIN_RSS_STATE_KEY, current => {
         this.#assertLive(); const book = readBook(current);
         if (reconcile(book, input.requestId, fingerprint)) return book;
         assertRevision(book, input.expectedRevision);
         const existing = book.tasks.find(item => item.id === task.id);
-        if (existing) { if (existing.creation !== fingerprint) throw conflict('同一请求 ID 已用于其他内容'); return book; }
+        if (existing) { if (existing.creation !== fingerprint) throw conflict('requestReused'); return book; }
         const active = book.tasks.filter(item => item.state !== 'cancelled' && item.state !== 'failed');
-        if (active.length >= MAX_TASKS) throw invalid('管理员 RSS 订阅已达 8 条上限，请先取消任务');
-        if (active.some(item => item.url === url && JSON.stringify(item.target) === JSON.stringify(target))) throw invalid('此完整目标已有该源的管理员订阅，请先核实原任务');
+        if (active.length >= MAX_TASKS) throw invalid('quota');
+        if (active.some(item => item.url === url && JSON.stringify(item.target) === JSON.stringify(target))) throw invalid('duplicate');
         const historyLimit = MAX_TASKS - active.length - 1;
         const history = historyLimit ? book.tasks.filter(item => item.state === 'cancelled' || item.state === 'failed').slice(-historyLimit) : [];
         return bounded({ version: 2, revision, tasks: [...active, ...history, task], receipts: receipt(book, input.requestId, fingerprint, task.id, 'create') });
       });
-      return this.#snapshot(readBook(book));
-    });
+      return this.#snapshot(readBook(book), input.locale);
+    }, input.locale);
   }
   async change(input: PluginTaskMutation & Readonly<{ id: string; action: PluginTaskAction; parameters?: Readonly<Record<string, JsonValue>> }>): Promise<PluginTaskSnapshot> {
     return this.#admit(async () => {
       assertMutation(input);
-      if (!isUuid(input.id) || !['pause', 'resume', 'cancel', 'update'].includes(input.action)) throw invalid('任务 ID 或操作无效');
-      if (input.action !== 'update' && input.parameters !== undefined) throw invalid('仅编辑操作接受参数');
+      if (!isUuid(input.id) || !['pause', 'resume', 'cancel', 'update'].includes(input.action)) throw invalid('invalidAction');
+      if (input.action !== 'update' && input.parameters !== undefined) throw invalid('updateParameters');
       const parameters = input.action === 'update' ? parseParameters(input.parameters) : undefined;
       const url = parameters?.url;
       const fingerprint = digest({ operation: input.action, id: input.id, url: url ?? null, ...(parameters?.quiet ? { quiet: parameters.quiet } : {}) }), revision = randomUUID(), version = randomUUID();
@@ -106,28 +124,28 @@ export class AdministratorRssTasks implements PluginTaskProvider {
         if (reconcile(book, input.requestId, fingerprint)) return book;
         assertRevision(book, input.expectedRevision);
         const task = book.tasks.find(item => item.id === input.id);
-        if (!task) throw new PluginTaskError('not_found', '未找到当前实例的管理员 RSS 订阅；聊天订阅不在此入口管理');
+        if (!task) throw new LocalizedTaskError('not_found', 'notFound');
         let changed: Task;
         switch (input.action) {
           case 'pause':
-            if (task.state !== 'scheduled') throw invalid('仅待轮询订阅可以暂停');
-            changed = { ...task, version, state: 'paused', pending: null, detail: '管理员暂停并清空待发摘要；恢复时重新建立基线，不补发历史文章' }; break;
+            if (task.state !== 'scheduled') throw invalid('pauseState');
+            changed = { ...task, version, state: 'paused', pending: null, ...taskDetail('paused') }; break;
           case 'resume':
-            if (task.state !== 'paused') throw invalid('仅暂停订阅可以恢复；未确认投递不能恢复或重试');
-            changed = { ...task, version, state: 'scheduled', seen: null, pending: null, detail: '已恢复，等待重新建立基线，不补发历史文章' }; break;
+            if (task.state !== 'paused') throw invalid('resumeState');
+            changed = { ...task, version, state: 'scheduled', seen: null, pending: null, ...taskDetail('resumed') }; break;
           case 'update':
-            if (task.state !== 'paused') throw invalid('编辑前请先暂停订阅；未确认投递不能编辑');
+            if (task.state !== 'paused') throw invalid('updateState');
             if (book.tasks.some(item => item.id !== task.id && item.state !== 'cancelled' && item.state !== 'failed' && item.url === url
-              && JSON.stringify(item.target) === JSON.stringify(task.target))) throw invalid('此完整目标已有该源的管理员订阅');
-            changed = { ...withoutQuiet(task), version, url: url!, ...(parameters?.quiet ? { quiet: parameters.quiet } : {}), pending: null, seen: null, detail: '已编辑并清空待发摘要，保持暂停，恢复后首次抓取只建立基线' }; break;
+              && JSON.stringify(item.target) === JSON.stringify(task.target))) throw invalid('duplicateUpdate');
+            changed = { ...withoutQuiet(task), version, url: url!, ...(parameters?.quiet ? { quiet: parameters.quiet } : {}), pending: null, seen: null, ...taskDetail('edited') }; break;
           case 'cancel':
-            if (task.state === 'cancelled' || task.state === 'failed') throw invalid('任务已结束，不能再次取消');
-            changed = { ...task, version, state: 'cancelled', pending: null, detail: '管理员取消并清空待发摘要；已经开始的投递无法撤回' }; break;
+            if (task.state === 'cancelled' || task.state === 'failed') throw invalid('finished');
+            changed = { ...task, version, state: 'cancelled', pending: null, ...taskDetail('cancelled') }; break;
         }
         return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === task.id ? changed : item), receipts: receipt(book, input.requestId, fingerprint, task.id, input.action) });
       });
-      return this.#snapshot(readBook(result));
-    });
+      return this.#snapshot(readBook(result), input.locale);
+    }, input.locale);
   }
 
   /** Called by the plugin's one existing RSS poll registration, never by chat rss-check. */
@@ -144,7 +162,7 @@ export class AdministratorRssTasks implements PluginTaskProvider {
           if (this.#stopped) break;
           if (task.state !== 'scheduled' || !task.quiet || !task.pending || isRssQuietMinute(task.quiet, Date.now())) continue;
           const claimed = await this.#claimPending(task);
-          if (claimed) { flushed.add(task.id); await this.#deliver(claimed, formatSummary(claimed.url, claimed.pending!, this.#config.maxItems)); }
+          if (claimed) { flushed.add(task.id); await this.#deliver(claimed, formatSummary(claimed.url, claimed.pending!, this.#config.maxItems, resolveLocale(claimed.locale))); }
         }
         const tasks = readBook(await this.#state.get<AdministratorRssBook>(ADMIN_RSS_STATE_KEY)).tasks;
         for (const task of tasks) {
@@ -152,7 +170,7 @@ export class AdministratorRssTasks implements PluginTaskProvider {
           if (task.state !== 'scheduled' || flushed.has(task.id)) continue;
           let feed: Awaited<ReturnType<FeedLoader>>;
           try { feed = await this.#load(task.url, this.#config.timeout); }
-          catch { await this.#recordCheck(task, '源站抓取失败；尚未尝试投递，下轮重查'); continue; }
+          catch { await this.#recordCheck(task, 'fetchFailed'); continue; }
           if (this.#stopped) break;
           // Keep only bounded identifiers, never arbitrary feed bodies, in durable state.
           const unique = new Map<string, FeedItem>();
@@ -168,15 +186,14 @@ export class AdministratorRssTasks implements PluginTaskProvider {
             const live = book.tasks.find(item => item.id === task.id);
             if (this.#stopped || live?.version !== task.version || live.state !== 'scheduled') return current;
             const changed: Task = { ...live, seen, version, lastCheckAt: now, pending, ...(shouldSend
-              ? { state: 'unknown', claimId, lastRunAt: now, detail: '投递中或未确认；不会自动重试' }
-              : { detail: pending ? `静默中，已积累${pending.countCapped ? '至少' : ''}${pending.count} 条更新；退出静默后的首轮轮询汇总`
-                : task.seen === null ? '已建立基线；从后续新文章开始推送' : '抓取完成，暂无新文章' }) };
+              ? { state: 'unknown', claimId, lastRunAt: now, ...taskDetail('delivering') }
+              : taskDetail(pending ? 'quietPending' : task.seen === null ? 'baseline' : 'noNew')) };
             return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === task.id ? changed : item) });
           });
           const claimed = readBook(result).tasks.find(item => item.id === task.id && item.claimId === claimId && item.state === 'unknown');
           if (!claimed || this.#stopped) continue;
-          await this.#deliver(claimed, claimed.pending ? formatSummary(claimed.url, claimed.pending, this.#config.maxItems)
-            : formatNewItems(feed.title || claimed.url, newItems, this.#config.maxItems));
+          await this.#deliver(claimed, claimed.pending ? formatSummary(claimed.url, claimed.pending, this.#config.maxItems, resolveLocale(claimed.locale))
+            : formatNewItems(feed.title || claimed.url, newItems, this.#config.maxItems, resolveLocale(claimed.locale)));
         }
       });
     } finally { this.#working = false; }
@@ -187,48 +204,53 @@ export class AdministratorRssTasks implements PluginTaskProvider {
       const book = readBook(current), live = book.tasks.find(item => item.id === task.id);
       if (this.#stopped || !live || live.version !== task.version || live.state !== 'scheduled' || !live.pending || !live.quiet || isRssQuietMinute(live.quiet, now)) return current;
       return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === task.id
-        ? { ...item, version, claimId, lastRunAt: now, state: 'unknown', detail: '摘要投递中或未确认；不会自动重试' } : item) });
+        ? { ...item, version, claimId, lastRunAt: now, state: 'unknown', ...taskDetail('summaryDelivering') } : item) });
     });
     return readBook(result).tasks.find(item => item.id === task.id && item.claimId === claimId && item.state === 'unknown');
   }
   async #deliver(claimed: Task, content: string): Promise<void> {
     if (this.#stopped) return;
-    let state: Task['state'] = 'unknown', detail = '平台未确认投递，请核实目标会话后取消并另建订阅；不会自动重试';
+    let state: Task['state'] = 'unknown', detail = taskDetail('unknown');
     try {
-      const id = await this.#outbound.sendTarget!(claimed.target, content);
-      if (id) { state = 'scheduled'; detail = '已确认投递；等待后续新文章'; }
+      const id = await this.#outbound.sendTarget!(claimed.target, content, { locale: resolveLocale(claimed.locale) });
+      if (id) { state = 'scheduled'; detail = taskDetail('delivered'); }
     } catch (error) {
-      if (error instanceof EndpointDeliveryError && error.disposition !== 'unknown') { state = 'failed'; detail = '平台明确未投递或拒绝；订阅已停止'; }
+      if (error instanceof EndpointDeliveryError && error.disposition !== 'unknown') { state = 'failed'; detail = taskDetail('rejected'); }
     }
     const revision = randomUUID(), version = randomUUID();
     await this.#state.update<AdministratorRssBook>(ADMIN_RSS_STATE_KEY, current => {
       const book = readBook(current), live = book.tasks.find(item => item.id === claimed.id);
       if (live?.claimId !== claimed.claimId || live.state !== 'unknown') return current;
       return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === claimed.id
-        ? { ...item, state, detail, version, ...(state === 'scheduled' ? { pending: null } : {}) } : item) });
+        ? { ...item, state, ...detail, version, ...(state === 'scheduled' ? { pending: null } : {}) } : item) });
     });
   }
-  async #recordCheck(task: Task, detail: string): Promise<void> {
+  async #recordCheck(task: Task, detailKey: AdminTextKey): Promise<void> {
     if (this.#stopped) return;
     const revision = randomUUID(), version = randomUUID(), now = Date.now();
     await this.#state.update<AdministratorRssBook>(ADMIN_RSS_STATE_KEY, current => {
       const book = readBook(current);
       if (this.#stopped || !book.tasks.some(item => item.id === task.id && item.version === task.version && item.state === 'scheduled')) return current;
-      return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === task.id ? { ...item, version, detail, lastCheckAt: now } : item) });
+      return bounded({ ...book, version: 2, revision, tasks: book.tasks.map(item => item.id === task.id ? { ...item, version, ...taskDetail(detailKey), lastCheckAt: now } : item) });
     });
   }
-  #assertLive(): void { if (this.#stopped) throw unavailable('管理员 RSS 服务属于已停止的插件实例'); }
-  async #admit<T>(operation: () => Promise<T>): Promise<T> {
-    this.#assertLive(); const release = this.#admission.acquire();
-    if (!release) throw unavailable('管理员 RSS 服务属于未发布或已退役的 generation');
-    try { return await operation(); } finally { release(); }
+  #assertLive(): void { if (this.#stopped) throw unavailable('stopped'); }
+  async #admit<T>(operation: () => Promise<T>, locale?: Locale): Promise<T> {
+    let release: (() => void) | undefined;
+    try {
+    this.#assertLive(); release = this.#admission.acquire();
+    if (!release) throw unavailable('retired');
+    return await operation();
+    } catch (error) { throw error instanceof LocalizedTaskError ? error.localize(locale) : error; } finally { release?.(); }
   }
-  #snapshot(book: AdministratorRssBook): PluginTaskSnapshot {
+  #snapshot(book: AdministratorRssBook, locale?: Locale): PluginTaskSnapshot {
     return { revision: book.revision, receipts: book.receipts.map(item => ({ requestId: item.id, taskId: item.taskId, operation: item.operation })),
       tasks: book.tasks.map(task => ({ id: task.id, ownership: 'administrator', title: `RSS · ${task.url}`.slice(0, 200), target: task.target,
         state: task.state, createdAt: task.createdAt, ...(task.lastRunAt === null ? {} : { lastRunAt: task.lastRunAt }), parameters: { url: task.url,
           ...(task.quiet ? { quietTimezone: task.quiet.timezone, quietStart: task.quiet.start, quietEnd: task.quiet.end } : {}) },
-        detail: `${task.detail}${task.quiet ? `；静默 ${task.quiet.timezone} ${task.quiet.start}–${task.quiet.end}` : ''}${task.pending ? `；${task.state === 'scheduled' ? '待汇总' : '本次摘要'}${task.pending.countCapped ? '至少' : ''}${task.pending.count} 条更新` : ''}；实例轮询 ${this.#config.pollCron}${task.lastCheckAt === null ? '' : `；最近抓取 ${new Date(task.lastCheckAt).toISOString()}`}；状态不代表平台连接健康`,
+        detail: [formatTaskDetail(task, locale), task.quiet ? adminText(locale, 'quietDescription', task.quiet) : '',
+          task.pending ? adminText(locale, task.state === 'scheduled' ? 'pendingDescription' : 'summaryDescription', { count: task.pending.countCapped ? adminText(locale, 'countCapped', { count: task.pending.count }) : task.pending.count }) : '',
+          adminText(locale, 'pollDescription', { cron: this.#config.pollCron }), task.lastCheckAt === null ? '' : adminText(locale, 'checkedDescription', { at: new Date(task.lastCheckAt).toISOString() }), adminText(locale, 'stateNote')].filter(Boolean).join(locale === 'en' ? '; ' : '；'),
         actions: task.state === 'scheduled' ? ['pause', 'cancel'] : task.state === 'paused' ? ['update', 'resume', 'cancel'] : task.state === 'unknown' ? ['cancel'] : [],
       })) };
   }
@@ -236,21 +258,21 @@ export class AdministratorRssTasks implements PluginTaskProvider {
 
 function parseParameters(value: Readonly<Record<string, JsonValue>> | undefined): { url: string; quiet?: RssQuietHours } {
   if (!value || Array.isArray(value) || Object.keys(value).some(key => !['url', 'quietTimezone', 'quietStart', 'quietEnd'].includes(key))
-    || typeof value.url !== 'string' || value.url.length > 2048) throw invalid('参数须包含有效 HTTP(S) RSS 地址及可选的三项静默设置');
+    || typeof value.url !== 'string' || value.url.length > 2048) throw invalid('invalidParameters');
   let quiet: RssQuietHours | undefined;
   try { quiet = parseQuietHours(value); }
-  catch (error) { throw invalid(error instanceof TypeError ? error.message : '静默设置无效'); }
+  catch (error) { if (error instanceof LocalizedQuietHoursError) throw invalid(error.messageKey); throw invalid('invalidQuiet'); }
   try {
     const url = new URL(value.url);
     if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password || /\s/u.test(value.url)) throw new Error('url');
     url.hash = '';
     if (url.href.length > 2048) throw new Error('url length');
     return { url: url.href, ...(quiet ? { quiet } : {}) };
-  } catch { throw invalid('请提供有效 HTTP(S) RSS 地址，不接受 URL 用户名或密码'); }
+  } catch { throw invalid('invalidUrl'); }
 }
 function assertMutation(input: PluginTaskMutation): void {
   if (!isUuid(input.requestId) || typeof input.expectedRevision !== 'string'
-    || !input.expectedRevision || input.expectedRevision.length > 128) throw invalid('操作须包含 UUID requestId 和读取到的 expectedRevision');
+    || !input.expectedRevision || input.expectedRevision.length > 128) throw invalid('invalidMutation');
 }
 function digest(value: unknown): string { return createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
 function isUuid(value: unknown): value is string { return typeof value === 'string' && UUID.test(value); }
@@ -258,21 +280,21 @@ function isDigest(value: unknown): value is string { return typeof value === 'st
 function isTimestamp(value: unknown): value is number {
   return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && Number.isFinite(new Date(value).getTime());
 }
-function invalid(message: string): PluginTaskError { return new PluginTaskError('invalid_input', message); }
-function conflict(message: string): PluginTaskError { return new PluginTaskError('conflict', message); }
-function unavailable(message: string): PluginTaskError { return new PluginTaskError('unavailable', message); }
-function assertRevision(book: AdministratorRssBook, revision: string): void { if (book.revision !== revision) throw conflict('订阅状态已变化，请刷新后重新确认'); }
+function invalid(message: AdminTextKey): PluginTaskError { return new LocalizedTaskError('invalid_input', message); }
+function conflict(message: AdminTextKey): PluginTaskError { return new LocalizedTaskError('conflict', message); }
+function unavailable(message: AdminTextKey): PluginTaskError { return new LocalizedTaskError('unavailable', message); }
+function assertRevision(book: AdministratorRssBook, revision: string): void { if (book.revision !== revision) throw conflict('revision'); }
 function reconcile(book: AdministratorRssBook, id: string, fingerprint: string): boolean {
   const previous = book.receipts.find(item => item.id === id);
   if (!previous) return false;
-  if (previous.fingerprint !== fingerprint) throw conflict('同一操作请求 ID 已用于其他内容，禁止重放');
+  if (previous.fingerprint !== fingerprint) throw conflict('replayConflict');
   return true;
 }
 function receipt(book: AdministratorRssBook, id: string, fingerprint: string, taskId: string, operation: Receipt['operation']): readonly Receipt[] {
   return [...book.receipts, { id, fingerprint, taskId, operation }].slice(-MAX_RECEIPTS);
 }
 function bounded(book: AdministratorRssBook): AdministratorRssBook {
-  if (book.tasks.length > MAX_TASKS || bytes(book) > 60 * 1024) throw invalid('管理员 RSS 状态达到 8 条或 60 KiB 上限，请先取消并整理订阅');
+  if (book.tasks.length > MAX_TASKS || bytes(book) > 60 * 1024) throw invalid('capacity');
   // Reserve future bounded cursors, summary samples and claim metadata at mutation
   // time. Once accepted, ordinary quiet accumulation cannot exceed the state port.
   const reserved = { ...book, revision: 'f'.repeat(36), tasks: book.tasks.map(task => !task.quiet || task.state === 'cancelled' || task.state === 'failed' ? task : {
@@ -282,7 +304,7 @@ function bounded(book: AdministratorRssBook): AdministratorRssBook {
     pending: { from: 8_640_000_000_000_000, to: 8_640_000_000_000_000, count: MAX_PENDING_COUNT, countCapped: false,
       items: Array.from({ length: MAX_PENDING_ITEMS }, () => ({ key: 'f'.repeat(64), title: 'x'.repeat(128), link: 'x'.repeat(384) })) },
   }) };
-  if (bytes(reserved) > 60 * 1024) throw invalid('管理员 RSS 状态空间不足以保留静默摘要及去重游标；请先取消并整理订阅，现有数据未改动');
+  if (bytes(reserved) > 60 * 1024) throw invalid('capacityReserved');
   return book;
 }
 function readBook(value: AdministratorRssBook | undefined): AdministratorRssBook {
@@ -303,6 +325,7 @@ function readBook(value: AdministratorRssBook | undefined): AdministratorRssBook
         || (task.lastRunAt !== null && !isTimestamp(task.lastRunAt))
         || (task.claimId !== null && !isUuid(task.claimId)) || (task.state === 'unknown' && (!task.claimId || task.seen === null || task.lastRunAt === null))
         || (task.seen !== null && (!Array.isArray(task.seen) || task.seen.length > MAX_SEEN || !task.seen.every((key: unknown) => typeof key === 'string' && DIGEST.test(key))))
+        || (task.locale !== undefined && task.locale !== 'zh-CN' && task.locale !== 'en') || (task.detailKey !== undefined && !isAdminTextKey(task.detailKey))
         || typeof task.detail !== 'string' || task.detail.length > 1000 || parseParameters({ url: task.url }).url !== task.url) throw new Error('task');
       if (task.quiet !== undefined) {
         if (value.version !== 2 || !task.quiet || Object.keys(task.quiet).sort().join(',') !== 'end,start,timezone'
@@ -326,7 +349,7 @@ function readBook(value: AdministratorRssBook | undefined): AdministratorRssBook
       ids.add(task.id);
     }
     return bounded(value);
-  } catch { throw unavailable('管理员 RSS 持久状态格式无效，已停止管理员轮询与投递；请保留原数据核查'); }
+  } catch { throw unavailable('corrupt'); }
 }
 
 function withoutQuiet(task: Task): Omit<Task, 'quiet'> { const { quiet: _quiet, ...rest } = task; return rest; }
@@ -360,10 +383,10 @@ function shortLink(value: string): string {
     return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password && bytes(url.href) <= 384 ? url.href : '';
   } catch { return ''; }
 }
-function formatSummary(url: string, pending: PendingSummary, maxItems: number): string {
-  const lines = [`RSS 静默摘要：累计检测到${pending.countCapped ? '至少' : ''} ${pending.count} 条更新`, `来源：${url}`];
+function formatSummary(url: string, pending: PendingSummary, maxItems: number, locale: Locale = 'zh-CN'): string {
+  const lines = [t(locale, 'summaryHeading', { minimum: pending.countCapped ? t(locale, 'atLeast') : '', count: pending.count }), t(locale, 'source', { url })];
   const shown = pending.items.slice(0, Math.min(MAX_PENDING_ITEMS, maxItems));
-  for (const item of shown) lines.push('', item.title || '未命名文章', ...(item.link ? [item.link] : []));
-  if (pending.count > shown.length || pending.countCapped) lines.push('', `仅展示 ${shown.length} 条短明细，其余请查看源站；计数基于有界轮询窗口。`);
+  for (const item of shown) lines.push('', item.title || t(locale, 'untitled'), ...(item.link ? [item.link] : []));
+  if (pending.count > shown.length || pending.countCapped) lines.push('', t(locale, 'summaryMore', { count: shown.length }));
   return lines.join('\n');
 }

package/src/channel.ts

@@ -1,3 +1,5 @@
+import type { Locale } from 'zhin.js/i18n';
+import { rssMessages as t } from './i18n.js';
 /** A subscription destination uses public Message fields, never CapabilityId internals. */
 
 export interface ChannelInfo {
@@ -26,8 +28,8 @@ function hasUnsupportedAddress(input: unknown): boolean {
 }
 
 /** Explain rejection without silently flattening a thread/container address. */
-export function channelSourceError(input: unknown): string {
-  return hasUnsupportedAddress(input) ? UNSUPPORTED_ADDRESS_MESSAGE : CHANNEL_REQUIRED_MESSAGE;
+export function channelSourceError(input: unknown, locale: Locale = 'zh-CN'): string {
+  return t(locale, hasUnsupportedAddress(input) ? 'unsupportedAddress' : 'channelRequired');
 }
 
 /** No IM source means no destination; callers must not invent a global subscription. */

package/src/feed.ts

@@ -1,3 +1,5 @@
+import type { Locale } from 'zhin.js/i18n';
+import { rssMessages as t } from './i18n.js';
 /**
  * RSS feed fetch/preview helpers (no Plugin host).
  */
@@ -92,15 +94,15 @@ export async function fetchFeed(
   return { title: (feed.title || url).trim(), items };
 }
 
-export function formatFeedPreview(title: string, items: FeedItem[]): string {
-  if (items.length === 0) return `${title}: 暂无内容`;
-  const lines = [`${title} (共 ${items.length} 条)`];
+export function formatFeedPreview(title: string, items: FeedItem[], locale: Locale = 'zh-CN'): string {
+  if (items.length === 0) return t(locale, 'previewEmpty', { title });
+  const lines = [t(locale, 'previewTitle', { title, count: items.length })];
   for (const item of items.slice(0, 5)) {
     lines.push('');
     lines.push(`${item.title}`);
-    if (item.date) lines.push(`  ${new Date(item.date).toLocaleString('zh-CN')}`);
+    if (item.date) lines.push(`  ${new Date(item.date).toLocaleString(locale)}`);
     if (item.link) lines.push(`  ${item.link}`);
   }
-  if (items.length > 5) lines.push(`\n...还有 ${items.length - 5} 条`);
+  if (items.length > 5) lines.push(t(locale, 'more', { count: items.length - 5 }));
   return lines.join('\n');
 }

package/src/i18n.ts

@@ -0,0 +1,168 @@
+import { createMessages } from 'zhin.js/i18n';
+
+export const rssMessages = createMessages({
+  toolPreviewEmpty: { 'zh-CN': '{title}: 无内容', en: '{title}: No items' },
+  toolPreviewFailed: { 'zh-CN': '解析失败: {error}', en: 'Parsing failed: {error}' },
+  allEmpty: { 'zh-CN': '暂无任何 RSS 订阅', en: 'There are no RSS subscriptions' },
+  allList: { 'zh-CN': 'RSS 订阅总览 ({count} 条):\n{items}', en: 'RSS subscriptions ({count}):\n{items}' },
+  "databaseUnavailable": {
+    "zh-CN": "RSS 数据库尚未就绪",
+    "en": "The RSS database is not ready"
+  },
+  "databaseRetry": {
+    "zh-CN": "RSS 数据库尚未就绪，请稍后重试",
+    "en": "The RSS database is not ready; try again later"
+  },
+  "urlRequired": {
+    "zh-CN": "请提供 RSS 源地址",
+    "en": "Provide an RSS feed URL"
+  },
+  "httpRequired": {
+    "zh-CN": "请提供有效的 HTTP/HTTPS 地址",
+    "en": "Provide a valid HTTP/HTTPS URL"
+  },
+  "existing": {
+    "zh-CN": "当前会话已订阅该源，无需重复添加",
+    "en": "This conversation already subscribes to that feed"
+  },
+  "limit": {
+    "zh-CN": "当前会话订阅数已达上限 ({max})，请先取消一些",
+    "en": "This conversation has reached its subscription limit ({max}); remove a subscription first"
+  },
+  "loadFailed": {
+    "zh-CN": "无法解析该地址: {error}\n请确认是有效的 RSS/Atom 源",
+    "en": "Could not parse this URL: {error}\nCheck that it is a valid RSS/Atom feed"
+  },
+  "added": {
+    "zh-CN": "订阅成功！\n源: {feed}\n新内容将在轮询时推送到本会话（需 OutboundHost）",
+    "en": "Subscribed!\nFeed: {feed}\nNew items will be sent to this conversation when polled (requires OutboundHost)"
+  },
+  "empty": {
+    "zh-CN": "当前会话没有订阅任何 RSS 源",
+    "en": "This conversation has no RSS subscriptions"
+  },
+  "addHint": {
+    "zh-CN": "使用 {command} <URL> 添加订阅",
+    "en": "Use {command} <URL> to subscribe"
+  },
+  "unknownTitle": {
+    "zh-CN": "(未知标题)",
+    "en": "(Untitled)"
+  },
+  "list": {
+    "zh-CN": "当前订阅 ({count}/{max})：\n{items}",
+    "en": "Subscriptions ({count}/{max}):\n{items}"
+  },
+  "notSubscribed": {
+    "zh-CN": "当前会话未订阅该源",
+    "en": "This conversation does not subscribe to that feed"
+  },
+  "noSubscriptions": {
+    "zh-CN": "当前会话没有任何订阅",
+    "en": "This conversation has no subscriptions"
+  },
+  "removeUrl": {
+    "zh-CN": "请提供要取消的 RSS 源地址",
+    "en": "Provide the RSS feed URL to unsubscribe"
+  },
+  "notFound": {
+    "zh-CN": "未找到该订阅",
+    "en": "Subscription not found"
+  },
+  "removed": {
+    "zh-CN": "已取消订阅: {feed}",
+    "en": "Unsubscribed: {feed}"
+  },
+  "previewFailed": {
+    "zh-CN": "解析失败: {error}\n请确认是有效的 RSS/Atom 地址",
+    "en": "Parsing failed: {error}\nCheck that it is a valid RSS/Atom URL"
+  },
+  "channelRequired": {
+    "zh-CN": "请在机器人私聊、群聊或频道内执行此命令；当前调用没有有效的订阅会话",
+    "en": "Run this command in a bot private chat, group or channel; this invocation has no valid subscription conversation"
+  },
+  "unsupportedAddress": {
+    "zh-CN": "暂不支持线程／父频道寻址的订阅，请在无需线程或父频道信息的会话内执行",
+    "en": "Thread or parent-channel subscription addresses are not supported; use a conversation that does not require them"
+  },
+  "previewEmpty": {
+    "zh-CN": "{title}: 暂无内容",
+    "en": "{title}: No items"
+  },
+  "previewTitle": {
+    "zh-CN": "{title} (共 {count} 条)",
+    "en": "{title} ({count} items)"
+  },
+  "more": {
+    "zh-CN": "\n...还有 {count} 条",
+    "en": "\n...{count} more items"
+  },
+  "newItems": {
+    "zh-CN": "{title} 有 {count} 条新内容：",
+    "en": "{title}: {count} new items:"
+  },
+  "moreSource": {
+    "zh-CN": "\n...还有 {count} 条，请查看源站",
+    "en": "\n...{count} more items; visit the source website"
+  },
+  "noNew": {
+    "zh-CN": "{title}: 无新内容",
+    "en": "{title}: No new items"
+  },
+  "checkFailed": {
+    "zh-CN": "{url}: 检查失败 — {error}",
+    "en": "{url}: Check failed — {error}"
+  },
+  "nothingToCheck": {
+    "zh-CN": "没有可检查的订阅",
+    "en": "There are no subscriptions to check"
+  },
+  "pushed": {
+    "zh-CN": "，已推送 {count} 个会话",
+    "en": ", sent to {count} conversations"
+  },
+  "notPushed": {
+    "zh-CN": "，无出站推送",
+    "en": ", no outbound delivery"
+  },
+  "localOnly": {
+    "zh-CN": "（未装配 OutboundHost，仅本地标记）",
+    "en": " (OutboundHost is not configured; items were only marked locally)"
+  },
+  "checked": {
+    "zh-CN": "检查完成，共 {count} 条新内容{pushNote}",
+    "en": "Check complete: {count} new items{pushNote}"
+  },
+  "checkedEmpty": {
+    "zh-CN": "检查完成，暂无新内容",
+    "en": "Check complete: no new items"
+  },
+  "noFeeds": {
+    "zh-CN": "暂无任何 RSS 订阅",
+    "en": "There are no RSS subscriptions"
+  },
+  "summaryTitle": {
+    "zh-CN": "RSS 静默摘要",
+    "en": "RSS quiet-hours digest"
+  },
+  "summaryHeading": {
+    "zh-CN": "RSS 静默摘要：累计检测到{minimum} {count} 条更新",
+    "en": "RSS quiet-hours digest: detected {minimum} {count} updates"
+  },
+  "atLeast": {
+    "zh-CN": "至少",
+    "en": "at least"
+  },
+  "source": {
+    "zh-CN": "来源：{url}",
+    "en": "Source: {url}"
+  },
+  "untitled": {
+    "zh-CN": "未命名文章",
+    "en": "Untitled article"
+  },
+  "summaryMore": {
+    "zh-CN": "仅展示 {count} 条短明细，其余请查看源站；计数基于有界轮询窗口。",
+    "en": "Showing {count} short items; visit the source for the rest. Counts are based on the bounded polling window."
+  }
+});