koishi-plugin-disaster-warning 0.0.6 → 0.0.8

package/lib/commands.js

@@ -10,36 +10,6 @@ function applyCommands(ctx, config, service) {
         if (!session)
             return;
         await session.send('正在发送测试消息...');
-        const testEvent = {
-            id: 'test_event_' + Date.now(),
-            data: {
-                id: 'test_id',
-                event_id: 'test_event_id',
-                source: 'Test Source',
-                disaster_type: 'earthquake_warning',
-                shock_time: new Date().toISOString(),
-                latitude: 30.0,
-                longitude: 120.0,
-                depth: 10,
-                magnitude: 5.0,
-                intensity: 4.0,
-                place_name: '测试地点',
-                updates: 1,
-                is_final: false,
-                is_cancel: false,
-                raw_data: {}
-            },
-            source: 'test',
-            disaster_type: 'earthquake_warning',
-            receive_time: new Date().toISOString(),
-            push_count: 0,
-            raw_data: {}
-        };
-        // We can use the service's pusher to format and send, 
-        // but pusher broadcasts to configured groups. 
-        // Here we might want to send to the current session.
-        // Let's manually format it using a simplified version or expose pusher's formatter.
-        // For simplicity, let's just send a text message here.
         const msg = [
             '【测试消息】',
             '这是一个测试用的地震预警消息。',

package/lib/handlers/fanstudio.d.ts

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

package/lib/handlers/fanstudio.js

@@ -13,18 +13,15 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             const msgData = data.Data || data.data || data;
             if (!msgData)
                 return null;
-            // Identify type based on fields
+            // 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);
+            if (msgData.epiIntensity !== undefined || (msgData.magnitude !== undefined && msgData.isFinal !== undefined)) {
+                return this.parseEarthquakeWarning(msgData, source);
             }
-            // Earthquake Info (CENC, USGS, JMA Info) - usually has 'type' or specific fields
-            // But FanStudio might normalize them.
-            // Let's look at CENC/USGS fields from previous analysis if possible, or infer.
-            // CENC usually has "cenc_earthquake" or similar if it was tagged, but here we just have raw data.
-            // If it has 'eventId' and 'magnitude' but no 'epiIntensity', it might be earthquake info.
+            // Earthquake Info (CENC, USGS, JMA Info)
             if (msgData.eventId && msgData.magnitude !== undefined && msgData.epiIntensity === undefined) {
-                return this.parseEarthquakeInfo(msgData);
+                return this.parseEarthquakeInfo(msgData, source);
             }
             // Weather
             if (msgData.headline && msgData.description) {
@@ -41,13 +38,49 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             return null;
         }
     }
-    parseEarthquakeWarning(data) {
-        // Determine source more specifically if possible, otherwise default to CEA
-        // This is a simplification. In reality we might need to check specific fields to distinguish CEA/CWA/JMA
-        let source = models_1.DataSource.FAN_STUDIO_CEA;
-        // If it has 'scale' instead of 'intensity', it might be JMA
-        // If it has 'province' like '台湾', it might be CWA
-        // For now, let's map based on some heuristics or default to CEA
+    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;
+        }
+        // Check for USGS fields
+        if (data.net === 'us' || data.properties?.net === 'us') {
+            return models_1.DataSource.FAN_STUDIO_USGS;
+        }
+        // Default to CEA for Chinese earthquake warnings
+        return models_1.DataSource.FAN_STUDIO_CEA;
+    }
+    parseEarthquakeWarning(data, source) {
         const earthquake = {
             id: data.id || '',
             event_id: data.eventId || data.id || '',
@@ -59,11 +92,12 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             depth: Number(data.depth),
             magnitude: Number(data.magnitude),
             intensity: Number(data.epiIntensity),
+            scale: data.scale !== undefined ? Number(data.scale) : undefined,
             place_name: data.placeName || '',
             province: data.province,
             updates: data.updates || 1,
             is_final: data.isFinal || false,
-            is_cancel: false, // TODO: Check for cancel signal
+            is_cancel: data.isCancel || false,
             raw_data: data
         };
         return {
@@ -76,12 +110,13 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             raw_data: data
         };
     }
-    parseEarthquakeInfo(data) {
-        // CENC or USGS
+    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;
         const earthquake = {
             id: data.id || '',
             event_id: data.eventId || data.id || '',
-            source: models_1.DataSource.FAN_STUDIO_CENC, // Default to CENC
+            source: finalSource,
             disaster_type: models_1.DisasterType.EARTHQUAKE,
             shock_time: this.parseDateTime(data.shockTime) || new Date().toISOString(),
             latitude: Number(data.latitude) || 0,
@@ -97,7 +132,7 @@ class FanStudioHandler extends base_1.BaseDataHandler {
         return {
             id: earthquake.id,
             data: earthquake,
-            source: models_1.DataSource.FAN_STUDIO_CENC,
+            source: finalSource,
             disaster_type: models_1.DisasterType.EARTHQUAKE,
             receive_time: new Date().toISOString(),
             push_count: 0,
@@ -115,7 +150,7 @@ class FanStudioHandler extends base_1.BaseDataHandler {
             effective_time: this.parseDateTime(data.effectiveTime) || new Date().toISOString(),
             disaster_type: models_1.DisasterType.WEATHER_ALARM,
             issue_time: this.parseDateTime(data.issueTime),
-            affected_areas: [], // TODO: Parse affected areas if available
+            affected_areas: data.affectedAreas || [],
             raw_data: data
         };
         return {

package/lib/handlers/p2p.js

@@ -33,8 +33,30 @@ class P2PHandler extends base_1.BaseDataHandler {
         const areas = data.areas || [];
         if (data.cancelled) {
             this.logger.info(`[${this.sourceId}] EEW Cancelled`);
-            // We might want to handle cancellation
-            return null;
+            // Return a cancelled event so it can be broadcasted
+            const earthquake = {
+                id: data.id || '',
+                event_id: issueInfo.eventId || data.id || '',
+                source: models_1.DataSource.P2P_EEW,
+                disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+                shock_time: new Date().toISOString(),
+                latitude: 0,
+                longitude: 0,
+                place_name: '取消',
+                updates: 1,
+                is_final: true,
+                is_cancel: true,
+                raw_data: data
+            };
+            return {
+                id: earthquake.id,
+                data: earthquake,
+                source: models_1.DataSource.P2P_EEW,
+                disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+                receive_time: new Date().toISOString(),
+                push_count: 0,
+                raw_data: data
+            };
         }
         let maxScale = -1;
         if (earthquakeInfo.maxScale !== undefined)
@@ -65,7 +87,7 @@ class P2PHandler extends base_1.BaseDataHandler {
             is_cancel: data.cancelled || false,
             is_training: data.test || false,
             serial: issueInfo.serial,
-            updates: 1, // P2P doesn't explicitly send update count in the same way, but serial might be it
+            updates: 1,
             raw_data: data
         };
         return {
@@ -90,7 +112,7 @@ class P2PHandler extends base_1.BaseDataHandler {
         const scale = maxScale !== -1 ? this.convertP2PScale(maxScale) : undefined;
         let depth = Number(hypocenter.depth);
         if (isNaN(depth))
-            depth = 0; // Or undefined
+            depth = 0;
         const earthquake = {
             id: data.id || '',
             event_id: data.id || '',
@@ -122,9 +144,56 @@ class P2PHandler extends base_1.BaseDataHandler {
         };
     }
     parseTsunami(data) {
-        // TODO: Implement Tsunami parsing if needed
-        // For now return null or basic implementation
-        return null;
+        // P2P Tsunami format (code 552)
+        // Reference: https://www.p2pquake.net/json_api_v2/
+        const issueInfo = data.issue || {};
+        const areas = data.areas || [];
+        // Determine tsunami level from areas
+        let maxGrade = '';
+        const gradeOrder = ['Warning', 'Watch', 'Advisory', 'Unknown'];
+        for (const area of areas) {
+            const grade = area.grade || '';
+            if (!maxGrade || gradeOrder.indexOf(grade) < gradeOrder.indexOf(maxGrade)) {
+                maxGrade = grade;
+            }
+        }
+        // Map grade to Chinese
+        const gradeMap = {
+            'MajorWarning': '大津波警报',
+            'Warning': '津波警报',
+            'Watch': '津波注意报',
+            'Advisory': '津波予报',
+            'Unknown': '未知'
+        };
+        const forecasts = areas.map((a) => ({
+            name: a.name || '',
+            grade: gradeMap[a.grade] || a.grade || '',
+            immediate: a.immediate || false,
+            firstHeight: a.firstHeight,
+            maxHeight: a.maxHeight
+        }));
+        const tsunami = {
+            id: data.id || `tsunami_${Date.now()}`,
+            code: String(data.code),
+            source: models_1.DataSource.P2P_TSUNAMI,
+            title: issueInfo.type === 'Focus' ? '津波情報（各地の満潮時刻・津波到達予想時刻）' : '津波予報',
+            level: gradeMap[maxGrade] || maxGrade || 'Unknown',
+            disaster_type: models_1.DisasterType.TSUNAMI,
+            org_unit: '気象庁',
+            issue_time: this.parseDateTime(issueInfo.time),
+            forecasts: forecasts,
+            monitoring_stations: [],
+            raw_data: data
+        };
+        return {
+            id: tsunami.id,
+            data: tsunami,
+            source: models_1.DataSource.P2P_TSUNAMI,
+            disaster_type: models_1.DisasterType.TSUNAMI,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
     }
     convertP2PScale(scale) {
         const mapping = {

package/lib/handlers/wolfx.d.ts

@@ -5,6 +5,8 @@ export declare class WolfxHandler extends BaseDataHandler {
     parseMessage(data: any): DisasterEvent | null;
     private parseJMAEEW;
     private parseCENCEEW;
+    private parseCWAEEW;
     private parseJMAEqList;
+    private parseCENCEqList;
     private parseJMAScale;
 }

package/lib/handlers/wolfx.js

@@ -16,12 +16,38 @@ class WolfxHandler extends base_1.BaseDataHandler {
             else if (type === 'cenc_eew') {
                 return this.parseCENCEEW(data);
             }
+            else if (type === 'cwa_eew') {
+                return this.parseCWAEEW(data);
+            }
             else if (type === 'jma_eqlist') {
                 return this.parseJMAEqList(data);
             }
             else if (type === 'cenc_eqlist') {
-                // TODO: Implement CENC EqList
-                return null;
+                return this.parseCENCEqList(data);
+            }
+            // If no type field, try to detect from data structure
+            if (data.EventID && data.OriginTime) {
+                // Likely EEW data
+                if (data.Hypocenter && data.Hypocenter.includes('日本')) {
+                    return this.parseJMAEEW(data);
+                }
+                else if (data.HypoCenter) {
+                    return this.parseCENCEEW(data);
+                }
+            }
+            // Check for eqlist structure
+            if (data.No1 || Object.keys(data).some(k => k.startsWith('No'))) {
+                // Detect based on location content
+                const firstKey = Object.keys(data).find(k => k.startsWith('No'));
+                if (firstKey && data[firstKey]) {
+                    const loc = data[firstKey].location || '';
+                    if (loc.includes('中国') || loc.includes('省') || loc.includes('市')) {
+                        return this.parseCENCEqList(data);
+                    }
+                    else {
+                        return this.parseJMAEqList(data);
+                    }
+                }
             }
             return null;
         }
@@ -87,9 +113,36 @@ class WolfxHandler extends base_1.BaseDataHandler {
             raw_data: data
         };
     }
+    parseCWAEEW(data) {
+        const earthquake = {
+            id: data.EventID || data.ID || '',
+            event_id: data.EventID || '',
+            source: models_1.DataSource.WOLFX_CWA_EEW,
+            disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+            shock_time: this.parseDateTime(data.OriginTime) || new Date().toISOString(),
+            latitude: Number(data.Latitude) || 0,
+            longitude: Number(data.Longitude) || 0,
+            depth: Number(data.Depth),
+            magnitude: Number(data.Magnitude),
+            intensity: Number(data.MaxIntensity),
+            place_name: data.HypoCenter || data.Location || '台湾',
+            updates: Number(data.ReportNum) || 1,
+            is_final: data.isFinal || false,
+            is_cancel: false,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.WOLFX_CWA_EEW,
+            disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
     parseJMAEqList(data) {
-        // Find the latest earthquake (usually No1 or similar key, or we iterate)
-        // The original code iterated and found the one with 'No' prefix
+        // Find the latest earthquake (usually No1 or similar key)
         let eqInfo = null;
         for (const key in data) {
             if (key.startsWith('No') && typeof data[key] === 'object') {
@@ -130,6 +183,47 @@ class WolfxHandler extends base_1.BaseDataHandler {
             raw_data: data
         };
     }
+    parseCENCEqList(data) {
+        // Find the latest earthquake
+        let eqInfo = null;
+        for (const key in data) {
+            if (key.startsWith('No') && typeof data[key] === 'object') {
+                eqInfo = data[key];
+                break;
+            }
+        }
+        if (!eqInfo)
+            return null;
+        let depth = Number(eqInfo.depth);
+        if (isNaN(depth) && typeof eqInfo.depth === 'string') {
+            depth = Number(eqInfo.depth.replace(/[^0-9.]/g, ''));
+        }
+        const earthquake = {
+            id: eqInfo.md5 || eqInfo.id || '',
+            event_id: eqInfo.md5 || eqInfo.id || '',
+            source: models_1.DataSource.WOLFX_CENC_EQ,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            shock_time: this.parseDateTime(eqInfo.time) || new Date().toISOString(),
+            latitude: Number(eqInfo.latitude) || 0,
+            longitude: Number(eqInfo.longitude) || 0,
+            depth: depth || 0,
+            magnitude: Number(eqInfo.magnitude),
+            place_name: eqInfo.location || '',
+            updates: 1,
+            is_final: true,
+            is_cancel: false,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.WOLFX_CENC_EQ,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
     parseJMAScale(scaleStr) {
         if (!scaleStr)
             return undefined;

package/lib/index.d.ts

@@ -7,51 +7,19 @@ export declare const inject: {
 export interface Config {
     enabled: boolean;
     target_groups: string[];
-    data_sources: {
-        fan_studio: {
-            enabled: boolean;
-            china_earthquake_warning: boolean;
-            taiwan_cwa_earthquake: boolean;
-            china_cenc_earthquake: boolean;
-            japan_jma_eew: boolean;
-            usgs_earthquake: boolean;
-            china_weather_alarm: boolean;
-            china_tsunami: boolean;
-        };
-        p2p_earthquake: {
-            enabled: boolean;
-            japan_jma_eew: boolean;
-            japan_jma_earthquake: boolean;
-            japan_jma_tsunami: boolean;
-        };
-        wolfx: {
-            enabled: boolean;
-            japan_jma_eew: boolean;
-            china_cenc_eew: boolean;
-            taiwan_cwa_eew: boolean;
-            japan_jma_earthquake: boolean;
-            china_cenc_earthquake: boolean;
-        };
-        global_quake: {
-            enabled: boolean;
-        };
+    data_types: {
+        earthquake_warning: boolean;
+        earthquake_info: boolean;
+        tsunami_warning: boolean;
+        weather_alarm: boolean;
     };
-    earthquake_filters: {
-        intensity_filter: {
-            enabled: boolean;
-            min_magnitude: number;
-            min_intensity: number;
-        };
-        scale_filter: {
-            enabled: boolean;
-            min_magnitude: number;
-            min_scale: number;
-        };
-        magnitude_only_filter: {
-            enabled: boolean;
-            min_magnitude: number;
-        };
+    regions: {
+        china: boolean;
+        taiwan: boolean;
+        japan: boolean;
+        global: boolean;
     };
+    source_priority: 'auto' | 'wolfx' | 'fanstudio' | 'p2p';
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -12,52 +12,25 @@ 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('需要推送消息的群号列表'),
-    data_sources: koishi_1.Schema.object({
-        fan_studio: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(true).description('启用FAN Studio数据源'),
-            china_earthquake_warning: koishi_1.Schema.boolean().default(true).description('中国地震网地震预警'),
-            taiwan_cwa_earthquake: koishi_1.Schema.boolean().default(true).description('台湾中央气象署：强震即时警报'),
-            china_cenc_earthquake: koishi_1.Schema.boolean().default(false).description('中国地震台网（CENC）：地震测定'),
-            japan_jma_eew: koishi_1.Schema.boolean().default(false).description('日本气象厅（JMA）：紧急地震速报'),
-            usgs_earthquake: koishi_1.Schema.boolean().default(false).description('美国地质调查局（USGS）：地震测定'),
-            china_weather_alarm: koishi_1.Schema.boolean().default(false).description('中国气象局：气象预警'),
-            china_tsunami: koishi_1.Schema.boolean().default(false).description('自然资源部海啸预警中心：海啸预警信息'),
-        }).description('FAN Studio WebSocket 数据源'),
-        p2p_earthquake: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(false).description('启用P2P地震情報数据源'),
-            japan_jma_eew: koishi_1.Schema.boolean().default(true).description('日本気象庁：緊急地震速報'),
-            japan_jma_earthquake: koishi_1.Schema.boolean().default(true).description('日本気象庁（JMA）：地震情報'),
-            japan_jma_tsunami: koishi_1.Schema.boolean().default(true).description('日本気象庁：津波予報'),
-        }).description('P2P地震情報 WebSocket 数据源'),
-        wolfx: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(false).description('启用Wolfx数据源'),
-            japan_jma_eew: koishi_1.Schema.boolean().default(true).description('日本気象庁：緊急地震速報'),
-            china_cenc_eew: koishi_1.Schema.boolean().default(true).description('中国地震台网（CENC）：地震预警'),
-            taiwan_cwa_eew: koishi_1.Schema.boolean().default(true).description('台湾中央气象署：地震预警'),
-            japan_jma_earthquake: koishi_1.Schema.boolean().default(true).description('日本気象庁（JMA）：地震情報'),
-            china_cenc_earthquake: koishi_1.Schema.boolean().default(true).description('中国地震台网（CENC）：地震测定'),
-        }).description('Wolfx API 数据源'),
-        global_quake: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(false).description('启用Global Quake数据源'),
-        }).description('Global Quake 服务器推送'),
-    }).description('数据源配置'),
-    earthquake_filters: koishi_1.Schema.object({
-        intensity_filter: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(true).description('启用烈度过滤器'),
-            min_magnitude: koishi_1.Schema.number().default(2.0).description('最小震级'),
-            min_intensity: koishi_1.Schema.number().default(4.0).description('最小烈度'),
-        }).description('基于震级和烈度的地震过滤器'),
-        scale_filter: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(true).description('启用震度过滤器'),
-            min_magnitude: koishi_1.Schema.number().default(2.0).description('最小震级'),
-            min_scale: koishi_1.Schema.number().default(1.0).description('最小震度'),
-        }).description('基于震级和震度的地震过滤器'),
-        magnitude_only_filter: koishi_1.Schema.object({
-            enabled: koishi_1.Schema.boolean().default(true).description('启用仅震级过滤器'),
-            min_magnitude: koishi_1.Schema.number().default(4.5).description('最小震级'),
-        }).description('USGS震级过滤器'),
-    }).description('地震信息过滤器配置'),
+    target_groups: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('推送目标群号列表，格式: 平台:群号（如 onebot:123456）'),
+    data_types: koishi_1.Schema.object({
+        earthquake_warning: koishi_1.Schema.boolean().default(true).description('地震预警（实时速报，震前预警）'),
+        earthquake_info: koishi_1.Schema.boolean().default(true).description('地震信息（震后测定报告）'),
+        tsunami_warning: koishi_1.Schema.boolean().default(true).description('海啸预警'),
+        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('数据源优先级'),
 });
 function apply(ctx, config) {
     const service = new service_1.DisasterWarningService(ctx, config);

package/lib/pusher.d.ts

@@ -13,5 +13,6 @@ export declare class MessagePushManager {
     private formatWeather;
     private formatTime;
     private formatScale;
+    private formatSource;
     private broadcast;
 }

package/lib/pusher.js

@@ -4,6 +4,13 @@ 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
+    MIN_MAGNITUDE_FOR_PUSH: 4.0, // Push if magnitude >= 4.0
+    MIN_INTENSITY_FOR_PUSH: 4.0, // Or push if intensity >= 4.0 (China)
+    MIN_SCALE_FOR_PUSH: 4.0, // Or push if shindo scale >= 4 (Japan)
+};
 class MessagePushManager {
     constructor(ctx, config) {
         this.ctx = ctx;
@@ -21,39 +28,33 @@ class MessagePushManager {
         await this.broadcast(message);
     }
     shouldFilter(event) {
-        if (event.disaster_type === models_1.DisasterType.EARTHQUAKE || event.disaster_type === models_1.DisasterType.EARTHQUAKE_WARNING) {
-            const data = event.data;
-            const filters = this.config.earthquake_filters;
-            // Intensity Filter
-            if (filters.intensity_filter.enabled) {
-                const minMag = filters.intensity_filter.min_magnitude;
-                const minInt = filters.intensity_filter.min_intensity;
-                // Pass if magnitude OR intensity condition is met (OR logic as per schema hint)
-                // Wait, schema hint says "Satisfy magnitude requirement OR satisfy intensity requirement"
-                // Usually it means if (mag >= minMag || int >= minInt) -> Pass
-                let magPass = false;
-                let intPass = false;
-                if (data.magnitude !== undefined && data.magnitude >= minMag)
-                    magPass = true;
-                if (data.intensity !== undefined && data.intensity >= minInt)
-                    intPass = true;
-                // If neither is met (and relevant fields exist), filter out
-                // If fields are missing, we might be lenient or strict. Let's be lenient if one is missing but other passes.
-                if (!magPass && !intPass)
-                    return true;
-            }
-            // Scale Filter (Japan)
-            if (filters.scale_filter.enabled && data.scale !== undefined) {
-                const minMag = filters.scale_filter.min_magnitude;
-                const minScale = filters.scale_filter.min_scale;
-                let magPass = false;
-                let scalePass = false;
-                if (data.magnitude !== undefined && data.magnitude >= minMag)
-                    magPass = true;
-                if (data.scale >= minScale)
-                    scalePass = true;
-                if (!magPass && !scalePass)
-                    return true;
+        // 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
+        }
+        const data = event.data;
+        const { MIN_MAGNITUDE_ABSOLUTE, MIN_MAGNITUDE_FOR_PUSH, MIN_INTENSITY_FOR_PUSH, MIN_SCALE_FOR_PUSH } = FILTER_THRESHOLDS;
+        // Always filter out very small earthquakes
+        if (data.magnitude !== undefined && data.magnitude < MIN_MAGNITUDE_ABSOLUTE) {
+            return true;
+        }
+        // Pass if magnitude is significant
+        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_FOR_PUSH) {
+            return false;
+        }
+        // Pass if scale is significant (Japanese sources)
+        if (data.scale !== undefined && data.scale >= MIN_SCALE_FOR_PUSH) {
+            return false;
+        }
+        // If magnitude is between 3.0-4.0 and no significant intensity/scale, filter out
+        if (data.magnitude !== undefined && data.magnitude >= MIN_MAGNITUDE_ABSOLUTE && data.magnitude < MIN_MAGNITUDE_FOR_PUSH) {
+            // Only filter if we don't have intensity/scale data that would make it significant
+            if (data.intensity === undefined && data.scale === undefined) {
+                return true;
             }
         }
         return false;
@@ -72,42 +73,42 @@ class MessagePushManager {
         }
     }
     formatEarthquake(data) {
-        const type = data.disaster_type === models_1.DisasterType.EARTHQUAKE_WARNING ? '地震预警' : '地震信息';
+        const type = data.disaster_type === models_1.DisasterType.EARTHQUAKE_WARNING ? '🚨 地震预警' : '📋 地震信息';
         const finalStr = data.is_final ? '【最终报】' : `【第${data.updates}报】`;
         const cancelStr = data.is_cancel ? '【已取消】' : '';
         let msg = `${cancelStr}${type} ${finalStr}\n`;
-        msg += `震源：${data.place_name}\n`;
-        msg += `时间：${this.formatTime(data.shock_time)}\n`;
-        msg += `震级：M${data.magnitude?.toFixed(1) || '未知'}\n`;
-        msg += `深度：${data.depth !== undefined ? data.depth + 'km' : '未知'}\n`;
+        msg += `📍 震源：${data.place_name}\n`;
+        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) {
-            msg += `最大烈度：${data.intensity.toFixed(1)}\n`;
+            msg += `🔥 最大烈度：${data.intensity.toFixed(1)}\n`;
         }
         if (data.scale !== undefined) {
-            msg += `最大震度：${this.formatScale(data.scale)}\n`;
+            msg += `🎚️ 最大震度：${this.formatScale(data.scale)}\n`;
         }
-        msg += `数据源：${data.source}`;
+        msg += `📡 数据源：${this.formatSource(data.source)}`;
         return msg;
     }
     formatTsunami(data) {
-        let msg = `【海啸预警】${data.title}\n`;
-        msg += `级别：${data.level}\n`;
-        msg += `发布单位：${data.org_unit}\n`;
+        let msg = `🌊 【海啸预警】${data.title}\n`;
+        msg += `⚠️ 级别：${data.level}\n`;
+        msg += `🏛️ 发布单位：${data.org_unit}\n`;
         if (data.forecasts && data.forecasts.length > 0) {
-            msg += `预报区域：\n`;
+            msg += `📍 预报区域：\n`;
             data.forecasts.slice(0, 5).forEach((f) => {
-                msg += `- ${f.name || f.areaName}: ${f.grade || f.level}\n`;
+                msg += `  • ${f.name || f.areaName}: ${f.grade || f.level}\n`;
             });
             if (data.forecasts.length > 5)
-                msg += `...等${data.forecasts.length}个区域\n`;
+                msg += `  ...等${data.forecasts.length}个区域\n`;
         }
         return msg;
     }
     formatWeather(data) {
-        let msg = `【气象预警】${data.headline}\n`;
-        msg += `类型：${data.type}\n`;
-        msg += `发布时间：${this.formatTime(data.issue_time || data.effective_time)}\n`;
-        msg += `详情：${data.description}\n`;
+        let msg = `⛈️ 【气象预警】${data.headline}\n`;
+        msg += `📋 类型：${data.type}\n`;
+        msg += `🕐 发布时间：${this.formatTime(data.issue_time || data.effective_time)}\n`;
+        msg += `📝 详情：${data.description}\n`;
         return msg;
     }
     formatTime(isoStr) {
@@ -119,29 +120,35 @@ class MessagePushManager {
         }
     }
     formatScale(scale) {
-        // Convert numeric scale back to JMA string (e.g. 5.5 -> 5强)
-        if (scale === 4.5)
-            return '5弱';
-        if (scale === 5.0)
-            return '5强'; // Wait, 5.0 is 5强 in my logic? 
-        // In p2p.ts: 50 -> 5.0. 
-        // Usually 5- is 5 Lower, 5+ is 5 Upper.
-        // Let's stick to simple formatting or check logic.
-        // 5.0 -> 5强, 4.5 -> 5弱.
-        // 5.5 -> 6弱, 6.0 -> 6强.
-        if (scale === 4.5)
-            return '5弱';
-        if (scale === 5.0)
-            return '5强';
-        if (scale === 5.5)
-            return '6弱';
-        if (scale === 6.0)
-            return '6强';
-        return scale.toString();
+        const scaleMap = {
+            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();
+    }
+    formatSource(source) {
+        const sourceMap = {
+            'fan_studio_cea': '中国地震预警网',
+            'fan_studio_cwa': '台湾中央气象署',
+            'fan_studio_cenc': '中国地震台网',
+            'fan_studio_jma': '日本气象厅',
+            'fan_studio_usgs': 'USGS',
+            'fan_studio_weather': '中国气象局',
+            'fan_studio_tsunami': '海啸预警中心',
+            'p2p_eew': 'P2P地震情報',
+            'p2p_earthquake': 'P2P地震情報',
+            'p2p_tsunami': '日本气象厅',
+            'wolfx_jma_eew': 'Wolfx-JMA',
+            'wolfx_cenc_eew': 'Wolfx-CENC',
+            'wolfx_cwa_eew': 'Wolfx-CWA',
+            'wolfx_jma_eq': 'Wolfx-JMA',
+            'wolfx_cenc_eq': 'Wolfx-CENC',
+            'global_quake': 'GlobalQuake'
+        };
+        return sourceMap[source] || source;
     }
     async broadcast(message) {
         for (const groupId of this.config.target_groups) {
-            // Default to onebot if no platform specified
             const channelId = groupId.includes(':') ? groupId : `onebot:${groupId}`;
             try {
                 await this.ctx.broadcast([channelId], message);

package/lib/service.d.ts

@@ -7,15 +7,16 @@ export declare class DisasterWarningService {
     private pusher;
     private ctx;
     private handlers;
+    private wolfxHandlers;
     constructor(ctx: Context, config: Config);
     start(): Promise<void>;
     stop(): Promise<void>;
-    private connectAll;
+    private connectBasedOnConfig;
     private connectWebSocket;
     private handleEvent;
     private shouldPushEvent;
     private connectFanStudio;
     private connectP2P;
-    private connectWolfx;
+    private connectWolfxSource;
     private connectGlobalQuake;
 }

package/lib/service.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DisasterWarningService = void 0;
 const koishi_1 = require("koishi");
 const ws_1 = require("ws");
+const models_1 = require("./models");
 const handlers_1 = require("./handlers");
 const pusher_1 = require("./pusher");
 const logger = new koishi_1.Logger('disaster-warning');
@@ -10,21 +11,26 @@ class DisasterWarningService {
     constructor(ctx, config) {
         this.connections = {};
         this.reconnectTimers = {};
+        this.wolfxHandlers = {};
         this.ctx = ctx;
         this.config = config;
         this.pusher = new pusher_1.MessagePushManager(ctx, config);
         this.handlers = {
             fanStudio: new handlers_1.FanStudioHandler(),
             p2p: new handlers_1.P2PHandler(),
-            wolfx: new handlers_1.WolfxHandler('wolfx'),
             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}`);
+        }
     }
     async start() {
         if (!this.config.enabled)
             return;
         logger.info('Disaster Warning Service starting...');
-        this.connectAll();
+        this.connectBasedOnConfig();
     }
     async stop() {
         logger.info('Disaster Warning Service stopping...');
@@ -35,17 +41,51 @@ class DisasterWarningService {
             clearTimeout(this.reconnectTimers[key]);
         }
     }
-    connectAll() {
-        if (this.config.data_sources.fan_studio.enabled) {
-            this.connectFanStudio();
+    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');
+            }
         }
-        if (this.config.data_sources.p2p_earthquake.enabled) {
-            this.connectP2P();
+        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();
+                }
+            }
         }
-        if (this.config.data_sources.wolfx.enabled) {
-            this.connectWolfx();
+        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();
+            }
         }
-        if (this.config.data_sources.global_quake.enabled) {
+        // Global Quake for global coverage
+        if (needsGlobal && data_types.earthquake_warning) {
             this.connectGlobalQuake();
         }
     }
@@ -87,47 +127,45 @@ class DisasterWarningService {
         await this.pusher.pushEvent(event);
     }
     shouldPushEvent(event) {
-        const ds = this.config.data_sources;
-        switch (event.source) {
-            // Fan Studio
-            case 'fan_studio_cea': // DataSource.FAN_STUDIO_CEA
-                return ds.fan_studio.china_earthquake_warning;
-            case 'fan_studio_cwa': // DataSource.FAN_STUDIO_CWA
-                return ds.fan_studio.taiwan_cwa_earthquake;
-            case 'fan_studio_cenc': // DataSource.FAN_STUDIO_CENC
-                return ds.fan_studio.china_cenc_earthquake;
-            case 'fan_studio_jma': // DataSource.FAN_STUDIO_JMA
-                return ds.fan_studio.japan_jma_eew;
-            case 'fan_studio_usgs': // DataSource.FAN_STUDIO_USGS
-                return ds.fan_studio.usgs_earthquake;
-            case 'fan_studio_weather': // DataSource.FAN_STUDIO_WEATHER
-                return ds.fan_studio.china_weather_alarm;
-            case 'fan_studio_tsunami': // DataSource.FAN_STUDIO_TSUNAMI
-                return ds.fan_studio.china_tsunami;
-            // P2P
-            case 'p2p_eew': // DataSource.P2P_EEW
-                return ds.p2p_earthquake.japan_jma_eew;
-            case 'p2p_earthquake': // DataSource.P2P_EARTHQUAKE
-                return ds.p2p_earthquake.japan_jma_earthquake;
-            case 'p2p_tsunami': // DataSource.P2P_TSUNAMI
-                return ds.p2p_earthquake.japan_jma_tsunami;
-            // Wolfx
-            case 'wolfx_jma_eew': // DataSource.WOLFX_JMA_EEW
-                return ds.wolfx.japan_jma_eew;
-            case 'wolfx_cenc_eew': // DataSource.WOLFX_CENC_EEW
-                return ds.wolfx.china_cenc_eew;
-            case 'wolfx_cwa_eew': // DataSource.WOLFX_CWA_EEW
-                return ds.wolfx.taiwan_cwa_eew;
-            case 'wolfx_jma_eq': // DataSource.WOLFX_JMA_EQ
-                return ds.wolfx.japan_jma_earthquake;
-            case 'wolfx_cenc_eq': // DataSource.WOLFX_CENC_EQ
-                return ds.wolfx.china_cenc_earthquake;
-            // Global Quake
-            case 'global_quake': // DataSource.GLOBAL_QUAKE
-                return ds.global_quake.enabled;
-            default:
-                return true;
-        }
+        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;
+        const isWeather = event.disaster_type === models_1.DisasterType.WEATHER_ALARM;
+        if (isEarthquakeWarning && !data_types.earthquake_warning)
+            return false;
+        if (isEarthquakeInfo && !data_types.earthquake_info)
+            return false;
+        if (isTsunami && !data_types.tsunami_warning)
+            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)
+            return false;
+        if (isChinaSource && !regions.china)
+            return false;
+        if (isTaiwanSource && !regions.taiwan)
+            return false;
+        if (isGlobalSource && !regions.global)
+            return false;
+        return true;
     }
     connectFanStudio() {
         const url = "wss://ws.fanstudio.tech/all";
@@ -143,23 +181,12 @@ class DisasterWarningService {
             this.handleEvent(event);
         });
     }
-    connectWolfx() {
-        const wolfx_sources = {
-            "japan_jma_eew": "wss://ws-api.wolfx.jp/jma_eew",
-            "china_cenc_eew": "wss://ws-api.wolfx.jp/cenc_eew",
-            "taiwan_cwa_eew": "wss://ws-api.wolfx.jp/cwa_eew",
-            "japan_jma_earthquake": "wss://ws-api.wolfx.jp/jma_eqlist",
-            "china_cenc_earthquake": "wss://ws-api.wolfx.jp/cenc_eqlist",
-        };
-        for (const [key, url] of Object.entries(wolfx_sources)) {
-            if (this.config.data_sources.wolfx[key]) {
-                this.connectWebSocket(`wolfx_${key}`, url, (data) => {
-                    const handler = new handlers_1.WolfxHandler(`wolfx_${key}`);
-                    const event = handler.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);
+        });
     }
     connectGlobalQuake() {
         const url = "wss://gqm.aloys233.top/ws";

package/package.json

@@ -1,19 +1,30 @@
 {
     "name": "koishi-plugin-disaster-warning",
+    "version": "0.0.8",
     "description": "Koishi 灾害预警插件，支持多数据源（地震、海啸、气象预警）",
-    "version": "0.0.6",
+    "contributors": [
+        "lumia.wang <fenglian19980510@gmail.com>"
+    ],
     "main": "lib/index.js",
     "typings": "lib/index.d.ts",
     "files": [
         "lib",
         "dist"
     ],
+    "homepage": "https://github.com/lumia1998/koishi-plugin-disaster-warning",
+    "bugs": {
+        "url": "https://github.com/lumia1998/koishi-plugin-disaster-warning/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/lumia1998/koishi-plugin-disaster-warning.git"
+    },
     "license": "AGPL-3.0",
     "scripts": {
-        "build": "tsc",
-        "lint": "eslint src --ext .ts"
+        "build": "tsc"
     },
     "keywords": [
+        "chatbot",
         "koishi",
         "plugin",
         "disaster",
@@ -23,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": {