koishi-plugin-disaster-warning 0.0.10 → 0.1.1

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/fanstudio.d.ts

@@ -3,7 +3,9 @@ import { DisasterEvent } from '../models';
 export declare class FanStudioHandler extends BaseDataHandler {
     constructor();
     parseMessage(data: any): DisasterEvent | null;
-    private detectSource;
+    private parseUpdate;
+    private parseInitialAll;
+    private dispatchBySource;
     private parseEarthquakeWarning;
     private parseEarthquakeInfo;
     private parseWeather;

package/lib/handlers/fanstudio.js

@@ -3,33 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FanStudioHandler = void 0;
 const base_1 = require("./base");
 const models_1 = require("../models");
+/**
+ * FanStudio WebSocket /all 端点消息解析器
+ *
+ * 协议格式：
+ *   { type: "update",       source: "<src>", Data: { ... } }
+ *   { type: "initial_all",  "<src>": { ... }, ... }
+ *
+ * source 取值：cea | cenc | jma | cwa | cwa-eew | usgs | weatheralarm | tsunami | cea-pr
+ */
+const FS_SOURCE_MAP = {
+    'cea': models_1.DataSource.FAN_STUDIO_CEA,
+    'cea-pr': models_1.DataSource.FAN_STUDIO_CEA,
+    'cenc': models_1.DataSource.FAN_STUDIO_CENC,
+    'jma': models_1.DataSource.FAN_STUDIO_JMA,
+    'cwa': models_1.DataSource.FAN_STUDIO_CWA,
+    'cwa-eew': models_1.DataSource.FAN_STUDIO_CWA,
+    'usgs': models_1.DataSource.FAN_STUDIO_USGS,
+    'weatheralarm': models_1.DataSource.FAN_STUDIO_WEATHER,
+    'tsunami': models_1.DataSource.FAN_STUDIO_TSUNAMI,
+};
 class FanStudioHandler extends base_1.BaseDataHandler {
     constructor() {
         super('fan_studio');
     }
     parseMessage(data) {
         try {
-            // FanStudio data usually comes in a 'Data' or 'data' field, or just the object itself
-            const msgData = data.Data || data.data || data;
-            if (!msgData)
-                return null;
-            // Detect data source based on message content
-            const source = this.detectSource(msgData);
-            // Earthquake Warning (CEA, CWA, JMA EEW)
-            if (msgData.epiIntensity !== undefined || (msgData.magnitude !== undefined && msgData.isFinal !== undefined)) {
-                return this.parseEarthquakeWarning(msgData, source);
-            }
-            // Earthquake Info (CENC, USGS, JMA Info)
-            if (msgData.eventId && msgData.magnitude !== undefined && msgData.epiIntensity === undefined) {
-                return this.parseEarthquakeInfo(msgData, source);
-            }
-            // Weather
-            if (msgData.headline && msgData.description) {
-                return this.parseWeather(msgData);
+            if (data.type === 'update') {
+                return this.parseUpdate(data);
             }
-            // Tsunami
-            if (msgData.warningInfo || (msgData.title && msgData.level && msgData.forecasts)) {
-                return this.parseTsunami(msgData);
+            else if (data.type === 'initial_all') {
+                return this.parseInitialAll(data);
             }
             return null;
         }
@@ -38,51 +42,63 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             return null;
         }
     }
-    detectSource(data) {
-        // Check for explicit type field
-        if (data.type) {
-            const typeMap = {
-                'cenc_eew': models_1.DataSource.FAN_STUDIO_CEA,
-                'cwa_eew': models_1.DataSource.FAN_STUDIO_CWA,
-                'jma_eew': models_1.DataSource.FAN_STUDIO_JMA,
-                'cenc_eq': models_1.DataSource.FAN_STUDIO_CENC,
-                'usgs_eq': models_1.DataSource.FAN_STUDIO_USGS,
-                'weather': models_1.DataSource.FAN_STUDIO_WEATHER,
-                'tsunami': models_1.DataSource.FAN_STUDIO_TSUNAMI,
-            };
-            if (typeMap[data.type])
-                return typeMap[data.type];
-        }
-        // Check for source field
-        if (data.source) {
-            const sourceStr = String(data.source).toLowerCase();
-            if (sourceStr.includes('cenc'))
-                return models_1.DataSource.FAN_STUDIO_CENC;
-            if (sourceStr.includes('cwa') || sourceStr.includes('taiwan'))
-                return models_1.DataSource.FAN_STUDIO_CWA;
-            if (sourceStr.includes('jma') || sourceStr.includes('japan'))
-                return models_1.DataSource.FAN_STUDIO_JMA;
-            if (sourceStr.includes('usgs'))
-                return models_1.DataSource.FAN_STUDIO_USGS;
-        }
-        // Check province for Taiwan
-        if (data.province && String(data.province).includes('台湾')) {
-            return models_1.DataSource.FAN_STUDIO_CWA;
-        }
-        // Check for Japan-specific fields (scale instead of intensity)
-        if (data.scale !== undefined && data.epiIntensity === undefined) {
-            return models_1.DataSource.FAN_STUDIO_JMA;
+    parseUpdate(msg) {
+        const src = String(msg.source || '').toLowerCase();
+        const source = FS_SOURCE_MAP[src];
+        if (!source)
+            return null;
+        const payload = msg.Data || msg.data;
+        if (!payload)
+            return null;
+        return this.dispatchBySource(source, src, payload);
+    }
+    parseInitialAll(msg) {
+        // initial_all 包含多个数据源快照，取第一个有效的推送
+        for (const [key, payload] of Object.entries(msg)) {
+            if (key === 'type')
+                continue;
+            const src = key.toLowerCase();
+            const source = FS_SOURCE_MAP[src];
+            if (!source || !payload)
+                continue;
+            const event = this.dispatchBySource(source, src, payload);
+            if (event)
+                return event;
         }
-        // Check for USGS fields
-        if (data.net === 'us' || data.properties?.net === 'us') {
-            return models_1.DataSource.FAN_STUDIO_USGS;
+        return null;
+    }
+    dispatchBySource(source, src, data) {
+        switch (source) {
+            case models_1.DataSource.FAN_STUDIO_CEA:
+                return this.parseEarthquakeWarning(data, source);
+            case models_1.DataSource.FAN_STUDIO_CWA:
+                // cwa-eew 是预警，cwa 是地震报告
+                if (src === 'cwa-eew')
+                    return this.parseEarthquakeWarning(data, source);
+                return this.parseEarthquakeInfo(data, source);
+            case models_1.DataSource.FAN_STUDIO_JMA:
+                // jma 消息既有 EEW 也有地震信息，通过 isFinal/epiIntensity 判断
+                if (data.epiIntensity !== undefined || data.isFinal !== undefined) {
+                    return this.parseEarthquakeWarning(data, source);
+                }
+                return this.parseEarthquakeInfo(data, source);
+            case models_1.DataSource.FAN_STUDIO_CENC:
+                return this.parseEarthquakeInfo(data, source);
+            case models_1.DataSource.FAN_STUDIO_USGS:
+                return this.parseEarthquakeInfo(data, source);
+            case models_1.DataSource.FAN_STUDIO_WEATHER:
+                return this.parseWeather(data);
+            case models_1.DataSource.FAN_STUDIO_TSUNAMI:
+                return this.parseTsunami(data);
+            default:
+                return null;
         }
-        // Default to CEA for Chinese earthquake warnings
-        return models_1.DataSource.FAN_STUDIO_CEA;
     }
     parseEarthquakeWarning(data, source) {
+        if (!data.id && !data.eventId)
+            return null;
         const earthquake = {
-            id: data.id || '',
+            id: data.id || data.eventId || '',
             event_id: data.eventId || data.id || '',
             source: source,
             disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
@@ -91,7 +107,7 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             longitude: Number(data.longitude) || 0,
             depth: Number(data.depth),
             magnitude: Number(data.magnitude),
-            intensity: Number(data.epiIntensity),
+            intensity: data.epiIntensity !== undefined ? Number(data.epiIntensity) : undefined,
             scale: data.scale !== undefined ? Number(data.scale) : undefined,
             place_name: data.placeName || '',
             province: data.province,
@@ -111,18 +127,20 @@ class FanStudioHandler extends base_1.BaseDataHandler {
         };
     }
     parseEarthquakeInfo(data, source) {
-        // Determine if USGS or CENC based on source detection
-        const finalSource = source === models_1.DataSource.FAN_STUDIO_CEA ? models_1.DataSource.FAN_STUDIO_CENC : source;
+        if (!data.id && !data.eventId)
+            return null;
         const earthquake = {
-            id: data.id || '',
+            id: data.id || data.eventId || '',
             event_id: data.eventId || data.id || '',
-            source: finalSource,
+            source: source,
             disaster_type: models_1.DisasterType.EARTHQUAKE,
             shock_time: this.parseDateTime(data.shockTime) || new Date().toISOString(),
             latitude: Number(data.latitude) || 0,
             longitude: Number(data.longitude) || 0,
             depth: Number(data.depth),
             magnitude: Number(data.magnitude),
+            intensity: data.epiIntensity !== undefined ? Number(data.epiIntensity) : undefined,
+            scale: data.scale !== undefined ? Number(data.scale) : undefined,
             place_name: data.placeName || '',
             updates: 1,
             is_final: true,
@@ -132,7 +150,7 @@ class FanStudioHandler extends base_1.BaseDataHandler {
         return {
             id: earthquake.id,
             data: earthquake,
-            source: finalSource,
+            source: source,
             disaster_type: models_1.DisasterType.EARTHQUAKE,
             receive_time: new Date().toISOString(),
             push_count: 0,
@@ -140,12 +158,14 @@ class FanStudioHandler extends base_1.BaseDataHandler {
         };
     }
     parseWeather(data) {
+        if (!data.headline && !data.title)
+            return null;
         const weather = {
             id: data.id || `weather_${Date.now()}`,
             source: models_1.DataSource.FAN_STUDIO_WEATHER,
-            headline: data.headline,
-            title: data.title || data.headline,
-            description: data.description,
+            headline: data.headline || data.title || '',
+            title: data.title || data.headline || '',
+            description: data.description || '',
             type: data.type || 'unknown',
             effective_time: this.parseDateTime(data.effectiveTime) || new Date().toISOString(),
             disaster_type: models_1.DisasterType.WEATHER_ALARM,
@@ -164,6 +184,8 @@ class FanStudioHandler extends base_1.BaseDataHandler {
         };
     }
     parseTsunami(data) {
+        if (!data.title && !data.warningInfo)
+            return null;
         const tsunami = {
             id: data.id || `tsunami_${Date.now()}`,
             code: data.code || '',

package/lib/handlers/global_quake.d.ts

@@ -1,5 +1,13 @@
 import { BaseDataHandler } from './base';
 import { DisasterEvent } from '../models';
+/**
+ * GlobalQuake WebSocket 消息解析器
+ *
+ * JSON 格式字段（来自 astrbot 参考实现）：
+ *   id, latitude, longitude, depth, magnitude, region,
+ *   originTimeIso / origin_time_iso / origin_time_ms,
+ *   revisionId / revision_id
+ */
 export declare class GlobalQuakeHandler extends BaseDataHandler {
     constructor();
     parseMessage(data: any): DisasterEvent | null;

package/lib/handlers/global_quake.js

@@ -3,35 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalQuakeHandler = void 0;
 const base_1 = require("./base");
 const models_1 = require("../models");
+/**
+ * GlobalQuake WebSocket 消息解析器
+ *
+ * JSON 格式字段（来自 astrbot 参考实现）：
+ *   id, latitude, longitude, depth, magnitude, region,
+ *   originTimeIso / origin_time_iso / origin_time_ms,
+ *   revisionId / revision_id
+ */
 class GlobalQuakeHandler extends base_1.BaseDataHandler {
     constructor() {
         super('global_quake');
     }
     parseMessage(data) {
         try {
-            // Assuming GlobalQuake format based on typical JSON structure or inferring from usage
-            // Since I didn't see explicit GlobalQuake handler code in the file list (maybe I missed it or it's simple)
-            // I'll assume a generic structure or try to find it.
-            // Wait, `global_sources.py` might contain it.
-            // For now, let's implement a placeholder or basic structure.
-            // If data has 'magnitude' and 'latitude', it's likely an earthquake.
-            if (!data.uuid || !data.magnitude)
+            const id = data.id;
+            if (!id || data.magnitude == null)
                 return null;
+            const lat = Number(data.latitude);
+            const lon = Number(data.longitude);
+            if (isNaN(lat) || isNaN(lon))
+                return null;
+            const originTime = data.originTimeIso ||
+                data.origin_time_iso ||
+                (data.origin_time_ms ? new Date(data.origin_time_ms).toISOString() : null);
             const earthquake = {
-                id: data.uuid,
-                event_id: data.uuid,
+                id: String(id),
+                event_id: String(id),
                 source: models_1.DataSource.GLOBAL_QUAKE,
-                disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING, // GQ is usually real-time
-                shock_time: this.parseDateTime(data.origin) || new Date().toISOString(),
-                latitude: Number(data.lat),
-                longitude: Number(data.lon),
-                depth: Number(data.depth),
+                disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+                shock_time: (originTime && this.parseDateTime(originTime)) || new Date().toISOString(),
+                latitude: lat,
+                longitude: lon,
+                depth: data.depth != null ? Number(data.depth) : undefined,
                 magnitude: Number(data.magnitude),
-                place_name: data.region || 'Unknown',
-                updates: data.revision || 1,
-                is_final: false, // GQ updates frequently
+                place_name: data.region || 'Global',
+                updates: data.revisionId ?? data.revision_id ?? 1,
+                is_final: false,
                 is_cancel: false,
-                max_pga: data.maxPGA,
                 raw_data: data
             };
             return {

package/lib/handlers/p2p.js

@@ -196,9 +196,10 @@ class P2PHandler extends base_1.BaseDataHandler {
         };
     }
     convertP2PScale(scale) {
+        // 46 = "5弱以上（暫定）"，显示同 5弱（4.5）
         const mapping = {
             10: 1.0, 20: 2.0, 30: 3.0, 40: 4.0,
-            45: 4.5, 46: 4.6, 50: 5.0, 55: 5.5,
+            45: 4.5, 46: 4.5, 50: 5.0, 55: 5.5,
             60: 6.0, 70: 7.0
         };
         return mapping[scale];

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 {
@@ -227,6 +251,7 @@ class WolfxHandler extends base_1.BaseDataHandler {
     parseJMAScale(scaleStr) {
         if (!scaleStr)
             return undefined;
+        // JMA 震度映射：5弱→4.5, 5強→5.0, 6弱→5.5, 6強→6.0
         const match = scaleStr.match(/(\d+)(弱|強)?/);
         if (match) {
             const base = parseInt(match[1]);
@@ -234,7 +259,7 @@ class WolfxHandler extends base_1.BaseDataHandler {
             if (suffix === '弱')
                 return base - 0.5;
             if (suffix === '強')
-                return base + 0.5;
+                return base; // 5強=5.0, 6強=6.0
             return base;
         }
         return undefined;

package/lib/index.d.ts

@@ -5,7 +5,6 @@ export declare const inject: {
     optional: string[];
 };
 export interface Config {
-    enabled: boolean;
     target_groups: string[];
     data_types: {
         earthquake_warning: boolean;
@@ -19,10 +18,12 @@ export interface Config {
         japan: boolean;
         global: boolean;
     };
-    source_priority: 'auto' | 'wolfx' | 'fanstudio' | 'p2p';
-    min_magnitude: number;
-    min_intensity: number;
-    min_scale: number;
+    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

@@ -11,8 +11,9 @@ exports.inject = {
     optional: ['database']
 };
 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('地震信息（震后测定报告）'),
@@ -20,20 +21,17 @@ exports.Config = koishi_1.Schema.object({
         weather_alarm: koishi_1.Schema.boolean().default(false).description('气象预警（中国）'),
     }).description('接收的灾害类型'),
     regions: 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）'),
-    }).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）'),
+        china: koishi_1.Schema.boolean().default(true).description('中国大陆（CEA预警 / CENC地震台网 / 气象 / 海啸）'),
+        taiwan: koishi_1.Schema.boolean().default(true).description('台湾（CWA预警与地震报告）'),
+        japan: koishi_1.Schema.boolean().default(true).description('日本（JMA EEW / P2P地震情报 / 海啸）'),
+        global: koishi_1.Schema.boolean().default(false).description('全球（USGS 地震信息 / 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 = 8 * 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 重连延迟，超过阈值次数后切换到备用服务器
+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,160 @@ 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 } = this.config;
+        // FanStudio /all：覆盖中国(CEA/CENC/气象/海啸)、台湾(CWA)、日本(JMA)、全球(USGS)
+        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 (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（仅预警类型）
+        if (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 (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() {
+        const { regions, data_types } = this.config;
+        if (!data_types.earthquake_info)
+            return;
+        if (!regions.china && !regions.japan)
+            return;
+        const poll = async () => {
+            if (this.stopped)
+                return;
+            try {
+                if (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 (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);
+            }
+        };
+        // 延迟首次拉取，避免重启时将旧地震当新事件推送
+        // 去重窗口（8分钟）> 轮询间隔（5分钟），不会漏报
+        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 +195,43 @@ class DisasterWarningService {
             return false;
         if (isWeather && !data_types.weather_alarm)
             return false;
-        // Check region based on data source
-        const source = event.source;
-        const isJapanSource = [
-            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 = [
-            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 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];
+        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];
+        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
+            };
+        }
+        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.1",
     "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": {
@@ -57,4 +55,4 @@
             ]
         }
     }
-}
+}