koishi-plugin-disaster-warning 0.0.1

package/lib/handlers/base.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from 'koishi';
+import { DisasterEvent } from '../models';
+export declare abstract class BaseDataHandler {
+    protected sourceId: string;
+    protected logger: Logger;
+    constructor(sourceId: string);
+    abstract parseMessage(message: any): DisasterEvent | null;
+    protected parseDateTime(timeStr: string): string | undefined;
+}

package/lib/handlers/base.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDataHandler = void 0;
+const koishi_1 = require("koishi");
+const logger = new koishi_1.Logger('disaster-warning');
+class BaseDataHandler {
+    constructor(sourceId) {
+        this.sourceId = sourceId;
+        this.logger = logger;
+    }
+    parseDateTime(timeStr) {
+        if (!timeStr)
+            return undefined;
+        try {
+            // Try to parse as ISO string or other formats
+            // JS Date constructor is quite flexible
+            const date = new Date(timeStr);
+            if (isNaN(date.getTime())) {
+                this.logger.warn(`[${this.sourceId}] Failed to parse time: ${timeStr}`);
+                return undefined;
+            }
+            return date.toISOString();
+        }
+        catch (e) {
+            this.logger.warn(`[${this.sourceId}] Failed to parse time: ${timeStr}`);
+            return undefined;
+        }
+    }
+}
+exports.BaseDataHandler = BaseDataHandler;

package/lib/handlers/fanstudio.d.ts

@@ -0,0 +1,10 @@
+import { BaseDataHandler } from './base';
+import { DisasterEvent } from '../models';
+export declare class FanStudioHandler extends BaseDataHandler {
+    constructor();
+    parseMessage(data: any): DisasterEvent | null;
+    private parseEarthquakeWarning;
+    private parseEarthquakeInfo;
+    private parseWeather;
+    private parseTsunami;
+}

package/lib/handlers/fanstudio.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FanStudioHandler = void 0;
+const base_1 = require("./base");
+const models_1 = require("../models");
+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;
+            // Identify type based on fields
+            // Earthquake Warning (CEA, CWA, JMA EEW)
+            if (msgData.epiIntensity !== undefined || msgData.magnitude !== undefined && msgData.isFinal !== undefined) {
+                return this.parseEarthquakeWarning(msgData);
+            }
+            // 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.
+            if (msgData.eventId && msgData.magnitude !== undefined && msgData.epiIntensity === undefined) {
+                return this.parseEarthquakeInfo(msgData);
+            }
+            // Weather
+            if (msgData.headline && msgData.description) {
+                return this.parseWeather(msgData);
+            }
+            // Tsunami
+            if (msgData.warningInfo || (msgData.title && msgData.level && msgData.forecasts)) {
+                return this.parseTsunami(msgData);
+            }
+            return null;
+        }
+        catch (e) {
+            this.logger.error(`[${this.sourceId}] Error parsing message:`, e);
+            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
+        const earthquake = {
+            id: data.id || '',
+            event_id: data.eventId || data.id || '',
+            source: source,
+            disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+            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: Number(data.epiIntensity),
+            place_name: data.placeName || '',
+            province: data.province,
+            updates: data.updates || 1,
+            is_final: data.isFinal || false,
+            is_cancel: false, // TODO: Check for cancel signal
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: source,
+            disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseEarthquakeInfo(data) {
+        // CENC or USGS
+        const earthquake = {
+            id: data.id || '',
+            event_id: data.eventId || data.id || '',
+            source: models_1.DataSource.FAN_STUDIO_CENC, // Default to CENC
+            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),
+            place_name: data.placeName || '',
+            updates: 1,
+            is_final: true,
+            is_cancel: false,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.FAN_STUDIO_CENC,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseWeather(data) {
+        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,
+            type: data.type || 'unknown',
+            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
+            raw_data: data
+        };
+        return {
+            id: weather.id,
+            data: weather,
+            source: models_1.DataSource.FAN_STUDIO_WEATHER,
+            disaster_type: models_1.DisasterType.WEATHER_ALARM,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseTsunami(data) {
+        const tsunami = {
+            id: data.id || `tsunami_${Date.now()}`,
+            code: data.code || '',
+            source: models_1.DataSource.FAN_STUDIO_TSUNAMI,
+            title: data.title || '',
+            level: data.level || '',
+            disaster_type: models_1.DisasterType.TSUNAMI,
+            org_unit: data.orgUnit || '',
+            forecasts: data.forecasts || [],
+            monitoring_stations: [],
+            raw_data: data
+        };
+        return {
+            id: tsunami.id,
+            data: tsunami,
+            source: models_1.DataSource.FAN_STUDIO_TSUNAMI,
+            disaster_type: models_1.DisasterType.TSUNAMI,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+}
+exports.FanStudioHandler = FanStudioHandler;

package/lib/handlers/global_quake.d.ts

@@ -0,0 +1,6 @@
+import { BaseDataHandler } from './base';
+import { DisasterEvent } from '../models';
+export declare class GlobalQuakeHandler extends BaseDataHandler {
+    constructor();
+    parseMessage(data: any): DisasterEvent | null;
+}

package/lib/handlers/global_quake.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalQuakeHandler = void 0;
+const base_1 = require("./base");
+const models_1 = require("../models");
+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)
+                return null;
+            const earthquake = {
+                id: data.uuid,
+                event_id: data.uuid,
+                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),
+                magnitude: Number(data.magnitude),
+                place_name: data.region || 'Unknown',
+                updates: data.revision || 1,
+                is_final: false, // GQ updates frequently
+                is_cancel: false,
+                max_pga: data.maxPGA,
+                raw_data: data
+            };
+            return {
+                id: earthquake.id,
+                data: earthquake,
+                source: models_1.DataSource.GLOBAL_QUAKE,
+                disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+                receive_time: new Date().toISOString(),
+                push_count: 0,
+                raw_data: data
+            };
+        }
+        catch (e) {
+            this.logger.error(`[${this.sourceId}] Error parsing message:`, e);
+            return null;
+        }
+    }
+}
+exports.GlobalQuakeHandler = GlobalQuakeHandler;

package/lib/handlers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './fanstudio';
+export * from './p2p';
+export * from './wolfx';
+export * from './global_quake';

package/lib/handlers/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./fanstudio"), exports);
+__exportStar(require("./p2p"), exports);
+__exportStar(require("./wolfx"), exports);
+__exportStar(require("./global_quake"), exports);

package/lib/handlers/p2p.d.ts

@@ -0,0 +1,10 @@
+import { BaseDataHandler } from './base';
+import { DisasterEvent } from '../models';
+export declare class P2PHandler extends BaseDataHandler {
+    constructor();
+    parseMessage(data: any): DisasterEvent | null;
+    private parseEEW;
+    private parseEarthquake;
+    private parseTsunami;
+    private convertP2PScale;
+}

package/lib/handlers/p2p.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2PHandler = void 0;
+const base_1 = require("./base");
+const models_1 = require("../models");
+class P2PHandler extends base_1.BaseDataHandler {
+    constructor() {
+        super('p2p_earthquake');
+    }
+    parseMessage(data) {
+        try {
+            const code = data.code;
+            if (code === 556) {
+                return this.parseEEW(data);
+            }
+            else if (code === 551) {
+                return this.parseEarthquake(data);
+            }
+            else if (code === 552) {
+                return this.parseTsunami(data);
+            }
+            return null;
+        }
+        catch (e) {
+            this.logger.error(`[${this.sourceId}] Error parsing message:`, e);
+            return null;
+        }
+    }
+    parseEEW(data) {
+        const earthquakeInfo = data.earthquake || {};
+        const hypocenter = earthquakeInfo.hypocenter || {};
+        const issueInfo = data.issue || {};
+        const areas = data.areas || [];
+        if (data.cancelled) {
+            this.logger.info(`[${this.sourceId}] EEW Cancelled`);
+            // We might want to handle cancellation
+            return null;
+        }
+        let maxScale = -1;
+        if (earthquakeInfo.maxScale !== undefined)
+            maxScale = earthquakeInfo.maxScale;
+        else if (earthquakeInfo.max_scale !== undefined)
+            maxScale = earthquakeInfo.max_scale;
+        else {
+            // Calculate from areas
+            const scales = areas.map((a) => Math.max(a.scaleFrom || 0, a.scaleTo || 0));
+            if (scales.length > 0)
+                maxScale = Math.max(...scales);
+        }
+        const scale = maxScale !== -1 ? this.convertP2PScale(maxScale) : undefined;
+        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: this.parseDateTime(earthquakeInfo.time || earthquakeInfo.originTime) || new Date().toISOString(),
+            latitude: Number(hypocenter.latitude) || 0,
+            longitude: Number(hypocenter.longitude) || 0,
+            depth: Number(hypocenter.depth),
+            magnitude: Number(hypocenter.magnitude),
+            place_name: hypocenter.name || 'Unknown',
+            scale: scale,
+            max_scale: maxScale,
+            is_final: data.is_final || false,
+            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
+            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
+        };
+    }
+    parseEarthquake(data) {
+        const earthquakeInfo = data.earthquake || {};
+        const hypocenter = earthquakeInfo.hypocenter || {};
+        const magnitude = Number(hypocenter.magnitude);
+        const lat = Number(hypocenter.latitude);
+        const lon = Number(hypocenter.longitude);
+        if (isNaN(magnitude) || isNaN(lat) || isNaN(lon))
+            return null;
+        const maxScale = earthquakeInfo.maxScale !== undefined ? earthquakeInfo.maxScale : -1;
+        const scale = maxScale !== -1 ? this.convertP2PScale(maxScale) : undefined;
+        let depth = Number(hypocenter.depth);
+        if (isNaN(depth))
+            depth = 0; // Or undefined
+        const earthquake = {
+            id: data.id || '',
+            event_id: data.id || '',
+            source: models_1.DataSource.P2P_EARTHQUAKE,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            shock_time: this.parseDateTime(earthquakeInfo.time) || new Date().toISOString(),
+            latitude: lat,
+            longitude: lon,
+            depth: depth,
+            magnitude: magnitude,
+            place_name: hypocenter.name || 'Unknown',
+            scale: scale,
+            max_scale: maxScale,
+            domestic_tsunami: earthquakeInfo.domesticTsunami,
+            foreign_tsunami: earthquakeInfo.foreignTsunami,
+            updates: 1,
+            is_final: true,
+            is_cancel: false,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.P2P_EARTHQUAKE,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseTsunami(data) {
+        // TODO: Implement Tsunami parsing if needed
+        // For now return null or basic implementation
+        return null;
+    }
+    convertP2PScale(scale) {
+        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,
+            60: 6.0, 70: 7.0
+        };
+        return mapping[scale];
+    }
+}
+exports.P2PHandler = P2PHandler;

package/lib/handlers/wolfx.d.ts

@@ -0,0 +1,10 @@
+import { BaseDataHandler } from './base';
+import { DisasterEvent } from '../models';
+export declare class WolfxHandler extends BaseDataHandler {
+    constructor(sourceId: string);
+    parseMessage(data: any): DisasterEvent | null;
+    private parseJMAEEW;
+    private parseCENCEEW;
+    private parseJMAEqList;
+    private parseJMAScale;
+}

package/lib/handlers/wolfx.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WolfxHandler = void 0;
+const base_1 = require("./base");
+const models_1 = require("../models");
+class WolfxHandler extends base_1.BaseDataHandler {
+    constructor(sourceId) {
+        super(sourceId);
+    }
+    parseMessage(data) {
+        try {
+            const type = data.type;
+            if (type === 'jma_eew') {
+                return this.parseJMAEEW(data);
+            }
+            else if (type === 'cenc_eew') {
+                return this.parseCENCEEW(data);
+            }
+            else if (type === 'jma_eqlist') {
+                return this.parseJMAEqList(data);
+            }
+            else if (type === 'cenc_eqlist') {
+                // TODO: Implement CENC EqList
+                return null;
+            }
+            return null;
+        }
+        catch (e) {
+            this.logger.error(`[${this.sourceId}] Error parsing message:`, e);
+            return null;
+        }
+    }
+    parseJMAEEW(data) {
+        const earthquake = {
+            id: data.EventID || '',
+            event_id: data.EventID || '',
+            source: models_1.DataSource.WOLFX_JMA_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.Magunitude || data.Magnitude),
+            place_name: data.Hypocenter || '',
+            scale: this.parseJMAScale(data.MaxIntensity),
+            is_final: data.isFinal || false,
+            is_cancel: data.isCancel || false,
+            is_training: data.isTraining || false,
+            updates: 1,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.WOLFX_JMA_EEW,
+            disaster_type: models_1.DisasterType.EARTHQUAKE_WARNING,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseCENCEEW(data) {
+        const earthquake = {
+            id: data.ID || '',
+            event_id: data.EventID || '',
+            source: models_1.DataSource.WOLFX_CENC_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 || '',
+            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_CENC_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
+        let eqInfo = null;
+        for (const key in data) {
+            if (key.startsWith('No') && typeof data[key] === 'object') {
+                eqInfo = data[key];
+                break; // Assuming first one is latest
+            }
+        }
+        if (!eqInfo)
+            return null;
+        let depth = Number(eqInfo.depth);
+        if (isNaN(depth) && typeof eqInfo.depth === 'string' && eqInfo.depth.endsWith('km')) {
+            depth = Number(eqInfo.depth.replace('km', ''));
+        }
+        const earthquake = {
+            id: eqInfo.md5 || '',
+            event_id: eqInfo.md5 || '',
+            source: models_1.DataSource.WOLFX_JMA_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 || '',
+            scale: this.parseJMAScale(eqInfo.shindo),
+            updates: 1,
+            is_final: true,
+            is_cancel: false,
+            raw_data: data
+        };
+        return {
+            id: earthquake.id,
+            data: earthquake,
+            source: models_1.DataSource.WOLFX_JMA_EQ,
+            disaster_type: models_1.DisasterType.EARTHQUAKE,
+            receive_time: new Date().toISOString(),
+            push_count: 0,
+            raw_data: data
+        };
+    }
+    parseJMAScale(scaleStr) {
+        if (!scaleStr)
+            return undefined;
+        const match = scaleStr.match(/(\d+)(弱|強)?/);
+        if (match) {
+            const base = parseInt(match[1]);
+            const suffix = match[2];
+            if (suffix === '弱')
+                return base - 0.5;
+            if (suffix === '強')
+                return base + 0.5;
+            return base;
+        }
+        return undefined;
+    }
+}
+exports.WolfxHandler = WolfxHandler;

package/lib/index.d.ts

@@ -0,0 +1,55 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "disaster-warning";
+export declare const inject: string[];
+export interface Config {
+    enabled: boolean;
+    target_groups: string[];
+    platform_name: 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;
+        };
+    };
+    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;
+        };
+    };
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const service_1 = require("./service");
+exports.name = 'disaster-warning';
+exports.inject = ['database?']; // Optional database dependency if needed later
+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('需要推送消息的群号列表'),
+    platform_name: koishi_1.Schema.string().default('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(true).description('中国地震台网（CENC）：地震测定'),
+            japan_jma_eew: koishi_1.Schema.boolean().default(true).description('日本气象厅（JMA）：紧急地震速报'),
+            usgs_earthquake: koishi_1.Schema.boolean().default(true).description('美国地质调查局（USGS）：地震测定'),
+            china_weather_alarm: koishi_1.Schema.boolean().default(true).description('中国气象局：气象预警'),
+            china_tsunami: koishi_1.Schema.boolean().default(true).description('自然资源部海啸预警中心：海啸预警信息'),
+        }).description('FAN Studio WebSocket 数据源'),
+        p2p_earthquake: koishi_1.Schema.object({
+            enabled: koishi_1.Schema.boolean().default(true).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(true).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(true).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('地震信息过滤器配置'),
+});
+function apply(ctx, config) {
+    ctx.plugin(service_1.DisasterWarningService, config);
+}

package/lib/models.d.ts

@@ -0,0 +1,106 @@
+export declare enum DisasterType {
+    EARTHQUAKE = "earthquake",
+    EARTHQUAKE_WARNING = "earthquake_warning",
+    TSUNAMI = "tsunami",
+    WEATHER_ALARM = "weather_alarm"
+}
+export declare enum DataSource {
+    FAN_STUDIO_CENC = "fan_studio_cenc",
+    FAN_STUDIO_CEA = "fan_studio_cea",
+    FAN_STUDIO_CWA = "fan_studio_cwa",
+    FAN_STUDIO_USGS = "fan_studio_usgs",
+    FAN_STUDIO_JMA = "fan_studio_jma",
+    FAN_STUDIO_WEATHER = "fan_studio_weather",
+    FAN_STUDIO_TSUNAMI = "fan_studio_tsunami",
+    P2P_EEW = "p2p_eew",
+    P2P_EARTHQUAKE = "p2p_earthquake",
+    P2P_TSUNAMI = "p2p_tsunami",
+    WOLFX_JMA_EEW = "wolfx_jma_eew",
+    WOLFX_CENC_EEW = "wolfx_cenc_eew",
+    WOLFX_CWA_EEW = "wolfx_cwa_eew",
+    WOLFX_CENC_EQ = "wolfx_cenc_eq",
+    WOLFX_JMA_EQ = "wolfx_jma_eq",
+    GLOBAL_QUAKE = "global_quake"
+}
+export declare const DATA_SOURCE_MAPPING: Record<string, DataSource>;
+export declare function getDataSourceFromId(id: string): DataSource | undefined;
+export interface EarthquakeData {
+    id: string;
+    event_id: string;
+    source: DataSource;
+    disaster_type: DisasterType;
+    shock_time: string;
+    latitude: number;
+    longitude: number;
+    place_name: string;
+    depth?: number;
+    magnitude?: number;
+    intensity?: number;
+    scale?: number;
+    max_intensity?: number;
+    max_scale?: number;
+    province?: string;
+    updates: number;
+    is_final: boolean;
+    is_cancel: boolean;
+    info_type?: string;
+    domestic_tsunami?: string;
+    foreign_tsunami?: string;
+    update_time?: string;
+    create_time?: string;
+    source_id?: string;
+    report_num?: number;
+    serial?: string;
+    is_training?: boolean;
+    revision?: number;
+    max_pga?: number;
+    stations?: Record<string, number>;
+    raw_data: any;
+}
+export interface TsunamiData {
+    id: string;
+    code: string;
+    source: DataSource;
+    title: string;
+    level: string;
+    disaster_type: DisasterType;
+    subtitle?: string;
+    org_unit: string;
+    issue_time?: string;
+    forecasts: any[];
+    monitoring_stations: any[];
+    source_id?: string;
+    estimated_arrival_time?: string;
+    max_wave_height?: string;
+    raw_data: any;
+}
+export interface WeatherAlarmData {
+    id: string;
+    source: DataSource;
+    headline: string;
+    title: string;
+    description: string;
+    type: string;
+    effective_time: string;
+    disaster_type: DisasterType;
+    issue_time?: string;
+    longitude?: number;
+    latitude?: number;
+    source_id?: string;
+    alert_level?: string;
+    affected_areas: string[];
+    raw_data: any;
+}
+export interface DisasterEvent {
+    id: string;
+    data: EarthquakeData | TsunamiData | WeatherAlarmData;
+    source: DataSource;
+    disaster_type: DisasterType;
+    receive_time: string;
+    source_id?: string;
+    processing_time?: string;
+    is_filtered?: boolean;
+    filter_reason?: string;
+    push_count: number;
+    raw_data: any;
+}

package/lib/models.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_SOURCE_MAPPING = exports.DataSource = exports.DisasterType = void 0;
+exports.getDataSourceFromId = getDataSourceFromId;
+var DisasterType;
+(function (DisasterType) {
+    DisasterType["EARTHQUAKE"] = "earthquake";
+    DisasterType["EARTHQUAKE_WARNING"] = "earthquake_warning";
+    DisasterType["TSUNAMI"] = "tsunami";
+    DisasterType["WEATHER_ALARM"] = "weather_alarm";
+})(DisasterType || (exports.DisasterType = DisasterType = {}));
+var DataSource;
+(function (DataSource) {
+    // FAN Studio
+    DataSource["FAN_STUDIO_CENC"] = "fan_studio_cenc";
+    DataSource["FAN_STUDIO_CEA"] = "fan_studio_cea";
+    DataSource["FAN_STUDIO_CWA"] = "fan_studio_cwa";
+    DataSource["FAN_STUDIO_USGS"] = "fan_studio_usgs";
+    DataSource["FAN_STUDIO_JMA"] = "fan_studio_jma";
+    DataSource["FAN_STUDIO_WEATHER"] = "fan_studio_weather";
+    DataSource["FAN_STUDIO_TSUNAMI"] = "fan_studio_tsunami";
+    // P2P
+    DataSource["P2P_EEW"] = "p2p_eew";
+    DataSource["P2P_EARTHQUAKE"] = "p2p_earthquake";
+    DataSource["P2P_TSUNAMI"] = "p2p_tsunami";
+    // Wolfx
+    DataSource["WOLFX_JMA_EEW"] = "wolfx_jma_eew";
+    DataSource["WOLFX_CENC_EEW"] = "wolfx_cenc_eew";
+    DataSource["WOLFX_CWA_EEW"] = "wolfx_cwa_eew";
+    DataSource["WOLFX_CENC_EQ"] = "wolfx_cenc_eq";
+    DataSource["WOLFX_JMA_EQ"] = "wolfx_jma_eq";
+    // Global Quake
+    DataSource["GLOBAL_QUAKE"] = "global_quake";
+})(DataSource || (exports.DataSource = DataSource = {}));
+exports.DATA_SOURCE_MAPPING = {
+    "cea_fanstudio": DataSource.FAN_STUDIO_CEA,
+    "cea_wolfx": DataSource.WOLFX_CENC_EEW,
+    "cwa_fanstudio": DataSource.FAN_STUDIO_CWA,
+    "cwa_wolfx": DataSource.WOLFX_CWA_EEW,
+    "jma_fanstudio": DataSource.FAN_STUDIO_JMA,
+    "jma_p2p": DataSource.P2P_EEW,
+    "jma_wolfx": DataSource.WOLFX_JMA_EEW,
+    "global_quake": DataSource.GLOBAL_QUAKE,
+    "cenc_fanstudio": DataSource.FAN_STUDIO_CENC,
+    "cenc_wolfx": DataSource.WOLFX_CENC_EQ,
+    "jma_p2p_info": DataSource.P2P_EARTHQUAKE,
+    "jma_wolfx_info": DataSource.WOLFX_JMA_EQ,
+    "usgs_fanstudio": DataSource.FAN_STUDIO_USGS,
+    "china_weather_fanstudio": DataSource.FAN_STUDIO_WEATHER,
+    "china_tsunami_fanstudio": DataSource.FAN_STUDIO_TSUNAMI,
+    "jma_tsunami_p2p": DataSource.P2P_TSUNAMI,
+};
+function getDataSourceFromId(id) {
+    return exports.DATA_SOURCE_MAPPING[id];
+}

package/lib/pusher.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'koishi';
+import { Config } from './index';
+import { DisasterEvent } from './models';
+export declare class MessagePushManager {
+    private ctx;
+    private config;
+    constructor(ctx: Context, config: Config);
+    pushEvent(event: DisasterEvent): Promise<void>;
+    private shouldFilter;
+    private formatMessage;
+    private formatEarthquake;
+    private formatTsunami;
+    private formatWeather;
+    private formatTime;
+    private formatScale;
+    private broadcast;
+}

package/lib/pusher.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePushManager = void 0;
+const koishi_1 = require("koishi");
+const models_1 = require("./models");
+const logger = new koishi_1.Logger('disaster-pusher');
+class MessagePushManager {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+    }
+    async pushEvent(event) {
+        if (this.shouldFilter(event)) {
+            logger.debug(`Event ${event.id} filtered.`);
+            return;
+        }
+        const message = this.formatMessage(event);
+        if (!message)
+            return;
+        logger.info(`Pushing event ${event.id} to ${this.config.target_groups.length} groups.`);
+        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;
+            }
+        }
+        return false;
+    }
+    formatMessage(event) {
+        switch (event.disaster_type) {
+            case models_1.DisasterType.EARTHQUAKE:
+            case models_1.DisasterType.EARTHQUAKE_WARNING:
+                return this.formatEarthquake(event.data);
+            case models_1.DisasterType.TSUNAMI:
+                return this.formatTsunami(event.data);
+            case models_1.DisasterType.WEATHER_ALARM:
+                return this.formatWeather(event.data);
+            default:
+                return `Unknown disaster event: ${event.disaster_type}`;
+        }
+    }
+    formatEarthquake(data) {
+        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`;
+        if (data.intensity !== undefined) {
+            msg += `最大烈度：${data.intensity.toFixed(1)}\n`;
+        }
+        if (data.scale !== undefined) {
+            msg += `最大震度：${this.formatScale(data.scale)}\n`;
+        }
+        msg += `数据源：${data.source}`;
+        return msg;
+    }
+    formatTsunami(data) {
+        let msg = `【海啸预警】${data.title}\n`;
+        msg += `级别：${data.level}\n`;
+        msg += `发布单位：${data.org_unit}\n`;
+        if (data.forecasts && data.forecasts.length > 0) {
+            msg += `预报区域：\n`;
+            data.forecasts.slice(0, 5).forEach((f) => {
+                msg += `- ${f.name || f.areaName}: ${f.grade || f.level}\n`;
+            });
+            if (data.forecasts.length > 5)
+                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`;
+        return msg;
+    }
+    formatTime(isoStr) {
+        try {
+            return new Date(isoStr).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+        }
+        catch {
+            return isoStr;
+        }
+    }
+    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();
+    }
+    async broadcast(message) {
+        for (const groupId of this.config.target_groups) {
+            // Construct session string like "platform:groupId" or use bot.sendMessage
+            // Koishi's broadcast method usually takes channelIds.
+            // If platform_name is 'onebot', channelId is usually the group number.
+            // We need to find the bot first or use ctx.broadcast.
+            // ctx.broadcast(channels, content)
+            // channels can be [`${platform}:${groupId}`]
+            const channelId = `${this.config.platform_name}:${groupId}`;
+            try {
+                await this.ctx.broadcast([channelId], message);
+            }
+            catch (e) {
+                logger.error(`Failed to send to ${channelId}:`, e);
+            }
+        }
+    }
+}
+exports.MessagePushManager = MessagePushManager;

package/lib/service.d.ts

@@ -0,0 +1,20 @@
+import { Context } from 'koishi';
+import { Config } from './index';
+export declare class DisasterWarningService {
+    private config;
+    private connections;
+    private reconnectTimers;
+    private pusher;
+    private ctx;
+    private handlers;
+    constructor(ctx: Context, config: Config);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private connectAll;
+    private connectWebSocket;
+    private handleEvent;
+    private connectFanStudio;
+    private connectP2P;
+    private connectWolfx;
+    private connectGlobalQuake;
+}

package/lib/service.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisasterWarningService = void 0;
+const koishi_1 = require("koishi");
+const ws_1 = require("ws");
+const handlers_1 = require("./handlers");
+const pusher_1 = require("./pusher");
+const logger = new koishi_1.Logger('disaster-warning');
+class DisasterWarningService {
+    constructor(ctx, config) {
+        this.connections = {};
+        this.reconnectTimers = {};
+        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()
+        };
+    }
+    async start() {
+        if (!this.config.enabled)
+            return;
+        logger.info('Disaster Warning Service starting...');
+        this.connectAll();
+    }
+    async stop() {
+        logger.info('Disaster Warning Service stopping...');
+        for (const key in this.connections) {
+            this.connections[key].close();
+        }
+        for (const key in this.reconnectTimers) {
+            clearTimeout(this.reconnectTimers[key]);
+        }
+    }
+    connectAll() {
+        if (this.config.data_sources.fan_studio.enabled) {
+            this.connectFanStudio();
+        }
+        if (this.config.data_sources.p2p_earthquake.enabled) {
+            this.connectP2P();
+        }
+        if (this.config.data_sources.wolfx.enabled) {
+            this.connectWolfx();
+        }
+        if (this.config.data_sources.global_quake.enabled) {
+            this.connectGlobalQuake();
+        }
+    }
+    connectWebSocket(name, url, onMessage) {
+        if (this.connections[name]) {
+            this.connections[name].close();
+        }
+        logger.info(`Connecting to ${name} at ${url}...`);
+        const ws = new ws_1.WebSocket(url);
+        ws.on('open', () => {
+            logger.info(`Connected to ${name}`);
+        });
+        ws.on('message', (data) => {
+            try {
+                const parsed = JSON.parse(data.toString());
+                onMessage(parsed);
+            }
+            catch (e) {
+                logger.warn(`Failed to parse message from ${name}:`, e);
+            }
+        });
+        ws.on('close', () => {
+            logger.warn(`Disconnected from ${name}, reconnecting in 10s...`);
+            delete this.connections[name];
+            this.reconnectTimers[name] = setTimeout(() => {
+                this.connectWebSocket(name, url, onMessage);
+            }, 10000);
+        });
+        ws.on('error', (err) => {
+            logger.error(`Error in ${name} connection:`, err);
+        });
+        this.connections[name] = ws;
+    }
+    async handleEvent(event) {
+        if (!event)
+            return;
+        await this.pusher.pushEvent(event);
+    }
+    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);
+        });
+    }
+    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);
+                });
+            }
+        }
+    }
+    connectGlobalQuake() {
+        const url = "wss://gqm.aloys233.top/ws";
+        this.connectWebSocket('global_quake', url, (data) => {
+            const event = this.handlers.globalQuake.parseMessage(data);
+            this.handleEvent(event);
+        });
+    }
+}
+exports.DisasterWarningService = DisasterWarningService;

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "koishi-plugin-disaster-warning",
+    "description": "Disaster warning plugin for Koishi, supporting Earthquake, Tsunami, and Weather alerts from multiple sources.",
+    "version": "0.0.1",
+    "main": "lib/index.js",
+    "typings": "lib/index.d.ts",
+    "files": [
+        "lib",
+        "dist"
+    ],
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc",
+        "lint": "eslint src --ext .ts"
+    },
+    "keywords": [
+        "koishi",
+        "plugin",
+        "disaster",
+        "earthquake",
+        "warning"
+    ],
+    "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"
+    }
+}