dsh-rss 0.4.3 → 0.5.1

package/lib/network.js

@@ -1,9 +1,12 @@
 /** RSS 网络边界：地址校验、重定向、响应大小与调用取消。 */
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
-import { createProxyFetch } from './proxy-fetch.js';
+import { createFeedTransport } from './proxy-fetch.js';
+import { lookupPublicDns } from './public-dns.js';
+import { readResponseText } from './response.js';
+import { readWindowsProxy, selectWindowsProxy } from './system-proxy.js';
 const MAX_REDIRECTS = 5;
-const PROXY_HINT = '。若该订阅源需要特殊代理（梯子）才能访问，请在 cordis.patch.yml 里给 dsh-rss 配置 proxyUrl（如 http://127.0.0.1:7890）后重启。';
+const PROXY_HINT = '。请检查网络与代理连接；也可在 dsh-rss 配置中指定 proxyUrl。';
 function parseHttpUrl(url) {
     let parsed;
     try {
@@ -101,7 +104,11 @@ async function lookupWithSignal(hostname, lookupImpl, signal) {
         });
     });
 }
-async function assertPublicUrl(url, cfg, lookupImpl, signal) {
+function isFakeIp(address) {
+    const bytes = ipv4Bytes(address);
+    return bytes !== null && bytes[0] === 198 && (bytes[1] === 18 || bytes[1] === 19);
+}
+async function resolvePublicUrl(url, cfg, lookupImpl, signal, fallbackLookup) {
     if (cfg.allowPrivateNetwork)
         return;
     const hostname = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
@@ -112,7 +119,7 @@ async function assertPublicUrl(url, cfg, lookupImpl, signal) {
         if (isBlockedNetworkAddress(hostname)) {
             throw new Error('出于安全原因，默认禁止访问回环、私网、链路本地或保留地址：' + hostname + '。若确需访问可信内网源，请显式配置 allowPrivateNetwork: true。');
         }
-        return;
+        return [{ address: hostname, family: isIP(hostname) }];
     }
     let addresses;
     try {
@@ -124,113 +131,91 @@ async function assertPublicUrl(url, cfg, lookupImpl, signal) {
     }
     if (addresses.length === 0)
         throw new Error('无法安全解析订阅源域名 ' + hostname + '：DNS 未返回地址。');
-    const blocked = addresses.find((entry) => isBlockedNetworkAddress(entry.address));
-    if (blocked !== undefined) {
-        const v4 = ipv4Bytes(blocked.address);
-        if (v4 !== null && v4[0] === 198 && (v4[1] === 18 || v4[1] === 19)) {
-            throw new Error('订阅源域名 ' + hostname + ' 被解析为保留地址 ' + blocked.address + '，可能是代理软件的 Fake-IP，已拒绝访问。请在代理 DNS 设置中让该域名返回真实 IP（如加入 fake-ip-filter），然后重试。无需开启内网访问。');
-        }
-        throw new Error('出于安全原因，域名 ' + hostname + ' 解析到了非公网地址 ' + blocked.address + '，已拒绝访问。若确需访问可信内网源，请显式配置 allowPrivateNetwork: true。');
+    const privateAddress = addresses.find(entry => isBlockedNetworkAddress(entry.address) && !isFakeIp(entry.address));
+    if (privateAddress !== undefined) {
+        throw new Error('出于安全原因，域名 ' + hostname + ' 解析到了非公网地址 ' + privateAddress.address + '，已拒绝访问。若确需访问可信内网源，请显式配置 allowPrivateNetwork: true。');
     }
-}
-/** 构造默认 fetch：配置了 proxyUrl 时走插件级代理。 */
-function makeFetch(cfg) {
-    if (cfg.proxyUrl === '')
-        return globalThis.fetch;
-    return createProxyFetch(cfg.proxyUrl);
-}
-/**
- * 抓取订阅源 XML：校验地址、限时、限制体积、剥 BOM。
- */
-async function readResponseText(response, maxBodyBytes, signal) {
-    signal.throwIfAborted();
-    const declaredLength = Number(response.headers.get('content-length'));
-    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
-        await response.body?.cancel('response body exceeds maxBodyBytes');
-        throw new Error('订阅源内容超过 ' + maxBodyBytes + ' 字节上限，已停止读取。');
-    }
-    if (response.body === null)
-        return '';
-    const reader = response.body.getReader();
-    const onAbort = () => { void reader.cancel(signal.reason).catch(() => { }); };
-    signal.addEventListener('abort', onAbort, { once: true });
-    const decoder = new TextDecoder('utf-8', { fatal: false });
-    let byteLength = 0;
-    let text = '';
-    try {
-        while (true) {
-            signal.throwIfAborted();
-            const chunk = await reader.read();
-            signal.throwIfAborted();
-            if (chunk.done)
-                break;
-            byteLength += chunk.value.byteLength;
-            if (byteLength > maxBodyBytes) {
-                await reader.cancel('response body exceeds maxBodyBytes');
-                throw new Error('订阅源内容超过 ' + maxBodyBytes + ' 字节上限，已停止读取。');
-            }
-            text += decoder.decode(chunk.value, { stream: true });
+    if (addresses.some(entry => isFakeIp(entry.address))) {
+        if (!cfg.fakeIpDnsFallback) {
+            throw new Error('无法安全解析订阅源域名 ' + hostname + '：检测到代理 Fake-IP。可启用 fakeIpDnsFallback 查询真实 IP 后重试，VPN 可以保持开启。');
         }
-        return text + decoder.decode();
+        addresses = await lookupWithSignal(hostname, fallbackLookup, signal);
+        if (addresses.length === 0)
+            throw new Error('无法安全解析订阅源域名 ' + hostname + '：HTTPS DNS 未返回地址。');
     }
-    finally {
-        signal.removeEventListener('abort', onAbort);
-        reader.releaseLock();
+    const blocked = addresses.find((entry) => isBlockedNetworkAddress(entry.address));
+    if (blocked !== undefined) {
+        throw new Error('出于安全原因，域名 ' + hostname + ' 解析到了非公网地址 ' + blocked.address + '，已拒绝访问。若确需访问可信内网源，请显式配置 allowPrivateNetwork: true。');
     }
+    return addresses;
 }
 export async function fetchFeedXml(url, cfg, exec, fetchImpl, lookupImpl = async (hostname) => await lookup(hostname, { all: true, verbatim: true })) {
     let currentUrl = parseHttpUrl(url);
-    const fetcher = fetchImpl ?? makeFetch(cfg);
     const signal = mergedSignal(cfg.timeoutMs, exec?.signal);
     let response;
+    let transport;
     try {
-        for (let redirectCount = 0;; redirectCount++) {
+        const systemProxy = fetchImpl === undefined && cfg.proxyUrl === '' && cfg.useSystemProxy
+            ? await readWindowsProxy(signal) : undefined;
+        const fallbackLookup = hostname => lookupPublicDns(hostname, signal, cfg.proxyUrl, systemProxy, fetchImpl);
+        const validate = (target) => resolvePublicUrl(target, cfg, lookupImpl, signal, fallbackLookup);
+        try {
+            for (let redirectCount = 0;; redirectCount++) {
+                signal.throwIfAborted();
+                const addresses = await validate(currentUrl);
+                transport = fetchImpl === undefined ? createFeedTransport(currentUrl, cfg.proxyUrl || selectWindowsProxy(systemProxy, currentUrl), addresses) : undefined;
+                response = await (fetchImpl ?? transport.fetch)(currentUrl.href, {
+                    headers: {
+                        'user-agent': cfg.userAgent,
+                        accept: 'application/rss+xml, application/atom+xml, application/xml, text/xml, */*',
+                    },
+                    redirect: 'manual',
+                    signal,
+                });
+                signal.throwIfAborted();
+                if (![301, 302, 303, 307, 308].includes(response.status))
+                    break;
+                const location = response.headers.get('location');
+                if (location === null)
+                    break;
+                await response.body?.cancel('following validated redirect');
+                await transport?.dispose();
+                transport = undefined;
+                if (redirectCount >= MAX_REDIRECTS)
+                    throw new Error('抓取失败：重定向次数超过 ' + MAX_REDIRECTS + ' 次上限。');
+                currentUrl = parseHttpUrl(new URL(location, currentUrl).href);
+            }
+        }
+        catch (error) {
             signal.throwIfAborted();
-            await assertPublicUrl(currentUrl, cfg, lookupImpl, signal);
-            response = await fetcher(currentUrl.href, {
-                headers: {
-                    'user-agent': cfg.userAgent,
-                    accept: 'application/rss+xml, application/atom+xml, application/xml, text/xml, */*',
-                },
-                redirect: 'manual',
-                signal,
-            });
+            if (error instanceof Error && (error.message.includes('出于安全原因') || error.message.includes('无法安全解析') || error.message.includes('重定向次数超过')))
+                throw error;
+            throw new Error('抓取失败：' + (error instanceof Error ? error.message : String(error)) + PROXY_HINT);
+        }
+        if (response === undefined)
+            throw new Error('抓取失败：未收到服务器响应。');
+        if (!response.ok) {
+            await response.body?.cancel('unsuccessful feed response');
+            throw new Error('抓取失败：服务器返回 HTTP ' + response.status + '。');
+        }
+        const reportedUrl = response.url === '' ? currentUrl : parseHttpUrl(response.url);
+        if (reportedUrl.href !== currentUrl.href)
+            await validate(reportedUrl);
+        let xml;
+        try {
+            xml = await readResponseText(response, cfg.maxBodyBytes, signal);
+        }
+        catch (error) {
             signal.throwIfAborted();
-            if (![301, 302, 303, 307, 308].includes(response.status))
-                break;
-            const location = response.headers.get('location');
-            if (location === null)
-                break;
-            await response.body?.cancel('following validated redirect');
-            if (redirectCount >= MAX_REDIRECTS)
-                throw new Error('抓取失败：重定向次数超过 ' + MAX_REDIRECTS + ' 次上限。');
-            currentUrl = parseHttpUrl(new URL(location, currentUrl).href);
+            if (error instanceof Error && error.message.includes('字节上限'))
+                throw error;
+            throw new Error('读取订阅源内容失败：' + (error instanceof Error ? error.message : String(error)));
         }
+        xml = xml.replace(/^\uFEFF/, '');
+        return { xml, finalUrl: reportedUrl.href };
     }
-    catch (error) {
-        signal.throwIfAborted();
-        if (error instanceof Error && (error.message.includes('出于安全原因') || error.message.includes('无法安全解析') || error.message.includes('重定向次数超过')))
-            throw error;
-        throw new Error('抓取失败：' + (error instanceof Error ? error.message : String(error)) + PROXY_HINT);
-    }
-    if (response === undefined)
-        throw new Error('抓取失败：未收到服务器响应。');
-    if (!response.ok) {
-        await response.body?.cancel('unsuccessful feed response');
-        throw new Error('抓取失败：服务器返回 HTTP ' + response.status + '。');
-    }
-    const reportedUrl = response.url === '' ? currentUrl : parseHttpUrl(response.url);
-    await assertPublicUrl(reportedUrl, cfg, lookupImpl, signal);
-    let xml;
-    try {
-        xml = await readResponseText(response, cfg.maxBodyBytes, signal);
-    }
-    catch (error) {
-        signal.throwIfAborted();
-        if (error instanceof Error && error.message.includes('字节上限'))
-            throw error;
-        throw new Error('读取订阅源内容失败：' + (error instanceof Error ? error.message : String(error)));
+    finally {
+        await response?.body?.cancel().catch(() => { });
+        await transport?.dispose();
     }
-    xml = xml.replace(/^\uFEFF/, '');
-    return { xml, finalUrl: reportedUrl.href };
 }

package/lib/opml.d.ts

@@ -27,6 +27,11 @@ export interface OpmlImportResult {
     existedCount: number;
     skippedCount: number;
     skipped: OpmlSkipped[];
+    duplicates: Array<{
+        url: string;
+        before: Feed;
+        after: Feed;
+    }>;
 }
 /** OPML 文档解析结果。 */
 export interface OpmlDocument {
@@ -40,4 +45,4 @@ 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;
+export declare function importOpmlFeeds(current: Feed[], document: OpmlDocument, updateExisting?: boolean): OpmlImportResult;

package/lib/opml.js

@@ -6,8 +6,9 @@
  *
  * @module dsh-rss/opml
  */
-import { XMLParser } from 'fast-xml-parser';
-import { addFeed } from './feeds.js';
+import { XMLParser, XMLValidator } from 'fast-xml-parser';
+import { addFeed, sameFeedUrl } from './feeds.js';
+import { assertHttpUrl } from './network.js';
 const opmlParser = new XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: '@_',
@@ -42,6 +43,9 @@ export function parseOpml(text) {
     const trimmed = (text ?? '').trim();
     if (trimmed === '')
         throw new Error('OPML 内容为空，请提供 OPML XML 文本。');
+    const validation = XMLValidator.validate(trimmed);
+    if (validation !== true)
+        throw new Error('OPML 解析失败：第 ' + validation.err.line + ' 行，' + validation.err.msg);
     let doc;
     try {
         doc = opmlParser.parse(trimmed);
@@ -120,21 +124,36 @@ export function buildOpml(feeds) {
 }
 const HTTP_URL = /^https?:\/\//i;
 /** 把 OPML 导入合并进现有订阅（按 url 去重），非法项跳过。 */
-export function importOpmlFeeds(current, document) {
+export function importOpmlFeeds(current, document, updateExisting = true) {
     const feeds = [...current];
     const added = [];
     const skipped = [];
+    const duplicates = [];
     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;
         }
+        try {
+            assertHttpUrl(outline.url);
+        }
+        catch (error) {
+            skipped.push({ title: outline.name, url: outline.url, reason: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        const previous = feeds.find(feed => sameFeedUrl(feed.url, outline.url));
+        if (!updateExisting && previous) {
+            existedCount += 1;
+            duplicates.push({ url: outline.url, before: previous, after: previous });
+            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;
+            duplicates.push({ url: outline.url, before: previous, after: outcome.added });
         }
         else if (feeds.length > before) {
             added.push(outcome.added);
@@ -147,5 +166,6 @@ export function importOpmlFeeds(current, document) {
         existedCount,
         skippedCount: skipped.length,
         skipped,
+        duplicates,
     };
 }

package/lib/proxy-fetch.d.ts

@@ -1,3 +1,9 @@
+import type { FetchLike, DnsLookupLike } from './network.js';
+/** One request/redirect hop owns its dispatcher until its body has been read. */
+export declare function createFeedTransport(url: URL, proxyUrl: string, addresses?: Awaited<ReturnType<DnsLookupLike>>): {
+    fetch: FetchLike;
+    dispose: () => Promise<void>;
+};
 /**
  * 构造一个把所有请求路由到 proxyUrl 的 fetch。
  * @param proxyUrl - 如 http://127.0.0.1:7890

package/lib/proxy-fetch.js

@@ -1,7 +1,48 @@
 /**
  * 插件级 HTTP 代理：给 RSS 抓取请求一个走指定代理的 fetch，不影响同进程其他插件。
  */
-import { ProxyAgent, fetch as undiciFetch } from 'undici';
+import { Agent, Client, ProxyAgent, fetch as undiciFetch } from 'undici';
+import { isIP } from 'node:net';
+/** One request/redirect hop owns its dispatcher until its body has been read. */
+export function createFeedTransport(url, proxyUrl, addresses) {
+    const hostname = url.hostname.replace(/^\[|\]$/g, '');
+    const servername = isIP(hostname) === 0 ? hostname : undefined;
+    const dispatcher = proxyUrl === ''
+        ? new Agent({ connect: addresses === undefined ? {} : {
+                lookup: (name, options, callback) => {
+                    if (name !== hostname) {
+                        callback(new Error('Unexpected RSS connection hostname'), '', 4);
+                        return;
+                    }
+                    const candidates = addresses.filter(entry => !options.family || entry.family === options.family);
+                    if (candidates.length === 0) {
+                        callback(new Error('No validated RSS address for this family'), '', 4);
+                        return;
+                    }
+                    if (options.all)
+                        callback(null, [...candidates]);
+                    else
+                        callback(null, candidates[0].address, candidates[0].family);
+                },
+            } })
+        : new ProxyAgent({ uri: proxyUrl, proxyTunnel: true, requestTls: { servername },
+            factory: (origin, options) => {
+                const delegate = options.connect;
+                if (addresses === undefined || typeof delegate !== 'function')
+                    return new Client(origin, options);
+                return new Client(origin, { ...options, connect: (socketOptions, callback) => {
+                        const address = addresses[0].address;
+                        const port = socketOptions.port || (url.protocol === 'https:' ? '443' : '80');
+                        const host = (isIP(address) === 6 ? '[' + address + ']' : address) + ':' + port;
+                        delegate({ ...socketOptions, hostname: address, host, port, servername }, callback);
+                    } });
+            },
+        });
+    return {
+        fetch: async (input, init) => await undiciFetch(input, { ...init, redirect: 'manual', dispatcher }),
+        dispose: async () => { await dispatcher.destroy(); },
+    };
+}
 /**
  * 构造一个把所有请求路由到 proxyUrl 的 fetch。
  * @param proxyUrl - 如 http://127.0.0.1:7890

package/lib/public-dns.d.ts

@@ -0,0 +1,3 @@
+import type { FetchLike, DnsLookupLike } from './network.js';
+import { type SystemProxy } from './system-proxy.js';
+export declare function lookupPublicDns(hostname: string, signal: AbortSignal, proxyUrl: string, systemProxy?: SystemProxy, fetchImpl?: FetchLike): Promise<Awaited<ReturnType<DnsLookupLike>>>;

package/lib/public-dns.js

@@ -0,0 +1,49 @@
+/** HTTPS DNS is used only when the OS returns a VPN's 198.18/15 Fake-IP. */
+import { isIP } from 'node:net';
+import { createFeedTransport } from './proxy-fetch.js';
+import { readResponseText } from './response.js';
+import { selectWindowsProxy } from './system-proxy.js';
+const PROVIDERS = ['https://cloudflare-dns.com/dns-query', 'https://dns.google/resolve'];
+export async function lookupPublicDns(hostname, signal, proxyUrl, systemProxy, fetchImpl) {
+    let lastError;
+    for (const provider of PROVIDERS) {
+        try {
+            for (const family of [4, 6]) {
+                signal.throwIfAborted();
+                const url = new URL(provider);
+                url.searchParams.set('name', hostname);
+                url.searchParams.set('type', family === 4 ? 'A' : 'AAAA');
+                const transport = fetchImpl === undefined ? createFeedTransport(url, proxyUrl || selectWindowsProxy(systemProxy, url)) : undefined;
+                let response;
+                try {
+                    response = await (fetchImpl ?? transport.fetch)(url.href, { redirect: 'manual', signal, headers: { accept: 'application/dns-json' } });
+                    if (!response.ok)
+                        throw new Error('HTTPS DNS 返回 HTTP ' + response.status);
+                    const value = JSON.parse(await readResponseText(response, 64 * 1024, signal));
+                    if (value.Status !== 0 || value.TC === true)
+                        throw new Error('HTTPS DNS 未返回完整有效的解析结果');
+                    const records = value.Answer ?? [];
+                    if (!Array.isArray(records))
+                        throw new Error('HTTPS DNS 解析结果格式无效');
+                    const answers = records.filter(record => record.type === (family === 4 ? 1 : 28)).map(record => {
+                        if (typeof record.data !== 'string' || isIP(record.data) !== family)
+                            throw new Error('HTTPS DNS 返回无效 IP 地址');
+                        return { address: record.data, family };
+                    });
+                    if (answers.length > 0)
+                        return answers;
+                }
+                finally {
+                    await response?.body?.cancel().catch(() => { });
+                    await transport?.dispose();
+                }
+            }
+            throw new Error('HTTPS DNS 未返回地址');
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            lastError = error;
+        }
+    }
+    throw new Error('无法安全解析订阅源域名 ' + hostname + ' 的真实 IP：' + (lastError instanceof Error ? lastError.message : String(lastError)) + '。VPN 可以保持开启，请检查代理连接。');
+}

package/lib/response.d.ts

@@ -0,0 +1,2 @@
+/** Read a bounded response while retaining the caller's cancellation reason. */
+export declare function readResponseText(response: Response, maxBodyBytes: number, signal: AbortSignal): Promise<string>;

package/lib/response.js

@@ -0,0 +1,37 @@
+/** Read a bounded response while retaining the caller's cancellation reason. */
+export async function readResponseText(response, maxBodyBytes, signal) {
+    signal.throwIfAborted();
+    const declaredLength = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+        await response.body?.cancel('response body exceeds maxBodyBytes');
+        throw new Error('订阅源内容超过 ' + maxBodyBytes + ' 字节上限，已停止读取。');
+    }
+    if (response.body === null)
+        return '';
+    const reader = response.body.getReader();
+    const onAbort = () => { void reader.cancel(signal.reason).catch(() => { }); };
+    signal.addEventListener('abort', onAbort, { once: true });
+    const decoder = new TextDecoder('utf-8', { fatal: false });
+    let byteLength = 0;
+    let text = '';
+    try {
+        while (true) {
+            signal.throwIfAborted();
+            const chunk = await reader.read();
+            signal.throwIfAborted();
+            if (chunk.done)
+                break;
+            byteLength += chunk.value.byteLength;
+            if (byteLength > maxBodyBytes) {
+                await reader.cancel('response body exceeds maxBodyBytes');
+                throw new Error('订阅源内容超过 ' + maxBodyBytes + ' 字节上限，已停止读取。');
+            }
+            text += decoder.decode(chunk.value, { stream: true });
+        }
+        return text + decoder.decode();
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+        reader.releaseLock();
+    }
+}

package/lib/settings.d.ts

@@ -5,6 +5,8 @@ export declare const Config: modern<Schemastery.ObjectS<NoInfer<{
     proxyUrl: modern<string, string, "plain">;
     timeoutMs: modern<number, number, "plain">;
     maxBodyBytes: modern<number, number, "plain">;
+    useSystemProxy: modern<boolean, boolean, "plain">;
+    fakeIpDnsFallback: modern<boolean, boolean, "plain">;
     userAgent: modern<string, string, "plain">;
     allowPrivateNetwork: modern<boolean, boolean, "plain">;
     opmlWriteApproval: modern<boolean, boolean, "plain">;
@@ -15,6 +17,8 @@ export declare const Config: modern<Schemastery.ObjectS<NoInfer<{
     proxyUrl: modern<string, string, "plain">;
     timeoutMs: modern<number, number, "plain">;
     maxBodyBytes: modern<number, number, "plain">;
+    useSystemProxy: modern<boolean, boolean, "plain">;
+    fakeIpDnsFallback: modern<boolean, boolean, "plain">;
     userAgent: modern<string, string, "plain">;
     allowPrivateNetwork: modern<boolean, boolean, "plain">;
     opmlWriteApproval: modern<boolean, boolean, "plain">;

package/lib/settings.js

@@ -8,6 +8,7 @@ import modern from '@deepseek-ai/schemastery';
 export const Config = modern.object({
     feedsYaml: modern.string().volatile(), cursorsJson: modern.string().volatile(),
     proxyUrl: modern.string(), timeoutMs: modern.number(), maxBodyBytes: modern.number(),
+    useSystemProxy: modern.boolean(), fakeIpDnsFallback: modern.boolean(),
     userAgent: modern.string(), allowPrivateNetwork: modern.boolean(), opmlWriteApproval: modern.boolean(),
     legacySettingsImported: modern.boolean().volatile(),
 });

package/lib/subscriptions.d.ts

@@ -0,0 +1,33 @@
+import { type Feed } from './feeds.js';
+import type { RssSettingsScope } from './tools.js';
+import type { ResolvedRssConfig } from './config.js';
+import type { RssToolExecution } from './execution.js';
+import { type FetchLike, type DnsLookupLike } from './network.js';
+export declare class SubscriptionError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status?: number, code?: string);
+}
+export declare const feedId: (url: string) => string;
+export declare function subscriptionSnapshot(scope: RssSettingsScope): {
+    feeds: Feed[];
+    revision: string;
+};
+/** Read inside the queue: concurrent tool/UI writes cannot overwrite one another. */
+export declare function mutateSubscriptions<T>(scope: RssSettingsScope, mutate: (feeds: Feed[]) => {
+    feeds: Feed[];
+    value: T;
+}, expectedRevision?: string): Promise<T>;
+export interface FeedCheck {
+    checkedAt: string;
+    ok: boolean;
+    title?: string;
+    entryCount?: number;
+    error?: string;
+}
+export declare function recentFeedChecks(scope: RssSettingsScope): Map<string, FeedCheck>;
+/** Same network boundary, parsing and status for tool calls and manual checks. */
+export declare function readRssFeed(scope: RssSettingsScope, url: string, config: ResolvedRssConfig, exec?: RssToolExecution, fetchImpl?: FetchLike, lookupImpl?: DnsLookupLike): Promise<{
+    parsed: import("./parser.js").ParsedFeed;
+    finalUrl: string;
+}>;

package/lib/subscriptions.js

@@ -0,0 +1,76 @@
+/** Shared subscription storage for tools and the settings panel. */
+import { createHash } from 'node:crypto';
+import { parseFeedsYaml, serializeFeeds } from './feeds.js';
+import { fetchFeedXml } from './network.js';
+import { parseFeed } from './parser.js';
+export class SubscriptionError extends Error {
+    status;
+    code;
+    constructor(message, status = 400, code = 'invalid') {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+const writes = new WeakMap();
+export const feedId = (url) => createHash('sha256').update(url).digest('hex');
+export function subscriptionSnapshot(scope) {
+    const value = scope.get();
+    const yaml = value && typeof value.feedsYaml === 'string' ? value.feedsYaml : '';
+    return { feeds: parseFeedsYaml(yaml), revision: feedId(yaml) };
+}
+/** Read inside the queue: concurrent tool/UI writes cannot overwrite one another. */
+export async function mutateSubscriptions(scope, mutate, expectedRevision) {
+    const task = (writes.get(scope) ?? Promise.resolve()).catch(() => { }).then(async () => {
+        const snapshot = subscriptionSnapshot(scope);
+        if (expectedRevision !== undefined && snapshot.revision !== expectedRevision) {
+            throw new SubscriptionError('订阅列表已经变化。请刷新列表后重新预览或保存；你的输入已保留。', 409, 'conflict');
+        }
+        const result = mutate(snapshot.feeds);
+        try {
+            await scope.update({ feedsYaml: serializeFeeds(result.feeds) });
+        }
+        catch (error) {
+            throw new SubscriptionError('写入订阅配置失败（可能已被其他会话修改，请重试）：' + (error instanceof Error ? error.message : String(error)), 503, 'save_failed');
+        }
+        return result.value;
+    });
+    writes.set(scope, task);
+    try {
+        return await task;
+    }
+    finally {
+        if (writes.get(scope) === task)
+            writes.delete(scope);
+    }
+}
+const checks = new WeakMap();
+export function recentFeedChecks(scope) {
+    let map = checks.get(scope);
+    if (!map) {
+        map = new Map();
+        checks.set(scope, map);
+    }
+    return map;
+}
+/** Same network boundary, parsing and status for tool calls and manual checks. */
+export async function readRssFeed(scope, url, config, exec, fetchImpl, lookupImpl) {
+    const map = recentFeedChecks(scope);
+    const save = (check) => {
+        map.delete(url);
+        map.set(url, check);
+        if (map.size > 256)
+            map.delete(map.keys().next().value);
+    };
+    try {
+        const { xml, finalUrl } = await fetchFeedXml(url, config, exec, fetchImpl, lookupImpl);
+        const parsed = parseFeed(xml, finalUrl);
+        save({ checkedAt: new Date().toISOString(), ok: true, title: parsed.feed.title, entryCount: parsed.entries.length });
+        return { parsed, finalUrl };
+    }
+    catch (error) {
+        if (!exec?.signal.aborted)
+            save({ checkedAt: new Date().toISOString(), ok: false, error: error instanceof Error ? error.message : String(error) });
+        throw error;
+    }
+}

package/lib/system-proxy.d.ts

@@ -0,0 +1,7 @@
+export interface SystemProxy {
+    server: string;
+    bypass: string;
+}
+export declare function parseWindowsProxy(output: string): SystemProxy | undefined;
+export declare function selectWindowsProxy(proxy: SystemProxy | undefined, url: URL): string;
+export declare function readWindowsProxy(signal: AbortSignal): Promise<SystemProxy | undefined>;