koishi-plugin-disaster-warning 0.0.10 → 0.1.0

package/lib/commands.js

@@ -5,46 +5,75 @@ const koishi_1 = require("koishi");
 const logger = new koishi_1.Logger('disaster-commands');
 function applyCommands(ctx, config, service) {
     ctx.command('disaster', '灾害预警插件');
+    // disaster.status — 查看各 WebSocket 连接状态
+    ctx.command('disaster.status', '查看各数据源连接状态')
+        .action(() => {
+        const status = service.getStatus();
+        const lines = ['📡 数据源连接状态：'];
+        for (const [name, s] of Object.entries(status)) {
+            const icon = s.connected ? '🟢' : '🔴';
+            const retry = s.retryCount > 0 ? ` (重试: ${s.retryCount})` : '';
+            lines.push(`${icon} ${name}${retry}`);
+        }
+        return lines.join('\n');
+    });
+    // disaster.test — 发送测试消息
     ctx.command('disaster.test', '发送测试预警消息')
-        .action(async ({ session }) => {
-        if (!session)
-            return;
-        await session.send('正在发送测试消息...');
-        const msg = [
+        .action(() => {
+        return [
             '【测试消息】',
             '这是一个测试用的地震预警消息。',
             '震源：测试地点',
-            `时间：${new Date().toLocaleString()}`,
+            `时间：${new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })}`,
             '震级：M5.0',
             '最大烈度：4.0'
         ].join('\n');
-        return msg;
     });
-    ctx.command('disaster.history', '查看最近地震记录 (CENC)')
-        .action(async ({ session }) => {
-        try {
-            const data = await ctx.http.get('https://api.wolfx.jp/cenc_eqlist.json');
-            if (!data)
-                return '获取数据失败';
-            const list = [];
-            let count = 0;
-            for (const key in data) {
-                if (key.startsWith('No') && count < 5) {
-                    const eq = data[key];
-                    list.push(eq);
-                    count++;
-                }
+    // disaster.history — 查询最近地震记录
+    ctx.command('disaster.history [source:string] [count:number]', '查询最近地震记录')
+        .usage('source: cenc（中国）或 jma（日本），默认 cenc\ncount: 条数，默认 5，最多 10')
+        .action(async ({ session }, source = 'cenc', count = 5) => {
+        source = source.toLowerCase();
+        if (source !== 'cenc' && source !== 'jma') {
+            return '❌ 数据源只支持 cenc 或 jma';
+        }
+        count = Math.min(Math.max(1, count), 10);
+        // 先尝试从内存缓存读取（避免重复 HTTP 请求）
+        const cache = service.getEqListCache();
+        let data = cache[source];
+        // 缓存为空时实时拉取
+        if (!data || Object.keys(data).length === 0) {
+            try {
+                const url = source === 'cenc'
+                    ? 'https://api.wolfx.jp/cenc_eqlist.json'
+                    : 'https://api.wolfx.jp/jma_eqlist.json';
+                data = await ctx.http.get(url);
+            }
+            catch (e) {
+                logger.error('Failed to fetch eqlist:', e);
+                return '❌ 获取数据失败，请检查网络或日志。';
             }
-            if (list.length === 0)
-                return '未找到最近地震记录';
-            const messages = list.map(eq => {
-                return `时间: ${eq.time}\n地点: ${eq.location}\n震级: M${eq.magnitude}\n深度: ${eq.depth}km`;
-            });
-            return messages.join('\n\n');
         }
-        catch (e) {
-            logger.error('Failed to fetch history:', e);
-            return '获取历史记录失败，请检查网络或日志。';
+        if (!data)
+            return '❌ 未获取到数据';
+        const items = [];
+        let n = 1;
+        while (items.length < count && data[`No${n}`]) {
+            items.push(data[`No${n}`]);
+            n++;
         }
+        if (!items.length)
+            return '暂无地震记录';
+        const sourceName = source === 'cenc' ? 'CENC 中国地震台网' : 'JMA 日本气象厅';
+        const lines = [`📋 最近 ${items.length} 条地震记录（${sourceName}）：`, ''];
+        items.forEach((eq, i) => {
+            const intensity = eq.shindo
+                ? `震度 ${eq.shindo}`
+                : eq.intensity
+                    ? `烈度 ${eq.intensity}`
+                    : '';
+            lines.push(`[${i + 1}] ${eq.time}`, `    📍 ${eq.location}  M${eq.magnitude}  深度 ${eq.depth}${intensity ? `  ${intensity}` : ''}`, '');
+        });
+        return lines.join('\n').trim();
     });
 }

package/lib/handlers/wolfx.d.ts

@@ -1,7 +1,17 @@
 import { BaseDataHandler } from './base';
 import { DisasterEvent } from '../models';
 export declare class WolfxHandler extends BaseDataHandler {
+    private eqListCache;
     constructor(sourceId: string);
+    getEqListCache(): {
+        cenc: Record<string, any>;
+        jma: Record<string, any>;
+    };
+    /**
+     * 解析 Wolfx HTTP eqlist JSON（cenc 或 jma），
+     * 提取最新一条记录作为 DisasterEvent 推送。
+     */
+    parseEqList(data: any, type: 'cenc' | 'jma'): DisasterEvent | null;
     parseMessage(data: any): DisasterEvent | null;
     private parseJMAEEW;
     private parseCENCEEW;

package/lib/handlers/wolfx.js

@@ -6,6 +6,30 @@ const models_1 = require("../models");
 class WolfxHandler extends base_1.BaseDataHandler {
     constructor(sourceId) {
         super(sourceId);
+        // HTTP 轮询缓存（用于 commands history 复用，避免重复请求）
+        this.eqListCache = { cenc: {}, jma: {} };
+    }
+    getEqListCache() {
+        return this.eqListCache;
+    }
+    /**
+     * 解析 Wolfx HTTP eqlist JSON（cenc 或 jma），
+     * 提取最新一条记录作为 DisasterEvent 推送。
+     */
+    parseEqList(data, type) {
+        try {
+            // 更新缓存
+            this.eqListCache[type] = data;
+            // 提取 No1（最新一条）
+            const eqInfo = data['No1'];
+            if (!eqInfo || typeof eqInfo !== 'object')
+                return null;
+            return type === 'cenc' ? this.parseCENCEqList(data) : this.parseJMAEqList(data);
+        }
+        catch (e) {
+            this.logger.error(`[${this.sourceId}] parseEqList error:`, e);
+            return null;
+        }
     }
     parseMessage(data) {
         try {

package/lib/index.d.ts

@@ -19,10 +19,18 @@ export interface Config {
         japan: boolean;
         global: boolean;
     };
-    source_priority: 'auto' | 'wolfx' | 'fanstudio' | 'p2p';
-    min_magnitude: number;
-    min_intensity: number;
-    min_scale: number;
+    data_sources: {
+        fan_studio: boolean;
+        wolfx: boolean;
+        p2p: boolean;
+        global_quake: boolean;
+    };
+    filter: {
+        min_magnitude_absolute: number;
+        min_magnitude_for_push: number;
+        min_intensity_for_push: number;
+        min_scale_for_push: number;
+    };
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -12,7 +12,9 @@ exports.inject = {
 };
 exports.Config = koishi_1.Schema.object({
     enabled: koishi_1.Schema.boolean().default(true).description('启用灾害预警插件'),
-    target_groups: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('推送目标群号列表，格式: 平台:群号（如 onebot:123456）'),
+    target_groups: koishi_1.Schema.array(koishi_1.Schema.string())
+        .default([])
+        .description('推送目标群号列表，直接填写群号即可，例如 123456789'),
     data_types: koishi_1.Schema.object({
         earthquake_warning: koishi_1.Schema.boolean().default(true).description('地震预警（实时速报，震前预警）'),
         earthquake_info: koishi_1.Schema.boolean().default(true).description('地震信息（震后测定报告）'),
@@ -23,17 +25,20 @@ exports.Config = koishi_1.Schema.object({
         china: koishi_1.Schema.boolean().default(true).description('中国大陆'),
         taiwan: koishi_1.Schema.boolean().default(true).description('台湾'),
         japan: koishi_1.Schema.boolean().default(true).description('日本'),
-        global: koishi_1.Schema.boolean().default(false).description('全球（USGS/GlobalQuake）'),
+        global: koishi_1.Schema.boolean().default(false).description('全球（USGS / GlobalQuake）'),
     }).description('接收的地区'),
-    source_priority: koishi_1.Schema.union([
-        koishi_1.Schema.const('auto').description('自动选择最佳数据源'),
-        koishi_1.Schema.const('wolfx').description('优先使用 Wolfx API'),
-        koishi_1.Schema.const('fanstudio').description('优先使用 FAN Studio'),
-        koishi_1.Schema.const('p2p').description('优先使用 P2P地震情報'),
-    ]).default('auto').description('数据源优先级'),
-    min_magnitude: koishi_1.Schema.number().default(4.0).description('最小推送震级（M）'),
-    min_intensity: koishi_1.Schema.number().default(4.0).description('最小推送烈度（中国标准）'),
-    min_scale: koishi_1.Schema.number().default(3.0).description('最小推送震度（日本标准，3.0=震度3）'),
+    data_sources: koishi_1.Schema.object({
+        fan_studio: koishi_1.Schema.boolean().default(true).description('FAN Studio（中国预警/台湾/USGS/日本/气象/海啸）'),
+        wolfx: koishi_1.Schema.boolean().default(true).description('Wolfx（中国/台湾/日本 EEW，以及中国/日本地震列表）'),
+        p2p: koishi_1.Schema.boolean().default(true).description('P2P地震情報（日本 EEW / 地震情报 / 海啸）'),
+        global_quake: koishi_1.Schema.boolean().default(false).description('GlobalQuake（全球实时地震，流量较大）'),
+    }).description('数据源开关（可单独禁用某个来源）'),
+    filter: koishi_1.Schema.object({
+        min_magnitude_absolute: koishi_1.Schema.number().default(3.0).description('绝对过滤震级：低于此震级直接丢弃（不推送）'),
+        min_magnitude_for_push: koishi_1.Schema.number().default(4.0).description('推送震级门槛：震级达到此值则推送'),
+        min_intensity_for_push: koishi_1.Schema.number().default(4.0).description('推送烈度门槛（中国）：最大烈度达到此值则推送'),
+        min_scale_for_push: koishi_1.Schema.number().default(4.0).description('推送震度门槛（日本）：最大震度达到此值则推送（4 = 震度4）'),
+    }).description('过滤阈值（地震类事件，海啸/气象不受此限制）'),
 });
 function apply(ctx, config) {
     const service = new service_1.DisasterWarningService(ctx, config);

package/lib/models.d.ts

@@ -104,3 +104,16 @@ export interface DisasterEvent {
     push_count: number;
     raw_data: any;
 }
+/**
+ * 跨数据源事件去重器
+ * 用 place+magnitude+分钟桶 作为指纹，窗口期内同一事件只推一次
+ */
+export declare class EventDeduplicator {
+    private seen;
+    private windowMs;
+    constructor(windowMs?: number);
+    /** 返回 true 表示已见过（应丢弃），false 表示首次（应推送） */
+    isDuplicate(event: DisasterEvent): boolean;
+    private fingerprint;
+    private evict;
+}

package/lib/models.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_SOURCE_MAPPING = exports.DataSource = exports.DisasterType = void 0;
+exports.EventDeduplicator = exports.DATA_SOURCE_MAPPING = exports.DataSource = exports.DisasterType = void 0;
 exports.getDataSourceFromId = getDataSourceFromId;
 var DisasterType;
 (function (DisasterType) {
@@ -53,3 +53,44 @@ exports.DATA_SOURCE_MAPPING = {
 function getDataSourceFromId(id) {
     return exports.DATA_SOURCE_MAPPING[id];
 }
+/**
+ * 跨数据源事件去重器
+ * 用 place+magnitude+分钟桶 作为指纹，窗口期内同一事件只推一次
+ */
+class EventDeduplicator {
+    constructor(windowMs = 5 * 60 * 1000) {
+        // fingerprint -> first-seen timestamp (ms)
+        this.seen = new Map();
+        this.windowMs = windowMs;
+    }
+    /** 返回 true 表示已见过（应丢弃），false 表示首次（应推送） */
+    isDuplicate(event) {
+        this.evict();
+        const fp = this.fingerprint(event);
+        if (this.seen.has(fp))
+            return true;
+        this.seen.set(fp, Date.now());
+        return false;
+    }
+    fingerprint(event) {
+        const data = event.data;
+        if (event.disaster_type === DisasterType.EARTHQUAKE || event.disaster_type === DisasterType.EARTHQUAKE_WARNING) {
+            // 优先用 event_id，相同机构的多数据源共享同一 event_id
+            if (data.event_id)
+                return `eq:${data.event_id}`;
+            // 降级：地点 + 震级 + 分钟桶
+            const bucket = data.shock_time ? data.shock_time.slice(0, 16) : 'unknown';
+            return `eq:${data.place_name}|${data.magnitude?.toFixed(1)}|${bucket}`;
+        }
+        // 海啸/气象用 id 即可
+        return `${event.disaster_type}:${event.id}`;
+    }
+    evict() {
+        const cutoff = Date.now() - this.windowMs;
+        for (const [fp, ts] of this.seen) {
+            if (ts < cutoff)
+                this.seen.delete(fp);
+        }
+    }
+}
+exports.EventDeduplicator = EventDeduplicator;

package/lib/pusher.d.ts

@@ -14,5 +14,10 @@ export declare class MessagePushManager {
     private formatTime;
     private formatScale;
     private formatSource;
+    /**
+     * 直接向每个群号广播。
+     * target_groups 里存的是纯群号（如 "123456789"），
+     * 通过 ctx.bots 遍历所有在线 Bot 发送，这样无需硬编码平台前缀。
+     */
     private broadcast;
 }

package/lib/pusher.js

@@ -4,10 +4,6 @@ exports.MessagePushManager = void 0;
 const koishi_1 = require("koishi");
 const models_1 = require("./models");
 const logger = new koishi_1.Logger('disaster-pusher');
-// Hardcoded filter thresholds - no user configuration needed
-const FILTER_THRESHOLDS = {
-    MIN_MAGNITUDE_ABSOLUTE: 3.0, // Always ignore earthquakes below M3.0
-};
 class MessagePushManager {
     constructor(ctx, config) {
         this.ctx = ctx;
@@ -15,48 +11,40 @@ class MessagePushManager {
     }
     async pushEvent(event) {
         if (this.shouldFilter(event)) {
-            logger.debug(`Event ${event.id} filtered.`);
+            logger.debug(`Event ${event.id} filtered by threshold.`);
             return;
         }
         const message = this.formatMessage(event);
         if (!message)
             return;
-        logger.info(`Pushing event ${event.id} to ${this.config.target_groups.length} groups.`);
+        logger.info(`Pushing event ${event.id} to ${this.config.target_groups.length} group(s).`);
         await this.broadcast(message);
     }
+    // ---- 过滤逻辑 --------------------------------------------------------
     shouldFilter(event) {
-        // Only filter earthquake events
         if (event.disaster_type !== models_1.DisasterType.EARTHQUAKE && event.disaster_type !== models_1.DisasterType.EARTHQUAKE_WARNING) {
-            return false; // Don't filter tsunami/weather
+            return false;
         }
         const data = event.data;
-        const { MIN_MAGNITUDE_ABSOLUTE } = FILTER_THRESHOLDS;
-        const { min_magnitude, min_intensity, min_scale } = this.config;
-        // Always filter out very small earthquakes
-        if (data.magnitude !== undefined && data.magnitude < MIN_MAGNITUDE_ABSOLUTE) {
+        const { min_magnitude_absolute, min_magnitude_for_push, min_intensity_for_push, min_scale_for_push } = this.config.filter;
+        if (data.magnitude !== undefined && data.magnitude < min_magnitude_absolute)
             return true;
-        }
-        // Pass if magnitude is significant
-        if (data.magnitude !== undefined && data.magnitude >= min_magnitude) {
+        if (data.magnitude !== undefined && data.magnitude >= min_magnitude_for_push)
             return false;
-        }
-        // Pass if intensity is significant (Chinese sources)
-        if (data.intensity !== undefined && data.intensity >= min_intensity) {
+        if (data.intensity !== undefined && data.intensity >= min_intensity_for_push)
             return false;
-        }
-        // Pass if scale is significant (Japanese sources)
-        if (data.scale !== undefined && data.scale >= min_scale) {
+        if (data.scale !== undefined && data.scale >= min_scale_for_push)
             return false;
-        }
-        // If magnitude is between 3.0 and min_magnitude, and no significant intensity/scale, filter out
-        if (data.magnitude !== undefined && data.magnitude >= MIN_MAGNITUDE_ABSOLUTE && data.magnitude < min_magnitude) {
-            // Only filter if we don't have intensity/scale data that would make it significant
-            if (data.intensity === undefined && data.scale === undefined) {
-                return true;
-            }
+        // M 在 [min_magnitude_absolute, min_magnitude_for_push) 且无显著烈度/震度 → 过滤
+        if (data.magnitude !== undefined &&
+            data.magnitude >= min_magnitude_absolute &&
+            data.magnitude < min_magnitude_for_push &&
+            data.intensity === undefined && data.scale === undefined) {
+            return true;
         }
         return false;
     }
+    // ---- 格式化 ----------------------------------------------------------
     formatMessage(event) {
         switch (event.disaster_type) {
             case models_1.DisasterType.EARTHQUAKE:
@@ -79,12 +67,10 @@ class MessagePushManager {
         msg += `🕐 时间：${this.formatTime(data.shock_time)}\n`;
         msg += `📊 震级：M${data.magnitude?.toFixed(1) || '未知'}\n`;
         msg += `📏 深度：${data.depth !== undefined ? data.depth + 'km' : '未知'}\n`;
-        if (data.intensity !== undefined) {
+        if (data.intensity !== undefined)
             msg += `🔥 最大烈度：${data.intensity.toFixed(1)}\n`;
-        }
-        if (data.scale !== undefined) {
+        if (data.scale !== undefined)
             msg += `🎚️ 最大震度：${this.formatScale(data.scale)}\n`;
-        }
         msg += `📡 数据源：${this.formatSource(data.source)}`;
         return msg;
     }
@@ -92,7 +78,7 @@ class MessagePushManager {
         let msg = `🌊 【海啸预警】${data.title}\n`;
         msg += `⚠️ 级别：${data.level}\n`;
         msg += `🏛️ 发布单位：${data.org_unit}\n`;
-        if (data.forecasts && data.forecasts.length > 0) {
+        if (data.forecasts?.length) {
             msg += `📍 预报区域：\n`;
             data.forecasts.slice(0, 5).forEach((f) => {
                 msg += `  • ${f.name || f.areaName}: ${f.grade || f.level}\n`;
@@ -109,6 +95,7 @@ class MessagePushManager {
         msg += `📝 详情：${data.description}\n`;
         return msg;
     }
+    // ---- 工具 ------------------------------------------------------------
     formatTime(isoStr) {
         try {
             return new Date(isoStr).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
@@ -118,14 +105,14 @@ class MessagePushManager {
         }
     }
     formatScale(scale) {
-        const scaleMap = {
+        const map = {
             1.0: '1', 2.0: '2', 3.0: '3', 4.0: '4',
             4.5: '5弱', 5.0: '5强', 5.5: '6弱', 6.0: '6强', 7.0: '7'
         };
-        return scaleMap[scale] || scale.toString();
+        return map[scale] ?? scale.toString();
     }
     formatSource(source) {
-        const sourceMap = {
+        const map = {
             'fan_studio_cea': '中国地震预警网',
             'fan_studio_cwa': '台湾中央气象署',
             'fan_studio_cenc': '中国地震台网',
@@ -143,16 +130,34 @@ class MessagePushManager {
             'wolfx_cenc_eq': 'Wolfx-CENC',
             'global_quake': 'GlobalQuake'
         };
-        return sourceMap[source] || source;
+        return map[source] ?? source;
     }
+    // ---- 推送 ------------------------------------------------------------
+    /**
+     * 直接向每个群号广播。
+     * target_groups 里存的是纯群号（如 "123456789"），
+     * 通过 ctx.bots 遍历所有在线 Bot 发送，这样无需硬编码平台前缀。
+     */
     async broadcast(message) {
-        for (const groupId of this.config.target_groups) {
-            const channelId = groupId.includes(':') ? groupId : `onebot:${groupId}`;
-            try {
-                await this.ctx.broadcast([channelId], message);
+        if (!this.config.target_groups.length)
+            return;
+        for (const gid of this.config.target_groups) {
+            const groupId = String(gid).trim();
+            if (!groupId)
+                continue;
+            let sent = false;
+            for (const bot of this.ctx.bots) {
+                try {
+                    await bot.sendMessage(groupId, message);
+                    sent = true;
+                    break; // 同一群由第一个能发送的 bot 处理即可
+                }
+                catch {
+                    // 该 bot 不在此群，继续尝试下一个
+                }
             }
-            catch (e) {
-                logger.error(`Failed to send to ${channelId}:`, e);
+            if (!sent) {
+                logger.warn(`Could not send to group ${groupId}: no available bot.`);
             }
         }
     }

package/lib/service.d.ts

@@ -2,22 +2,31 @@ import { Context } from 'koishi';
 import { Config } from './index';
 export declare class DisasterWarningService {
     private config;
-    private connections;
-    private reconnectTimers;
-    private pusher;
     private ctx;
     private stopped;
+    private pusher;
+    private deduplicator;
     private handlers;
-    private wolfxHandlers;
+    private wolfxHandler;
+    private connections;
+    private wolfxHttpTimer;
     constructor(ctx: Context, config: Config);
     start(): Promise<void>;
     stop(): Promise<void>;
-    private connectBasedOnConfig;
-    private connectWebSocket;
+    private connectAll;
+    private openConnection;
+    private doConnect;
+    private startWolfxHttpPoller;
     private handleEvent;
     private shouldPushEvent;
-    private connectFanStudio;
-    private connectP2P;
-    private connectWolfxSource;
-    private connectGlobalQuake;
+    getStatus(): Record<string, {
+        connected: boolean;
+        retryCount: number;
+        url: string;
+    }>;
+    /** 给 commands 用：拿到 wolfxHandler 最新的 eqlist 缓存 */
+    getEqListCache(): {
+        cenc: Record<string, any>;
+        jma: Record<string, any>;
+    };
 }

package/lib/service.js

@@ -7,12 +7,20 @@ const models_1 = require("./models");
 const handlers_1 = require("./handlers");
 const pusher_1 = require("./pusher");
 const logger = new koishi_1.Logger('disaster-warning');
+// Wolfx HTTP 列表获取间隔（5 分钟）
+const WOLFX_HTTP_INTERVAL_MS = 5 * 60 * 1000;
+// FanStudio 备用服务器
+const FAN_STUDIO_PRIMARY = 'wss://ws.fanstudio.tech/all';
+const FAN_STUDIO_BACKUP = 'wss://ws.fanstudio.hk/all';
+// WebSocket 重连延迟（秒），超过 MAX_RETRY 次后切备用服务器
+const RECONNECT_DELAY_MS = 10000;
+const FALLBACK_RETRY_THRESHOLD = 5;
 class DisasterWarningService {
     constructor(ctx, config) {
+        this.stopped = false;
+        this.deduplicator = new models_1.EventDeduplicator();
         this.connections = {};
-        this.reconnectTimers = {};
-        this.stopped = false; // Flag to prevent reconnection after stop
-        this.wolfxHandlers = {};
+        this.wolfxHttpTimer = null;
         this.ctx = ctx;
         this.config = config;
         this.pusher = new pusher_1.MessagePushManager(ctx, config);
@@ -21,135 +29,163 @@ class DisasterWarningService {
             p2p: new handlers_1.P2PHandler(),
             globalQuake: new handlers_1.GlobalQuakeHandler()
         };
-        // Initialize Wolfx handlers
-        const wolfxKeys = ['jma_eew', 'cenc_eew', 'cwa_eew', 'jma_eqlist', 'cenc_eqlist'];
-        for (const key of wolfxKeys) {
-            this.wolfxHandlers[key] = new handlers_1.WolfxHandler(`wolfx_${key}`);
-        }
+        this.wolfxHandler = new handlers_1.WolfxHandler('wolfx_all');
     }
     async start() {
         if (!this.config.enabled)
             return;
-        this.stopped = false; // Reset stopped flag on start
+        this.stopped = false;
         logger.info('Disaster Warning Service starting...');
-        this.connectBasedOnConfig();
+        this.connectAll();
+        this.startWolfxHttpPoller();
     }
     async stop() {
         logger.info('Disaster Warning Service stopping...');
-        this.stopped = true; // Set stopped flag to prevent reconnection
-        // Clear all reconnect timers first
-        for (const key in this.reconnectTimers) {
-            clearTimeout(this.reconnectTimers[key]);
-            delete this.reconnectTimers[key];
+        this.stopped = true;
+        if (this.wolfxHttpTimer) {
+            clearInterval(this.wolfxHttpTimer);
+            this.wolfxHttpTimer = null;
         }
-        // Close all connections
-        for (const key in this.connections) {
-            const ws = this.connections[key];
-            // Remove all listeners to prevent any further events
-            ws.removeAllListeners();
-            // Force close the connection
-            ws.terminate();
-            delete this.connections[key];
+        for (const name in this.connections) {
+            const entry = this.connections[name];
+            if (entry.reconnectTimer)
+                clearTimeout(entry.reconnectTimer);
+            if (entry.ws) {
+                entry.ws.removeAllListeners('close');
+                entry.ws.close();
+            }
         }
+        this.connections = {};
         logger.info('Disaster Warning Service stopped.');
     }
-    connectBasedOnConfig() {
-        const { regions, data_types, source_priority } = this.config;
-        // Determine which connections to make based on regions and source priority
-        const needsJapan = regions.japan;
-        const needsChina = regions.china;
-        const needsTaiwan = regions.taiwan;
-        const needsGlobal = regions.global;
-        // Connect to appropriate sources based on priority
-        if (source_priority === 'auto' || source_priority === 'wolfx') {
-            // Wolfx is best for real-time EEW
-            if (needsJapan && data_types.earthquake_warning) {
-                this.connectWolfxSource('jma_eew', 'wss://ws-api.wolfx.jp/jma_eew');
-            }
-            if (needsChina && data_types.earthquake_warning) {
-                this.connectWolfxSource('cenc_eew', 'wss://ws-api.wolfx.jp/cenc_eew');
-            }
-            if (needsTaiwan && data_types.earthquake_warning) {
-                this.connectWolfxSource('cwa_eew', 'wss://ws-api.wolfx.jp/cwa_eew');
-            }
-            if (needsJapan && data_types.earthquake_info) {
-                this.connectWolfxSource('jma_eqlist', 'wss://ws-api.wolfx.jp/jma_eqlist');
-            }
-            if (needsChina && data_types.earthquake_info) {
-                this.connectWolfxSource('cenc_eqlist', 'wss://ws-api.wolfx.jp/cenc_eqlist');
+    // ---- 连接调度 --------------------------------------------------------
+    connectAll() {
+        const { regions, data_types, data_sources } = this.config;
+        // FAN Studio — 单连接 /all，覆盖中国/台湾/USGS/日本/气象/海啸
+        if (data_sources.fan_studio) {
+            const needFanStudio = (regions.china && (data_types.earthquake_warning || data_types.earthquake_info || data_types.weather_alarm || data_types.tsunami_warning)) ||
+                (regions.taiwan && (data_types.earthquake_warning || data_types.earthquake_info)) ||
+                (regions.japan && (data_types.earthquake_warning || data_types.earthquake_info)) ||
+                (regions.global && data_types.earthquake_info);
+            if (needFanStudio) {
+                this.openConnection('fan_studio', FAN_STUDIO_PRIMARY, FAN_STUDIO_BACKUP, (data) => {
+                    this.handleEvent(this.handlers.fanStudio.parseMessage(data));
+                });
             }
         }
-        if (source_priority === 'auto' || source_priority === 'p2p') {
-            // P2P is good for Japan data including tsunami
-            if (needsJapan) {
-                if (data_types.earthquake_warning || data_types.earthquake_info || data_types.tsunami_warning) {
-                    this.connectP2P();
-                }
-            }
+        // P2P — 日本 EEW / 地震情报 / 海啸
+        if (data_sources.p2p && regions.japan &&
+            (data_types.earthquake_warning || data_types.earthquake_info || data_types.tsunami_warning)) {
+            this.openConnection('p2p', 'wss://api.p2pquake.net/v2/ws', undefined, (data) => {
+                this.handleEvent(this.handlers.p2p.parseMessage(data));
+            });
         }
-        if (source_priority === 'auto' || source_priority === 'fanstudio') {
-            // FAN Studio has Chinese weather and tsunami
-            const needsFanStudio = (needsChina && data_types.weather_alarm) ||
-                (needsChina && data_types.tsunami_warning) ||
-                (needsGlobal && data_types.earthquake_info); // USGS via FanStudio
-            if (needsFanStudio) {
-                this.connectFanStudio();
-            }
+        // Wolfx — /all_eew 合并端点，接收中国/台湾/日本 EEW
+        // eqlist 改为 HTTP 轮询（见 startWolfxHttpPoller）
+        if (data_sources.wolfx &&
+            (data_types.earthquake_warning) &&
+            (regions.china || regions.taiwan || regions.japan)) {
+            this.openConnection('wolfx_eew', 'wss://ws-api.wolfx.jp/all_eew', undefined, (data) => {
+                this.handleEvent(this.wolfxHandler.parseMessage(data));
+            });
         }
-        // Global Quake for global coverage
-        if (needsGlobal && data_types.earthquake_warning) {
-            this.connectGlobalQuake();
+        // GlobalQuake — 全球实时预警
+        if (data_sources.global_quake && regions.global && data_types.earthquake_warning) {
+            this.openConnection('global_quake', 'wss://gqm.aloys233.top/ws', undefined, (data) => {
+                this.handleEvent(this.handlers.globalQuake.parseMessage(data));
+            });
         }
     }
-    connectWebSocket(name, url, onMessage) {
-        // Don't connect if service is stopped
+    // ---- WebSocket 生命周期 ----------------------------------------------
+    openConnection(name, url, backupUrl, onMessage) {
         if (this.stopped)
             return;
-        if (this.connections[name]) {
-            this.connections[name].removeAllListeners('close');
-            this.connections[name].close();
-        }
-        logger.info(`Connecting to ${name} at ${url}...`);
+        const entry = {
+            url,
+            backupUrl,
+            retryCount: 0,
+            ws: null,
+            reconnectTimer: null
+        };
+        this.connections[name] = entry;
+        this.doConnect(name, onMessage);
+    }
+    doConnect(name, onMessage) {
+        if (this.stopped)
+            return;
+        const entry = this.connections[name];
+        if (!entry)
+            return;
+        // 超过阈值切换到备用服务器
+        const useBackup = entry.backupUrl && entry.retryCount >= FALLBACK_RETRY_THRESHOLD;
+        const url = useBackup ? entry.backupUrl : entry.url;
+        logger.info(`[${name}] Connecting to ${url}${useBackup ? ' (backup)' : ''}...`);
         const ws = new ws_1.WebSocket(url);
+        entry.ws = ws;
         ws.on('open', () => {
-            logger.info(`Connected to ${name}`);
+            logger.info(`[${name}] Connected`);
+            entry.retryCount = 0;
         });
-        ws.on('message', (data) => {
-            if (this.stopped)
-                return;
+        ws.on('message', (raw) => {
             try {
-                const parsed = JSON.parse(data.toString());
-                onMessage(parsed);
+                onMessage(JSON.parse(raw.toString()));
             }
             catch (e) {
-                logger.warn(`Failed to parse message from ${name}:`, e);
+                logger.warn(`[${name}] Parse error:`, e);
             }
         });
         ws.on('close', () => {
-            // Only reconnect if service is not stopped
-            if (!this.stopped) {
-                logger.warn(`Disconnected from ${name}, reconnecting in 10s...`);
-                delete this.connections[name];
-                this.reconnectTimers[name] = setTimeout(() => {
-                    this.connectWebSocket(name, url, onMessage);
-                }, 10000);
-            }
+            if (this.stopped)
+                return;
+            entry.retryCount++;
+            logger.warn(`[${name}] Disconnected (retry #${entry.retryCount}), reconnecting in ${RECONNECT_DELAY_MS / 1000}s...`);
+            entry.reconnectTimer = setTimeout(() => this.doConnect(name, onMessage), RECONNECT_DELAY_MS);
         });
         ws.on('error', (err) => {
-            logger.error(`Error in ${name} connection:`, err);
+            logger.error(`[${name}] Error:`, err);
         });
-        this.connections[name] = ws;
     }
+    // ---- Wolfx HTTP 轮询（地震列表） -------------------------------------
+    startWolfxHttpPoller() {
+        if (!this.config.data_sources.wolfx || !this.config.data_types.earthquake_info)
+            return;
+        const poll = async () => {
+            if (this.stopped)
+                return;
+            try {
+                if (this.config.regions.china) {
+                    const data = await this.ctx.http.get('https://api.wolfx.jp/cenc_eqlist.json');
+                    if (data)
+                        this.handleEvent(this.wolfxHandler.parseEqList(data, 'cenc'));
+                }
+                if (this.config.regions.japan) {
+                    const data = await this.ctx.http.get('https://api.wolfx.jp/jma_eqlist.json');
+                    if (data)
+                        this.handleEvent(this.wolfxHandler.parseEqList(data, 'jma'));
+                }
+            }
+            catch (e) {
+                logger.warn('[wolfx_http] Fetch failed:', e);
+            }
+        };
+        // 立即执行一次，然后每 5 分钟轮询
+        poll();
+        this.wolfxHttpTimer = setInterval(poll, WOLFX_HTTP_INTERVAL_MS);
+    }
+    // ---- 事件处理 --------------------------------------------------------
     async handleEvent(event) {
         if (!event)
             return;
         if (!this.shouldPushEvent(event))
             return;
+        if (this.deduplicator.isDuplicate(event)) {
+            logger.debug(`[dedup] Skipping duplicate event: ${event.id}`);
+            return;
+        }
         await this.pusher.pushEvent(event);
     }
     shouldPushEvent(event) {
         const { data_types, regions } = this.config;
-        // Check disaster type
         const isEarthquakeWarning = event.disaster_type === models_1.DisasterType.EARTHQUAKE_WARNING;
         const isEarthquakeInfo = event.disaster_type === models_1.DisasterType.EARTHQUAKE;
         const isTsunami = event.disaster_type === models_1.DisasterType.TSUNAMI;
@@ -162,59 +198,48 @@ class DisasterWarningService {
             return false;
         if (isWeather && !data_types.weather_alarm)
             return false;
-        // Check region based on data source
-        const source = event.source;
-        const isJapanSource = [
+        const src = event.source;
+        const japanSources = [
             models_1.DataSource.P2P_EEW, models_1.DataSource.P2P_EARTHQUAKE, models_1.DataSource.P2P_TSUNAMI,
             models_1.DataSource.WOLFX_JMA_EEW, models_1.DataSource.WOLFX_JMA_EQ, models_1.DataSource.FAN_STUDIO_JMA
-        ].includes(source);
-        const isChinaSource = [
+        ];
+        const chinaSources = [
             models_1.DataSource.FAN_STUDIO_CEA, models_1.DataSource.FAN_STUDIO_CENC, models_1.DataSource.FAN_STUDIO_WEATHER,
             models_1.DataSource.FAN_STUDIO_TSUNAMI, models_1.DataSource.WOLFX_CENC_EEW, models_1.DataSource.WOLFX_CENC_EQ
-        ].includes(source);
-        const isTaiwanSource = [
-            models_1.DataSource.FAN_STUDIO_CWA, models_1.DataSource.WOLFX_CWA_EEW
-        ].includes(source);
-        const isGlobalSource = [
-            models_1.DataSource.FAN_STUDIO_USGS, models_1.DataSource.GLOBAL_QUAKE
-        ].includes(source);
-        if (isJapanSource && !regions.japan)
+        ];
+        const taiwanSources = [models_1.DataSource.FAN_STUDIO_CWA, models_1.DataSource.WOLFX_CWA_EEW];
+        const globalSources = [models_1.DataSource.FAN_STUDIO_USGS, models_1.DataSource.GLOBAL_QUAKE];
+        if (japanSources.includes(src) && !regions.japan)
             return false;
-        if (isChinaSource && !regions.china)
+        if (chinaSources.includes(src) && !regions.china)
             return false;
-        if (isTaiwanSource && !regions.taiwan)
+        if (taiwanSources.includes(src) && !regions.taiwan)
             return false;
-        if (isGlobalSource && !regions.global)
+        if (globalSources.includes(src) && !regions.global)
             return false;
         return true;
     }
-    connectFanStudio() {
-        const url = "wss://ws.fanstudio.tech/all";
-        this.connectWebSocket('fan_studio', url, (data) => {
-            const event = this.handlers.fanStudio.parseMessage(data);
-            this.handleEvent(event);
-        });
-    }
-    connectP2P() {
-        const url = "wss://api.p2pquake.net/v2/ws";
-        this.connectWebSocket('p2p', url, (data) => {
-            const event = this.handlers.p2p.parseMessage(data);
-            this.handleEvent(event);
-        });
-    }
-    connectWolfxSource(key, url) {
-        const handler = this.wolfxHandlers[key];
-        this.connectWebSocket(`wolfx_${key}`, url, (data) => {
-            const event = handler.parseMessage(data);
-            this.handleEvent(event);
-        });
+    // ---- 状态查询（供 commands 使用）------------------------------------
+    getStatus() {
+        const result = {};
+        for (const [name, entry] of Object.entries(this.connections)) {
+            result[name] = {
+                connected: entry.ws?.readyState === ws_1.WebSocket.OPEN,
+                retryCount: entry.retryCount,
+                url: entry.url
+            };
+        }
+        // Wolfx HTTP poller 状态
+        result['wolfx_http_poller'] = {
+            connected: this.wolfxHttpTimer !== null,
+            retryCount: 0,
+            url: 'https://api.wolfx.jp/{cenc,jma}_eqlist.json'
+        };
+        return result;
     }
-    connectGlobalQuake() {
-        const url = "wss://gqm.aloys233.top/ws";
-        this.connectWebSocket('global_quake', url, (data) => {
-            const event = this.handlers.globalQuake.parseMessage(data);
-            this.handleEvent(event);
-        });
+    /** 给 commands 用：拿到 wolfxHandler 最新的 eqlist 缓存 */
+    getEqListCache() {
+        return this.wolfxHandler.getEqListCache();
     }
 }
 exports.DisasterWarningService = DisasterWarningService;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koishi-plugin-disaster-warning",
-    "version": "0.0.10",
+    "version": "0.1.0",
     "description": "Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）",
     "contributors": [
         "lumia.wang <fenglian19980510@gmail.com>"
@@ -34,14 +34,12 @@
     "peerDependencies": {
         "koishi": "^4.18.0"
     },
-    "dependencies": {
-        "ws": "^8.18.0"
-    },
     "devDependencies": {
         "@types/node": "^20.0.0",
         "@types/ws": "^8.5.10",
         "koishi": "^4.18.0",
-        "typescript": "^5.0.0"
+        "typescript": "^5.0.0",
+        "ws": "^8.18.0"
     },
     "koishi": {
         "description": {