dsh-rss 0.1.0 → 0.3.0

package/README.en.md

@@ -0,0 +1,94 @@
+# dsh-rss
+
+[![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
+
+DSH (DeepSeek Harness) plugin for RSS/Atom subscriptions: manage feeds, fetch and parse RSS 0.9x / 1.0 / 2.0 and Atom, with OPML bulk import/export, exposing seven model-facing tools.
+
+## Compatibility
+
+Verified against `@deepseek-ai/dsh@0.1.1-rc.2` on 2026-08-26. Built for the cordis patch-bundle plugin model (`cordis.patch.yml` + `dsh.bundle.patch`). No runtime imports of `@deepseek-ai/*` internals.
+
+## Installation
+
+```bash
+dsh plugin --profile web add dsh-rss
+```
+
+Restart the web service after installing.
+
+## Uninstall
+
+```bash
+dsh plugin --profile web remove dsh-rss
+```
+
+Then restart the web service. To clean up fully, also remove the plugin entry from your profile `cordis.patch.yml` if you overrode it.
+
+
+## Configuration
+
+Override the plugin row in your profile's `cordis.patch.yml` (the plugin also loads with all defaults when absent):
+
+```yaml
+- id: rss
+  name: 'dsh-rss'
+  config:
+    # proxyUrl: http://127.0.0.1:7890   # enable when a feed needs a special proxy
+    timeoutMs: 15000                     # fetch timeout in ms (default 15000)
+    # maxBodyBytes: 5242880              # response size cap (default 5MB, guards oversized responses)
+    # userAgent: 'dsh-rss/0.2.0'         # custom fetch UA
+    # feedsYaml: |                        # optional: pre-seed subscriptions (or use the rss_add tool)
+    #   - url: https://example.com/feed.xml
+    #     name: My feed
+    #     category: tech
+```
+
+## Tools
+
+| Tool | Purpose | Key parameters |
+| :-- | :-- | :-- |
+| `rss_list` | List subscribed feeds | none |
+| `rss_add` | Add a subscription (fetches and validates the URL first) | `url` required; `name`/`category` optional |
+| `rss_remove` | Remove a subscription | `url` or `name`, at least one |
+| `rss_fetch` | Fetch and parse a feed, returning feed info and entries (with full `content`) | `url` or `name`, at least one; `limit` 1-100, default 20 |
+| `rss_check` | Validate that a URL is a parseable feed | `url` required |
+| `rss_opml_export` | Export subscriptions as OPML 2.0 text (optionally write a file) | `path` optional |
+| `rss_opml_import` | Bulk-import subscriptions from OPML 2.0 text | `opml` required |
+
+### Examples
+
+```text
+rss_add { url: https://example.com/feed.xml, name: my-feed }
+rss_fetch { name: my-feed, limit: 10 }
+rss_check { url: https://example.com/feed.xml }
+rss_opml_export { path: subscriptions.opml }
+rss_opml_import { opml: "<?xml version=\"1.0\"?>..." }
+```
+
+## Subscriptions
+
+Subscriptions live in the settings namespace `dsh-rss` (the `feedsYaml` field): `rss_add` / `rss_remove` read and write it automatically and changes persist across restarts. You can also pre-seed subscriptions via the `feedsYaml` config field. Use `url` to distinguish feeds that share a name.
+
+## Proxy
+
+Most feeds are reachable directly; a few require a special proxy from your network. When you hit a `fetch failed` error suggesting a proxy, set `proxyUrl` to your local proxy address (e.g. `http://127.0.0.1:7890`) and restart. The proxy only routes this plugin's fetch requests and does not affect other plugins in the same process.
+
+## Parsing capabilities
+
+- RSS 2.0 / RSS 1.0 (RDF) / Atom, normalized to one output shape
+- Entity decoding, CDATA, `content:encoded`, `dc:creator` and other common fields
+- RFC 822 / ISO 8601 dates normalized to ISO 8601 UTC (`pubDate`); the raw text stays in `pubDateRaw`
+- Relative links resolved against the feed URL
+- Summaries stripped of HTML tags and truncated at 500 chars; RSS `content:encoded` / Atom `content` is preserved as a `content` field (tags stripped, up to 20000 chars)
+- Safety: no DTD / external entity parsing; 5MB body cap; configurable fetch timeout
+
+## Development
+
+```bash
+pnpm install
+pnpm test       # builds + 55 tests
+```
+
+## License
+
+MIT

package/README.md

@@ -1,6 +1,19 @@
+[English](README.en.md)
+
 # dsh-rss
 
-DSH（DeepSeek Harness）的 RSS/Atom 订阅工具插件：管理订阅源，抓取并解析 RSS 0.9x / 1.0 / 2.0 与 Atom，给模型提供五个可直接调用的工具。
+> **agent 的资讯雷达**：订阅管理 + RSS/Atom 抓取解析。
+
+![npm version](https://img.shields.io/npm/v/dsh-rss?label=npm&color=blue) ![npm downloads](https://img.shields.io/npm/dm/dsh-rss) ![license](https://img.shields.io/npm/l/dsh-rss) ![stars](https://img.shields.io/github/stars/STARDUSTLC666/dsh-rss?style=social)
+
+[![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
+
+
+DSH（DeepSeek Harness）的 RSS/Atom 订阅工具插件：管理订阅源，抓取并解析 RSS 0.9x / 1.0 / 2.0 与 Atom，支持 OPML 批量导入导出，给模型提供九个可直接调用的工具。
+
+## 兼容性
+
+在 `@deepseek-ai/dsh@0.1.1-rc.2` 上验证（2026-08-26）。遵循 cordis 组合包补丁模型（`cordis.patch.yml` + `dsh.bundle.patch`），运行时不 import 任何 `@deepseek-ai/*` 内部模块。
 
 ## 安装
 
@@ -10,6 +23,15 @@ dsh plugin --profile web add dsh-rss
 
 安装后重启 Web 服务即可。
 
+## 卸载
+
+```bash
+dsh plugin --profile web remove dsh-rss
+```
+
+卸载后重启 Web 服务。如需彻底清理，可再手动删除自己 profile `cordis.patch.yml` 中覆盖的插件行。
+
+
 ## 配置
 
 在你自己的 profile 的 `cordis.patch.yml` 里覆盖本插件行（缺省时插件也能加载，只是全部用默认值）：
@@ -21,7 +43,7 @@ dsh plugin --profile web add dsh-rss
     # proxyUrl: http://127.0.0.1:7890   # 部分订阅源需要特殊代理（梯子）才能访问时启用
     timeoutMs: 15000                     # 抓取超时（毫秒，默认 15000）
     # maxBodyBytes: 5242880              # 订阅源体积上限（默认 5MB，防超大响应）
-    # userAgent: 'dsh-rss/0.1.0'         # 自定义抓取 UA
+    # userAgent: 'dsh-rss/0.2.0'         # 自定义抓取 UA
     # feedsYaml: |                        # 可选：预置订阅列表（也可用 rss_add 工具添加）
     #   - url: https://example.com/feed.xml
     #     name: 示例订阅
@@ -35,8 +57,12 @@ dsh plugin --profile web add dsh-rss
 | `rss_list` | 列出已订阅源 | 无 |
 | `rss_add` | 添加订阅（先抓取校验地址） | `url` 必填；`name`/`category` 可选 |
 | `rss_remove` | 删除订阅 | `url` 或 `name` 至少一个 |
-| `rss_fetch` | 抓取解析订阅源，返回源信息与条目 | `url` 或 `name` 至少一个；`limit` 1-100 默认 20 |
+| `rss_fetch` | 抓取解析订阅源，返回源信息与条目（含正文 content） | `url` 或 `name` 至少一个；`limit` 1-100 默认 20 |
 | `rss_check` | 校验地址是否为可解析的订阅源 | `url` 必填 |
+| `rss_opml_export` | 导出订阅列表为 OPML 2.0 文本（可写入文件） | `path` 可选 |
+| `rss_opml_import` | 从 OPML 2.0 文本批量导入订阅源 | `opml` 必填 |
+| `rss_search` | 跨订阅源关键词搜索条目（标题/摘要/正文/作者） | `query` 必填；`name`/`url`/`since`/`limit` 可选 |
+| `rss_health` | 插件自检（配置/订阅/游标/解析器，离线） | 无 |
 
 ### 示例
 
@@ -44,6 +70,8 @@ dsh plugin --profile web add dsh-rss
 rss_add { url: https://example.com/feed.xml, name: 我的订阅 }
 rss_fetch { name: 我的订阅, limit: 10 }
 rss_check { url: https://example.com/feed.xml }
+rss_opml_export { path: subscriptions.opml }
+rss_opml_import { opml: "<?xml version=\"1.0\"?>..." }
 ```
 
 ## 订阅存储
@@ -60,18 +88,18 @@ rss_check { url: https://example.com/feed.xml }
 - 实体解码、CDATA、`content:encoded`、`dc:creator`、`itunes` 等常见字段
 - RFC 822 / ISO 8601 日期统一转 ISO 8601 UTC（`pubDate`），原始文本保留在 `pubDateRaw`
 - 相对链接按订阅源地址解析成绝对链接
-- 摘要去 HTML 标签并截断到 500 字符；正文全文读取在后续版本提供
+- 摘要去 HTML 标签并截断到 500 字符；RSS `content:encoded` / Atom `content` 作为 `content` 字段保留（去标签后最多 20000 字符）
 - 安全：不解析 DTD/外部实体，内容只做文本抽取；响应体积上限 5MB；抓取超时可配
 
 ## 开发
 
 ```bash
 pnpm install
-pnpm test       # 构建 + 47 个测试
+pnpm test       # 构建 + 63 个测试
 ```
 
 发布前门禁：危险模式扫描、manifest 自检、`pnpm audit --prod`、全量测试，以及全新 profile 的真实启动冒烟测试。
 
 ## License
 
-MIT
+MIT

package/lib/config.js

@@ -6,7 +6,7 @@
  */
 const DEFAULT_TIMEOUT_MS = 15000;
 const DEFAULT_MAX_BODY_BYTES = 5 * 1024 * 1024;
-const DEFAULT_USER_AGENT = 'dsh-rss/0.1.0 (DeepSeek Harness RSS plugin)';
+const DEFAULT_USER_AGENT = 'dsh-rss/0.2.0 (DeepSeek Harness RSS plugin)';
 function optionalString(value) {
     return typeof value === 'string' ? value : undefined;
 }

package/lib/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * dsh-rss —— RSS/Atom 订阅工具插件（node 半身，配置走 cordis.patch.yml）。
  *
- * 插件导出 apply(ctx, config)：把五个面向模型的工具（rss_list / rss_add / rss_remove /
- * rss_fetch / rss_check）注册进宿主进程的工具注册表，并把订阅列表接入 settings
+ * 插件导出 apply(ctx, config)：把七个面向模型的工具（rss_list / rss_add / rss_remove /
+ * rss_fetch / rss_check / rss_opml_export / rss_opml_import）注册进宿主进程的工具注册表，并把订阅列表接入 settings
  * 命名空间（dsh-rss.feedsYaml）。配置缺失时插件照常加载，工具在 execute 时才抛出
  * 带中文指引的错误。
  *
@@ -11,6 +11,7 @@
 import { type RssConfig } from './config.js';
 import { type RssSettingsScope, type RssToolDefinition } from './tools.js';
 /** cordis 服务注入：apply 里要用 ctx.settings 与 ctx.tools，必须显式声明，否则宿主会抛 cannot get property without inject。 */
+export declare const name = "rss";
 export declare const inject: string[];
 /** 插件所需的最小 ctx 面（社区插件不依赖宿主内部类型）。 */
 export interface RssPluginContext {
@@ -33,6 +34,7 @@ export interface RssPluginContext {
 export declare function apply(ctx: RssPluginContext, config?: RssConfig | null): void;
 export * from './config.js';
 export * from './feeds.js';
+export * from './opml.js';
 export * from './parser.js';
 export * from './proxy-fetch.js';
 export * from './settings.js';

package/lib/index.js

@@ -1,8 +1,8 @@
 /**
  * dsh-rss —— RSS/Atom 订阅工具插件（node 半身，配置走 cordis.patch.yml）。
  *
- * 插件导出 apply(ctx, config)：把五个面向模型的工具（rss_list / rss_add / rss_remove /
- * rss_fetch / rss_check）注册进宿主进程的工具注册表，并把订阅列表接入 settings
+ * 插件导出 apply(ctx, config)：把七个面向模型的工具（rss_list / rss_add / rss_remove /
+ * rss_fetch / rss_check / rss_opml_export / rss_opml_import）注册进宿主进程的工具注册表，并把订阅列表接入 settings
  * 命名空间（dsh-rss.feedsYaml）。配置缺失时插件照常加载，工具在 execute 时才抛出
  * 带中文指引的错误。
  *
@@ -12,6 +12,7 @@ import { resolveConfig } from './config.js';
 import { RSS_SETTINGS_NAMESPACE, RssSettingsSchema } from './settings.js';
 import { buildRssTools } from './tools.js';
 /** cordis 服务注入：apply 里要用 ctx.settings 与 ctx.tools，必须显式声明，否则宿主会抛 cannot get property without inject。 */
+export const name = 'rss';
 export const inject = ['settings', 'tools'];
 /**
  * 插件入口：解析配置、注册 settings 命名空间与五个 RSS 工具。
@@ -44,6 +45,7 @@ export function apply(ctx, config) {
 }
 export * from './config.js';
 export * from './feeds.js';
+export * from './opml.js';
 export * from './parser.js';
 export * from './proxy-fetch.js';
 export * from './settings.js';

package/lib/opml.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OPML 导入 / 导出：把 dsh-rss 的订阅列表与常见 RSS 阅读器的 OPML 2.0 互转。
+ *
+ * 导入只读取 outline 树中的 xmlUrl / title / text / category 属性，忽略脚本与
+ * 未知扩展；URL 必须 http(s)，非法项跳过并报告原因，不中断整个导入。
+ *
+ * @module dsh-rss/opml
+ */
+import { type Feed } from './feeds.js';
+/** OPML 解析出的一个订阅。 */
+export interface OpmlOutline {
+    name: string;
+    url: string;
+    category: string;
+}
+/** 导入时被跳过的项。 */
+export interface OpmlSkipped {
+    title: string;
+    url: string;
+    reason: string;
+}
+/** OPML 导入结果。 */
+export interface OpmlImportResult {
+    feeds: Feed[];
+    added: Feed[];
+    addedCount: number;
+    existedCount: number;
+    skippedCount: number;
+    skipped: OpmlSkipped[];
+}
+/** OPML 文档解析结果。 */
+export interface OpmlDocument {
+    title: string;
+    outlines: OpmlOutline[];
+}
+/**
+ * 解析 OPML 2.0 文本。没有 xmlUrl 的 outline 当作分类节点，其 text 会传给后代。
+ */
+export declare function parseOpml(text: string): OpmlDocument;
+/** 把订阅列表序列化为 OPML 2.0 文本。 */
+export declare function buildOpml(feeds: Feed[]): string;
+/** 把 OPML 导入合并进现有订阅（按 url 去重），非法项跳过。 */
+export declare function importOpmlFeeds(current: Feed[], document: OpmlDocument): OpmlImportResult;

package/lib/opml.js

@@ -0,0 +1,151 @@
+/**
+ * OPML 导入 / 导出：把 dsh-rss 的订阅列表与常见 RSS 阅读器的 OPML 2.0 互转。
+ *
+ * 导入只读取 outline 树中的 xmlUrl / title / text / category 属性，忽略脚本与
+ * 未知扩展；URL 必须 http(s)，非法项跳过并报告原因，不中断整个导入。
+ *
+ * @module dsh-rss/opml
+ */
+import { XMLParser } from 'fast-xml-parser';
+import { addFeed } from './feeds.js';
+const opmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    processEntities: true,
+    trimValues: true,
+    parseTagValue: false,
+    isArray: (name) => name === 'outline',
+});
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function attr(rec, key) {
+    const value = rec[key];
+    return typeof value === 'string' ? value.trim() : '';
+}
+function firstText(value) {
+    if (typeof value === 'string')
+        return value.trim();
+    if (Array.isArray(value))
+        return firstText(value[0]);
+    if (typeof value === 'object' && value !== null) {
+        const text = value['#text'];
+        if (typeof text === 'string')
+            return text.trim();
+    }
+    return '';
+}
+/**
+ * 解析 OPML 2.0 文本。没有 xmlUrl 的 outline 当作分类节点，其 text 会传给后代。
+ */
+export function parseOpml(text) {
+    const trimmed = (text ?? '').trim();
+    if (trimmed === '')
+        throw new Error('OPML 内容为空，请提供 OPML XML 文本。');
+    let doc;
+    try {
+        doc = opmlParser.parse(trimmed);
+    }
+    catch (error) {
+        throw new Error('OPML 解析失败：' + (error instanceof Error ? error.message : String(error)));
+    }
+    const root = asRecord(doc);
+    const opml = asRecord(root.opml);
+    if (Object.keys(opml).length === 0)
+        throw new Error('内容不是 OPML 文档（缺少 <opml> 根元素）。');
+    const head = asRecord(opml.head);
+    const body = asRecord(opml.body);
+    const outlines = [];
+    const walk = (node, inheritedCategory) => {
+        const rec = asRecord(node);
+        const xmlUrl = attr(rec, '@_xmlUrl') || attr(rec, '@_xmlurl');
+        const text = attr(rec, '@_text') || attr(rec, '@_title') || firstText(rec);
+        const category = attr(rec, '@_category') || inheritedCategory;
+        if (xmlUrl !== '') {
+            outlines.push({
+                name: attr(rec, '@_title') || text || xmlUrl,
+                url: xmlUrl,
+                category,
+            });
+            return;
+        }
+        const rawChildren = rec.outline;
+        const children = Array.isArray(rawChildren) ? rawChildren : (rawChildren === undefined || rawChildren === null ? [] : [rawChildren]);
+        const nextCategory = text !== '' ? text : inheritedCategory;
+        for (const child of children)
+            walk(child, nextCategory);
+    };
+    const rawBodyOutlines = body.outline;
+    const bodyOutlines = Array.isArray(rawBodyOutlines) ? rawBodyOutlines : (rawBodyOutlines === undefined || rawBodyOutlines === null ? [] : [rawBodyOutlines]);
+    for (const child of bodyOutlines)
+        walk(child, '');
+    return { title: firstText(head.title), outlines };
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/** 把订阅列表序列化为 OPML 2.0 文本。 */
+export function buildOpml(feeds) {
+    const now = new Date().toISOString();
+    const rows = feeds.map((feed) => {
+        const text = feed.name !== '' ? feed.name : feed.url;
+        const attrs = [
+            'text="' + escapeXml(text) + '"',
+            'title="' + escapeXml(feed.name) + '"',
+            'type="rss"',
+            'xmlUrl="' + escapeXml(feed.url) + '"',
+        ];
+        if (feed.category !== '')
+            attrs.push('category="' + escapeXml(feed.category) + '"');
+        return '    <outline ' + attrs.join(' ') + ' />';
+    });
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<opml version="2.0">',
+        '  <head>',
+        '    <title>dsh-rss subscriptions</title>',
+        '    <dateCreated>' + now + '</dateCreated>',
+        '  </head>',
+        '  <body>',
+        ...rows,
+        '  </body>',
+        '</opml>',
+        '',
+    ].join('\n');
+}
+const HTTP_URL = /^https?:\/\//i;
+/** 把 OPML 导入合并进现有订阅（按 url 去重），非法项跳过。 */
+export function importOpmlFeeds(current, document) {
+    const feeds = [...current];
+    const added = [];
+    const skipped = [];
+    let existedCount = 0;
+    for (const outline of document.outlines) {
+        if (!HTTP_URL.test(outline.url)) {
+            skipped.push({ title: outline.name, url: outline.url, reason: 'URL 不是 http(s) 地址' });
+            continue;
+        }
+        const before = feeds.length;
+        const outcome = addFeed(feeds, outline.url, outline.name, outline.category);
+        feeds.splice(0, feeds.length, ...outcome.feeds);
+        if (outcome.existed) {
+            existedCount += 1;
+        }
+        else if (feeds.length > before) {
+            added.push(outcome.added);
+        }
+    }
+    return {
+        feeds,
+        added,
+        addedCount: added.length,
+        existedCount,
+        skippedCount: skipped.length,
+        skipped,
+    };
+}

package/lib/parser.d.ts

@@ -14,6 +14,8 @@ export interface RssEntry {
     author: string;
     summary: string;
     categories: string[];
+    /** RSS content:encoded / Atom content 的正文（去标签，最多 20000 字符）；缺失时省略。 */
+    content?: string;
     enclosure?: RssEnclosure;
 }
 /** 订阅源元信息。 */

package/lib/parser.js

@@ -6,6 +6,7 @@
  */
 import { XMLParser } from 'fast-xml-parser';
 const SUMMARY_MAX_CHARS = 500;
+const CONTENT_MAX_CHARS = 20000;
 const xmlParser = new XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: '@_',
@@ -146,6 +147,7 @@ function normalizeRssItem(item, baseUrl) {
     link = resolveUrl(link, baseUrl);
     const pubDateRaw = firstText(item.pubDate) || firstText(item.date) || firstText(item.updated);
     const summaryRaw = firstText(item.description) || firstText(item.encoded) || firstText(item.summary);
+    const contentRaw = firstText(item.encoded) || firstText(item.content);
     const enclosure = pickRssEnclosure(item);
     const entry = {
         title,
@@ -157,6 +159,9 @@ function normalizeRssItem(item, baseUrl) {
         summary: truncate(stripHtml(summaryRaw), SUMMARY_MAX_CHARS),
         categories: pickCategories(item.category),
     };
+    const content = truncate(stripHtml(contentRaw), CONTENT_MAX_CHARS);
+    if (content !== '')
+        entry.content = content;
     if (enclosure !== undefined)
         entry.enclosure = enclosure;
     return entry;
@@ -170,6 +175,7 @@ function normalizeAtomEntry(entry, baseUrl) {
     link = resolveUrl(link, baseUrl);
     const pubDateRaw = firstText(entry.published) || firstText(entry.updated) || firstText(entry.issued);
     const summaryRaw = firstText(entry.summary) || firstText(entry.content);
+    const contentRaw = firstText(entry.content);
     let enclosure;
     const links = Array.isArray(entry.link) ? entry.link : (entry.link === undefined || entry.link === null ? [] : [entry.link]);
     for (const raw of links) {
@@ -195,6 +201,9 @@ function normalizeAtomEntry(entry, baseUrl) {
         summary: truncate(stripHtml(summaryRaw), SUMMARY_MAX_CHARS),
         categories: pickCategories(entry.category),
     };
+    const content = truncate(stripHtml(contentRaw), CONTENT_MAX_CHARS);
+    if (content !== '')
+        normalized.content = content;
     if (enclosure !== undefined)
         normalized.enclosure = enclosure;
     return normalized;

package/lib/settings.d.ts

@@ -9,10 +9,13 @@ export declare const RSS_SETTINGS_NAMESPACE = "dsh-rss";
 /** settings 页形状：目前只有订阅列表（YAML 文本）。 */
 export declare const RssSettingsSchema: z<Schemastery.ObjectS<{
     feedsYaml: z<string, string>;
+    cursorsJson: z<string, string>;
 }>, Schemastery.ObjectT<{
     feedsYaml: z<string, string>;
+    cursorsJson: z<string, string>;
 }>>;
 /** settings 解析后的值。 */
 export interface RssSettingsValue {
     feedsYaml: string;
+    cursorsJson: string;
 }

package/lib/settings.js

@@ -9,4 +9,5 @@ export const RSS_SETTINGS_NAMESPACE = 'dsh-rss';
 /** settings 页形状：目前只有订阅列表（YAML 文本）。 */
 export const RssSettingsSchema = z.object({
     feedsYaml: z.string().default(''),
+    cursorsJson: z.string().default(''),
 });

package/lib/tools.d.ts

@@ -1,5 +1,5 @@
 /**
- * 五个面向模型的 RSS 工具：list / add / remove / fetch / check。
+ * 九个面向模型的 RSS 工具：list / add / remove / fetch / check / opml_export / opml_import / search / health（fetch 支持增量）。
  * 直接调用 ctx.tools.register 注册【编译好的 JSON Schema】参数与 canonical 输出。
  *
  * @module dsh-rss/tools
@@ -37,8 +37,19 @@ export type FetchLike = (url: string, init?: {
     redirect?: string;
     signal?: AbortSignal;
 }) => Promise<Response>;
+/** 单个订阅源的增量游标：已知条目 id 列表与更新时间。 */
+export interface FeedCursor {
+    guids: string[];
+    updatedAt: string;
+}
+/** 解析 settings 里的增量游标 JSON，损坏时返回空对象（不阻断功能）。 */
+export declare function parseCursors(json: string): Record<string, FeedCursor>;
+/** 合并本次抓到的条目 id，截断到上限，返回新游标。 */
+export declare function advanceCursor(prev: FeedCursor | undefined, entries: unknown[], now: string): FeedCursor;
+/** 用游标过滤出未见过的条目（无游标时全部视为新）。 */
+export declare function filterNewEntries(cursor: FeedCursor | undefined, entries: unknown[]): unknown[];
 /**
- * 构建五个工具定义。每个 execute 惰性读取配置与订阅，错误时抛出中文指引。
+ * 构建七个工具定义。每个 execute 惰性读取配置与订阅，错误时抛出中文指引。
  * @param config - 已解析配置。
  * @param settingsScope - dsh-rss settings scope（get/update）。
  * @param fetchImpl - 可选注入的 fetch（测试用），缺省按 proxyUrl 构造。

package/lib/tools.js

@@ -1,10 +1,12 @@
 /**
- * 五个面向模型的 RSS 工具：list / add / remove / fetch / check。
+ * 九个面向模型的 RSS 工具：list / add / remove / fetch / check / opml_export / opml_import / search / health（fetch 支持增量）。
  * 直接调用 ctx.tools.register 注册【编译好的 JSON Schema】参数与 canonical 输出。
  *
  * @module dsh-rss/tools
  */
+import { writeFile } from 'node:fs/promises';
 import { addFeed, findFeedsByName, parseFeedsYaml, removeFeed, serializeFeeds } from './feeds.js';
+import { buildOpml, importOpmlFeeds, parseOpml } from './opml.js';
 import { parseFeed } from './parser.js';
 import { createProxyFetch } from './proxy-fetch.js';
 const TIMEOUT_MS = 30000;
@@ -122,6 +124,7 @@ const entrySchema = {
         pubDateRaw: { type: 'string' },
         author: { type: 'string' },
         summary: { type: 'string' },
+        content: { type: 'string' },
         categories: { type: 'array', items: { type: 'string' } },
         enclosure: {
             type: 'object',
@@ -199,6 +202,27 @@ const checkSchema = {
     },
     additionalProperties: true,
 };
+const opmlExportSchema = {
+    type: 'object',
+    properties: {
+        opml: { type: 'string' },
+        path: { type: 'string' },
+        feedCount: { type: 'integer' },
+    },
+    additionalProperties: true,
+};
+const opmlImportSchema = {
+    type: 'object',
+    properties: {
+        addedCount: { type: 'integer' },
+        existedCount: { type: 'integer' },
+        skippedCount: { type: 'integer' },
+        totalCount: { type: 'integer' },
+        added: { type: 'array', items: feedItemSchema },
+        skipped: { type: 'array', items: { type: 'object', additionalProperties: true } },
+    },
+    additionalProperties: true,
+};
 // ---------- render 帮助函数 ----------
 function feedLabel(feed) {
     const rec = asRecord(feed);
@@ -254,9 +278,173 @@ function renderCheck(_args, value) {
     const text = '订阅源可用：' + title + '（' + String(rec.feedType) + '），共 ' + String(rec.entryCount) + ' 条。';
     return [{ type: 'text', text }];
 }
+function renderOpmlExport(_args, value) {
+    const rec = asRecord(value);
+    const path = typeof rec.path === 'string' && rec.path !== '' ? '，已写入 ' + rec.path : '';
+    return [{ type: 'text', text: '已导出 ' + String(rec.feedCount ?? 0) + ' 个订阅为 OPML' + path + '。' }];
+}
+function renderOpmlImport(_args, value) {
+    const rec = asRecord(value);
+    const lines = [
+        'OPML 导入完成：新增 ' + String(rec.addedCount ?? 0) + '，已存在 ' + String(rec.existedCount ?? 0) + '，跳过 ' + String(rec.skippedCount ?? 0) + '。当前共 ' + String(rec.totalCount ?? 0) + ' 个订阅源。',
+    ];
+    const skipped = Array.isArray(rec.skipped) ? rec.skipped : [];
+    for (const item of skipped) {
+        const row = asRecord(item);
+        lines.push('- 跳过：' + String(row.title ?? '') + '（' + String(row.reason ?? '') + '）');
+    }
+    return [{ type: 'text', text: lines.join('\n') }];
+}
+const CURSOR_GUID_LIMIT = 200;
+/** 条目唯一 id：优先 guid，退回 link，再退回 标题|发布时间。 */
+function entryId(entry) {
+    const rec = asRecord(entry);
+    const guid = typeof rec.guid === 'string' && rec.guid !== '' ? rec.guid : '';
+    if (guid !== '')
+        return guid;
+    const link = typeof rec.link === 'string' && rec.link !== '' ? rec.link : '';
+    if (link !== '')
+        return link;
+    const title = typeof rec.title === 'string' ? rec.title : '';
+    const pubDate = typeof rec.pubDate === 'string' ? rec.pubDate : '';
+    return title + '|' + pubDate;
+}
+/** 解析 settings 里的增量游标 JSON，损坏时返回空对象（不阻断功能）。 */
+export function parseCursors(json) {
+    if (json.trim() === '')
+        return {};
+    try {
+        const value = JSON.parse(json);
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return {};
+        const out = {};
+        for (const [url, cur] of Object.entries(value)) {
+            const rec = typeof cur === 'object' && cur !== null ? cur : {};
+            const guids = Array.isArray(rec.guids) ? rec.guids.filter((g) => typeof g === 'string') : [];
+            out[url] = { guids, updatedAt: typeof rec.updatedAt === 'string' ? rec.updatedAt : '' };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** 合并本次抓到的条目 id，截断到上限，返回新游标。 */
+export function advanceCursor(prev, entries, now) {
+    const known = new Set(prev?.guids ?? []);
+    for (const entry of entries)
+        known.add(entryId(entry));
+    const guids = [...known];
+    return { guids: guids.slice(-CURSOR_GUID_LIMIT), updatedAt: now };
+}
+/** 用游标过滤出未见过的条目（无游标时全部视为新）。 */
+export function filterNewEntries(cursor, entries) {
+    if (cursor === undefined || cursor.guids.length === 0)
+        return entries;
+    const known = new Set(cursor.guids);
+    return entries.filter((entry) => !known.has(entryId(entry)));
+}
+// ---------- 搜索辅助 ----------
+/** 解析 since 参数为毫秒时间戳，非法时报错。 */
+function parseSinceMs(input) {
+    if (input === undefined)
+        return null;
+    const text = input.trim();
+    const ms = /^\d{4}-\d{2}-\d{2}$/.test(text) ? Date.parse(text + 'T00:00:00Z') : Date.parse(text);
+    if (Number.isNaN(ms)) {
+        throw new Error('since 参数不是有效日期，请给形如 2026-08-01 或 2026-08-01T00:00:00Z 的值。');
+    }
+    return ms;
+}
+/** 关键词是否命中条目的标题/摘要/正文/作者/分类（不区分大小写）。 */
+function entryMatches(entry, queryLower) {
+    const rec = asRecord(entry);
+    const fields = [];
+    for (const key of ['title', 'summary', 'content', 'author']) {
+        const value = rec[key];
+        if (typeof value === 'string')
+            fields.push(value);
+    }
+    const categories = rec.categories;
+    if (Array.isArray(categories)) {
+        for (const category of categories) {
+            if (typeof category === 'string')
+                fields.push(category);
+        }
+    }
+    return fields.some((value) => value.toLowerCase().includes(queryLower));
+}
+// ---------- 搜索与健康自检输出 Schema ----------
+const searchHitSchema = {
+    type: 'object',
+    properties: {
+        feedName: { type: 'string' },
+        feedUrl: { type: 'string' },
+        title: { type: 'string' },
+        link: { type: 'string' },
+        pubDate: { type: 'string' },
+        summary: { type: 'string' },
+    },
+    additionalProperties: true,
+};
+const searchSchema = {
+    type: 'object',
+    properties: {
+        count: { type: 'integer' },
+        hits: { type: 'array', items: searchHitSchema },
+        failedFeeds: { type: 'array', items: { type: 'object', additionalProperties: true } },
+    },
+    additionalProperties: true,
+};
+const healthSchema = {
+    type: 'object',
+    properties: {
+        ok: { type: 'boolean' },
+        plugin: { type: 'string' },
+        feedCount: { type: 'integer' },
+        proxyConfigured: { type: 'boolean' },
+        cursorCount: { type: 'integer' },
+        parserSelfTest: { type: 'boolean' },
+        config: { type: 'object', additionalProperties: true },
+    },
+    additionalProperties: true,
+};
+/** rss_search 的渲染。 */
+function renderSearch(_args, value) {
+    const rec = asRecord(value);
+    const hits = Array.isArray(rec.hits) ? rec.hits : [];
+    const failed = Array.isArray(rec.failedFeeds) ? rec.failedFeeds : [];
+    const lines = ['搜索命中 ' + hits.length + ' 条：'];
+    for (const hit of hits) {
+        const item = asRecord(hit);
+        const title = typeof item.title === 'string' && item.title !== '' ? item.title : '(无标题)';
+        const from = typeof item.feedName === 'string' && item.feedName !== '' ? '【' + item.feedName + '】' : '';
+        const pubDate = typeof item.pubDate === 'string' && item.pubDate !== '' ? '（' + item.pubDate + '）' : '';
+        const link = typeof item.link === 'string' && item.link !== '' ? ' ' + item.link : '';
+        lines.push('- ' + from + title + pubDate + link);
+    }
+    for (const item of failed) {
+        const row = asRecord(item);
+        lines.push('- 抓取失败 ' + String(row.name ?? row.url ?? '') + '：' + String(row.error ?? ''));
+    }
+    return [{ type: 'text', text: lines.join('\n') }];
+}
+/** rss_health 的渲染。 */
+function renderHealth(_args, value) {
+    const rec = asRecord(value);
+    const ok = rec.ok === true;
+    const lines = [
+        'dsh-rss 自检' + (ok ? '：正常。' : '：发现异常，请查看下方详情。'),
+        '- 订阅源数量：' + String(rec.feedCount ?? 0),
+        '- 特殊代理（梯子）：' + (rec.proxyConfigured === true ? '已配置' : '未配置'),
+        '- 增量游标数量：' + String(rec.cursorCount ?? 0),
+        '- 解析器自检：' + (rec.parserSelfTest === true ? '通过' : '失败'),
+    ];
+    return [{ type: 'text', text: lines.join('\n') }];
+}
 // ---------- 工具构建 ----------
 /**
- * 构建五个工具定义。每个 execute 惰性读取配置与订阅，错误时抛出中文指引。
+ * 构建七个工具定义。每个 execute 惰性读取配置与订阅，错误时抛出中文指引。
  * @param config - 已解析配置。
  * @param settingsScope - dsh-rss settings scope（get/update）。
  * @param fetchImpl - 可选注入的 fetch（测试用），缺省按 proxyUrl 构造。
@@ -336,13 +524,26 @@ export function buildRssTools(config, settingsScope, fetchImpl) {
         },
         timeoutMs: TIMEOUT_MS,
     };
+    const readCursorsJson = () => {
+        const value = settingsScope.get();
+        return value !== null && typeof value === 'object' && typeof value.cursorsJson === 'string' ? value.cursorsJson : '';
+    };
+    const persistCursors = async (cursors) => {
+        try {
+            await settingsScope.update({ cursorsJson: JSON.stringify(cursors) });
+        }
+        catch (error) {
+            throw new Error('写入增量游标失败（可能已被其他会话修改，请重试）：' + (error instanceof Error ? error.message : String(error)));
+        }
+    };
     const rssFetch = {
         name: 'rss_fetch',
-        description: '抓取并解析一个 RSS/Atom 订阅源，返回源信息与最新条目（标题、链接、guid、发布时间、作者、摘要、分类、附件）。url 与 name 至少给一个：name 查已订阅源（同名多个时需改用 url），url 直接抓取任意地址。limit 控制返回条数（1-100，默认 20），超过部分以 truncated=true 提示。',
+        description: '抓取并解析一个 RSS/Atom 订阅源，返回源信息与最新条目（标题、链接、guid、发布时间、作者、摘要、分类、附件）。url 与 name 至少给一个：name 查已订阅源（同名多个时需改用 url），url 直接抓取任意地址。limit 控制返回条数（1-100，默认 20），超过部分以 truncated=true 提示。incremental=true 时启用增量模式：只返回上次抓取以来的新条目（按条目 id 去重，游标持久化在 settings），适合定时巡检省 token。',
         parameters: compileParameters({
             url: { type: 'string', description: '订阅源地址（可选，与 name 至少给一个）。' },
             name: { type: 'string', description: '已订阅源的名字（可选，可用 rss_list 查看）。' },
             limit: { type: 'integer', description: '返回条数，1-100，默认 20。' },
+            incremental: { type: 'boolean', description: '增量模式：只返回上次抓取后的新条目（默认 false）。' },
         }),
         output: {
             schema: fetchSchema,
@@ -367,10 +568,19 @@ export function buildRssTools(config, settingsScope, fetchImpl) {
             }
             assertHttpUrl(url);
             const limit = clampedInteger(args, 'limit', 20, 1, 100);
+            const incremental = args.incremental === true;
             const { xml, finalUrl } = await fetchFeedXml(url, cfg, fetchImpl);
             const parsed = parseFeed(xml, finalUrl);
-            const entries = parsed.entries.slice(0, limit);
-            return { url: finalUrl, feed: parsed.feed, entries, truncated: parsed.entries.length > limit };
+            if (!incremental) {
+                const entries = parsed.entries.slice(0, limit);
+                return { url: finalUrl, feed: parsed.feed, entries, truncated: parsed.entries.length > limit };
+            }
+            const cursors = parseCursors(readCursorsJson());
+            const fresh = filterNewEntries(cursors[url], parsed.entries);
+            cursors[url] = advanceCursor(cursors[url], parsed.entries, new Date().toISOString());
+            await persistCursors(cursors);
+            const entries = fresh.slice(0, limit);
+            return { url: finalUrl, feed: parsed.feed, entries, truncated: fresh.length > limit, incremental: true, newCount: fresh.length };
         },
         timeoutMs: TIMEOUT_MS,
     };
@@ -401,5 +611,146 @@ export function buildRssTools(config, settingsScope, fetchImpl) {
         },
         timeoutMs: TIMEOUT_MS,
     };
-    return [rssList, rssAdd, rssRemove, rssFetch, rssCheck];
+    const rssOpmlExport = {
+        name: 'rss_opml_export',
+        description: '把当前订阅列表导出为 OPML 2.0 文本（可直接导入 Feedly / Inoreader / NetNewsWire 等阅读器）。path 可选：提供时同时写入工作区文件。',
+        parameters: compileParameters({
+            path: { type: 'string', description: '可选输出文件路径（相对当前工作区）。缺省时只返回 OPML 文本。' },
+        }),
+        output: {
+            schema: opmlExportSchema,
+            render: renderOpmlExport,
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const feeds = getFeeds();
+            const opml = buildOpml(feeds);
+            const target = optionalString(args, 'path');
+            if (target !== undefined) {
+                await writeFile(target, opml, 'utf8');
+            }
+            return { opml, path: target ?? '', feedCount: feeds.length };
+        },
+        timeoutMs: TIMEOUT_MS,
+    };
+    const rssOpmlImport = {
+        name: 'rss_opml_import',
+        description: '从 OPML 2.0 文本批量导入订阅源（与现有订阅按 url 去重，已存在的只更新 name/category；非法 URL 跳过并报告原因）。导入结果持久化到 settings。',
+        parameters: compileParameters({
+            opml: { type: 'string', required: true, description: 'OPML 2.0 XML 文本（必填，可直接粘贴导出文件的内容）。' },
+        }),
+        output: {
+            schema: opmlImportSchema,
+            render: renderOpmlImport,
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const opmlText = requiredString(args, 'opml', 'OPML 文本');
+            const document = parseOpml(opmlText);
+            const outcome = importOpmlFeeds(getFeeds(), document);
+            await persistFeeds(outcome.feeds);
+            return {
+                addedCount: outcome.addedCount,
+                existedCount: outcome.existedCount,
+                skippedCount: outcome.skippedCount,
+                totalCount: outcome.feeds.length,
+                added: outcome.added,
+                skipped: outcome.skipped,
+            };
+        },
+        timeoutMs: TIMEOUT_MS,
+    };
+    const rssSearch = {
+        name: 'rss_search',
+        description: '跨订阅源搜索条目：实时抓取已订阅源，对标题/摘要/正文/作者/分类做不区分大小写的关键词匹配。query 必填；name 或 url 可限定单个订阅；since 过滤发布日期（如 2026-08-01）；limit 控制返回条数（1-50，默认 20）。个别源抓取失败会单独报告，不影响其他源的搜索。',
+        parameters: compileParameters({
+            query: { type: 'string', required: true, description: '搜索关键词（必填，不区分大小写）。' },
+            name: { type: 'string', description: '只搜索这个名字的订阅（可选）。' },
+            url: { type: 'string', description: '只搜索这个地址的订阅（可选）。' },
+            since: { type: 'string', description: '只要该日期之后发布的条目（可选，如 2026-08-01）。' },
+            limit: { type: 'integer', description: '返回条数，1-50，默认 20。' },
+        }),
+        output: {
+            schema: searchSchema,
+            render: renderSearch,
+        },
+        async execute(rawArgs) {
+            const args = asRecord(rawArgs);
+            const query = requiredString(args, 'query', '搜索关键词').toLowerCase();
+            const limit = clampedInteger(args, 'limit', 20, 1, 50);
+            const sinceMs = parseSinceMs(optionalString(args, 'since'));
+            const urlFilter = optionalString(args, 'url');
+            const nameFilter = optionalString(args, 'name');
+            let targets = getFeeds();
+            if (urlFilter !== undefined)
+                targets = targets.filter((feed) => feed.url.toLowerCase() === urlFilter.toLowerCase());
+            if (nameFilter !== undefined)
+                targets = findFeedsByName(targets, nameFilter);
+            if (targets.length === 0) {
+                if (urlFilter !== undefined || nameFilter !== undefined) {
+                    throw new Error('没有找到匹配的订阅。可用 rss_list 查看订阅列表。');
+                }
+                throw new Error('当前还没有订阅。请先用 rss_add 添加订阅。');
+            }
+            const hits = [];
+            const failedFeeds = [];
+            for (const feed of targets) {
+                if (hits.length >= limit)
+                    break;
+                try {
+                    const { xml, finalUrl } = await fetchFeedXml(feed.url, cfg, fetchImpl);
+                    const parsed = parseFeed(xml, finalUrl);
+                    for (const entry of parsed.entries) {
+                        const rec = asRecord(entry);
+                        const at = Date.parse(typeof rec.pubDate === 'string' ? rec.pubDate : '');
+                        if (sinceMs !== null && !Number.isNaN(at) && at < sinceMs)
+                            continue;
+                        if (entryMatches(entry, query)) {
+                            hits.push({ feedName: feed.name, feedUrl: feed.url, ...rec });
+                            if (hits.length >= limit)
+                                break;
+                        }
+                    }
+                }
+                catch (error) {
+                    failedFeeds.push({ url: feed.url, name: feed.name, error: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            return { count: hits.length, hits, failedFeeds };
+        },
+        timeoutMs: Math.min(300000, Math.max(TIMEOUT_MS, cfg.timeoutMs * 10)),
+    };
+    const rssHealth = {
+        name: 'rss_health',
+        description: 'dsh-rss 自检：检查配置有效性、订阅数量、增量游标与解析器自检（不发任何网络请求）。遇到问题时先运行本工具定位。',
+        parameters: compileParameters({}),
+        output: {
+            schema: healthSchema,
+            render: renderHealth,
+        },
+        async execute() {
+            const feeds = getFeeds();
+            const settingsValue = settingsScope.get();
+            const cursorsJson = settingsValue !== null && typeof settingsValue === 'object' && typeof settingsValue.cursorsJson === 'string' ? settingsValue.cursorsJson : '';
+            let parserSelfTest = false;
+            try {
+                const sample = parseFeed('<?xml version="1.0"?><rss version="2.0"><channel><title>selftest</title><item><title>item</title></item></channel></rss>', 'https://selftest.local/');
+                parserSelfTest = sample.entries.length === 1 && sample.feed.feedType === 'rss';
+            }
+            catch {
+                parserSelfTest = false;
+            }
+            return {
+                ok: parserSelfTest,
+                plugin: 'dsh-rss',
+                feedCount: feeds.length,
+                proxyConfigured: cfg.proxyUrl !== '',
+                cursorCount: Object.keys(parseCursors(cursorsJson)).length,
+                parserSelfTest,
+                config: { timeoutMs: cfg.timeoutMs, maxBodyBytes: cfg.maxBodyBytes, userAgent: cfg.userAgent },
+            };
+        },
+        timeoutMs: TIMEOUT_MS,
+    };
+    return [rssList, rssAdd, rssRemove, rssFetch, rssCheck, rssOpmlExport, rssOpmlImport, rssSearch, rssHealth];
 }

package/package.json

@@ -1,65 +1,65 @@
-{
-  "name": "dsh-rss",
-  "version": "0.1.0",
-  "description": "DSH RSS 订阅工具插件：管理订阅源并抓取解析 RSS/Atom（rss_list / rss_add / rss_remove / rss_fetch / rss_check）",
-  "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "lib",
-    "cordis.patch.yml",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepare": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "pnpm run build && node --test \"test/*.test.mjs\"",
-    "prepublishOnly": "pnpm run build"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  },
-  "keywords": [
-    "dsh",
-    "deepseek-harness",
-    "plugin",
-    "rss",
-    "atom",
-    "feed"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "fast-xml-parser": "^5.0.0",
-    "schemastery": "^3.18.0",
-    "undici": "^8.10.0",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.0.0",
-    "typescript": "^5.6.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/STARDUSTLC666/dsh-rss"
-  },
-  "bugs": {
-    "url": "https://github.com/STARDUSTLC666/dsh-rss/issues"
-  },
-  "homepage": "https://github.com/STARDUSTLC666/dsh-rss#readme",
-  "author": "stardustlc",
-  "packageManager": "pnpm@11.7.0"
-}
+{
+  "name": "dsh-rss",
+  "version": "0.3.0",
+  "description": "DSH RSS 订阅工具插件：管理订阅源、OPML 导入导出、抓取解析 RSS/Atom 并保留正文（rss_list / rss_add / rss_remove / rss_fetch / rss_check / rss_opml_export / rss_opml_import）",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "README.en.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm run build && node --test \"test/*.test.mjs\"",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "rss",
+    "atom",
+    "feed"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^5.0.0",
+    "schemastery": "^3.18.0",
+    "undici": "^8.10.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/STARDUSTLC666/dsh-rss.git"
+  },
+  "bugs": {
+    "url": "https://github.com/STARDUSTLC666/dsh-rss/issues"
+  },
+  "homepage": "https://github.com/STARDUSTLC666/dsh-rss#readme",
+  "author": "stardustlc",
+  "packageManager": "pnpm@11.7.0"
+}